mimicpy 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

mimicpy/topology/mpt.py

@@ -1,6 +1,6 @@
 #
 #    MiMiCPy: Python Based Tools for MiMiC
-#    Copyright (C) 2020-2021 Bharath Raghavan,
+#    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
 #
 #    This file is part of MiMiCPy.

mimicpy/topology/top.py

@@ -1,6 +1,6 @@
 #
 #    MiMiCPy: Python Based Tools for MiMiC
-#    Copyright (C) 2020-2021 Bharath Raghavan,
+#    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
 #
 #    This file is part of MiMiCPy.
@@ -24,6 +24,7 @@
 import logging
 from os import environ
 from os.path import basename, join, isfile
+from pathlib import Path
 import pandas as pd
 from .itp import Itp
 from .topol_dict import TopolDict
@@ -66,7 +67,8 @@ class Top:
         self.molecules = None
         self.bonds = None
         self.topol_dict = None
-
+        self.mol_offsets = None
+        self.nrexcl_values = {}  # Store nrexcl values for all molecules
         if mode == 'r':
             self.__read()
         elif mode == 'w':
@@ -82,13 +84,20 @@ class Top:
         self.atomtypes = top.atom_types_df
         if get_only_atomtypes: return
         molecule_types = top.molecule_types
-
         if self.nonstandard_atomtypes is not None:
             atom_types.update(self.nonstandard_atomtypes)
-
+        
+        self.atom_types_df = pd.DataFrame()
         atoms = {}
         bonds = {}
+        angles = {}
+        dihedrals = {}
+        pairs = {}
         guessed_elems_history = {}
+        source_files = {}  # Store source file information in a dictionary
+        nrexcl_values = {}  # Store nrexcl values from all ITP files
+        force_fields = {}  # Store force field data
+        parameter_definitions = {}  # Store parameter definitions (#define statements)
 
         for itp_file in top.topology_files:
             itp_file_name = basename(itp_file)
@@ -99,22 +108,84 @@ class Top:
                           self.buffer,
                           'r',
                           self.guess_elements,
-                          self.gmxdata)
+                          self.gmxdata,
+                          parameter_definitions)
+                _ = itp.atom_types
+                if not itp.atom_types_df.empty:
+                    self.atom_types_df = pd.concat([self.atom_types_df,itp.atom_types_df], axis=0, ignore_index=True)
+                
+                # Collect parameter definitions from all files (not just force field files)
+                if itp.parameter_definitions:
+                    parameter_definitions.update(itp.parameter_definitions)
+                    logging.debug('Read parameter definitions from %s.', itp_file_name)
+                
+                # Check if this is a force field file (contains force field sections)
+                if itp.bondtypes or itp.angletypes or itp.dihedraltypes:
+                    # Extract force field name from filename
+                    force_field_name = Path(itp_file_name).stem
+                    if force_field_name not in force_fields:
+                        force_fields[force_field_name] = {
+                            'bondtypes': {},
+                            'angletypes': {},
+                            'dihedraltypes': {}
+                        }
+                    force_fields[force_field_name]['bondtypes'].update(itp.bondtypes)
+                    force_fields[force_field_name]['angletypes'].update(itp.angletypes)
+                    force_fields[force_field_name]['dihedraltypes'].update(itp.dihedraltypes)
+                    logging.debug('Read force field parameters from %s.', itp_file_name)
+                
                 if itp.topol is not None:
                     atoms.update(itp.topol)
                     bonds.update(itp.bonds)
+                    angles.update(itp.angles)
+                    dihedrals.update(itp.dihedrals)
+                    pairs.update(itp.pairs)
                     guessed_elems_history.update(itp.guessed_elems_history)
+                    # Store source file information in dictionary
+                    for mol in itp.topol:
+                        if hasattr(itp.topol[mol], 'source_file'):
+                            source_files[mol] = itp.topol[mol].source_file
+                    # Store nrexcl values
+                    nrexcl_values.update(itp.nrexcl_values)
                     logging.debug('Read atoms from %s.', itp_file_name)
                 else:
                     logging.debug('No atoms found in %s.', itp_file_name)
             except OSError:
                 logging.warning('Could not find %s in local or GROMACS data directory. Skipping.', itp_file_name)
-        topol_dict = TopolDict.from_dict(atoms)
-
+                
         self.molecules = top.molecules
-        self.topol_dict = topol_dict
+        
+        # Create TopolDict with all collected data
+        self.topol_dict = TopolDict.from_dict(atoms, bonds, angles, dihedrals, pairs)
+        # Add source file information to TopolDict
+        for mol, source_file in source_files.items():
+            self.topol_dict.add_source_file(mol, source_file)
+        # Add nrexcl values to TopolDict
+        for mol, nrexcl in nrexcl_values.items():
+            self.topol_dict.add_nrexcl_value(mol, nrexcl)
+        # Add force field data to TopolDict
+        for force_field_name, ff_data in force_fields.items():
+            self.topol_dict.add_force_field(
+                force_field_name,
+                bondtypes=ff_data['bondtypes'],
+                angletypes=ff_data['angletypes'],
+                dihedraltypes=ff_data['dihedraltypes']
+            )
+        # Add parameter definitions to TopolDict
+        self.topol_dict.add_parameter_definitions(parameter_definitions)
+        # Store nrexcl values
+        self.nrexcl_values = nrexcl_values
         self.bonds = self.__get_bonds(bonds)
 
+        mol_offsets = []
+        offset = 0
+        for mol, n_mols in self.molecules:
+            mol_len = len(self.topol_dict[mol])
+            for i in range(n_mols):
+                mol_offsets.append((mol, offset))
+                offset += mol_len
+        self.mol_offsets = mol_offsets
+
         mols_not_in = self.topol_dict.check_mols(self.molecules)
 
         if mols_not_in:
@@ -140,19 +211,32 @@ class Top:
         
         return pd.DataFrame(bonds_section_dct)
         
-    def write_atomtypes(self, file, delete_atomtypes=None):
+    
+    def write_atomtypes(self, file=None, delete_atomtypes=None):
+        """Write atomtypes to a file with support for modifying multiple files
+        
+        Args:
+            file (str, optional): Target file to write atomtypes to. If None, uses self.file
+            delete_atomtypes (list, optional): List of files to delete atomtypes sections from
+        """
+        if file is None:
+            file = self.file
+
         if self.mode != 'w':
             self.mode = 'w'
             self.__read(True)
 
+        # Get elements from topology dictionary
         elements = {}
         for k, df in self.topol_dict.todict().items():
             elements.update(dict(zip(df['type'], df['element'])))
         elements = {k:atomic_numbers[v] for k,v in elements.items()}
 
+        # Create atomtypes string
         itp_str = "; Created by mimicpy fixtop\n[ atomtypes ]\n"
-        itp_str += ";  {:^11}{:^6}{:^10}{:^10}{:^6}     {}     {}\n".format('name','at.num','mass','charge','ptype',
-                                                                           'sigma','epsilon')
+        itp_str += ";  {:^11}{:^6}{:^10}{:^10}{:^6}     {}     {}\n".format(
+            'name', 'at.num', 'mass', 'charge', 'ptype', 'sigma', 'epsilon')
+        
         for i, row in self.atomtypes.iterrows():
             lst = [row[c] for c in self.atomtypes.columns]
             if lst[0] in elements:
@@ -161,10 +245,10 @@ class Top:
                 lst[1] = int(lst[1])
             itp_str += "{:>11}{:6d}{:11.4f}{:11.4f}{:>6}     {:e}     {:e}\n".format(*lst)
 
-        import re
-        r = re.compile(r"(\[\s*atomtypes\s*\]\n(?:.+\n)+?)\s*(?:$|\[|#)", re.MULTILINE)
-
+        # Handle deletion of atomtypes sections from other files
         if delete_atomtypes is not None:
+            import re
+            r = re.compile(r"(\[\s*atomtypes\s*\]\n(?:.+\n)+?)\s*(?:$|\[|#)", re.MULTILINE)
             for i in delete_atomtypes:
                 txt = read(i)
                 atm_typs = r.findall(txt)
@@ -173,6 +257,7 @@ class Top:
                 write(txt, i)
             logging.info('Deleted atomtypes sections from %s', ', '.join(delete_atomtypes))
 
+        # Write to target file
         if isfile(file):
             txt = read(file)
             atm_typs = r.findall(txt)
@@ -183,4 +268,158 @@ class Top:
                 raise FileExistsError('%s exists and has no [ atomtypes ] section to replace', file)
         else:
             write(itp_str, file)
-            logging.info('Fixed [ atomtypes ] section and wrote to %s', file)
+            logging.info('Fixed [ atomtypes ] section and wrote to %s', file)
+
+    def write_topology(self, output_file):
+        """Write complete topology to file including all interactions
+        
+        Args:
+            output_file (str): Path to output file
+        """
+            
+        # Write system name
+        top_str = "; Created by mimicpy\n"
+        top_str += "[ system ]\n"
+        top_str += "; Name\n"
+        top_str += "System\n\n"
+        
+        # Write molecules section
+        top_str += "[ molecules ]\n"
+        top_str += "; Compound        #mols\n"
+        for mol, n_mols in self.molecules:
+            top_str += f"{mol:16s} {n_mols:6d}\n"
+        top_str += "\n"
+        
+        # Write atomtypes section
+        top_str += "[ atomtypes ]\n"
+        top_str += ";  {:^11}{:^6}{:^10}{:^10}{:^6}     {}     {}\n".format(
+            'name', 'at.num', 'mass', 'charge', 'ptype', 'sigma', 'epsilon')
+        
+        # Get unique atom types from topology
+        atom_types = set()
+        for mol in self.topol_dict.keys():
+            atom_types.update(self.topol_dict[mol]['type'].unique())
+
+        for atom_type in sorted(atom_types):
+            row = self.atom_types_df.loc[atom_type]
+            top_str += "{:>11}{:6d}{:11.4f}{:11.4f}{:>6}     {:e}     {:e}\n".format(
+                row['type'], row['X'], row['mass'], row['charge'],
+                row['ptype'], row['sigma'], row['epsilon'])
+        top_str += "\n"
+        
+        # Write molecule types and their interactions to separate .itp files
+        for mol, n_mols in self.molecules:
+            # Create .itp file for this molecule
+            itp_file = f"{mol}.itp"
+            
+            # Get nrexcl value for this molecule
+            nrexcl = self.topol_dict.get_nrexcl_value(mol)
+            
+            itp_str = f"; Created by mimicpy\n[ moleculetype ]\n; Name            nrexcl\n{mol:16s} {nrexcl}\n\n"
+            
+            # Write atoms section
+            itp_str += "[ atoms ]\n"
+            itp_str += ";   nr    type   resnr  residu    atom    cgnr        charge          mass\n"
+            atoms_df = self.topol_dict[mol]
+            for idx, row in atoms_df.iterrows():
+                itp_str += f"{idx:6d} {row['type']:8s} {row['resid']:6d} {row['resname']:8s} {row['name']:8s} {row['charge']:8.4f} {row['mass']:12.4f}\n"
+            itp_str += "\n"
+            
+            # Get interactions for this molecule
+            mol_bonds = self.topol_dict.get_bonds(mol)
+            mol_angles = self.topol_dict.get_angles(mol)
+            mol_dihedrals = self.topol_dict.get_dihedrals(mol)
+            mol_pairs = self.topol_dict.get_pairs(mol)
+            # Write bonds
+            if mol_bonds:
+                itp_str += "[ bonds ]\n"
+                itp_str += ";  ai    aj funct    param1    param2\n"
+                for j in range(len(mol_bonds[0])):
+                    i_idx = mol_bonds[0][j]
+                    j_idx = mol_bonds[1][j]
+                    func = mol_bonds[2][j]
+                    p1 = mol_bonds[3][j]
+                    p2 = mol_bonds[4][j]
+                    itp_str += f"{i_idx:6d} {j_idx:6d} {func:6d} {p1:10.5E} {p2:10.5E}\n"
+                itp_str += "\n"
+            
+            # Write pairs
+            if mol_pairs:
+                itp_str += "[ pairs ]\n"
+                itp_str += ";  ai    aj funct\n"
+                for j in range(len(mol_pairs[0])):
+                    i_idx = mol_pairs[0][j]
+                    j_idx = mol_pairs[1][j]
+                    func = mol_pairs[2][j]
+                    itp_str += f"{i_idx:6d} {j_idx:6d} {func:6d}\n"
+                itp_str += "\n"
+            # Write angles
+            if mol_angles:
+                itp_str += "[ angles ]\n"
+                itp_str += ";  ai    aj    ak funct    param1    param2\n"
+                for j in range(len(mol_angles[0])):
+                    i_idx = mol_angles[0][j]
+                    j_idx = mol_angles[1][j]
+                    k_idx = mol_angles[2][j]
+                    func = mol_angles[3][j]
+                    p1 = mol_angles[4][j]
+                    p2 = mol_angles[5][j]
+                    itp_str += f"{i_idx:6d} {j_idx:6d} {k_idx:6d} {func:6d} {p1:10.5E} {p2:10.5E}\n"
+                itp_str += "\n"
+            
+            # Write dihedrals
+            if mol_dihedrals:
+                # Group dihedrals by function type
+                dihedrals_by_func = {}
+                for j in range(len(mol_dihedrals[0])):
+                    func = mol_dihedrals[4][j]
+                    if func not in dihedrals_by_func:
+                        dihedrals_by_func[func] = []
+                    dihedrals_by_func[func].append(j)
+                
+                # Write each function type in a separate section
+                for func, indices in dihedrals_by_func.items():
+                    itp_str += "[ dihedrals ]\n"
+                    # Write header based on function type
+                    if func in [1, 4, 9]:  # Format 1
+                        itp_str += ";  ai    aj    ak    al funct    phi0       cp     mult\n"
+                    elif func == 2:  # Format 2
+                        itp_str += ";  ai    aj    ak    al funct    param1    param2\n"
+                    elif func == 3:  # Format 3
+                        itp_str += ";  ai    aj    ak    al funct    C0       C1       C2       C3       C4       C5\n"
+                    
+                    for j in indices:
+                        i_idx = mol_dihedrals[0][j]
+                        j_idx = mol_dihedrals[1][j]
+                        k_idx = mol_dihedrals[2][j]
+                        l_idx = mol_dihedrals[3][j]
+                        
+                        if func in [1, 4, 9]:  # Format 1
+                            phi0 = mol_dihedrals[5][j]
+                            cp = mol_dihedrals[6][j]
+                            mult = mol_dihedrals[7][j]
+                            itp_str += f"{i_idx:6d} {j_idx:6d} {k_idx:6d} {l_idx:6d} {func:6d} {phi0:8.1f} {cp:8.2f} {mult:6d}\n"
+                        elif func == 2:  # Format 2
+                            p1 = mol_dihedrals[8][j]
+                            p2 = mol_dihedrals[9][j]
+                            itp_str += f"{i_idx:6d} {j_idx:6d} {k_idx:6d} {l_idx:6d} {func:6d} {p1:8.3f} {p2:10.5E}\n"
+                        elif func == 3:  # Format 3
+                            c0, c1, c2, c3, c4, c5 = [mol_dihedrals[k][j] for k in range(10, 16)]
+                            itp_str += f"{i_idx:6d} {j_idx:6d} {k_idx:6d} {l_idx:6d} {func:6d} {c0:8.5f} {c1:8.5f} {c2:8.5f} {c3:8.5f} {c4:8.5f} {c5:8.5f}\n"
+                    itp_str += "\n"
+            
+            # Write the .itp file
+            with open(itp_file, 'w') as f:
+                f.write(itp_str)
+            
+            # Include the .itp file in the main topology
+            top_str += f'#include "{itp_file}"\n'
+        
+        # Write the main topology file
+        with open(output_file, 'w') as f:
+            f.write(top_str)
+        
+        logging.info(f'Successfully wrote topology to {output_file}')
+        return True
+        
+        

mimicpy/topology/topol_dict.py

@@ -1,6 +1,6 @@
 #
 #    MiMiCPy: Python Based Tools for MiMiC
-#    Copyright (C) 2020-2021 Bharath Raghavan,
+#    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
 #
 #    This file is part of MiMiCPy.
@@ -21,14 +21,21 @@
 
 """Module for MiMiCPy-specific molecule:topology dictionary"""
 
+import logging
+
 
 class TopolDict:
     """provides a dictionary with non-repeating topology information"""
 
     @classmethod
-    def from_dict(cls, dict_df):
+    def from_dict(cls, dict_df, bonds=None, angles=None, dihedrals=None, pairs=None):
         keys = list(dict_df.keys())
         repeating = {}
+        repeating_bonds = {}
+        repeating_angles = {}
+        repeating_dihedrals = {}
+        repeating_pairs = {}
+        
         i = 0
         while i < len(keys):
             key_i = keys[i]
@@ -36,15 +43,209 @@ class TopolDict:
                 key_j = keys[j]
                 if dict_df[key_i].equals(dict_df[key_j]):
                     repeating[key_j] = key_i
+                    if bonds and key_j in bonds:
+                        repeating_bonds[key_j] = key_i
+                    if angles and key_j in angles:
+                        repeating_angles[key_j] = key_i
+                    if dihedrals and key_j in dihedrals:
+                        repeating_dihedrals[key_j] = key_i
+                    if pairs and key_j in pairs:
+                        repeating_pairs[key_j] = key_i
                     del dict_df[key_j]
             i += 1
             keys = list(dict_df.keys())
-        return cls(dict_df, repeating)
+        return cls(dict_df, repeating, bonds, angles, dihedrals, pairs,
+                  repeating_bonds, repeating_angles, repeating_dihedrals, repeating_pairs)
 
-    def __init__(self, dict_df, repeating):
+    def __init__(self, dict_df, repeating, bonds=None, angles=None, dihedrals=None, pairs=None,
+                 repeating_bonds=None, repeating_angles=None, repeating_dihedrals=None, repeating_pairs=None):
         self.dict_df = dict_df
         self.repeating = repeating
+        self.bonds = bonds or {}
+        self.angles = angles or {}
+        self.dihedrals = dihedrals or {}
+        self.pairs = pairs or {}
+        self.repeating_bonds = repeating_bonds or {}
+        self.repeating_angles = repeating_angles or {}
+        self.repeating_dihedrals = repeating_dihedrals or {}
+        self.repeating_pairs = repeating_pairs or {}
+        # Add source file tracking
+        self.source_files = {}
+        self.nrexcl_values = {}  # Store nrexcl values for molecules
+        self.mol_num_atoms = {mol: len(self.dict_df[mol]) for mol in self.dict_df}
+        # Add force field storage
+        self.force_fields = {}  # Store force field parameters by force field name
+        self.parameter_definitions = {}  # Store parameter definitions (#define statements)
+
+    def add_source_file(self, mol_name, source_file):
+        """Add source file information for a molecule
+        
+        Args:
+            mol_name (str): Name of the molecule
+            source_file (str): Path to the source file
+        """
+        self.source_files[mol_name] = source_file
+
+    def get_source_file(self, mol_name):
+        """Get source file for a molecule
+        
+        Args:
+            mol_name (str): Name of the molecule
+            
+        Returns:
+            str: Path to the source file, or None if not found
+        """
+        if mol_name in self.source_files:
+            return self.source_files[mol_name]
+        if mol_name in self.repeating:
+            return self.source_files.get(self.repeating[mol_name])
+        return None
+
+    def add_nrexcl_value(self, mol_name, nrexcl):
+        """Add nrexcl value for a molecule
+        
+        Args:
+            mol_name (str): Name of the molecule
+            nrexcl (int): nrexcl value for the molecule
+        """
+        self.nrexcl_values[mol_name] = nrexcl
+
+    def get_nrexcl_value(self, mol_name):
+        """Get nrexcl value for a molecule
+        
+        Args:
+            mol_name (str): Name of the molecule
+            
+        Returns:
+            int: nrexcl value for the molecule, or 3 if not found (default)
+        """
+        if mol_name in self.nrexcl_values:
+            return self.nrexcl_values[mol_name]
+        if mol_name in self.repeating:
+            return self.nrexcl_values.get(self.repeating[mol_name], 3)
+        return 3  # Default value
+
+    def add_force_field(self, force_field_name, bondtypes=None, angletypes=None, dihedraltypes=None):
+        """Add force field parameters to the topology dictionary
+        
+        Args:
+            force_field_name (str): Name of the force field
+            bondtypes (dict): Bond type parameters
+            angletypes (dict): Angle type parameters  
+            dihedraltypes (dict): Dihedral type parameters
+        """
+        self.force_fields[force_field_name] = {
+            'bondtypes': bondtypes or {},
+            'angletypes': angletypes or {},
+            'dihedraltypes': dihedraltypes or {}
+        }
+
+    def get_force_field(self, force_field_name):
+        """Get force field parameters by name
+        
+        Args:
+            force_field_name (str): Name of the force field
+            
+        Returns:
+            dict: Force field parameters or None if not found
+        """
+        return self.force_fields.get(force_field_name)
+
+    def get_force_field_bondtypes(self, force_field_name):
+        """Get bond types for a specific force field
+        
+        Args:
+            force_field_name (str): Name of the force field
+            
+        Returns:
+            dict: Bond type parameters or empty dict if not found
+        """
+        ff = self.get_force_field(force_field_name)
+        return ff.get('bondtypes', {}) if ff else {}
+
+    def get_force_field_angletypes(self, force_field_name):
+        """Get angle types for a specific force field
+        
+        Args:
+            force_field_name (str): Name of the force field
+            
+        Returns:
+            dict: Angle type parameters or empty dict if not found
+        """
+        ff = self.get_force_field(force_field_name)
+        return ff.get('angletypes', {}) if ff else {}
 
+    def get_force_field_dihedraltypes(self, force_field_name):
+        """Get dihedral types for a specific force field
+        
+        Args:
+            force_field_name (str): Name of the force field
+            
+        Returns:
+            dict: Dihedral type parameters or empty dict if not found
+        """
+        ff = self.get_force_field(force_field_name)
+        return ff.get('dihedraltypes', {}) if ff else {}
+
+    def list_force_fields(self):
+        """Get list of available force fields
+        
+        Returns:
+            list: List of force field names
+        """
+        return list(self.force_fields.keys())
+
+    def add_parameter_definitions(self, parameter_definitions):
+        """Add parameter definitions (#define statements) to the topology dictionary
+        
+        Args:
+            parameter_definitions (dict): Dictionary of parameter definitions
+        """
+        self.parameter_definitions.update(parameter_definitions)
+
+    def get_parameter_definitions(self):
+        """Get all parameter definitions
+        
+        Returns:
+            dict: Dictionary of parameter definitions
+        """
+        return self.parameter_definitions
+
+    def resolve_parameter_reference(self, param_ref):
+        """Resolve a parameter reference to its actual values
+        
+        Args:
+            param_ref (str): Parameter reference name (e.g., 'torsion_ASN_CA_CB_CG_ND2_mult1')
+            
+        Returns:
+            list: List of parameter values or None if not found
+        """
+        if param_ref in self.parameter_definitions:
+            param_str = self.parameter_definitions[param_ref]
+            try:
+                # Remove comments and parse the parameter values (e.g., "0.0 -4.376464 1")
+                # Split by semicolon and take only the first part
+                clean_param_str = param_str.split(';')[0].strip()
+                values = [float(x) for x in clean_param_str.split()]
+                return values
+            except ValueError:
+                logging.warning(f'Could not parse parameter definition for {param_ref}: {param_str}')
+                return None
+        return None
+
+    def get_num_atoms(self, mol_name):
+        """Get the number of atoms in a molecule
+        
+        Args:
+            mol_name (str): Name of the molecule
+            
+        Returns:
+            int: Number of atoms in the molecule
+        """
+        if mol_name not in self.mol_num_atoms:
+            raise KeyError('Molecule {} is not in topology'.format(mol_name))
+        return self.mol_num_atoms[mol_name]
+    
     def __getitem__(self, key):
         if key in self.dict_df:
             return self.dict_df[key]
@@ -52,6 +253,34 @@ class TopolDict:
             return self.dict_df[self.repeating[key]]
         raise KeyError('Molecule {} is not in topology'.format(key))
 
+    def get_bonds(self, key):
+        if key in self.bonds:
+            return self.bonds[key]
+        if key in self.repeating_bonds:
+            return self.bonds[self.repeating_bonds[key]]
+        return None
+
+    def get_angles(self, key):
+        if key in self.angles:
+            return self.angles[key]
+        if key in self.repeating_angles:
+            return self.angles[self.repeating_angles[key]]
+        return None
+
+    def get_dihedrals(self, key):
+        if key in self.dihedrals:
+            return self.dihedrals[key]
+        if key in self.repeating_dihedrals:
+            return self.dihedrals[self.repeating_dihedrals[key]]
+        return None
+
+    def get_pairs(self, key):
+        if key in self.pairs:
+            return self.pairs[key]
+        if key in self.repeating_pairs:
+            return self.pairs[self.repeating_pairs[key]]
+        return None
+
     def __contains__(self, key):
         return key in self.dict_df or key in self.repeating
 

mimicpy/utils/__init__.py

@@ -1,6 +1,6 @@
 #
 #    MiMiCPy: Python Based Tools for MiMiC
-#    Copyright (C) 2020-2021 Bharath Raghavan,
+#    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
 #
 #    This file is part of MiMiCPy.

mimicpy/utils/atomic_numbers.py

@@ -1,6 +1,6 @@
 #
 #    MiMiCPy: Python Based Tools for MiMiC
-#    Copyright (C) 2020-2021 Bharath Raghavan,
+#    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
 #
 #    This file is part of MiMiCPy.

mimicpy/utils/constants.py

@@ -1,6 +1,6 @@
 #
 #    MiMiCPy: Python Based Tools for MiMiC
-#    Copyright (C) 2020-2021 Bharath Raghavan,
+#    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
 #
 #    This file is part of MiMiCPy.
@@ -19,5 +19,19 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-BOHR_RADIUS = 0.0529177210903  # in nm
-ATOMIC_TIME_UNIT = 2.4188843265857E-5  # in ps
+
+BOHR_RADIUS = 5.29177210859e-02  # in nm
+ATOMIC_TIME_UNIT = 2.4188843265864E-5  # in ps
+
+au_kjm=2.62549962505e+3
+kjm_au = 1 / au_kjm
+
+au_to_nm = BOHR_RADIUS
+nm_to_au = 1 / au_to_nm
+au_to_kjmolnm = au_kjm / au_to_nm
+kjmolnm_to_au = 1 / au_to_kjmolnm
+kb_gmx2au = kjm_au / nm_to_au**2
+kb_au2gmx = 1/ kb_gmx2au
+kb_g962au = kjm_au / nm_to_au**4
+kb_au2g96 = 1/ kb_g962au
+electric_conversion_factor = 138.935458