Lammps Writer Changes For Updated Topology Class

gmso/abc/abstract_site.py

@@ -137,7 +137,8 @@ def is_valid_position(cls, position):
 
         try:
             position = np.reshape(position, newshape=(3,), order="C")
-            position.convert_to_units(u.nm)
+            if position.units != u.dimensionless:
+                position.convert_to_units(u.nm)
         except ValueError:
             raise ValueError(
                 f"Position of shape {position.shape} is not valid. "

gmso/core/box.py

@@ -21,7 +21,8 @@ def _validate_lengths(lengths):
     np.reshape(lengths, newshape=(3,), order="C")
 
     lengths *= input_unit
-    lengths.convert_to_units(u.nm)
+    if input_unit != u.Unit("dimensionless"):
+        lengths.convert_to_units(u.nm)
 
     if np.any(
         np.less(

gmso/core/topology.py

@@ -26,6 +26,10 @@
 from gmso.utils.connectivity import (
     identify_connections as _identify_connections,
 )
+from gmso.utils.conversions import (
+    convert_params_units,
+    convert_topology_expressions,
+)
 from gmso.utils.units import GMSO_UnitRegsitry as UnitReg
 
 scaling_interaction_idxes = {"12": 0, "13": 1, "14": 2}
@@ -1693,6 +1697,62 @@ def load(cls, filename, **kwargs):
         loader = LoadersRegistry.get_callable(filename.suffix)
         return loader(filename, **kwargs)
 
+    def convert_potential_styles(self, expressionMap={}):
+        """Convert from one parameter form to another.
+
+        Parameters
+        ----------
+        expressionMap : dict, default={}
+            Map where the keys represent the current potential
+            type and the corresponding values represent the desired
+            potential type. The desired potential style can be
+            either a string with the corresponding name, or
+            a gmso.utils.expression.PotentialExpression type.
+
+        Examples
+        ________
+        # Convert from RB torsions to OPLS torsions
+        top.convert_potential_styles({"dihedrals": "OPLSTorsionPotential"})
+        # TODO: convert_potential_styles with PotentialExpression
+        """
+        # TODO: raise warnings for improper values or keys in expressionMap
+
+        return convert_topology_expressions(self, expressionMap)
+
+    def convert_unit_styles(self, unitsystem, exp_unitsDict):
+        """Convert from one set of base units to another.
+
+        Parameters
+        ----------
+        unitsystem : unyt.UnitSystem
+            set of base units to use for all expressions of the topology
+            in `unyt package <https://unyt.readthedocs.io/en/stable/>_`
+        exp_unitsDict : dict
+            keys with topology attributes that should be converted and
+            values with dictionary of parameter: expected_dimension
+
+        Examples
+        ________
+        top.convert_unit_styles(
+            u.UnitSystem(
+                "lammps_real", "Å", "amu", "fs", "K", "rad",
+            ),
+            {"bond":{"k":"energy/length**2", "r_eq":"length"}},
+        )
+        """
+
+        ref_values = {"energy": "kJ/mol", "length": "nm", "angle": "radians"}
+
+        # all potContainer ["atom", "bond", "angle", "dihedral", "improper"]
+        for potStr in exp_unitsDict:
+            potContainer = getattr(self, potStr + "_types")
+            convert_params_units(
+                potContainer,
+                expected_units_dim=exp_unitsDict[potStr],
+                base_units=unitsystem,
+                ref_values=ref_values,
+            )
+
 
 def _return_float_for_unyt(unyt_quant, unyts_bool):
     try:

gmso/core/views.py

@@ -57,7 +57,13 @@ def get_sorted_names(potential):
         else:
             return potential.member_types
     elif isinstance(potential, ImproperType):
-        return (potential.member_types[0], *sorted(potential.member_types[1:]))
+        return (
+            potential.member_types[0],
+            *potential.member_types[1:],
+        )  # could sort using `sorted`
+    return ValueError(
+        f"Potential {potential} not one of {potential_attribute_map.values()}"
+    )
 
 
 def get_parameters(potential):
@@ -170,6 +176,13 @@ def index(self, item):
         for j, potential in enumerate(self.yield_view()):
             if potential is item:
                 return j
+        return None
+
+    def equality_index(self, item):
+        for j, potential in enumerate(self.yield_view()):
+            if potential == item:
+                return j
+        return None
 
     def _collect_potentials(self):
         """Collect potentials from the iterator"""

gmso/external/convert_mbuild.py

@@ -314,7 +314,7 @@ def _parse_molecule_residue(site_map, compound):
         if molecule_tag.name in molecule_tracker:
             molecule_tracker[molecule_tag.name] += 1
         else:
-            molecule_tracker[molecule_tag.name] = 0
+            molecule_tracker[molecule_tag.name] = 1
         molecule_number = molecule_tracker[molecule_tag.name]
         """End of molecule parsing"""
 
@@ -329,7 +329,7 @@ def _parse_molecule_residue(site_map, compound):
                         residue_tracker[residue_tag.name]
                     )
             else:
-                residue_tracker[residue_tag.name] = {residue_tag: 0}
+                residue_tracker[residue_tag.name] = {residue_tag: 1}
 
             residue_number = residue_tracker[residue_tag.name][residue_tag]
             site_map[particle]["residue"] = (residue_tag.name, residue_number)

gmso/external/convert_parmed.py

@@ -1,4 +1,5 @@
 """Module support for converting to/from ParmEd objects."""
+import copy
 import warnings
 from operator import attrgetter, itemgetter
 
@@ -7,7 +8,7 @@
 from symengine import expand
 
 import gmso
-from gmso.core.element import element_by_atom_type, element_by_atomic_number
+from gmso.core.element import element_by_atomic_number, element_by_symbol
 from gmso.core.views import PotentialFilters, get_parameters
 
 pfilter = PotentialFilters.UNIQUE_PARAMETERS
@@ -71,12 +72,12 @@ def from_parmed(structure, refer_type=True):
                 charge=atom.charge * u.elementary_charge,
                 position=[atom.xx, atom.xy, atom.xz] * u.angstrom,
                 atom_type=None,
-                residue=(residue.name, residue.idx),
+                residue=(residue.name, residue.idx + 1),
                 element=element,
             )
-            site.molecule = (residue.name, residue.idx) if ind_res else None
+            site.molecule = (residue.name, residue.idx + 1) if ind_res else None
             site.atom_type = (
-                pmd_top_atomtypes[atom.atom_type]
+                copy.deepcopy(pmd_top_atomtypes[atom.atom_type])
                 if refer_type and isinstance(atom.atom_type, pmd.AtomType)
                 else None
             )
@@ -102,6 +103,7 @@ def from_parmed(structure, refer_type=True):
             }
             _add_conn_type_from_pmd(
                 connStr="BondType",
+                pmd_conn=bond,
                 gmso_conn=top_connection,
                 conn_params=conn_params,
                 name=name,
@@ -124,11 +126,12 @@ def from_parmed(structure, refer_type=True):
         )
         if refer_type and isinstance(angle.type, pmd.AngleType):
             conn_params = {
-                "k": (2 * angle.type.k * u.Unit("kcal / (rad**2 * mol)")),
+                "k": (2 * angle.type.k * u.Unit("kcal / (radian**2 * mol)")),
                 "theta_eq": (angle.type.theteq * u.degree),
             }
             _add_conn_type_from_pmd(
                 connStr="AngleType",
+                pmd_conn=angle,
                 gmso_conn=top_connection,
                 conn_params=conn_params,
                 name=name,
@@ -164,6 +167,7 @@ def from_parmed(structure, refer_type=True):
                 }
                 _add_conn_type_from_pmd(
                     connStr="ImproperType",
+                    pmd_conn=dihedral,
                     gmso_conn=top_connection,
                     conn_params=conn_params,
                     name=name_improper,
@@ -186,6 +190,7 @@ def from_parmed(structure, refer_type=True):
                 }
                 _add_conn_type_from_pmd(
                     connStr="DihedralType",
+                    pmd_conn=dihedral,
                     gmso_conn=top_connection,
                     conn_params=conn_params,
                     name=name_proper,
@@ -221,6 +226,7 @@ def from_parmed(structure, refer_type=True):
             }
             _add_conn_type_from_pmd(
                 connStr="DihedralType",
+                pmd_conn=rb_torsion,
                 gmso_conn=top_connection,
                 conn_params=conn_params,
                 name=name,
@@ -240,7 +246,7 @@ def from_parmed(structure, refer_type=True):
             connection_members=_sort_improper_members(
                 top,
                 site_map,
-                *attrgetter("atom1", "atom2", "atom3", "atom4")(improper),
+                *attrgetter("atom3", "atom2", "atom1", "atom4")(improper),
             )
         )
         if refer_type and isinstance(improper.type, pmd.ImproperType):
@@ -250,6 +256,7 @@ def from_parmed(structure, refer_type=True):
             }
             _add_conn_type_from_pmd(
                 connStr="ImproperType",
+                pmd_conn=improper,
                 gmso_conn=top_connection,
                 conn_params=conn_params,
                 name=name,
@@ -281,11 +288,11 @@ def _atom_types_from_pmd(structure):
             A dictionary linking a pmd.AtomType object to its
             corresponding GMSO.AtomType object.
     """
-    unique_atom_types = set()
-    for atom in structure.atoms:
-        if isinstance(atom.atom_type, pmd.AtomType):
-            unique_atom_types.add(atom.atom_type)
-    unique_atom_types = list(unique_atom_types)
+    unique_atom_types = [
+        atom.atom_type
+        for atom in structure.atoms
+        if isinstance(atom.atom_type, pmd.AtomType)
+    ]
     pmd_top_atomtypes = {}
     for atom_type in unique_atom_types:
         if atom_type.atomic_number:
@@ -302,7 +309,7 @@ def _atom_types_from_pmd(structure):
                 "epsilon": atom_type.epsilon * u.Unit("kcal / mol"),
             },
             independent_variables={"r"},
-            mass=atom_type.mass,
+            mass=copy.deepcopy(atom_type.mass),
         )
         pmd_top_atomtypes[atom_type] = top_atomtype
     return pmd_top_atomtypes
@@ -342,7 +349,7 @@ def _sort_improper_members(top, site_map, atom1, atom2, atom3, atom4):
 
 
 def _add_conn_type_from_pmd(
-    connStr, gmso_conn, conn_params, name, expression, variables
+    connStr, pmd_conn, gmso_conn, conn_params, name, expression, variables
 ):
     """Convert ParmEd dihedral types to GMSO DihedralType.
 
@@ -408,6 +415,9 @@ def to_parmed(top, refer_type=True):
     msg = "Provided argument is not a topology.Topology."
     assert isinstance(top, gmso.Topology)
 
+    # Copy structure to not overwrite object in memory
+    top = copy.deepcopy(top)
+
     # Set up Parmed structure and define general properties
     structure = pmd.Structure()
     structure.title = top.name
@@ -450,7 +460,9 @@ def to_parmed(top, refer_type=True):
         # Add atom to structure
         if site.residue:
             structure.add_atom(
-                pmd_atom, resname=site.residue.name, resnum=site.residue.number
+                pmd_atom,
+                resname=site.residue.name,
+                resnum=site.residue.number - 1,
             )
         else:
             structure.add_atom(pmd_atom, resname="RES", resnum=-1)
@@ -561,14 +573,20 @@ def _atom_types_from_gmso(top, structure, atom_map):
         atype_epsilon = float(
             atom_type.parameters["epsilon"].to("kcal/mol").value
         )
-        atype_element = element_by_atom_type(atom_type)
+        if atom_type.mass:
+            atype_mass = atom_type.mass.to("amu").value
+        else:
+            atype_mass = element_by_symbol(atom_type.name).mass.to("amu").value
+        atype_atomic_number = getattr(
+            element_by_symbol(atom_type.name), "atomic_number", None
+        )
         atype_rmin = atype_sigma * 2 ** (1 / 6) / 2  # to rmin/2
         # Create unique Parmed AtomType object
         atype = pmd.AtomType(
             atype_name,
             None,
             atype_mass,
-            atype_element.atomic_number,
+            atype_atomic_number,
             atype_charge,
         )
         atype.set_lj_params(atype_epsilon, atype_rmin)
@@ -645,7 +663,7 @@ def _angle_types_from_gmso(top, structure, angle_map):
         ), msg
         # Extract Topology angle_type information
         agltype_k = 0.5 * float(
-            angle_type.parameters["k"].to("kcal / (rad**2 * mol)").value
+            angle_type.parameters["k"].to("kcal / (radian**2 * mol)").value
         )
         agltype_theta_eq = float(
             angle_type.parameters["theta_eq"].to("degree").value
@@ -729,10 +747,17 @@ def _dihedral_types_from_gmso(top, structure, dihedral_map):
             )
             # Create unique DihedralType object
             dtype = pmd.RBTorsionType(
-                dtype_c0, dtype_c1, dtype_c2, dtype_c3, dtype_c4, dtype_c5
+                dtype_c0,
+                dtype_c1,
+                dtype_c2,
+                dtype_c3,
+                dtype_c4,
+                dtype_c5,
+                list=structure.rb_torsion_types,
             )
             # Add RBTorsionType to structure.rb_torsion_types
             structure.rb_torsion_types.append(dtype)
+            # dtype._idx = len(structure.rb_torsion_types) - 1
         else:
             raise GMSOError("msg")
         dtype_map[get_parameters(dihedral_type)] = dtype

gmso/formats/gro.py

@@ -80,8 +80,8 @@ def read_gro(filename):
 
             r = re.compile("([0-9]+)([a-zA-Z]+)")
             m = r.match(res)
-            site.molecule = (m.group(2), int(m.group(1)) - 1)
-            site.residue = (m.group(2), int(m.group(1)) - 1)
+            site.molecule = (m.group(2), int(m.group(1)))
+            site.residue = (m.group(2), int(m.group(1)))
             top.add_site(site, update_types=False)
         top.update_topology()