gromorg 0.3__py3-none-any.whl

gromorg/__init__.py

@@ -0,0 +1,309 @@
+__version__ = '0.3'
+
+from gromorg.swisparam import SwissParams
+from gromorg.utils import extract_energy, extract_forces
+from gromorg.capture import captured_stdout
+from gromorg.data_structure import DataStructure
+from gromorg.utils import commandline_operation
+import gmxapi as gmx
+import numpy as np
+import mdtraj
+import os
+import shutil
+import warnings
+
+
+class GromOrg:
+    def __init__(self, structure,
+                 params,
+                 box=(10, 10, 10),
+                 angles=(90, 90, 90),
+                 supercell=(1, 1, 1),
+                 solvent=None,
+                 solvent_scale=0.57,
+                 maxwarn=0,
+                 omp_num_threads=1,
+                 silent=False,
+                 delete_scratch=True):
+
+        self._structure = structure
+        self._filename = 'test'
+        self._box = np.array(box)/10.0  # from Angs to nm
+        self._supercell = supercell
+        self._angles = angles
+        self._silent = silent
+        self._delete_scratch = delete_scratch
+        self._solvent = solvent
+        self._solvent_scale = solvent_scale
+        self._maxwarn = maxwarn
+
+        os.putenv('GMX_MAXBACKUP', '-1')
+        os.putenv('OMP_NUM_THREADS', '{}'.format(omp_num_threads))
+
+        folder = os.getcwd()
+
+        self._work_dir = folder + 'gromorg_{}/'.format(os.getpid())
+        # os.mkdir(self._work_dir)
+        try:
+            os.mkdir(self._work_dir)
+        except FileExistsError:
+            pass
+
+        self._filename_dir = self._work_dir + self._filename
+
+        # Default parameters
+        self._params = {# Run paramters
+                        'integrator': 'md-vv',     # Verlet integrator
+                        'nsteps': 5000,            # 0.001 * 5000 = 50 ps
+                        'dt': 0.001,               # ps
+                        # Output control
+                        'nstxout': 1,              # save coordinates every 0.001 ps
+                        'nstvout': 1,              # save velocities every 0.001 ps
+                        'nstenergy': 1,            # save energies every 0.001 ps
+                        'nstlog': 100,             # update log file every 0.1 ps
+                        # Bond parameters
+                        'continuation': 'no',       # first dynamics run
+                        'cutoff-scheme': 'Verlet',  # Buffered neighbor searching
+                        'verlet-buffer-tolerance': 3.3e-03,
+                        # 'ns_type': 'grid',          # search neighboring grid cells
+                        'nstlist': 10,              # 20 fs, largely irrelevant with Verlet
+                        'rcoulomb': 1.0,            # short-range electrostatic cutoff (in nm)
+                        'rvdw': 1.0,                # short-range van der Waals cutoff (in nm)
+                        'DispCorr': 'EnerPres',     # account for cut-off vdW scheme
+                        # Electrostatics
+                        'coulombtype': 'PME',       # Particle Mesh Ewald for long-range electrostatics
+                        'pme_order': 4,             # cubic interpolation
+                        'fourierspacing': 0.16,     # grid spacing for FFT
+                        # Temperature coupling is on
+                        'tcoupl': 'nose-hoover',    # Nose-Hoover thermostat
+                        'tc-grps': 'system',        # one coupling group
+                        'tau_t': 0.3,               # time constant, in ps
+                        'ref_t': 100,               # reference temperature, one for each group, in K
+                        # Pressure coupling is off
+                        'pcoupl': 'no',             # no pressure coupling in NVT
+                        # Periodic boundary conditions
+                        'pbc': 'xyz',               # 3-D PBC
+                        # Velocity generation
+                        'gen_vel': 'yes',           # assign velocities from Maxwell distributio
+                        'gen_temp': 10,             # temperature for Maxwell distribution
+                        'gen_seed': -1,             # generate a random seed
+                        }
+
+        if params is not None:
+            self._params.update(params)
+
+    def get_mdp(self):
+        file = ';Autogenerated MDP\n'
+        for keys, values in self._params.items():
+            file += '{:30} = {}\n'.format(keys, values)
+
+        return file
+
+    def get_topology(self):
+
+        num_mol = np.prod(self._supercell)
+
+        topology_data = {'':['; Autogenerated Topology',
+                             '#include "charmm27.ff/forcefield.itp"',
+                             '#include "{}.itp"'.format(self._filename)],
+                         'system': ['molecular system name'],
+                         'molecules': ['{} {}\n'.format('test', num_mol)]}
+
+        return DataStructure(topology_data)
+
+    def get_tpr(self):
+
+        # write mdp file on disk
+        with open('{}.mdp'.format(self._filename_dir), 'w') as f:
+            f.write(self.get_mdp())
+
+        # get parameters for main system
+        sw = SwissParams(self._structure, silent=self._silent)
+
+        with open('{}.pdb'.format(self._filename_dir), 'w') as f:
+            f.write(sw.get_pdb_data())
+
+
+        # define unit cell and create gro file
+        if self._angles is None:
+
+            commandline_operation('gmx',
+                                  arguments=['editconf',
+                                             '-box', '{} {} {}'.format(*self._box)],
+                                  input_files={'-f': self._filename_dir + '.pdb'},
+                                  output_files={'-o': self._filename_dir + '.gro'})
+        else:
+            commandline_operation('gmx',
+                                  arguments=['editconf', #'-noc'
+                                            # '-f', self._filename_dir + '.pdb',
+                                             '-box {} {} {}'.format(*self._box),
+                                             '-bt triclinic',
+                                             '-angles {} {} {}'.format(*self._angles)],
+                                  input_files={'-f': self._filename_dir + '.pdb'},
+                                  output_files={'-o': self._filename_dir + '.gro'})
+
+        # create supercell from unitcell
+        commandline_operation('gmx',
+                              arguments=['genconf',
+                                         '-nbox {} {} {}'.format(*self._supercell)],
+                              input_files={'-f': self._filename_dir + '.gro'},
+                              output_files={'-o': self._filename_dir + '.gro'})
+
+        # get itp and topology data
+        itp = DataStructure(sw.get_itp_data())
+        top = self.get_topology()
+
+        # Add solvent to itp and top files
+        if self._solvent is not None:
+            top, itp = self._add_solvent(top, itp)
+
+        # write topology and itp files on disk
+        with open('{}.top'.format(self._filename_dir), 'w') as f:
+            f.write(top.get_txt())
+
+        with open('{}.itp'.format(self._filename_dir), 'w') as f:
+            f.write(itp.get_txt())
+
+
+        commandline_operation('gmx',
+                              arguments= ['grompp',
+                                          '-maxwarn {}'.format(self._maxwarn)],
+                              input_files={'-f': self._filename_dir + '.mdp',
+                                           '-c': self._filename_dir + '.gro',
+                                           '-p': self._filename_dir + '.top',
+                                           '-po': self._filename_dir + '_log.mdp'},
+                              output_files={'-o': self._filename_dir + '.tpr'})
+
+        tpr_data = gmx.read_tpr(self._filename_dir + '.tpr')
+
+        return tpr_data
+
+    def _add_solvent(self, top, itp):
+
+        sw_sol = SwissParams(self._solvent, silent=self._silent)
+
+        # solvent pdb
+        pdb_solvent = sw_sol.get_pdb_data().replace('LIG', 'SOL')
+
+        # get box that fits solvent
+        coords = []
+        for line in pdb_solvent.split('\n'):
+            if line.strip().startswith('ATOM'):
+                coords.append(line.split()[5:8])
+
+        s_box = np.max(np.array(coords, dtype=float), axis=0) - np.min(np.array(coords, dtype=float), axis=0)
+        s_box = np.maximum([1.0, 1.0, 1.0], s_box)
+
+        with open('{}_sol.pdb'.format(self._filename_dir), 'w') as f:
+            f.write(pdb_solvent)
+
+        # pdb to gro + box
+        commandline_operation('gmx',
+                              arguments=['editconf',
+                                         '-box {} {} {}'.format(*s_box)],
+                              input_files={'-f': self._filename_dir + '_sol.pdb'},
+                              output_files={'-o': self._filename_dir + '_sol.gro'})
+
+        # get solvent itp
+        itp_solvent = DataStructure(sw_sol.get_itp_data().replace('LIG', 'SOL').replace('test', 'test_sol'))
+        itp.append_data('atomtypes', itp_solvent.get_data('atomtypes'))
+        itp_solvent.remove_data('')
+        itp_solvent.remove_data('atomtypes')
+        itp_solvent.remove_data('pairtypes')
+
+        # store solvent itp file
+        with open('{}_sol.itp'.format(self._filename_dir), 'w') as f:
+            f.write(itp_solvent.get_txt())
+
+        # append itp file reference to topology
+        top.append_data('', ['#include "{}_sol.itp"'.format(self._filename)])
+
+        open(self._filename_dir + '_sol.top', 'w').close()  # temp file
+
+        # solvate system with solvent
+        commandline_operation('gmx',
+                              arguments=['solvate',
+                                         '-scale {}'.format(self._solvent_scale)],
+                              input_files={'-cp': self._filename_dir + '.gro',
+                                           '-cs': self._filename_dir + '_sol.gro',
+                                           '-p': self._filename_dir + '_sol.top'},
+                              output_files={'-o': self._filename_dir + '.gro'})
+
+        with open(self._filename_dir + '_sol.top', 'rb') as f:
+            line_sol = f.read().decode('utf-8')
+
+        os.remove(self._filename_dir + '_sol.top') # delete temp file
+
+        # append solvent molecule info to topology
+        try:
+            n_solvent_mol = int(line_sol.split()[1])
+            top.append_data('molecules', ['test_sol {}'.format(n_solvent_mol)])
+
+        except IndexError:
+            warnings.warn('Solvent molecules do not fit in the supercell. '
+                          'Decrease the solvent size or increase solvent density using solvent_scale')
+
+        return top, itp
+
+    def run_md(self, whole=True):
+
+        md = gmx.mdrun(input=self.get_tpr())
+
+        if self._silent:
+            with captured_stdout(self._filename_dir + '.log'):
+                md.run()
+        else:
+            md.run()
+
+        trajectory_file = md.output.trajectory.result()
+        md_data_dir = md.output.directory.result()
+
+        if whole:
+            commandline_operation('gmx',
+                                  arguments=['trjconv',
+                                             '-pbc whole'],
+                                  stdin='0',
+                                  input_files={'-f': trajectory_file,
+                                               '-s': self._filename_dir + '.tpr'},
+                                  output_files={'-o': md_data_dir + '/{}.trr'.format(self._filename)})
+
+            trajectory_file = md_data_dir + '/{}.trr'.format(self._filename)
+
+        trajectory = mdtraj.load_trr(trajectory_file, top=md_data_dir + '/confout.gro')
+        energy = extract_energy(md_data_dir + '/ener.edr', initial=0)
+
+        if self._delete_scratch:
+            shutil.rmtree(md.output.directory.result())
+            # shutil.rmtree(self._work_dir)
+
+        return trajectory, energy
+
+    def get_forces(self):
+
+        mod_input = gmx.modify_input(input=self.get_tpr(), parameters={'nsteps': 1, 'nstfout': 1})
+        md = gmx.mdrun(input=mod_input)
+
+        if self._silent:
+            with captured_stdout(self._filename_dir + '.log'):
+                md.run()
+        else:
+            md.run()
+
+        trajectory_file = md.output.trajectory.result()
+        md_data_dir = md.output._work_dir.result()
+
+        self._trajectory = mdtraj.load_trr(trajectory_file, top=md_data_dir + '/confout.gro')
+        forces = extract_forces(trajectory_file, self._filename_dir + '.tpr', step=0)
+
+        if self._delete_scratch:
+            shutil.rmtree(md.output._work_dir.result())
+            # shutil.rmtree(self._work_dir)
+
+        return forces
+
+    def __del__(self):
+        if os.path.isdir(self._work_dir) and self._delete_scratch:
+            shutil.rmtree(self._work_dir)
+
+if __name__ == '__main__':
+    pass

gromorg/cache.py

@@ -0,0 +1,99 @@
+import sys, pickle, time, fcntl
+import warnings
+
+
+# Singleton class to handle cache
+class SimpleCache:
+    __instance__ = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__instance__ is not None:
+            return cls.__instance__
+
+        # Py2 compatibility
+        if sys.version_info[0] < 3:
+            BlockingIOError = IOError
+
+        cls._calculation_data_filename = '.parameters.pkl'
+        cls._pickle_protocol = pickle.HIGHEST_PROTOCOL
+
+        cls.__instance__ = super(SimpleCache, cls, ).__new__(cls)
+        return cls.__instance__
+
+    def __init__(self, filename=None):
+        """
+        Constructor
+        """
+
+        if filename is not None:
+            self._calculation_data_filename = filename
+
+        # python 2 compatibility
+        if not '_calculation_data_filename' in dir(self):
+            self._calculation_data_filename = '.parameters.pkl'
+
+        try:
+            with open(self._calculation_data_filename, 'rb') as input:
+                self._calculation_data = pickle.load(input)
+                # print('Loaded data from {}'.format(self._calculation_data_filename))
+        except (IOError, EOFError, BlockingIOError):
+            # print('Creating new calculation data file {}'.format(self._calculation_data_filename))
+            self._calculation_data = {}
+        except (UnicodeDecodeError):
+            warnings.warn('Warning: Calculation data file is corrupted and will be overwritten')
+            self._calculation_data = {}
+
+    def redefine_calculation_data_filename(self, filename):
+
+        self._calculation_data_filename = filename
+        # print('Set data file to {}'.format(self._calculation_data_filename))
+
+        try:
+            with open(self._calculation_data_filename, 'rb') as input:
+                self._calculation_data = pickle.load(input)
+                # print('Loaded data from {}'.format(self._calculation_data_filename))
+        except (IOError, EOFError):
+            # print('Creating new calculation data file {}'.format(self._calculation_data_filename))
+            self._calculation_data = {}
+
+    def store_calculation_data(self, structure, keyword, data, timeout=60):
+
+        for iter in range(100):
+            try:
+                with open(self._calculation_data_filename, 'rb') as input:
+                    self._calculation_data = pickle.load(input)
+            except FileNotFoundError:
+                self._calculation_data = {}
+                continue
+            except (UnicodeDecodeError):
+                warnings.warn('Warning: {} file is corrupted and will be overwritten'.format(self._calculation_data_filename))
+                self._calculation_data = {}
+            except (BlockingIOError, IOError, EOFError):
+                # print('read_try: {}'.format(iter))
+                time.sleep(timeout/100)
+                continue
+            break
+
+        self._calculation_data[(hash(structure), keyword)] = data
+
+        for iter in range(100):
+            try:
+                with open(self._calculation_data_filename, 'wb') as f:
+                    fcntl.lockf(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    pickle.dump(self._calculation_data, f, self._pickle_protocol)
+            except BlockingIOError:
+                # print('read_try: {}'.format(iter))
+                time.sleep(timeout/100)
+                continue
+            break
+
+    def retrieve_calculation_data(self, input_qchem, keyword):
+        return self._calculation_data[(hash(input_qchem), keyword)] if (hash(input_qchem), keyword) in self._calculation_data else None
+
+    @property
+    def calculation_data(self):
+        return self._calculation_data
+
+    @calculation_data.setter
+    def calculation_data(self, calculation_data):
+        self._calculation_data = calculation_data

gromorg/capture.py

@@ -0,0 +1,23 @@
+import sys, os, io
+
+
+class captured_stdout:
+    def __init__(self, filename):
+        self.old_stdout = None
+        self.fnull = None
+        self._filename = filename
+
+    def __enter__(self):
+        self.F = open(self._filename, 'w')
+        try:
+            self.old_error = os.dup(sys.stderr.fileno())
+            os.dup2(self.F.fileno(), sys.stderr.fileno())
+        except (AttributeError, io.UnsupportedOperation):
+            self.old_error = None
+        return self.F
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.old_error is not None:
+            os.dup2(self.old_error, sys.stderr.fileno())
+
+        self.F.close()

gromorg/data_structure.py

@@ -0,0 +1,51 @@
+
+
+class DataStructure:
+    def __init__(self, itp_data):
+
+        if isinstance(itp_data, str):
+            self._data = {}
+            label = ''
+            self._data[label] = []
+            for lines in itp_data.split('\n'):
+                if len(lines.strip()) > 0: # and ';' not in lines:
+                    if '[' in lines and ']' in lines:
+                        label = lines.split('[')[1].split(']')[0].strip()
+                        self._data[label] = []
+                        continue
+
+                    self._data[label].append(lines)
+        elif isinstance(itp_data, dict):
+            self._data = itp_data
+
+        else:
+            raise TypeError('itp_data must be str or dict')
+
+    def get_txt(self):
+        itp_txt = ''
+        for label in self._data:
+            if len(label) > 0:
+                itp_txt += '\n[ {} ]\n'.format(label)
+            for line in self._data[label]:
+                itp_txt += line + '\n'
+
+        return itp_txt
+
+    def append_line(self, label, line):
+        self._data[label].append(line)
+
+    def append_data(self, label, data):
+        self._data[label] += list(data)
+
+    def get_data(self, label):
+        return self._data[label]
+
+    def remove_data(self, label):
+        del self._data[label]
+
+
+if __name__ == "__main__":
+    topology = DataStructure(open("../gromorg_50962/test.itp", 'r').read())
+    topology.append_line('atomtypes', 'CO  1  fr')
+    print(topology.get_txt())
+    print(topology.get_data('atomtypes'))

gromorg/setparam.py

@@ -0,0 +1,103 @@
+import openbabel
+from gromorg.cache import SimpleCache
+from gromorg.utils import pdb_to_xyz
+import numpy as np
+
+
+class SetParams:
+
+    def __init__(self, filename='.parameters.pkl'):
+        self._basename = 'test'
+
+        self._cache = SimpleCache(filename=filename)
+
+    def get_hashable_connectivity(self, xyz_txt):
+
+        def sort_pairs(test):
+            sorted_1 = np.sort(test, axis=1)
+
+            sorted_2 = sorted(sorted_1, key=lambda x: x[1])
+            sorted_3 = sorted(sorted_2, key=lambda x: x[0])
+
+            return np.array(sorted_3)
+
+        class Connectivity():
+            def __init__(self, xyz_txt, use_types=False):
+
+                obConversion = openbabel.OBConversion()
+                obConversion.SetInAndOutFormats("xyz", "mol2")
+
+                mol = openbabel.OBMol()
+                obConversion.ReadString(mol, xyz_txt)
+
+                # mol.AddHydrogens()
+
+                atomic_data = []
+                for i in range(mol.NumAtoms()):
+                    if use_types:
+                        atomic_data.append((mol.GetAtom(i+1).GetFormalCharge(),
+                                            np.product([ord(c) for c in mol.GetAtom(i+1).GetType()]),
+                                            ))
+                    else:
+                        atomic_data.append((mol.GetAtom(i + 1).GetFormalCharge(),
+                                            mol.GetAtom(i + 1).GetAtomicNum()
+                                            ))
+
+                conn_index = []
+                for i in range(mol.NumBonds()):
+                    conn_index.append((mol.GetBond(i).GetBeginAtomIdx()-1, mol.GetBond(i).GetEndAtomIdx()-1))
+
+                conn_index = sort_pairs(conn_index)
+
+                self._connectivity = []
+                for i, j in conn_index:
+                    self._connectivity.append((atomic_data[i], atomic_data[j]))
+
+                return
+
+            def __hash__(self):
+                return hash(tuple(self._connectivity))
+
+        return Connectivity(xyz_txt, use_types=False)
+
+    def add_data(self, itp_file, pdb_file):
+
+        with open(itp_file, 'r') as f:
+            itp_txt = f.read()
+
+        with open(pdb_file, 'r') as f:
+            pdb_txt = f.read()
+
+        files_dict = {self._basename + '.itp': itp_txt.encode(), self._basename + '.pdb': pdb_txt.encode()}
+        xyz_txt = pdb_to_xyz(pdb_txt)
+
+        self._cache.store_calculation_data(self.get_hashable_connectivity(xyz_txt), 'zip_files', files_dict)
+
+    def get_data(self, structure):
+
+        xyz_txt = structure.get_xyz()
+        files_dict = self._cache.retrieve_calculation_data(self.get_hashable_connectivity(xyz_txt), 'zip_files')
+
+        return files_dict
+
+
+if __name__ == '__main__':
+    from pyqchem.structure import Structure
+
+    data = SetParams(filename='.parameter.pkl')
+
+    data.add_data('test_param.itp', 'test_param.pdb')
+
+    structure = Structure(coordinates=[[ 0.6952,  0.0000,  0.0000],
+                                       [-0.6695,  0.0000,  0.0000],
+                                       [ 1.2321,  0.9289,  0.0000],
+                                       [ 1.2321, -0.9289,  0.0000],
+                                       [-1.2321,  0.9289,  0.0000],
+                                       [-1.2321, -0.9289,  0.0000]],
+                          symbols=['C', 'C', 'H', 'H', 'H', 'H'],
+                          charge=0,
+                          multiplicity=1)
+
+    a = data.get_data(structure)
+    print(a['test.itp'])
+    print(a['test.pdb'])

gromorg/swisparam.py

@@ -0,0 +1,225 @@
+import requests as req
+import time
+import io
+import tarfile
+from openbabel import openbabel
+from gromorg.cache import SimpleCache
+import numpy as np
+
+
+class SwissParams:
+
+    BASE_URL = 'https://www.swissparam.ch:8443'
+
+    def __init__(self, structure, silent=False, approach='both'):
+        """
+        :param structure: molecular structure object
+        :param silent: suppress progress output
+        :param approach: parameterization approach — 'both' (default), 'mmff-based', or 'match'
+        """
+        self._structure = structure
+        self._filename = 'test'
+        self._silent = silent
+        self._approach = approach
+
+        self._tar_data = None
+        self._session_number = None
+
+        self._cache = SimpleCache()
+
+    def get_mol2(self):
+        obConversion = openbabel.OBConversion()
+        obConversion.SetInAndOutFormats("xyz", "mol2")
+
+        mol = openbabel.OBMol()
+        obConversion.ReadString(mol, self._structure.get_xyz())
+
+        return obConversion.WriteString(mol).replace('UNL1', 'test') # change the molname
+
+    def get_hashable_connectivity(self):
+
+        def sort_pairs(test):
+            sorted_1 = np.sort(test, axis=1)
+            sorted_2 = sorted(sorted_1, key=lambda x: x[1])
+            sorted_3 = sorted(sorted_2, key=lambda x: x[0])
+            return np.array(sorted_3)
+
+        class Connectivity():
+            def __init__(self, structure, use_types=False):
+                obConversion = openbabel.OBConversion()
+                obConversion.SetInAndOutFormats("xyz", "mol2")
+
+                mol = openbabel.OBMol()
+                obConversion.ReadString(mol, structure.get_xyz())
+
+                atomic_data = []
+                for i in range(mol.NumAtoms()):
+                    if use_types:
+                        atomic_data.append((mol.GetAtom(i+1).GetFormalCharge(),
+                                            np.product([ord(c) for c in mol.GetAtom(i+1).GetType()]),
+                                            ))
+                    else:
+                        atomic_data.append((mol.GetAtom(i + 1).GetFormalCharge(),
+                                            mol.GetAtom(i + 1).GetAtomicNum()
+                                            ))
+
+                conn_index = []
+                for i in range(mol.NumBonds()):
+                    conn_index.append((mol.GetBond(i).GetBeginAtomIdx()-1, mol.GetBond(i).GetEndAtomIdx()-1))
+
+                conn_index = sort_pairs(conn_index)
+
+                self._connectivity = []
+                for i, j in conn_index:
+                    self._connectivity.append((atomic_data[i], atomic_data[j]))
+
+            def __hash__(self):
+                return hash(tuple(self._connectivity))
+
+        return Connectivity(self._structure, use_types=False)
+
+    def submit_file(self):
+        if self._session_number is not None:
+            return self._session_number
+
+        url = f'{self.BASE_URL}/startparam?approach={self._approach}'
+
+        files = {'myMol2': (self._filename + '.mol2',
+                            io.BytesIO(self.get_mol2().encode('utf-8')),
+                            'chemical/x-mol2')}
+
+        r = req.post(url, files=files)
+
+        if not self._silent or not r.ok:
+            print(f'Server response ({r.status_code}): {r.text}')
+
+        r.raise_for_status()
+
+        for line in r.text.splitlines():
+            if 'Session number' in line:
+                self._session_number = line.split(':')[1].strip()
+                break
+
+        if self._session_number is None:
+            raise Exception(f'Failed to get session number. Response:\n{r.text}')
+
+        if not self._silent:
+            print(f'Submitted to SwissParam. Session number: {self._session_number}')
+
+        r.close()
+        return self._session_number
+
+    def _check_session(self, session_number):
+        """Return the status text for a session."""
+        url = f'{self.BASE_URL}/checksession?sessionNumber={session_number}'
+        r = req.get(url)
+        r.raise_for_status()
+        text = r.text
+        r.close()
+        return text
+
+    def get_tar_file(self, wait_time=10):
+        """Poll until the job is done, then return the raw tar.gz bytes."""
+
+        if self._tar_data is not None:
+            return self._tar_data
+
+        session_number = self.submit_file()
+
+        if not self._silent:
+            print('Waiting for SwissParam...')
+
+        n = 0
+        while True:
+            status = self._check_session(session_number)
+
+            if 'Calculation is finished' in status:
+                break
+            elif 'Calculation is in the queue' in status or 'Calculation currently running' in status:
+                if not self._silent:
+                    print('\b' * (np.mod(n - 1, 10) + 7), end="", flush=True)
+                    print('waiting' + '.' * np.mod(n, 10), end="", flush=True)
+                    n += 1
+                time.sleep(wait_time)
+            else:
+                raise Exception(f'Unexpected status from SwissParam:\n{status}')
+
+        # Retrieve results as tar.gz
+        url = f'{self.BASE_URL}/retrievesession?sessionNumber={session_number}'
+        r = req.get(url)
+        r.raise_for_status()
+
+        if not self._silent:
+            print('.done')
+
+        self._tar_data = r.content
+        r.close()
+
+        return self._tar_data
+
+    def store_param_tar(self, filename='params.tar.gz'):
+        with open(filename, 'wb') as f:
+            f.write(self.get_tar_file())
+
+    def get_data_contents(self):
+        files_dict = self._cache.retrieve_calculation_data(self.get_hashable_connectivity(), 'tar_files')
+
+        if files_dict is None:
+            raw = self.get_tar_file()
+
+            # Debug: inspect the first bytes to identify format
+            if not self._silent:
+                print(f'Response first bytes: {raw[:16]}')
+
+            tar_bytes = io.BytesIO(raw)
+
+            # Try auto-detection: handles .tar, .tar.gz, .tar.bz2
+            try:
+                with tarfile.open(fileobj=tar_bytes, mode='r:*') as tar:
+                    files_dict = {}
+                    for member in tar.getmembers():
+                        f = tar.extractfile(member)
+                        if f is not None:
+                            name = member.name.split('/')[-1]
+                            files_dict[name] = f.read()
+            except tarfile.ReadError:
+                # Fallback: maybe it's still a zip
+                from zipfile import ZipFile
+                tar_bytes.seek(0)
+                with ZipFile(tar_bytes) as zf:
+                    files_dict = {name.split('/')[-1]: zf.read(name) for name in zf.namelist()}
+
+            self._cache.store_calculation_data(self.get_hashable_connectivity(), 'tar_files', files_dict)
+
+        return files_dict
+
+    def get_itp_data(self):
+        contents = self.get_data_contents()
+        # Find .itp file regardless of internal naming
+        itp_files = [k for k in contents if k.endswith('.itp')]
+        if not itp_files:
+            raise Exception('No .itp file found in SwissParam results')
+        return contents[itp_files[0]].decode()
+
+    def get_pdb_data(self):
+        contents = self.get_data_contents()
+        pdb_files = [k for k in contents if k.endswith('.pdb')]
+        if not pdb_files:
+            raise Exception('No .pdb file found in SwissParam results')
+        return contents[pdb_files[0]].decode()
+
+
+if __name__ == '__main__':
+    from pyqchem.structure import Structure
+
+    structure = Structure(coordinates=[[ 0.6952, 0.0000, 0.0000],
+                                       [-0.6695, 0.0000, 0.0000],
+                                       [ 1.2321, 0.9289, 0.0000],
+                                       [ 1.2321,-0.9289, 0.0000],
+                                       [-1.2321, 0.9289, 0.0000],
+                                       [-1.2321,-0.9289, 0.0000]],
+                          symbols=['C', 'C', 'H', 'H', 'H', 'H'],
+                          charge=0,
+                          multiplicity=1)
+
+    sp = SwissParams(structure)

gromorg/tools.py

@@ -0,0 +1,98 @@
+import numpy as np
+import mdtraj
+from pyqchem import Structure
+
+NM_TO_ANGSTROM = 1e1
+
+
+def _label_to_element(label):
+    element = ''
+    for char in label:
+        if char.isnumeric():
+            break
+        element += char
+
+    return element
+
+
+def mdtraj_to_pyqchem(trajectory, frame, residue, center=True):
+    """
+    Extract molecule from MDTraj trajectory in pyqhcem Structure format
+
+    :param trajectory: MDTraj trajectory
+    :param frame: frame index
+    :param residue: residue index
+    :param center: if true center coordinates at geometric center
+    :return: PyQChem structure
+    """
+
+    res_indices = []
+    names = []
+    for res in trajectory.topology.residues:
+        res_indices.append([atom.index for atom in res.atoms])
+        names.append([atom.name for atom in res.atoms])
+
+    # check limits
+    if np.abs(frame) >= trajectory.n_frames:
+        raise Exception('Frame error. Trajectory length is {}'.format(trajectory.n_frames))
+
+    if np.abs(residue) >= len(res_indices):
+        raise Exception('Residue error. Number of residues is {}'.format(len(res_indices)))
+
+
+    coordinates = trajectory.atom_slice(res_indices[residue])[frame].xyz[0] * NM_TO_ANGSTROM
+    symbols = [_label_to_element(symbol) for symbol in names[residue]]
+
+    if center:
+        gc_coordinates = np.average(coordinates, axis=0)
+        coordinates -= gc_coordinates
+
+    molecule = Structure(coordinates=coordinates,
+                         symbols=symbols)
+
+    return molecule
+
+
+def get_cluster(trajectory, frame, residue, cutoff=5.0, center=True):
+    """
+    Extract molecule cluster from a MDTraj trajectory
+
+    :param trajectory: MDTraj trajectory
+    :param frame: trajectory frame index
+    :param residue: central residue index
+    :param cutoff: cutoff distance in Angstroms
+    :param center: If true, center molecule at geometric center
+    :return: PyQChem structure
+    """
+
+    # res_indices = list(range(trajectory.topology.n_residues))
+
+    res_indices = [(residue, i) for i in range(trajectory.topology.n_residues)]
+    distances, pairs = mdtraj.compute_contacts(trajectory[frame], res_indices, scheme='closest', ignore_nonprotein=True)
+
+    indices = np.argwhere(distances[0] < cutoff / NM_TO_ANGSTROM).T[0]
+
+    res_indices = []
+    names = []
+    for res in trajectory.topology.residues:
+        res_indices.append([atom.index for atom in res.atoms])
+        names.append([atom.name for atom in res.atoms])
+
+    coordinates = []
+    symbols = []
+
+    if len(indices) == 0:
+        indices = [0]
+
+    for i in indices:
+        coordinates += list(trajectory.atom_slice(res_indices[i])[frame].xyz[0] * NM_TO_ANGSTROM)
+        symbols += list([_label_to_element(symbol) for symbol in names[i]])
+
+    if center:
+        gc_coordinates = np.average(coordinates, axis=0)
+        coordinates -= gc_coordinates
+
+    molecule = Structure(coordinates=coordinates,
+                         symbols=symbols)
+
+    return molecule

gromorg/utils.py

@@ -0,0 +1,167 @@
+import warnings
+
+import numpy as np
+import gmxapi as gmx
+import os
+from packaging import version
+
+
+def commandline_operation_v1(program, arguments, stdin=None, input_files=None, output_files=None):
+
+    from subprocess import Popen, PIPE
+
+    if isinstance(arguments, list):
+        arguments = ' '.join(arguments)
+
+    command = '{} {}'.format(program, arguments)
+
+    for key, value in input_files.items():
+
+        if isinstance(value, list):
+            value = ' '.join(value)
+
+        command += ' {} {}'.format(key, value)
+
+    for key, value in output_files.items():
+        if isinstance(value, list):
+            value = ' '.join(value)
+
+        command += ' {} {}'.format(key, value)
+
+    qchem_process = Popen(command, stdout=PIPE, stdin=PIPE, stderr=PIPE, shell=True)
+    (output, err) = qchem_process.communicate(input=None if stdin is None else stdin.encode('utf-8'))
+    qchem_process.wait()
+    output = output.decode()
+    err = err.decode()
+
+    # mock class to return same output
+    # mock_class = type("mock_classi", (object,), {"run": lambda: None, "output":
+    #              type("mock_class", (object,), {"erroroutput": type("mock_class", (object,), {"result": lambda: output + err}),
+    #                                             "returncode": type("mock_class", (object,), {"result": lambda: 0})
+    #                                             })})
+    # return mock_class
+
+
+def commandline_operation(program, arguments, stdin=None, input_files=None, output_files=None):
+
+    if version.parse(gmx.__version__) < version.parse('0.2.0'):
+        warnings.warn('Using mock function for commandline_operation for back compatibility. '
+                      'Update to gmxapi >0.2 to get full functionally')
+        return commandline_operation_v1(program, arguments, stdin, input_files, output_files)
+
+    arguments_split = []
+    for arg in arguments:
+        arguments_split += arg.split()
+
+    grompp = gmx.commandline_operation(program, arguments_split,
+                                       stdin=stdin,
+                                       input_files=input_files,
+                                       output_files=output_files)
+
+    grompp.run()
+
+
+    if grompp.output.returncode.result() != 0:
+        try:
+            print(grompp.output.stderr.result())
+        except AttributeError:
+            pass
+    else:
+        dir_path = grompp.output.directory.result()
+        os.removedirs(dir_path)
+
+
+def extract_energy(edr_file, output='property.xvg', initial=0, option=None):
+    """
+      1  Bond             2  Angle            3  Proper-Dih.      4  Improper-Dih.
+      5  LJ-14            6  Coulomb-14       7  LJ-(SR)          8  Disper.-corr.
+      9  Coulomb-(SR)    10  Coul.-recip.    11  Potential       12  Kinetic-En.
+     13  Total-Energy    14  Conserved-En.   15  Temperature     16  Pres.-DC
+     17  Pressure        18  Vir-XX          19  Vir-XY          20  Vir-XZ
+     21  Vir-YX          22  Vir-YY          23  Vir-YZ          24  Vir-ZX
+     25  Vir-ZY          26  Vir-ZZ          27  Pres-XX         28  Pres-XY
+     29  Pres-XZ         30  Pres-YX         31  Pres-YY         32  Pres-YZ
+     33  Pres-ZX         34  Pres-ZY         35  Pres-ZZ         36  #Surf*SurfTen
+     37  T-LIG
+
+    :param edr_file: EDR filename
+    :param output: output filename
+    :param option: option number from above
+    :return:
+    """
+
+    if option is None:
+        option = '11, 12, 13'
+
+    commandline_operation('gmx', ['energy'],
+                                       stdin=option,
+                                       input_files={'-f': edr_file},
+                                       output_files={'-o': edr_file + 'property.xvg'})
+
+    data = np.loadtxt(edr_file + 'property.xvg', comments=['#', '@'])[initial:].T
+    os.remove(edr_file + 'property.xvg')
+
+    data[1:, :] *= 0.010364272  # KJ/mol -> eV
+
+    if option == '11, 12, 13':
+        return {'time': list(data[0]),
+                'potential': list(data[1]),
+                'kinetic': list(data[2]),
+                'total': list(data[3])}
+    else:
+        return data
+
+
+def extract_forces(trajectory_file, tpr_file, step=500):
+
+    commandline_operation('gmx', ['traj', '-of'],
+                                       stdin='0',
+                                       input_files={'-f': trajectory_file,
+                                                    '-s': tpr_file,
+                                                    '-b': '{}'.format(step),
+                                                    '-e': '{}'.format(step),
+                                                    },
+                                       )
+
+
+    forces = np.loadtxt('force.xvg', comments=['#', '@'])[1:].reshape(-1, 3)
+    os.remove('force.xvg')
+
+    return forces * 0.00103642723  # KJ/(mol nm) to eV/ang
+
+
+def pdb_to_xyz(pdb_xyz):
+    """
+    Convert a pdb file to xyz format
+    :param pdb_xyz:
+    :return:
+    """
+
+    def _label_to_element(label):
+        element = ''
+        for char in label:
+            if char.isnumeric():
+                break
+            element += char.strip()
+
+        list_changes = {'CA': 'C', 'HA': 'H'}
+        if element in list_changes:
+            element = list_changes[element]
+        return element
+
+    def iter_coordinates():
+        for line in pdb_xyz.split('\n'):
+            if line.startswith('ATOM'):
+                yield np.array(line[30:55].split(), dtype=float)
+
+    def iter_symbols():
+        for line in pdb_xyz.split('\n'):
+            if line.startswith('ATOM'):
+                yield _label_to_element(line[13:16])
+
+    xyz_txt = '{}\n'.format(len(list(iter_symbols())))
+    for s, c in zip(iter_symbols(), iter_coordinates()):
+        xyz_txt += '\n' + s + ' {:10.5f} {:10.5f} {:10.5f}'.format(*c)
+
+    return xyz_txt
+

gromorg-0.3.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: gromorg
+Version: 0.3
+Summary: Simple Gromacs python wrapper
+Home-page: https://github.com/abelcarreras/gromorg
+Author: Abel Carreras
+Author-email: abelcarreras83@gmail.com
+Classifier: Programming Language :: Python
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: openbabel
+Requires-Dist: gmxapi
+Requires-Dist: mdtraj
+Requires-Dist: lxml
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+[![Documentation Status](https://readthedocs.org/projects/gromorg/badge/?version=latest)](https://gromorg.readthedocs.io/en/latest/?badge=latest)
+[![PyPI version](https://badge.fury.io/py/gromorg.svg)](https://badge.fury.io/py/gromorg)
+
+
+GroMorG
+=======
+
+A python tool to automate the calculation of MD simulations of small organic molecules using gromacs.  
+Online documentation is available at https://gromorg.readthedocs.io/
+
+Features
+--------
+- Link first principles & molecular mechanics calculations using PyQchem
+- Get parameters from SwissParam (https://www.swissparam.ch) automatically from molecular structure
+- Clean run without intermediate files
+- Add solvent molecules to the system
+- Extract structures from the trajectory (including surrounding solvent molecules)
+
+Requirements
+------------
+- PyQchem (https://github.com/abelcarreras/PyQchem)
+- Gromacs 2025+ (gmxapi) (http://www.gromacs.org)
+- Openbabel v3.x (python API) (http://openbabel.org)
+- MDtraj (https://www.mdtraj.org)
+
+Basic example
+-------------
+```python
+from gromorg import GromOrg
+import matplotlib.pyplot as plt
+from pyqchem.structure import Structure
+
+# Define moleule as PyQchem Structure
+structure = Structure(coordinates=[[ 0.6695, 0.0000, 0.0000],
+                                   [-0.6695, 0.0000, 0.0000],
+                                   [ 1.2321, 0.9289, 0.0000],
+                                   [ 1.2321,-0.9289, 0.0000],
+                                   [-1.2321, 0.9289, 0.0000],
+                                   [-1.2321,-0.9289, 0.0000]],
+                      symbols=['C', 'C', 'H', 'H', 'H', 'H'])
+
+# Define Gromacs parameters
+gmx_params = {
+             'integrator': 'md-vv',     # Verlet integrator
+             'nsteps': 5000,            # 0.001 * 5000 = 50 ps
+             'dt': 0.001,               # time step, in ps
+             # Temperature coupling is on
+             'tcoupl': 'nose-hoover',    # Nose-Hoover thermostat
+             'tau_t': 0.3,               # time constant, in ps
+             'ref_t': 300,               # reference temperature, one for each group, in K
+             # Bond parameters
+             'gen_vel': 'yes',           # assign velocities from Maxwell distributio
+             'gen_temp': 300,            # temperature for Maxwell distribution
+             'gen_seed': -1,             # generate a random seed
+             }
+
+# Define simulation
+calc = GromOrg(structure, 
+               params=gmx_params,        # MDP parms 
+               box=[10, 10, 10],         # a, b, c in angstrom
+               angles=[90, 90, 90],      # alpha, beta, gamma in degree
+               supercell=[3, 3, 3],
+               delete_scratch=True,      # delete temp files when finished
+               silent=False)             # print MD log info in screen
+
+# Run simulation and get trajectory (MDTraj) and energy
+trajectory, energy = calc.run_md(whole=True) 
+
+# plot energies
+plt.plot(energy['potential'], label='potential')
+plt.plot(energy['kinetic'], label='kinetic')
+plt.plot(energy['total'], label='total')
+plt.legend()
+plt.show()
+
+# Store trajectory
+trajectory.save('trajectory.gro')
+```
+
+Contact info
+------------
+Abel Carreras  
+abelcarreras83@gmail.com
+
+Donostia International Physics Center (DIPC)  
+Donostia-San Sebastian, Euskadi (Spain)

gromorg-0.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+gromorg/__init__.py,sha256=SndJPw0Wza9F_eKQ9xO8P3WeUSn2AP2zp7jsEg2ggOo,12796
+gromorg/cache.py,sha256=EDTicUumhZ-SKvXhVPxE3_SLgA1wyG5jWAsZwbk_kes,3792
+gromorg/capture.py,sha256=-TXe73KEDnu9SF22A9a7m8VyLa1UJcYoyxIGMVp02eM,656
+gromorg/data_structure.py,sha256=DUcGUfOA8SCP12Dpd3WxOta2rsYpx1ywFdmnudSyN-A,1495
+gromorg/setparam.py,sha256=8Gc3Lc1r2vtzqnlmCGJZD0It35FdGiBsr0H3h4eTUo0,3522
+gromorg/swisparam.py,sha256=Q-Gv_2f-pqQ-GcLpBATk5l39sGignS4q3h4Jlo0oPoQ,8054
+gromorg/tools.py,sha256=m6-LRTm_rfBNcm168Kxfnme6SyjvIprapa2n0GQwDok,2951
+gromorg/utils.py,sha256=xXK_BcQXb976298mlOSMVQ2wwv55bAHkdP3dEJVjthw,5796
+gromorg-0.3.dist-info/licenses/LICENSE,sha256=8WmMounu4uoRjJ0nhdKiAoWHs7IgG110IulVxkDxS4g,1086
+gromorg-0.3.dist-info/METADATA,sha256=am1Ns47_WzwZLxgTtmXQC1boE-qIU_49WiSA7Nm-6ao,3949
+gromorg-0.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gromorg-0.3.dist-info/top_level.txt,sha256=Ojqsi-boL37ckmXZmlYHyoqctfIjKTW2VIj-n3SxN6g,8
+gromorg-0.3.dist-info/RECORD,,

gromorg-0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gromorg-0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Abel Carreras Conill
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

gromorg-0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+gromorg