mdinterface 1.0.0__py3-none-any.whl

mdinterface/core/topology.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Apr 19 14:05:39 2024
+
+@author: roncofaber
+"""
+
+import copy
+#%%
+
+class Topology(object):
+    
+    def __init__(self, resname=None, formula=None):
+        
+        self._id = None
+        self._formula = formula
+        self._resname = resname
+        
+        return
+    
+    @property
+    def id(self):
+        return self._id
+    
+    @property
+    def formula(self):
+        return self._formula
+    
+    @property
+    def resname(self):
+        return self._resname
+    
+    def set_id(self, value):
+        self._id = value
+        return
+    
+    def set_formula(self, value):
+        self._formula = value
+        
+    def set_resname(self, value):
+        self._resname = value
+        
+    def copy(self):
+        return copy.deepcopy(self)
+
+#%%
+
+class Atom(Topology):
+    def __init__(self, symbol, label=None, eps=None, sig=None):
+        
+        super(Atom, self).__init__()
+        
+        self.symbol  = symbol
+        
+        self.eps = eps
+        self.sig = sig
+        
+        if label is None:
+            label = symbol
+
+        self.set_label(label)
+        
+        return
+    
+    def set_label(self, value):
+        self._label = value
+        return
+    
+    @property
+    def label(self):
+        return self._label
+    
+    @property
+    def extended_label(self):
+        return self._label + "_" + self.resname
+    
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.label}, eps={self.eps}, sig={self.sig})"
+    
+    # TODO CHANGE BACK IF DOESN'T WORK
+    def __eq__(self, other):
+        return self.eps == other.eps and self.sig == other.sig and self.symbol == other.symbol
+
+    # def __eq__(self, other):
+    #     return self.eps == other.eps and self.sig == other.sig and self.label == other.label
+    
+#%%
+
+class Bond(Topology):
+    def __init__(self, a1, a2, kr=None, r0=None):
+        super(Bond, self).__init__()
+        self._a1 = a1
+        self._a2 = a2
+        self.kr = kr
+        self.r0 = r0
+        return
+
+    @property
+    def symbols(self):
+        return self._a1, self._a2
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({'-'.join(self.symbols)},kr={self.kr}, r0={self.r0})"
+    
+    @property
+    def elements(self):
+        return self._a1.split('_')[0], self._a2.split('_')[0]
+
+    def __eq__(self, other):
+        return (self.kr == other.kr and self.r0 == other.r0 and
+                (self.elements == other.elements or self.elements == other.elements[::-1]))
+
+
+class Angle(Topology):
+    def __init__(self, a1, a2, a3, kr=None, theta0=None):
+        super(Angle, self).__init__()
+        self._a1 = a1
+        self._a2 = a2
+        self._a3 = a3
+        self.kr = kr
+        self.theta0 = theta0
+        return
+
+    @property
+    def symbols(self):
+        return self._a1, self._a2, self._a3
+    
+    @property
+    def elements(self):
+        return self._a1.split('_')[0], self._a2.split('_')[0], self._a3.split('_')[0]
+    
+    def __repr__(self):
+        return f"{self.__class__.__name__}({'-'.join(self.symbols)}, kr={self.kr}, theta0={self.theta0})"
+
+    def __eq__(self, other):
+        return (self.kr == other.kr and self.theta0 == other.theta0 and
+                (self.elements == other.elements or self.elements == other.elements[::-1]))
+
+
+class Dihedral(Topology):
+    def __init__(self, a1, a2, a3, a4, A1=None, A2=None, A3=None, A4=None, A5=None):
+        super(Dihedral, self).__init__()
+        self._a1 = a1
+        self._a2 = a2
+        self._a3 = a3
+        self._a4 = a4
+        self._values = [A1, A2, A3, A4, A5]
+        return
+
+    @property
+    def symbols(self):
+        return self._a1, self._a2, self._a3, self._a4
+
+    @property
+    def values(self):
+        return self._values
+    
+    @property
+    def elements(self):
+        return self._a1.split('_')[0], self._a2.split('_')[0],\
+            self._a3.split('_')[0], self._a4.split('_')[0]
+
+    def __repr__(self):
+        symbols = '-'.join(self.symbols)
+        values = '|'.join([str(ii) for ii in self._values])
+        return f"{self.__class__.__name__}({symbols}, A={values})"
+
+    def __eq__(self, other):
+        return (self.values == other.values and
+                (self.elements == other.elements or self.elements == other.elements[::-1]))
+
+    def write(self, fout):
+        atype = "{}-{}-{}-{}".format(*self.symbols)
+        if self._values[-1] is not None:
+            value = "{:>7.4f}  {:>7.4f}  {:>7.4f}  {:>7.4f}  {:>7.4f}".format(*self.values)
+        else:
+            value = "{:>7.4f}  {:>7.4f}  {:>7.4f}  {:>7.4f}".format(*self.values[:-1])
+        fout.write("{:>5}    {}  #  {:<8} | {}\n".format(self.id, value, atype, self.resname))
+
+
+class Improper(Topology):  # cvff improper style
+    def __init__(self, a1, a2="x", a3="x", a4="x", K=None, d=None, n=None):
+        super(Improper, self).__init__()
+        
+        self._a1 = a1
+        self._a2 = a2
+        self._a3 = a3
+        self._a4 = a4
+        
+        self._K = K
+        
+        assert d in [1, -1], "Wrong 'd' value"
+        self._d = d
+        
+        assert n in [0,1,2,3,4,5,6], "Wrong 'n' value"
+        self._n = n
+        
+        return
+
+    @property
+    def symbols(self):
+        return self._a1, self._a2, self._a3, self._a4
+
+    @property
+    def values(self):
+        return self._K, self._d, self._n
+    
+    def __repr__(self):
+        symbols = '-'.join(self.symbols)
+        values = '|'.join([str(ii) for ii in self.values])
+        return f"{self.__class__.__name__}({symbols}, K,d,n={values})"
+
+    def __eq__(self, other):
+        return (self.values == other.values and
+                self._a1.split('_')[0] == other._a1.split('_')[0])
+
+
+
+

mdinterface/io/__init__.py

@@ -0,0 +1,8 @@
+# io/__init__.py
+
+"""
+io: Provides input/output functionalities for various file formats.
+"""
+
+from .lammpswriter import *
+from .packmol import header, box_place, fix_place

mdinterface/io/lammpswriter.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Oct 25 15:03:47 2023
+
+@author: roncoroni
+"""
+
+import numpy as np
+
+from MDAnalysis.lib import util, mdamath
+from MDAnalysis.core.groups import requires
+from MDAnalysis.exceptions import NoDataError
+from MDAnalysis.coordinates import base
+
+
+btype_sections = {'bond':'Bonds', 'angle':'Angles',
+                  'dihedral':'Dihedrals', 'improper':'Impropers'}
+
+
+class DATAWriter(base.WriterBase):
+    """Write out the current time step as a LAMMPS DATA file.
+
+    This writer supports the sections Atoms, Masses, Velocities, Bonds,
+    Angles, Dihedrals, and Impropers. This writer will write the header
+    and these sections (if applicable). Atoms section is written in the
+    "full" sub-style if charges are available or "molecular" sub-style
+    if they are not. Molecule id is set to 0 for all atoms.
+
+    Note
+    ----
+    This writer assumes "conventional" or "real" LAMMPS units where length
+    is measured in Angstroms and velocity is measured in Angstroms per
+    femtosecond. To write in different units, specify `lengthunit`
+
+    If atom types are not already positive integers, the user must set them
+    to be positive integers, because the writer will not automatically
+    assign new types.
+
+    To preserve numerical atom types when writing a selection, the Masses
+    section will have entries for each atom type up to the maximum atom type.
+    If the universe does not contain atoms of some type in
+    {1, ... max(atom_types)}, then the mass for that type will be set to 1.
+
+    In order to write bonds, each selected bond type must be explicitly set to
+    an integer >= 1.
+
+    """
+    format = 'DATA'
+
+    def __init__(self, filename, convert_units=True, **kwargs):
+        """Set up a DATAWriter
+
+        Parameters
+        ----------
+        filename : str
+            output filename
+        convert_units : bool, optional
+            units are converted to the MDAnalysis base format; [``True``]
+        """
+        self.filename = util.filename(filename, ext='data', keep=True)
+
+        self.convert_units = convert_units
+
+        self.units = {'time': 'fs', 'length': 'Angstrom'}
+        self.units['length'] = kwargs.pop('lengthunit', self.units['length'])
+        self.units['time'] = kwargs.pop('timeunit', self.units['time'])
+        self.units['velocity'] = kwargs.pop('velocityunit',
+                                 self.units['length']+'/'+self.units['time'])
+
+    def _write_atoms(self, atoms, data):
+        self.f.write('\n')
+        self.f.write('Atoms\n')
+        self.f.write('\n')
+
+        try:
+            charges = atoms.charges
+        except (NoDataError, AttributeError):
+            has_charges = False
+        else:
+            has_charges = True
+
+        indices = atoms.indices + 1
+        i_l = len(str(indices.max()))
+        
+        unique_types, types = np.unique(atoms.types, return_inverse=True)
+        types += 1
+        t_l = len(str(len(unique_types)))
+
+        moltags = atoms.resindices
+        m_l = len(str(moltags.max()))+1
+    
+        if self.convert_units:
+            coordinates = self.convert_pos_to_native(atoms.positions, inplace=False)
+            
+        b_l = len(str(int(coordinates.max()))) + 1
+        b_t = b_l + 6
+
+        if has_charges:
+            for index, moltag, atype, charge, coords in zip(indices, moltags,
+                    types, charges, coordinates):
+                x, y, z = coords
+                self.f.write(f"{index:{i_l}d} {moltag:{m_l}d}  {atype:{t_l}d}  {charge: .7f}"
+                             f"  {x:> {b_t}.5f} {y:> {b_t}.5f} {z:> {b_t}.5f}\n")
+        else:
+            for index, moltag, atype, coords in zip(indices, moltags, types,
+                    coordinates):
+                x, y, z = coords
+                self.f.write(f"{index:{i_l}d} {moltag:{m_l}d} {atype:{t_l}d}"
+                             f" {x:> {b_t}.5f} {y:> {b_t}.5f} {z:> {b_t}.5f}\n")
+
+    def _write_velocities(self, atoms):
+        self.f.write('\n')
+        self.f.write('Velocities\n')
+        self.f.write('\n')
+        indices = atoms.indices + 1
+        velocities = self.convert_velocities_to_native(atoms.velocities,
+                                                       inplace=False)
+        for index, vel in zip(indices, velocities):
+            self.f.write('{i:d} {x:f} {y:f} {z:f}\n'.format(i=index, x=vel[0],
+                y=vel[1], z=vel[2]))
+
+    def _write_masses(self, atoms):
+        # self.f.write('\n')
+        self.f.write('Masses\n')
+        self.f.write('\n')
+        
+        for cc, atype in enumerate(np.unique(atoms.types)):
+            
+            # search entire universe for mass info, not just writing selection
+            masses = set(atoms.select_atoms('type {}'.format(atype)).masses)
+            
+            if len(masses) == 0:   
+                mass = 1.0  
+            else:
+                mass = masses.pop()
+                
+            if masses:
+                raise ValueError('LAMMPS DATAWriter: to write data file, '+
+                        'atoms with same type must have same mass')
+        
+        
+            self.f.write('{:d} {:> 8.3f}   # {}\n'.format(cc+1, mass, atype))
+
+    def _write_bonds(self, bonds):
+        self.f.write('\n')
+        self.f.write('{}\n'.format(btype_sections[bonds.btype]))
+        self.f.write('\n')
+        for bond, i in zip(bonds, range(1, len(bonds)+1)):
+            try:
+                self.f.write('{:d} {:d} '.format(i, int(bond.type))+\
+                        ' '.join((bond.atoms.indices + 1).astype(str))+'\n')
+            except TypeError:
+                errmsg = (f"LAMMPS DATAWriter: Trying to write bond, but bond "
+                          f"type {bond.type} is not numerical.")
+                raise TypeError(errmsg) from None
+
+    def _write_dimensions(self, dimensions):
+        """Convert dimensions to triclinic vectors, convert lengths to native
+        units and then write the dimensions section
+        """
+        if self.convert_units:
+            triv = self.convert_pos_to_native(mdamath.triclinic_vectors(
+                                              dimensions),inplace=False)
+        self.f.write('\n')
+        self.f.write('{:f} {:f} xlo xhi\n'.format(0., triv[0][0]))
+        self.f.write('{:f} {:f} ylo yhi\n'.format(0., triv[1][1]))
+        self.f.write('{:f} {:f} zlo zhi\n'.format(0., triv[2][2]))
+        if any([triv[1][0], triv[2][0], triv[2][1]]):
+            self.f.write('{xy:f} {xz:f} {yz:f} xy xz yz\n'.format(
+                xy=triv[1][0], xz=triv[2][0], yz=triv[2][1]))
+        self.f.write('\n')
+
+    @requires('types', 'masses')
+    def write(self, selection, frame=None):
+        """Write selection at current trajectory frame to file.
+
+        The sections for Atoms, Masses, Velocities, Bonds, Angles,
+        Dihedrals, and Impropers (if these are defined) are
+        written. The Atoms section is written in the "full" sub-style
+        if charges are available or "molecular" sub-style if they are
+        not. Molecule id in atoms section is set to to 0.
+
+        No other sections are written to the DATA file.
+        As of this writing, other sections are not parsed into the topology
+        by the :class:`DATAReader`.
+
+        Note
+        ----
+        If the selection includes a partial fragment, then only the bonds,
+        angles, etc. whose atoms are contained within the selection will be
+        included.
+
+        Parameters
+        ----------
+        selection : AtomGroup or Universe
+            MDAnalysis AtomGroup (selection or Universe.atoms) or also Universe
+        frame : int (optional)
+            optionally move to frame number `frame`
+
+        """
+        u = selection.universe
+        if frame is not None:
+            u.trajectory[frame]
+        else:
+            frame = u.trajectory.ts.frame
+
+        # make sure to use atoms (Issue 46)
+        atoms = selection.atoms
+
+        # check that types can be converted to ints if they aren't ints already
+        # try:
+        #     atoms.types.astype(np.int32)
+        # except ValueError:
+        #     errmsg = ("LAMMPS.DATAWriter: atom types must be convertible to "
+        #               "integers")
+        #     raise ValueError(errmsg) from None
+
+        try:
+            velocities = atoms.velocities
+        except (NoDataError, AttributeError):
+            has_velocities = False
+        else:
+            has_velocities = True
+
+        features = {}
+        with util.openany(self.filename, 'wt') as self.f:
+            self.f.write('LAMMPS data file via MDAnalysis\n')
+            self.f.write('\n')
+            self.f.write('{:>12d}  atoms\n'.format(len(atoms)))
+
+            attrs = [('bond', 'bonds'), ('angle', 'angles'),
+                ('dihedral', 'dihedrals'), ('improper', 'impropers')]
+
+            for btype, attr_name in attrs:
+                features[btype] = atoms.__getattribute__(attr_name)
+                self.f.write('{:>12d}  {}\n'.format(len(features[btype]),
+                                                    attr_name))
+                features[btype] = features[btype].atomgroup_intersection(
+                                    atoms, strict=True)
+
+            self.f.write('\n')
+            
+            ntypes = len(set(atoms.types))
+            self.f.write('{:>12d}  atom types\n'.format(ntypes))
+
+            for btype, attr in features.items():
+                self.f.write('{:>12d}  {} types\n'.format(len(attr.types()),
+                                                          btype))
+
+            self._write_dimensions(atoms.dimensions)
+
+            self._write_masses(atoms)
+            self._write_atoms(atoms, u.trajectory.ts.data)
+            for attr in features.values():
+                if attr is None or len(attr) == 0:
+                    continue
+                self._write_bonds(attr)
+
+            if has_velocities:
+                self._write_velocities(atoms)

mdinterface/io/packmol.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Nov 22 13:57:02 2023
+
+@author: roncoroni
+"""
+
+
+header = """\
+tolerance 2.0
+output    {}
+nloop     100
+seed      {}
+
+filetype  pdb
+# movebadrandom
+        """
+
+box_place = """
+structure mol_{}.pdb
+    number      {}
+    inside box  {}
+    resnumbers  2
+end structure
+            """
+            
+fix_place = """
+structure mol_{}.pdb
+    number      1
+    center
+    fixed {} {} {} 0. 0. 0. 
+    resnumbers  2
+end structure
+"""

mdinterface/io/read.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Oct 24 18:33:06 2024
+
+@author: roncofaber
+"""
+
+import numpy as np
+
+import ase
+import ase.visualize
+import ase.io.lammpsdata
+from mdinterface.core.topology import Atom, Bond, Angle, Dihedral, Improper
+
+#%%
+
+def read_lammps_data_file(filename):
+
+    system = ase.io.lammpsdata.read_lammps_data(filename)
+    system.set_pbc(False)
+    system.set_cell(None)
+
+    symbols = system.get_chemical_symbols()
+    # Initialize data containers
+    bond_coeff     = []
+    angle_coeff    = []
+    dihedral_coeff = []
+    improper_coeff = []
+    
+    atoms     = []
+    bonds     = []
+    angles    = []
+    dihedrals = []
+    impropers = []
+    
+    # Define a dictionary to map section names to their corresponding data lists
+    section_map = {
+        'pair coeffs'     : 'pair_coeff',
+        'bond coeffs'     : 'bond_coeff',
+        'angle coeffs'    : 'angle_coeff',
+        'dihedral coeffs' : 'dihedral_coeff',
+        'improper coeffs' : 'improper_coeff',
+        'atoms'     : 'atoms',
+        'bonds'     : 'bonds',
+        'angles'    : 'angles',
+        'dihedrals' : 'dihedrals',
+        'impropers' : 'impropers'
+    }
+    
+    # Read the file and process lines
+    with open(filename, "r") as file:
+        to_read = None
+        
+        for line in file:
+            line = line.strip()
+            
+            if not line:
+                continue
+            
+            section_key = line.lower()
+
+            if section_key in section_map:
+                to_read = section_map[section_key]
+                continue
+            
+            line = line.split()
+            
+            if to_read == "pair_coeff":
+                idx = int(line[0]) - 1
+                eps = float(line[1])
+                sig = float(line[2])
+                symbol = symbols[idx]
+                atom = Atom(symbol, f"{symbol}_{str(idx).zfill(3)}", eps, sig)
+                atoms.append(atom)
+            
+            elif to_read == "bond_coeff":
+                kr = float(line[1])
+                r0 = float(line[2])
+                bond_coeff.append([kr, r0])
+            
+            elif to_read == "angle_coeff":
+                kr = float(line[1])
+                theta0 = float(line[2])
+                angle_coeff.append([kr, theta0])
+            
+            elif to_read == "dihedral_coeff":
+                values = [float(ii) for ii in line[1:]]
+                dihedral_coeff.append(values)
+                
+            elif to_read == "improper_coeff":
+                values = [float(line[1]), int(line[2]), int(line[3])]
+                improper_coeff.append(values)
+            
+            elif to_read == "bonds":
+                idx1 = int(line[2]) - 1
+                idx2 = int(line[3]) - 1
+                kr, r0 = bond_coeff[int(line[1]) - 1]
+                bond = Bond(atoms[idx1].label, atoms[idx2].label, kr, r0)
+                bonds.append(bond)
+            
+            elif to_read == "angles":
+                idx1 = int(line[2]) - 1
+                idx2 = int(line[3]) - 1
+                idx3 = int(line[4]) - 1
+                kr, theta0 = angle_coeff[int(line[1]) - 1]
+                angle = Angle(atoms[idx1].label, atoms[idx2].label, atoms[idx3].label, kr, theta0)
+                angles.append(angle)
+            
+            elif to_read == "dihedrals":
+                idxs = [int(ii) - 1 for ii in line[2:]]
+                values = dihedral_coeff[int(line[1]) - 1]
+                dihedral = Dihedral(atoms[idxs[0]].label, atoms[idxs[1]].label,
+                                    atoms[idxs[2]].label, atoms[idxs[3]].label, *values)
+                dihedrals.append(dihedral)
+                
+            elif to_read == "impropers":
+                idxs = [int(ii) - 1 for ii in line[2:]]
+                values = improper_coeff[int(line[1]) - 1]
+                improper = Improper(atoms[idxs[0]].label, atoms[idxs[1]].label,
+                                    atoms[idxs[2]].label, atoms[idxs[3]].label,
+                                    K=values[0], d=values[1], n=values[2])
+                impropers.append(improper)
+                
+    system.new_array("stype", np.array(atoms))
+    return system, atoms, bonds, angles, dihedrals, impropers