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

mimicpy/plugins/__main_installer__.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+#
+#    MiMiCPy: Python Based Tools for MiMiC
+#    Copyright (C) 2020-2023 Bharath Raghavan,
+#                            Florian Schackert
+#
+#    This file is part of MiMiCPy.
+#
+#    MiMiCPy is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as
+#    published by the Free Software Foundation, either version 3 of
+#    the License, or (at your option) any later version.
+#
+#    MiMiCPy is distributed in the hope that it will be useful, but
+#    WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from os import path
+import sys
+import platform
+from shutil import copyfileobj
+import argparse
+
+def copy_script(source_script, dest):
+    # assume the plugin scripts are in the same directory as this script
+    source = path.join(path.dirname(path.realpath(__file__)), source_script)
+    if not path.isfile(source):
+        print("Cannot find plugin file {}".format(source))
+        sys.exit(1)
+    else:
+        with open(source, 'r') as fsrc, open(dest, 'a') as fdest:
+            copyfileobj(fsrc, fdest)
+                
+def main():
+    print("Program to install the PrepQM plugins bundled with MiMiCPy")
+    parser = argparse.ArgumentParser(prog='mimicpy_plugin_installer')
+    parser.add_argument('-vmddir', help='path to the PrepQM VMD plugin directory')
+    parser.add_argument('-pymoldir', help='path to the PrepQM PyMOL plugin directory')
+    args = parser.parse_args()
+    
+    pymol_dir = args.pymoldir
+    vmd_dir = args.vmddir
+    
+    if pymol_dir:
+        if platform.system() == 'Windows':
+            pymolrc = path.join(pymol_dir, 'pymolrc.py')
+        else:
+            pymolrc = path.join(pymol_dir, '.pymolrc.py')
+        
+        copy_script('pymol.py', pymolrc)
+        print("Wrote the PrepQM PyMOL plugin to {}".format(pymolrc))
+
+    if vmd_dir:
+        if platform.system() == 'Windows':
+            vmdrc = path.join(vmd_dir, 'vmd.rc')
+        else:
+            vmdrc = path.join(vmd_dir, '.vmdrc')
+
+        copy_script('vmd.tcl', vmdrc)
+        print("Wrote the PrepQM VMD plugin to file {}".format(vmdrc))
+    
+    if not pymol_dir and not vmd_dir:
+        print("Error! At least one plugin directory should be specified")
+    
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)

mimicpy/{__main_vmd__.py → plugins/__main_vmd__.py}

@@ -2,7 +2,7 @@
 
 #
 #    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.
@@ -110,7 +110,7 @@ class MockVMDSelector(mimicpy.VMDSelector):
 
 def main():
     if len(sys.argv) < 31:
-        print("This program is intented to be used solely by the VMD plugin\n")
+        print("This program is intended to be used solely by the PrepQM VMD plugin provided as part of MiMiCPy\n")
         sys.exit(1)
 
     top = sys.argv[1]

mimicpy/plugins/pymol.py

@@ -0,0 +1,56 @@
+#
+#    MiMiCPy: Python Based Tools for MiMiC
+#    Copyright (C) 2020-2023 Bharath Raghavan,
+#                            Florian Schackert
+#
+#    This file is part of MiMiCPy.
+#
+#    MiMiCPy is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as
+#    published by the Free Software Foundation, either version 3 of
+#    the License, or (at your option) any later version.
+#
+#    MiMiCPy is distributed in the hope that it will be useful, but
+#    WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import sys
+import mimicpy
+from pymol import cmd
+
+def prepqm(top, selection, bound_selection=None, ndx='index.ndx', out='cpmd.inp', inp=None, 
+           pad=0, abs=False, qma='qmatoms', path=None,  q=None, pp=None, find_bound=False):
+    try:
+        qm = mimicpy.Preparation(mimicpy.PyMOLSelector(top))
+    except FileNotFoundError as e:
+        print('\n\nError: Cannot find file {}! Exiting..\n'.format(e.filename))
+        sys.exit(1)
+    except (mimicpy.utils.errors.ParserError, mimicpy.utils.errors.MiMiCPyError) as e:
+        print(e)
+        sys.exit(1)
+    
+    try:
+        qm.add(selection)
+        
+        if bound_selection != None:
+            qm.add(bound_selection, True)
+        
+        if find_bound:
+            print("Boundary atoms added automatically.")
+            qm.find_bound_atoms()
+            
+        qm.get_mimic_input(inp, ndx, out, pad, abs, qma, path, q, pp)
+    except mimicpy.utils.errors.SelectionError as e:
+        print(e)
+    except FileNotFoundError as e:
+        print('\n\nError: Cannot find file {}! Exiting..\n'.format(e.filename))
+        sys.exit(1)
+
+cmd.extend('prepqm', prepqm)
+
+##################################

mimicpy/plugins/vmd.tcl

@@ -0,0 +1,78 @@
+#
+#    MiMiCPy: Python Based Tools for MiMiC
+#    Copyright (C) 2020-2023 Bharath Raghavan,
+#                            Florian Schackert
+#
+#    This file is part of MiMiCPy.
+#
+#    MiMiCPy is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as
+#    published by the Free Software Foundation, either version 3 of
+#    the License, or (at your option) any later version.
+#
+#    MiMiCPy is distributed in the hope that it will be useful, but
+#    WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+proc prepqm {
+        args
+    } {
+
+    array set options {
+        -sele atomselect0
+        -molid 0
+        -sele_bound None
+        -find_bound False
+        -inp None
+        -out cpmd.inp
+        -ndx index.ndx
+        -top topol.top
+        -q 0
+        -pad 0
+        -pp None
+        -abs False
+        -path None
+        -qma qmatoms
+        }
+
+    array set options $args
+
+    set a [molinfo $options(-molid) get a]
+    set b [molinfo $options(-molid) get b]
+    set c [molinfo $options(-molid) get c]
+    set alpha [molinfo $options(-molid) get alpha]
+    set beta [molinfo $options(-molid) get beta]
+    set gamma [molinfo $options(-molid) get gamma]
+
+    set name [$options(-sele) get name]
+    set index [$options(-sele) get index]
+    set resname [$options(-sele) get resname]
+    set x [$options(-sele) get x]
+    set y [$options(-sele) get y]
+    set z [$options(-sele) get z]
+
+    if {$options(-sele_bound) eq "None"} {
+        set name_ "None"
+        set index_ 0
+        set resname_ "None"
+        set x_ 0
+        set y_ 0
+        set z_ 0
+    } else {
+        set name_ [$options(-sele_bound) get name]
+        set index_ [$options(-sele_bound) get index]
+        set resname_ [$options(-sele_bound) get resname]
+        set x_ [$options(-sele_bound) get x]
+        set y_ [$options(-sele_bound) get y]
+        set z_ [$options(-sele_bound) get z]
+    }
+
+    puts $[exec mimicpy_vmd $options(-top) $options(-inp) $options(-ndx) $options(-out) $options(-molid) $options(-sele_bound) $options(-pad) $options(-abs) $options(-qma) $options(-path) $options(-q) $options(-pp)\
+        $options(-find_bound) $name $index $resname $x $y $z $name_ $index_ $resname_ $x_ $y_ $z_\
+        $a $b $c $alpha $beta $gamma]
+}

mimicpy/scripts/__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/scripts/cpmd.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/scripts/fm_input.py

@@ -0,0 +1,265 @@
+"""Module for force matching input files"""
+
+from .script import Script
+import json
+
+class FMInput(Script):
+    """Formats force matching input files"""
+    
+    def __init__(self, **kwargs):
+        super().__init__()
+        if 'title' not in kwargs:
+            kwargs['title'] = 'Force matching input'
+        
+        # Default values
+        self.eq_atoms = None  # Can be either global or local format
+        self.stride = None
+        self.wv = None
+        self.we = None
+        self.wh = None
+        self.wq = None
+        self.qm_total_charge = None
+        self.reference_charges = None
+        self.num_bonds_away = 2
+        self.skip_solvent_optimization = True
+        self.solvent_resnames = None
+        self.solvent_molecules = None
+        self.fixed_charge_indices = None
+        self.charge_group_constraints = True # Whether to use charge group constraints
+        self.weights_to_fix_charges = 100000.0 # Weight to fix charges
+        # New parameters for bonded optimization control
+        self.optimize_bond_length = True  # Whether to optimize bond lengths
+        self.optimize_bond_force = True   # Whether to optimize bond force constants
+        self.optimize_angle_value = True  # Whether to optimize angle values
+        self.optimize_angle_force = True  # Whether to optimize angle force constants
+        self.optimize_dihedral_force = True  # Whether to optimize dihedral force constants
+        
+        # New parameters for excluded interactions (using atom indices)
+        self.exclude_bonds = None  # List of atom pairs [(atom1, atom2), ...] to exclude from fitting
+        self.exclude_angles = None  # List of atom triplets [(atom1, atom2, atom3), ...] to exclude from fitting
+        self.exclude_dihedrals = None  # List of atom quartets [(atom1, atom2, atom3, atom4), ...] to exclude from fitting
+        # Fine-grained hydrogen exclusion controls
+        self.exclude_hydrogen_bonds = False
+        self.exclude_hydrogen_angles = False
+        self.exclude_hydrogen_dihedrals = False
+        
+        # Regularization parameters
+        self.regularization = True
+        self.regularization_alpha = 0.1  # L2 regularization strength (α)
+        self.regularization_prior_widths = None  # Prior widths for regularization (auto-generated if None)
+        self.regularization_bond_length_width = None  # Prior width for bond lengths
+        self.regularization_bond_force_width = None   # Prior width for bond force constants
+        self.regularization_angle_value_width = None  # Prior width for angle values
+        self.regularization_angle_force_width = None  # Prior width for angle force constants
+        self.regularization_dihedral_force_width = None  # Prior width for dihedral force constants
+        
+        # Optimization method selection
+        self.optimization_method = 'hierarchical'  # 'hierarchical', 'simultaneous'
+        
+        # Energy-weighted optimization parameters
+        self.bond_energy_weight = 1.0      # Weight for bond contributions
+        self.angle_energy_weight = 0.1     # Weight for angle contributions  
+        self.dihedral_energy_weight = 0.01 # Weight for dihedral contributions
+        
+        # Adaptive regularization parameters
+        self.adaptive_base_alpha = 0.1           # Base regularization strength for adaptive method
+        self.energy_hierarchy_scale = 10.0       # Scale factor for energy hierarchy in adaptive method
+        
+        # Update with provided kwargs
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+    
+    def __str__(self):
+        """Convert the input parameters to a string format"""
+        fm_input = f"; Force matching input parameters for {self.title}\n"
+        
+        # Add each parameter if it's not None
+        for param in ['stride', 'wv', 'we', 'wh', 'wq', 'qm_total_charge', 'regularization',
+                     'reference_charges', 'num_bonds_away', 'skip_solvent_optimization', 'solvent_resnames', 'solvent_molecules',
+                     'fixed_charge_indices', 'charge_group_constraints', 'weights_to_fix_charges',
+                     'optimize_bond_length', 'optimize_bond_force',
+                     'optimize_angle_value', 'optimize_angle_force',
+                     'optimize_dihedral_force',
+                     'regularization_alpha',
+                     'exclude_hydrogen_bonds', 'exclude_hydrogen_angles', 'exclude_hydrogen_dihedrals']:
+            value = getattr(self, param)
+            if value is not None:
+                value_str = str(value)
+                fm_input += f"{param}: {value_str}\n"
+        
+        # Add regularization prior widths if specified
+        for param in ['regularization_bond_length_width', 'regularization_bond_force_width',
+                     'regularization_angle_value_width', 'regularization_angle_force_width',
+                     'regularization_dihedral_force_width']:
+            value = getattr(self, param)
+            if value is not None:
+                fm_input += f"{param}: {value}\n"
+        
+        # Add excluded interactions if specified
+        for param in ['exclude_bonds', 'exclude_angles', 'exclude_dihedrals']:
+            value = getattr(self, param)
+            if value is not None:
+                # Convert list of tuples to string representation
+                value_str = str(value).replace('[', '(').replace(']', ')')
+                fm_input += f"{param}: {value_str}\n"
+        
+        # Special handling for eq_atoms
+        if self.eq_atoms is not None:
+            if isinstance(self.eq_atoms, dict):
+                # Handle either global or local format
+                for key, value in self.eq_atoms.items():
+                    if key in ['global', 'local']:
+                        # Convert list of tuples to string representation
+                        value_str = str(value).replace('[', '(').replace(']', ')')
+                        fm_input += f"eq_atoms_{key}: {value_str}\n"
+            else:
+                # Backward compatibility for old format
+                value_str = str(self.eq_atoms).replace('[', '(').replace(']', ')')
+                fm_input += f"eq_atoms: {value_str}\n"
+        
+        return fm_input
+    
+    @classmethod
+    def from_file(cls, filename):
+        """Create an FMInput instance from a file"""
+        with open(filename, 'r') as f:
+            return cls.from_string(f.read())
+    
+    @classmethod
+    def from_string(cls, string):
+        """Create an FMInput instance from a string"""
+        kwargs = {}
+        eq_atoms = {}
+        
+        for line in string.splitlines():
+            line = line.strip()
+            if line.startswith(('!', '#')) or not line:
+                continue
+            
+            if ':' in line:
+                line = line.split('#')[0]  # Remove comments
+                # Split on first colon only
+                key, val = line.split(':', 1)
+                key = key.strip()
+                val = val.strip()
+                
+                # Handle special cases
+                if key == 'eq_atoms':
+                    if val == 'use_atomtypes':
+                        eq_atoms = val
+                elif key == 'eq_atoms_global':
+                    if 'local' in eq_atoms:
+                        raise ValueError("Cannot specify both global and local equivalent atoms")
+                    eq_atoms['global'] = json.loads(val.replace(')', ']').replace('(', '['))
+                elif key == 'eq_atoms_local':
+                    if 'global' in eq_atoms:
+                        raise ValueError("Cannot specify both global and local equivalent atoms")
+                    # Parse local format: "mol_name: [atom_ids]"
+                    mol_name, atom_ids = val.split(':', 1)
+                    mol_name = mol_name.strip()
+                    atom_ids = json.loads(atom_ids.replace(')', ']').replace('(', '['))
+                    eq_atoms['local'] = {mol_name: atom_ids}
+                elif key == 'stride':
+                    val = json.loads(val)
+                elif key in ['wv', 'we', 'wh', 'wq', 'qm_total_charge', 'regularization_alpha', 'num_bonds_away', 'fixed_charge_indices', 'weights_to_fix_charges']:
+                    # Allow lists for wv, we, wh
+                    if val.startswith('[') or val.startswith('('):
+                        val = json.loads(val.replace('(', '[').replace(')', ']'))
+                    else:
+                        val = float(val) if '.' in val else int(val)
+                elif key == 'reference_charges':
+                    if val == 'ff_charges':
+                        val = 'ff_charges'
+                    else:
+                        val = float(val)
+                # Handle boolean parameters for optimization control
+                elif key in ['optimize_bond_length', 'optimize_bond_force',
+                           'optimize_angle_value', 'optimize_angle_force', 'charge_group_constraints', 'regularization',
+                           'optimize_dihedral_force', 'skip_solvent_optimization',
+                           'exclude_hydrogen_bonds', 'exclude_hydrogen_angles', 'exclude_hydrogen_dihedrals']:
+                    val = val.lower()
+                    if val in ('true', 'yes', '1', 't', 'y'):
+                        val = True
+                    elif val in ('false', 'no', '0', 'f', 'n'):
+                        val = False
+                    else:
+                        raise ValueError(f"Invalid boolean value '{val}' for parameter {key}")
+                # Handle regularization prior widths
+                elif key in ['regularization_bond_length_width', 'regularization_bond_force_width',
+                           'regularization_angle_value_width', 'regularization_angle_force_width',
+                           'regularization_dihedral_force_width']:
+                    val = float(val)
+                # Handle excluded interactions (using atom indices)
+                elif key in ['exclude_bonds', 'exclude_angles', 'exclude_dihedrals']:
+                    # Parse list of tuples of atom indices
+                    val = json.loads(val.replace('(', '[').replace(')', ']'))
+                    # Convert to list of tuples
+                    val = [tuple(x) for x in val]
+                elif key in ['optimization_method', 'solvent_resnames', 'solvent_molecules']:
+                    # Keep as string, validation will be done later
+                    val = val.strip()
+                elif key in ['bond_energy_weight', 'angle_energy_weight', 'dihedral_energy_weight',
+                           'adaptive_base_alpha', 'energy_hierarchy_scale']:
+                    val = float(val)
+                
+                if key not in ['eq_atoms', 'eq_atoms_global', 'eq_atoms_local']:
+                    kwargs[key] = val
+        
+        # Add eq_atoms to kwargs if any were found
+        if eq_atoms:
+            kwargs['eq_atoms'] = eq_atoms
+        
+        return cls(**kwargs)
+    
+    def to_dict(self):
+        """Convert the input parameters to a dictionary"""
+        return {
+            'eq_atoms': self.eq_atoms,
+            'stride': self.stride,
+            'wv': self.wv,
+            'we': self.we,
+            'wh': self.wh,
+            'wq': self.wq,
+            'qm_total_charge': self.qm_total_charge,
+            'reference_charges': self.reference_charges,
+            'num_bonds_away': self.num_bonds_away,
+            'skip_solvent_optimization': self.skip_solvent_optimization,
+            'solvent_resnames': self.solvent_resnames,
+            'solvent_molecules': self.solvent_molecules,
+            'fixed_charge_indices': self.fixed_charge_indices,
+            'charge_group_constraints': self.charge_group_constraints,
+            'weights_to_fix_charges': self.weights_to_fix_charges,
+            'optimize_bond_length': self.optimize_bond_length,
+            'optimize_bond_force': self.optimize_bond_force,
+            'optimize_angle_value': self.optimize_angle_value,
+            'optimize_angle_force': self.optimize_angle_force,
+            'optimize_dihedral_force': self.optimize_dihedral_force,
+            'exclude_bonds': self.exclude_bonds,
+            'exclude_angles': self.exclude_angles,
+            'exclude_dihedrals': self.exclude_dihedrals,
+            'regularization': self.regularization,
+            'regularization_alpha': self.regularization_alpha,
+            'regularization_prior_widths': self.regularization_prior_widths,
+            'regularization_bond_length_width': self.regularization_bond_length_width,
+            'regularization_bond_force_width': self.regularization_bond_force_width,
+            'regularization_angle_value_width': self.regularization_angle_value_width,
+            'regularization_angle_force_width': self.regularization_angle_force_width,
+            'regularization_dihedral_force_width': self.regularization_dihedral_force_width,
+            'exclude_hydrogen_bonds': self.exclude_hydrogen_bonds,
+            'exclude_hydrogen_angles': self.exclude_hydrogen_angles,
+            'exclude_hydrogen_dihedrals': self.exclude_hydrogen_dihedrals,
+            'optimization_method': getattr(self, 'optimization_method', 'hierarchical'),
+            'bond_energy_weight': getattr(self, 'bond_energy_weight', 1.0),
+            'angle_energy_weight': getattr(self, 'angle_energy_weight', 0.1),
+            'dihedral_energy_weight': getattr(self, 'dihedral_energy_weight', 0.01),
+            'adaptive_base_alpha': getattr(self, 'adaptive_base_alpha', 0.1),
+            'energy_hierarchy_scale': getattr(self, 'energy_hierarchy_scale', 10.0)
+        }
+    
+    def copy(self):
+        """Create a copy of the FMInput object"""
+        return FMInput(**self.to_dict())
+    
+    def __deepcopy__(self, memo):
+        """Implement deep copy for FMInput objects"""
+        return self.copy() 

mimicpy/scripts/fmdata.py

@@ -0,0 +1,120 @@
+import numpy as np
+import json
+import h5py
+from pathlib import Path
+from .script import Script
+
+class FMDataset(Script): 
+
+    def __init__(self, data_file, h5_file=None) -> None:
+        super().__init__()
+        self.data_file = Path(data_file)
+        self.h5_file = Path(h5_file) if h5_file else self.data_file.with_suffix('.h5')
+        
+        if self.h5_file.exists():
+            self._load_h5()
+        else:
+            self._convert_json_to_h5()
+    
+    def _convert_json_to_h5(self):
+        """Convert JSON data to HDF5 format"""
+        self.fm_data = []
+        
+        with open(self.data_file) as dt:
+            json_str = dt.read()
+
+        # Parse JSON data
+        bracecount = 0
+        jsonobj = ''
+        for jsonstr in json_str:
+            bracecount += jsonstr.count('{')
+            bracecount -= jsonstr.count('}')
+            jsonobj += jsonstr
+            if (bracecount==0 and jsonobj.strip()):
+                config_dict = json.loads(jsonobj)
+                self.fm_data.append(config_dict)
+                jsonobj = ''
+        
+        # Convert to HDF5
+        with h5py.File(self.h5_file, 'w') as f:
+            # Create groups for each configuration
+            for i, config in enumerate(self.fm_data):
+                grp = f.create_group(f'config_{i}')
+                
+                # Store atom data as structured arrays
+                atoms = config['atoms']
+                dtype = [
+                    ('id', 'i4'),  # Add atom ID field
+                    ('region', 'i4'),
+                    ('coordinate', 'f8', (3,)),
+                    ('electric_potential', 'f8'),
+                    ('electric_field', 'f8', (3,)),
+                    ('hirshfeld_charge', 'f8'),
+                    ('force', 'f8', (3,))
+                ]
+                
+                data = np.zeros(len(atoms), dtype=dtype)
+                for j, atom in enumerate(atoms):
+                    # Convert coordinates to numpy array if they aren't already
+                    coords = np.array(atom['coordinate'], dtype=np.float64)
+                    efield = np.array(atom['electric_field'], dtype=np.float64)
+                    force = np.array(atom.get('force', [0.0, 0.0, 0.0]), dtype=np.float64)
+                    
+                    # Handle electric_potential which might be a list
+                    epot = atom['electric_potential']
+                    if isinstance(epot, list):
+                        epot = epot[0] if epot else 0.0
+
+                    data[j] = (
+                        int(atom['id']),  # Add atom ID
+                        int(atom['region']),
+                        coords,
+                        float(epot),
+                        efield,
+                        float(atom['hirshfeld_charge']),
+                        force
+                    )
+                
+                grp.create_dataset('atoms', data=data, compression='gzip')
+        
+        # Clear the JSON data from memory
+        self.fm_data = None
+    
+    def _load_h5(self):
+        """Load data from HDF5 file"""
+        self.fm_data = None  # We don't need to keep the data in memory
+    
+    def get_configuration_properties(self, idx, property, region='all'):
+        """Get properties for a specific configuration"""
+        with h5py.File(self.h5_file, 'r') as f:
+            config = f[f'config_{idx}']['atoms']
+            
+            if region == 'all':
+                return config[property][:]
+            elif region == 'mm':
+                mask = config['region'][:] != 1
+                return config[property][mask]
+            elif region == 'qm':
+                mask = config['region'][:] == 1
+                return config[property][mask]
+            else:
+                raise ValueError(f"Invalid region: {region}")
+    
+    def get_atom_properties(self, idx, atom_id, property):
+        """Get properties for a specific atom"""
+        with h5py.File(self.h5_file, 'r') as f:
+            return f[f'config_{idx}']['atoms'][property][atom_id]
+    
+    def __len__(self):
+        """Return the number of configurations in the dataset"""
+        with h5py.File(self.h5_file, 'r') as f:
+            config_keys = [key for key in f.keys() if key.startswith('config_')]
+            return len(config_keys)
+    
+    def __str__(self):
+        n_configs = len(self)
+        return f"FMDataset with {n_configs} configurations from {self.data_file}"
+
+    @classmethod
+    def from_string(cls, string):
+        raise NotImplementedError("FMDataset does not support creation from string")

mimicpy/scripts/mdp.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/scripts/ndx.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/scripts/script.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/__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.