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

mimicpy/topology/itp.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.
@@ -33,7 +33,7 @@ from ..utils.errors import MiMiCPyError, ParserError
 class Itp:
     """reads itp files"""
 
-    columns = ['number', 'type', 'resid', 'resname', 'name', 'charge', 'element', 'mass']
+    columns = ['number', 'type', 'resid', 'resname', 'name', 'cgnr', 'charge', 'element', 'mass']
 
     def __init__(self,
                  file,
@@ -42,7 +42,8 @@ class Itp:
                  buffer=1000,
                  mode='r',
                  guess_elements=True,
-                 gmxdata=''):
+                 gmxdata='',
+                 parameter_definitions=None):
 
         self.file = file
         self.requested_molecules = requested_molecules
@@ -51,8 +52,12 @@ class Itp:
         self.mode = mode
         self.guess_elements = guess_elements
         self.gmxdata = gmxdata
+        self.external_parameter_definitions = parameter_definitions
         self._topol = None
         self._bonds = None
+        self._angles = None
+        self._dihedrals = None
+        self._pairs = None
         self._topology_files = None
         self._molecules = None
         self._molecule_types = None
@@ -111,6 +116,74 @@ class Itp:
         self.__read()
         return self._bonds
 
+    @property
+    def angles(self):
+        if self.mode == 'r':
+            return self._angles
+        self.mode = 'r'
+        self.__read()
+        return self._angles
+
+    @property
+    def dihedrals(self):
+        if self.mode == 'r':
+            return self._dihedrals
+        self.mode = 'r'
+        self.__read()
+        return self._dihedrals
+
+    @property
+    def pairs(self):
+        if self.mode == 'r':
+            return self._pairs
+        self.mode = 'r'
+        self.__read()
+
+    @property
+    def nrexcl_values(self):
+        """Get nrexcl values for molecules in this ITP file"""
+        if self.mode == 'r':
+            return getattr(self, '_nrexcl_values', {})
+        self.mode = 'r'
+        self.__read()
+        return getattr(self, '_nrexcl_values', {})
+
+    @property
+    def bondtypes(self):
+        """Get bond types from force field sections"""
+        if self.mode == 'r':
+            return getattr(self, '_bondtypes', {})
+        self.mode = 'r'
+        self.__read()
+        return getattr(self, '_bondtypes', {})
+
+    @property
+    def angletypes(self):
+        """Get angle types from force field sections"""
+        if self.mode == 'r':
+            return getattr(self, '_angletypes', {})
+        self.mode = 'r'
+        self.__read()
+        return getattr(self, '_angletypes', {})
+
+    @property
+    def dihedraltypes(self):
+        """Get dihedral types from force field sections"""
+        if self.mode == 'r':
+            return getattr(self, '_dihedraltypes', {})
+        self.mode = 'r'
+        self.__read()
+        return getattr(self, '_dihedraltypes', {})
+
+    @property
+    def parameter_definitions(self):
+        """Get parameter definitions (#define statements) from force field sections"""
+        if self.mode == 'r':
+            return getattr(self, '_parameter_definitions', {})
+        self.mode = 'r'
+        self.__read()
+        return getattr(self, '_parameter_definitions', {})
+
     @staticmethod
     def __get_molecules(topology):
         molecules = []
@@ -129,13 +202,33 @@ class Itp:
 
     @staticmethod
     def __get_section(section, string):
-        # Clean string - or not?
-        # Find text b/w [ section ] and either [ or EOF
-        # Look for [ section ] / look for lines / look for optional spaces and [
-        # string = clean(string, comments)
-        section_regex = re.compile(r"\[\s*"+str(section)+"\s*\]\s*\n((?:.+\n)+?)\s*(?:$|\[)", re.MULTILINE)
+        # Find all sections of the given type
+        # Use re.escape to handle special characters like '+' in section names
+        # Use a flexible regex to handle comments and empty lines
+        section_regex = re.compile(
+            r"\[\s*" + re.escape(str(section)) + r"\s*\]\s*\n((?:.*?)(?=\n\s*\[|\Z))",
+            re.DOTALL | re.MULTILINE
+        )
         section_list = section_regex.findall(string)
-        return section_list
+        
+        # Filter out lines that are directives or not part of the section content
+        filtered_sections = []
+        for section_content in section_list:
+            # Split into lines and filter out directives and empty lines
+            lines = section_content.split('\n')
+            filtered_lines = []
+            for line in lines:
+                line = line.strip()
+                # Skip empty lines, comments, and directives
+                if (line and 
+                    not line.startswith(';') and 
+                    not line.startswith('#') and
+                    not line.startswith('#include')):
+                    filtered_lines.append(line)
+            if filtered_lines:
+                filtered_sections.append('\n'.join(filtered_lines))
+        
+        return filtered_sections
 
     @staticmethod
     def __parse_block_till_section(itp, *sections):
@@ -193,15 +286,20 @@ class Itp:
         atm_types_section_dct = {k:[] for k in cols}
         for line in atomtypes_section.splitlines():
             line_split = line.split()
-            if len(line_split) not in [6, 7]:
+            if len(line_split) not in [6, 7, 8]:
                 raise ParserError(self.file, 'GROMACS topology',
                         details='following line in [ atomtypes ] section not formatted properly: {}'.format(line))
+            
+            if len(line_split) == 8:
+                # assume line is of format: name  bond_type  atom_no  mass    charge   ptype          sigma      epsilon
+                line_split = line_split[:1] + line_split[2:] # second value is bond type, ignore it
+                    
             if len(line_split) == 6:
                 line_split.insert(1, 'X')
 
             for i, col in enumerate(cols):
                 atm_types_section_dct[col].append(float(line_split[i]) if col in float_cols else line_split[i])
-
+        
         self.atom_types_df = pd.DataFrame(atm_types_section_dct)
         df = self.atom_types_df.copy()
 
@@ -227,9 +325,10 @@ class Itp:
         itp_file = Parser(self.file, self.buffer)
         itp_text = ''
         while not itp_file.is_closed:
-            block = Itp.__parse_block_till_section(itp_file, 'moleculetype', 'atoms', 'bonds')
-            if any([Itp.__section_is_in_string(section, block) for section in ['moleculetype', 'atoms', 'bonds']]):
-                itp_text += block
+            chunk = next(itp_file, '')
+            if chunk == '':
+                break
+            itp_text += chunk
         return itp_text
 
     def __guess_element_from(self, mass, name, atom_type):
@@ -259,12 +358,24 @@ class Itp:
         atom_info = {k:[] for k in cols}
         number_of_bad_lines = 0
         for i, line in enumerate(atom_section.splitlines()):
+            line = line.split(';', 1)[0].strip()  # Remove comments
+            if not line:
+                continue
             line = line.split()
-            if len(line) == 8:
-                number, atom_type, resid, resname, name, _, charge, mass = line[:8]
+            if len(line) == 8 or len(line) == 11: # Full format with cgnr; len 11 for perturbed molecule in a free energy perturbation calculation (see issue 57)
+                number, atom_type, resid, resname, name, cgnr, charge, mass = line[:8]
             elif len(line) == 7:
-                number, atom_type, resid, resname, name, _, charge = line[:7]
-                mass = 0
+                # Check if the last field looks like a mass (numeric) or charge (numeric)
+                # If both charge and mass are numeric, assume mass is included
+                try:
+                    # If both are numeric, assume format: number, type, resid, resname, name, charge, mass
+                    number, atom_type, resid, resname, name, charge, mass = line[:7]
+                    cgnr = number  # Use atom number as cgnr if not provided
+                except ValueError:
+                    # If mass is not numeric, assume format: number, type, resid, resname, name, charge, _
+                    number, atom_type, resid, resname, name, charge, _ = line[:7]
+                    mass = 0.0
+                    cgnr = number  # Use atom number as cgnr if not provided
             else:
                 if number_of_bad_lines > 5:
                     raise ParserError(self.file, 'GROMACS topology',
@@ -274,6 +385,7 @@ class Itp:
                 continue
             number = int(number)
             resid = int(resid)
+            cgnr = int(cgnr)
             charge = float(charge)
             mass = float(mass)
             if self.atom_types_dict is not None and atom_type in self.atom_types_dict:
@@ -288,59 +400,515 @@ class Itp:
             atom_info[cols[2]].append(resid)
             atom_info[cols[3]].append(resname)
             atom_info[cols[4]].append(name)
-            atom_info[cols[5]].append(charge)
-            atom_info[cols[6]].append(element)
-            atom_info[cols[7]].append(mass)
+            atom_info[cols[5]].append(cgnr)
+            atom_info[cols[6]].append(charge)
+            atom_info[cols[7]].append(element)
+            atom_info[cols[8]].append(mass)
         atoms = pd.DataFrame(atom_info).set_index(cols[0])
         return atoms
     
     @staticmethod
     def __read_bonds(bonds_section):
-        cols = ['atom_i', 'atom_j']
+        cols = ['atom_i', 'atom_j', 'func', 'param1', 'param2']
         bonds_section_dct = {k:[] for k in cols}
         for line in bonds_section.splitlines():
             line_split = line.split()
-            for i, col in enumerate(cols):
-                if line_split != []:
-                    bonds_section_dct[col].append(int(line_split[i]))
-        return (bonds_section_dct[cols[0]], bonds_section_dct[cols[1]])
+            if line_split != []:
+                # First 3 columns are always present (2 indices + func)
+                for i in range(3):
+                    bonds_section_dct[cols[i]].append(int(line_split[i]))
+                
+                # Handle parameters
+                for i in range(3, len(cols)):
+                    bonds_section_dct[cols[i]].append(float(line_split[i]) if i < len(line_split) else None)
+        
+        return (bonds_section_dct[cols[0]], bonds_section_dct[cols[1]], 
+                bonds_section_dct[cols[2]], bonds_section_dct[cols[3]], bonds_section_dct[cols[4]])
     
+
     @staticmethod
-    def __get_molecules_with_bond_section(string):
-        section_regex = re.compile(r"\[\s*moleculetype\s*\]\s*\n((?:.+\n)+?)\s*\[\s*bonds\s*\]", re.MULTILINE)
+    def __read_angles(angles_section):
+        cols = ['atom_i', 'atom_j', 'atom_k', 'func', 'param1', 'param2']
+        angles_section_dct = {k:[] for k in cols}
+        for line in angles_section.splitlines():
+            line_split = line.split()
+            if line_split != []:
+                # First 4 columns are always present (3 indices + func)
+                for i in range(4):
+                    angles_section_dct[cols[i]].append(int(line_split[i]))
+                
+                # Handle parameters
+                for i in range(4, len(cols)):
+                    angles_section_dct[cols[i]].append(float(line_split[i]) if i < len(line_split) else None)
+        
+        return (angles_section_dct[cols[0]], angles_section_dct[cols[1]], angles_section_dct[cols[2]],
+                angles_section_dct[cols[3]], angles_section_dct[cols[4]], angles_section_dct[cols[5]])
+
+    @staticmethod
+    def __read_dihedrals(dihedrals_section, parameter_definitions=None):
+        """Read dihedrals from a section, handling parameter references
+        
+        Args:
+            dihedrals_section (str): Content of [ dihedrals ] section
+            parameter_definitions (dict, optional): Dictionary of #define statements
+            
+        Returns:
+            tuple: Dihedral data in the same format as before
+        """
+        # Handle all three dihedral formats:
+        # Format 1: ai aj ak al func phi0 cp mult (func can be 1, 4, or 9)
+        # Format 2: ai aj ak al func param1 param2
+        # Format 3: ai aj ak al func C0 C1 C2 C3 C4 C5
+        cols = ['atom_i', 'atom_j', 'atom_k', 'atom_l', 'func']
+        dihedrals_section_dct = {k:[] for k in cols}
+        
+        # Initialize parameter lists
+        phi0 = []  # Format 1, 4, 9
+        cp = []    # Format 1, 4, 9
+        mult = []  # Format 1, 4, 9
+        param1 = []  # Format 2
+        param2 = []  # Format 2
+        C0 = []    # Format 3
+        C1 = []    # Format 3
+        C2 = []    # Format 3
+        C3 = []    # Format 3
+        C4 = []    # Format 3
+        C5 = []    # Format 3
+        
+        def add_none_params():
+            """Helper function to add None for all parameters"""
+            phi0.append(None)
+            cp.append(None)
+            mult.append(None)
+            param1.append(None)
+            param2.append(None)
+            C0.append(None)
+            C1.append(None)
+            C2.append(None)
+            C3.append(None)
+            C4.append(None)
+            C5.append(None)
+        
+        for line in dihedrals_section.splitlines():
+            line = line.strip()
+            if line and not line.startswith(';'):
+                parts = line.split()
+                if len(parts) >= 5:
+                    # First 5 columns are always present (4 indices + func)
+                    for i in range(5):
+                        dihedrals_section_dct[cols[i]].append(int(parts[i]) if i < len(parts) else None)
+                    
+                    func_type = int(parts[4])
+                    
+                    # Handle parameters
+                    if len(parts) > 5:
+                        # Check if the 6th part is a parameter reference (contains letters)
+                        is_parameter_reference = (parameter_definitions and 
+                                                len(parts) >= 6 and 
+                                                any(c.isalpha() for c in parts[5]))
+                        
+                        if is_parameter_reference:
+                            # Handle parameter reference
+                            param_ref = parts[5]
+                            if param_ref in parameter_definitions:
+                                param_values = parameter_definitions[param_ref].split()
+                                if len(param_values) >= 3:
+                                    # Format: phi0 cp mult
+                                    phi0.append(float(param_values[0]))
+                                    cp.append(float(param_values[1]))
+                                    mult.append(int(param_values[2]))
+                                    # Add None for other parameters
+                                    param1.append(None)
+                                    param2.append(None)
+                                    C0.extend([None] * 6)
+                                    C1.extend([None] * 6)
+                                    C2.extend([None] * 6)
+                                    C3.extend([None] * 6)
+                                    C4.extend([None] * 6)
+                                    C5.extend([None] * 6)
+                                else:
+                                    add_none_params()
+                            else:
+                                add_none_params()
+                        else:
+                            # Standard format handling
+                            if func_type in [1, 4, 9]:  # Format 1
+                                phi0.append(float(parts[5]) if len(parts) > 5 else None)
+                                cp.append(float(parts[6]) if len(parts) > 6 else None)
+                                mult.append(int(parts[7]) if len(parts) > 7 else None)
+                                param1.append(None)
+                                param2.append(None)
+                                C0.extend([None] * 6)
+                                C1.extend([None] * 6)
+                                C2.extend([None] * 6)
+                                C3.extend([None] * 6)
+                                C4.extend([None] * 6)
+                                C5.extend([None] * 6)
+                            elif func_type == 2:  # Format 2
+                                param1.append(float(parts[5]) if len(parts) > 5 else None)
+                                param2.append(float(parts[6]) if len(parts) > 6 else None)
+                                phi0.append(None)
+                                cp.append(None)
+                                mult.append(None)
+                                C0.extend([None] * 6)
+                                C1.extend([None] * 6)
+                                C2.extend([None] * 6)
+                                C3.extend([None] * 6)
+                                C4.extend([None] * 6)
+                                C5.extend([None] * 6)
+                            elif func_type == 3:  # Format 3
+                                C0.append(float(parts[5]) if len(parts) > 5 else None)
+                                C1.append(float(parts[6]) if len(parts) > 6 else None)
+                                C2.append(float(parts[7]) if len(parts) > 7 else None)
+                                C3.append(float(parts[8]) if len(parts) > 8 else None)
+                                C4.append(float(parts[9]) if len(parts) > 9 else None)
+                                C5.append(float(parts[10]) if len(parts) > 10 else None)
+                                phi0.append(None)
+                                cp.append(None)
+                                mult.append(None)
+                                param1.append(None)
+                                param2.append(None)
+                    else:
+                        # No parameters provided
+                        add_none_params()
+        
+        # Return all parameters in a structured way
+        return (dihedrals_section_dct[cols[0]], dihedrals_section_dct[cols[1]], 
+                dihedrals_section_dct[cols[2]], dihedrals_section_dct[cols[3]],
+                dihedrals_section_dct[cols[4]],  # func
+                phi0,  # Format 1
+                cp,
+                mult,
+                param1,  # Format 2
+                param2,
+                C0,  # Format 3
+                C1,
+                C2,
+                C3,
+                C4,
+                C5)
+    
+    @staticmethod
+    def __get_molecules_with_interaction_section(string, interaction_type):
+        # Find all moleculetype sections and their following interaction sections
+        section_regex = re.compile(r"\[\s*moleculetype\s*\]\s*\n((?:.+\n)+?)\s*\[\s*" + interaction_type + r"\s*\]", re.MULTILINE)
         section_list = section_regex.findall(string)
+        
+        # If no sections found, try to find just the interaction sections
+        if not section_list:
+            section_regex = re.compile(r"\[\s*" + interaction_type + r"\s*\]", re.MULTILINE)
+            section_list = section_regex.findall(string)
+            
         return section_list
 
+    @staticmethod
+    def __read_pairs(pairs_section):
+        cols = ['atom_i', 'atom_j', 'func']
+        pairs_section_dct = {k:[] for k in cols}
+        for line in pairs_section.splitlines():
+            line_split = line.split()
+            if line_split != []:
+                # First 3 columns are always present (2 indices + func)
+                for i in range(3):
+                    pairs_section_dct[cols[i]].append(int(line_split[i]))
+        
+        return (pairs_section_dct[cols[0]], pairs_section_dct[cols[1]], 
+                pairs_section_dct[cols[2]])
+
+    @staticmethod
+    def __read_bondtypes(bondtypes_section):
+        """Read bond types from force field section
+        
+        Args:
+            bondtypes_section (str): Content of [ bondtypes ] section
+            
+        Returns:
+            dict: Dictionary of bond type parameters keyed by atom type pairs
+        """
+        bondtypes = {}
+        for line in bondtypes_section.splitlines():
+            line = line.strip()
+            if line and not line.startswith(';'):
+                parts = line.split()
+                if len(parts) >= 5:
+                    atom1, atom2 = parts[0], parts[1]
+                    func = int(parts[2])
+                    param1 = float(parts[3])  # bond length
+                    param2 = float(parts[4])  # force constant
+                    key = f"{atom1}-{atom2}"
+                    bondtypes[key] = {
+                        'function': func,
+                        'length': param1,
+                        'force_constant': param2
+                    }
+        return bondtypes
+
+    @staticmethod
+    def __read_angletypes(angletypes_section):
+        """Read angle types from force field section
+        
+        Args:
+            angletypes_section (str): Content of [ angletypes ] section
+            
+        Returns:
+            dict: Dictionary of angle type parameters keyed by atom type triplets
+        """
+        angletypes = {}
+        for line in angletypes_section.splitlines():
+            line = line.strip()
+            if line and not line.startswith(';'):
+                parts = line.split()
+                if len(parts) >= 6:
+                    atom1, atom2, atom3 = parts[0], parts[1], parts[2]
+                    func = int(parts[3])
+                    param1 = float(parts[4])  # angle value
+                    param2 = float(parts[5])  # force constant
+                    key = f"{atom1}-{atom2}-{atom3}"
+                    angletypes[key] = {
+                        'function': func,
+                        'angle': param1,
+                        'force_constant': param2
+                    }
+        return angletypes
+
+    @staticmethod
+    def __read_dihedraltypes(dihedraltypes_section):
+        """Read dihedral types from force field section
+        
+        Args:
+            dihedraltypes_section (str): Content of [ dihedraltypes ] section
+            
+        Returns:
+            dict: Dictionary of dihedral type parameters keyed by atom type quartets
+        """
+        dihedraltypes = {}
+        for line in dihedraltypes_section.splitlines():
+            line = line.strip()
+            if line and not line.startswith(';'):
+                parts = line.split()
+                if len(parts) >= 5:
+                    atom1, atom2, atom3, atom4 = parts[0], parts[1], parts[2], parts[3]
+                    func = int(parts[4])
+                    key = f"{atom1}-{atom2}-{atom3}-{atom4}"
+                    
+                    if func in [1, 4, 9]:  # Format 1
+                        if len(parts) >= 8:
+                            param1 = float(parts[5])  # phi0
+                            param2 = float(parts[6])  # cp (force constant)
+                            param3 = int(parts[7])    # mult
+                            dihedraltypes[key] = {
+                                'function': func,
+                                'phi0': param1,
+                                'cp': param2,
+                                'mult': param3
+                            }
+                    elif func == 2:  # Format 2
+                        if len(parts) >= 7:
+                            param1 = float(parts[5])  # param1
+                            param2 = float(parts[6])  # param2 (force constant)
+                            dihedraltypes[key] = {
+                                'function': func,
+                                'param1': param1,
+                                'param2': param2
+                            }
+                    elif func == 3:  # Format 3
+                        if len(parts) >= 11:
+                            params = [float(parts[i]) for i in range(5, 11)]  # C0-C5
+                            dihedraltypes[key] = {
+                                'function': func,
+                                'params': params
+                            }
+        return dihedraltypes
+
+    @staticmethod
+    def __read_parameter_definitions(string):
+        """Read #define statements from a string.
+        
+        Args:
+            string (str): The string to search for #define statements.
+            
+        Returns:
+            dict: A dictionary of #define statements keyed by their name.
+        """
+        define_regex = re.compile(r"#define\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+(.*)", re.MULTILINE)
+        definitions = {}
+        for match in define_regex.finditer(string):
+            name = match.group(1)
+            value = match.group(2)
+            definitions[name] = value
+        return definitions
+
     def __read(self):
         itp_text = self.__load_molecules_and_atoms()
         clean_itp_text = clean(itp_text,  comments=[';', '#'])
         molecule_section = Itp.__get_section('moleculetype', clean_itp_text)
         atom_section = Itp.__get_section('atoms', clean_itp_text)
         
+        # Read force field sections from current file
+        bondtypes_section = Itp.__get_section('bondtypes', clean_itp_text)
+        angletypes_section = Itp.__get_section('angletypes', clean_itp_text)
+        dihedraltypes_section = Itp.__get_section('dihedraltypes', clean_itp_text)
+        
+        # Store force field data
+        self._bondtypes = {}
+        self._angletypes = {}
+        self._dihedraltypes = {}
+        self._parameter_definitions = {}  # Store #define statements
+        
+        # Read force field sections from current file
+        if bondtypes_section:
+            for section in bondtypes_section:
+                self._bondtypes.update(Itp.__read_bondtypes(section))
+        
+        if angletypes_section:
+            for section in angletypes_section:
+                self._angletypes.update(Itp.__read_angletypes(section))
+        
+        if dihedraltypes_section:
+            for section in dihedraltypes_section:
+                self._dihedraltypes.update(Itp.__read_dihedraltypes(section))
+        
+        # Read parameter definitions (#define statements) from current file and included files
+        # First, read from the original file content before cleaning
+        original_content = self.__load_molecules_and_atoms()
+        self._parameter_definitions = Itp.__read_parameter_definitions(original_content)
+        
+        # Also read force field sections from included files
+        included_itps = self.__get_included_topology_files(original_content)
+        for included_itp in included_itps:
+            try:
+                # Read the included file content
+                with open(included_itp, 'r') as f:
+                    included_content = f.read()
+                
+                # Clean the included file content
+                clean_included_content = clean(included_content, comments=[';', '#'])
+                
+                # Read force field sections from included file
+                included_bondtypes = Itp.__get_section('bondtypes', clean_included_content)
+                included_angletypes = Itp.__get_section('angletypes', clean_included_content)
+                included_dihedraltypes = Itp.__get_section('dihedraltypes', clean_included_content)
+                
+                # Add force field data from included file
+                if included_bondtypes:
+                    for section in included_bondtypes:
+                        self._bondtypes.update(Itp.__read_bondtypes(section))
+                
+                if included_angletypes:
+                    for section in included_angletypes:
+                        self._angletypes.update(Itp.__read_angletypes(section))
+                
+                if included_dihedraltypes:
+                    for section in included_dihedraltypes:
+                        self._dihedraltypes.update(Itp.__read_dihedraltypes(section))
+                        
+            except OSError:
+                pass  # Skip if file not found
+        
+        # Also read parameter definitions from included files
+        included_itps = self.__get_included_topology_files(original_content)
+        for included_itp in included_itps:
+            try:
+                # Read the included file content
+                with open(included_itp, 'r') as f:
+                    included_content = f.read()
+                # Extract parameter definitions from included file
+                included_definitions = Itp.__read_parameter_definitions(included_content)
+                self._parameter_definitions.update(included_definitions)
+            except OSError:
+                pass  # Skip if file not found
+        
+        # If external parameter definitions are provided, merge them
+        if self.external_parameter_definitions:
+            self._parameter_definitions.update(self.external_parameter_definitions)
+        
         if molecule_section == [] and atom_section == []:
             return None
         molecules = []
         atom_infos = []
-        
+        nrexcl_values = {}  # Store nrexcl values for each molecule
         for molecule, atoms in zip(molecule_section, atom_section):
             mol = molecule.split()[0]
             if self.requested_molecules is not None and mol not in self.requested_molecules:
                 continue
             molecules.append(mol)
             atom_infos.append(self.__read_atoms(atoms))
+            
+            # Extract nrexcl value from moleculetype section
+            parts = molecule.split()
+            if len(parts) >= 2:
+                try:
+                    nrexcl_values[mol] = int(parts[1])
+                except ValueError:
+                    nrexcl_values[mol] = 3  # Default value if parsing fails
+                    logging.warning(f'Could not parse nrexcl value for molecule {mol}, using default value 3')
         self._topol = dict(zip(molecules, atom_infos))
+        self._nrexcl_values = nrexcl_values  # Store nrexcl values
         
-        molecule_section = Itp.__get_molecules_with_bond_section(clean_itp_text) # get molecules with bonds section
+        # Read bonds
+        molecule_section = Itp.__get_molecules_with_interaction_section(clean_itp_text, 'bonds')
         bond_section = Itp.__get_section('bonds', clean_itp_text)
         bond_infos = []
-
         for molecule, bonds in zip(molecule_section, bond_section):
             mol = molecule.split()[0]
             if self.requested_molecules is not None and mol not in self.requested_molecules:
                 continue
-            molecules.append(mol)
             bond_infos.append(Itp.__read_bonds(bonds))
-        
         self._bonds = dict(zip(molecules, bond_infos))
-    #
-    ###
+
+        # Read angles
+        molecule_section = Itp.__get_molecules_with_interaction_section(clean_itp_text, 'angles')
+        angle_section = Itp.__get_section('angles', clean_itp_text)
+        angle_infos = []
+        for molecule, angles in zip(molecule_section, angle_section):
+            mol = molecule.split()[0]
+            if self.requested_molecules is not None and mol not in self.requested_molecules:
+                continue
+            angle_infos.append(Itp.__read_angles(angles))
+        self._angles = dict(zip(molecules, angle_infos))
+
+        # Read dihedrals - correctly handle multiple molecules with multiple dihedral sections
+        dihedral_infos = []
+        for mol in molecules:
+            if self.requested_molecules is not None and mol not in self.requested_molecules:
+                continue
+            
+            # Get all dihedral sections from the file
+            all_dihedral_sections = Itp.__get_section('dihedrals', clean_itp_text)
+            
+            # For now, use a simple approach: assign dihedral sections based on their order
+            # This assumes that dihedral sections appear in the same order as molecules
+            mol_index = molecules.index(mol)
+            
+            # Each molecule typically has 2 dihedral sections (propers and impropers)
+            # So we need to get sections 2*mol_index and 2*mol_index + 1
+            mol_dihedral_sections = []
+            start_idx = 2 * mol_index
+            end_idx = start_idx + 2
+            
+            for i in range(start_idx, min(end_idx, len(all_dihedral_sections))):
+                mol_dihedral_sections.append(all_dihedral_sections[i])
+            
+            # Combine all dihedral sections for this molecule
+            if mol_dihedral_sections:
+                combined_dihedrals = '\n'.join(mol_dihedral_sections)
+                dihedral_infos.append(Itp.__read_dihedrals(combined_dihedrals, self._parameter_definitions))
+            else:
+                dihedral_infos.append(None)
+        
+        self._dihedrals = dict(zip(molecules, dihedral_infos))
+        # Read pairs
+        molecule_section = Itp.__get_molecules_with_interaction_section(clean_itp_text, 'pairs')
+        pairs_section = Itp.__get_section('pairs', clean_itp_text)
+        pairs_infos = []
+        for molecule, pairs in zip(molecule_section, pairs_section):
+            mol = molecule.split()[0]
+            if self.requested_molecules is not None and mol not in self.requested_molecules:
+                continue
+            pairs_infos.append(Itp.__read_pairs(pairs))
+        self._pairs = dict(zip(molecules, pairs_infos))
+
+        # Store source file information for each molecule
+        if hasattr(self, '_topol') and self._topol is not None:
+            for mol in molecules:
+                self._topol[mol].source_file = self.file