rdworks 0.50.1__py3-none-any.whl → 0.52.1__py3-none-any.whl

rdworks/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.50.1'
+__version__ = '0.52.1'
 
 from rdworks.conf    import Conf
 from rdworks.mol     import Mol

rdworks/conf.py

@@ -270,6 +270,62 @@ class Conf:
                 return self.sync(ase_atoms.get_positions())
  
     
+    def protonate(self, atom_indices: list[int]) -> Self:
+        """Protonate given non-hydrogen atoms.
+
+        Args:
+            atom_indices (list[int]): atom indices of non-hydrogen atoms to protonate.
+
+        Returns:
+            Self: self.
+        """
+        for idx in atom_indices:
+            atom = self.rdmol.GetAtomWithIdx(idx)
+            h = atom.GetNumExplicitHs()
+            c = atom.GetFormalCharge()
+            atom.SetNumExplicitHs(h+1)
+            atom.SetFormalCharge(c+1)            
+            Chem.SanitizeMol(self.rdmol)
+            self.rdmol = Chem.AddHs(self.rdmol, addCoords=True)
+            # The Chem.AddHs function in RDKit returns a new Mol object with hydrogens added to the molecule. 
+            # It modifies the input molecule by adding hydrogens, 
+            # but the original molecule remains unchanged.
+        
+        return self
+    
+
+    def deprotonate(self, atom_indices: list[int]) -> Self:
+        """Deprotonate given non-hydrogen atoms.
+
+        Args:
+            atom_indices (list[int]): atom indices of non-hydrogen atoms to deprotonate.
+
+        Returns:
+            Self: self.
+        """
+        for idx in atom_indices:
+            bonded_H_idx = None
+            atom = self.rdmol.GetAtomWithIdx(idx)
+            h = atom.GetNumExplicitHs()
+            if h-1 >= 0 :
+                atom.SetNumExplicitHs(h-1) # (h-1) must be unsigned int
+            c = atom.GetFormalCharge()
+            atom.SetFormalCharge(c-1)            
+            neighbors = atom.GetNeighbors()
+            
+            for neighbor in neighbors:
+                if neighbor.GetAtomicNum() == 1:
+                    bonded_H_idx = neighbor.GetIdx()
+                    break
+
+            if bonded_H_idx is not None:
+                edit_mol = Chem.EditableMol(self.rdmol)
+                edit_mol.RemoveAtom(bonded_H_idx)
+                self.rdmol = edit_mol.GetMol()
+                Chem.SanitizeMol(self.rdmol)
+        
+        return self
+
 
     ##################################################
     ### Endpoint methods
@@ -299,6 +355,15 @@ class Conf:
         return True
     
 
+    def charge(self) -> int:
+        """Returns molecular formal charge.
+
+        Returns:
+            int: charge
+        """
+        return self.charge
+    
+
     def positions(self) -> np.array:
         """Returns the coordinates.
 

rdworks/microstates.py

@@ -0,0 +1,138 @@
+import numpy as np
+import math
+import itertools
+
+from types import SimpleNamespace
+from rdworks import Conf, Mol
+from rdworks.xtb.wrapper import GFN2xTB
+
+
+kT = 0.001987 * 298.0 # (kcal/mol K), standard condition
+C = math.log(10) * kT
+
+
+
+class Microstates():
+
+    def __init__(self, origin: Mol, calculator: str = 'xTB'):
+        self.origin = origin
+        self.calculator = calculator
+        self.basic_sites = []
+        self.acidic_sites = []
+        self.states = []
+        self.mols = []
+        self.reference = None
+    
+        # read QupKake results
+        for conf in self.origin:
+            print(conf.props)
+            pka = conf.props.get('pka', None)
+            if pka is None:
+                # no protonation/deprotonation sites
+                continue
+            if isinstance(pka, str) and pka.startswith('tensor'):
+                # ex. 'tensor(9.5784)'
+                pka = float(pka.replace('tensor(','').replace(')',''))
+            if conf.props.get('pka_type') == 'basic':
+                self.basic_sites.append(conf.props.get('idx'))
+            elif conf.props.get('pka_type') == 'acidic':
+                self.acidic_sites.append(conf.props.get('idx'))
+
+        # enumerate protonation/deprotonation sites to generate microstates
+
+        np = len(self.basic_sites)
+        nd = len(self.acidic_sites)
+        P = [c for n in range(np+1) for c in itertools.combinations(self.basic_sites, n)]
+        D = [c for n in range(nd+1) for c in itertools.combinations(self.acidic_sites, n)]
+        
+        PD = list(itertools.product(P, D))
+        
+        for (p, d) in PD:
+            conf = self.origin.confs[0].copy()
+            conf = conf.protonate(p).deprotonate(d).optimize(calculator=calculator)
+            charge = len(p) - len(d)
+            self.states.append(SimpleNamespace(
+                charge=charge, 
+                protonation_sites=p, 
+                deprotonation_sites=d,
+                conf=conf,
+                smiles=Mol(conf).smiles,
+                delta_m=None,
+                PE=None))
+            
+        # sort microstates by ascending charges
+        self.states = sorted(self.states, key=lambda x: x.charge)
+
+
+    @staticmethod
+    def Boltzmann_weighted_average(potential_energies: list) -> float:
+        """Calculate Boltzmann weighted average potential energy at pH 0.
+
+        Args:
+            potential_energies (list): a list of potential energies.
+
+        Returns:
+            float: Boltzmann weighted average potential energy.
+        """
+        pe_array = np.array(potential_energies)
+        pe = pe_array - min(potential_energies)
+        Boltzmann_factors = np.exp(-pe/kT)
+        Z = np.sum(Boltzmann_factors)
+        p = Boltzmann_factors/Z
+
+        return float(np.dot(p, pe_array))
+
+
+    def potential_energy(self) -> None:
+        for microstate in self.states:
+            mol = Mol(microstate.conf).make_confs(n=4).optimize_confs()
+            # mol = mol.drop_confs(similar=True, similar_rmsd=0.3, verbose=True)
+            # mol = mol.optimize_confs(calculator=calculator)
+            # mol = mol.drop_confs(k=10, window=15.0, verbose=True)
+            PE = []
+            for conf in mol.confs:
+                conf = conf.optimize(calculator=self.calculator, verbose=True)
+                # GFN2xTB requires 3D coordinates
+                # xtb = GFN2xTB(conf.rdmol).singlepoint(water='cpcmx', verbose=True)
+                xtb = GFN2xTB(conf.rdmol).singlepoint(verbose=True)
+                PE.append(xtb.PE)
+                # SimpleNamespace(
+                #             PE = datadict['total energy'] * hartree2kcalpermol,
+                #             Gsolv = Gsolv,
+                #             charges = datadict['partial charges'],
+                #             wbo = Wiberg_bond_orders,
+                #             )
+            print("PE=", PE)
+            microstate.PE = self.Boltzmann_weighted_average(PE)
+            print("Boltzmann weighted=", microstate.PE)
+            
+            self.mols.append(mol)
+            print("microstate.energy", microstate)
+
+
+    def populations(self, pH: float) -> list[tuple]:
+        # set the lowest dG as the reference
+        self.reference = self.states[np.argmin([microstate.PE for microstate in self.states])]
+        for microstate in self.states:
+            microstate.delta_m = microstate.charge - self.reference.charge
+        dG = []
+        for microstate in self.states:
+            dG.append((microstate.PE - self.reference.PE) + microstate.delta_m * C * pH)
+        dG = np.array(dG)
+
+        print("dG=", dG)
+        Boltzmann_factors = np.exp(-dG/kT)
+        Z = np.sum(Boltzmann_factors)
+        p = Boltzmann_factors/Z
+        idx_p = sorted(list(enumerate(p)), key=lambda x: x[1], reverse=True)
+        # [(0, p0), (1, p1), ...]
+
+        return idx_p
+    
+
+    def count(self) -> int:
+        return len(self.states)
+    
+
+    def get_mol(self, idx: int) -> Mol:
+        return self.mols[idx]

rdworks/mol.py

@@ -1619,4 +1619,46 @@ class Mol:
         self.props = data['props']
         self.confs = [Conf().deserialize(_) for _ in data['confs']] # for 3D conformers (iterable)
         
+        return self
+    
+    def from_molblock(self, molblock: str) -> Self:
+        """Initialize a new Mol object from MolBlock.
+
+        Args:
+            molblock (str): MolBlock string
+
+        Raises:
+            ValueError: invalid MolBlock
+
+        Returns:
+            Self: self.
+        """
+        molecule = Chem.MolFromMolBlock(molblock)
+        try:
+            self.rdmol, _ = clean_2d(molecule, reset_isotope=True, remove_H=True)
+            self.smiles = Chem.MolToSmiles(self.rdmol)
+            self.confs = [Conf(x) for x in _]
+        except:
+            raise ValueError(f'Mol() Error: invalid MolBlock string')
+
+        assert self.smiles and self.rdmol, "Mol() Error: invalid molecule"
+        
+        name = self.rdmol.GetProp('_Name')
+
+        rdDepictor.Compute2DCoords(self.rdmol)
+
+        try:
+            self.name = str(name)
+        except:
+            self.name = 'untitled'
+        
+        self.rdmol.SetProp('_Name', self.name) # _Name can't be None        
+        self.InChIKey = generate_inchi_key(self.rdmol)
+        self.props.update({
+            'aka' : [], # <-- to be set by MolLibr.unique()
+            'atoms' : self.rdmol.GetNumAtoms(), # hydrogens not excluded?
+            'charge': rdmolops.GetFormalCharge(self.rdmol),
+            "nrb" : Descriptors.NumRotatableBonds(self.rdmol),
+            })
+        
         return self

rdworks/readin.py

@@ -232,6 +232,7 @@ def read_sdf(path:str | Path, std:bool=False, confs:bool=False, props:bool=True,
                 # start a new molecule
                 rdmol_2d = Chem.RemoveHs(rdmol)
                 AllChem.Compute2DCoords(rdmol_2d)
+                # initialize a new molecule with the H-removed 2D
                 new_mol = Mol(rdmol_2d, isomer_name, std=False) # atom indices remain unchanged.
             new_conf = Conf(rdmol)
             new_conf.props.update(props)

rdworks/xtb/wrapper.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from types import SimpleNamespace
 
 from rdkit import Chem
+from rdkit.Chem import rdmolops
 from rdkit.Geometry import Point3D
 
 
@@ -32,6 +33,7 @@ class GFN2xTB:
         assert self.is_xtb_ready(), "xtb is not accessible"
 
         self.rdmol = molecule
+        self.charge = rdmolops.GetFormalCharge(self.rdmol)
         self.natoms = molecule.GetNumAtoms()
         self.symbols = [ atom.GetSymbol() for atom in molecule.GetAtoms() ]
         self.positions = molecule.GetConformer().GetPositions().tolist()
@@ -74,7 +76,8 @@ class GFN2xTB:
                 test_geometry = os.path.join(temp_dir, 'coord')
                 with open(test_geometry, 'w') as f:
                     f.write('\n'.join(h2o))
-                proc = subprocess.run(['xtb', test_geometry, '--opt'], 
+                proc = subprocess.run(['xtb', test_geometry, '--opt'],
+                                      cwd=temp_dir,
                                       capture_output=True, 
                                       text=True)
                 assert proc.returncode == 0
@@ -117,14 +120,15 @@ $ cp -r xtb-dist/share      /usr/local/ """)
             bool: True if the --cpcmx option is working, False otherwise.
         """
         if GFN2xTB.is_xtb_ready():
-            cmd = ['xtb', '--cpcmx']
-            proc = subprocess.run(cmd, capture_output=True, text=True)
-            # we are expecting an error because no input file is given
-            assert proc.returncode != 0
-            for line in proc.stdout.split('\n'):
-                line = line.strip()
-                if 'CPCM-X library was not included' in line:
-                    return False
+            with tempfile.TemporaryDirectory() as temp_dir: # tmpdir is a string
+                cmd = ['xtb', '--cpcmx']
+                proc = subprocess.run(cmd, cwd=temp_dir, capture_output=True, text=True)
+                # we are expecting an error because no input file is given
+                assert proc.returncode != 0
+                for line in proc.stdout.split('\n'):
+                    line = line.strip()
+                    if 'CPCM-X library was not included' in line:
+                        return False
         
         return True
 
@@ -150,12 +154,13 @@ $ cp -r xtb-dist/share      /usr/local/ """)
             str | None: version statement.
         """
         if GFN2xTB.is_xtb_ready():
-            cmd = ['xtb', '--version']
-            proc = subprocess.run(cmd, capture_output=True, text=True)
-            assert proc.returncode == 0, "GFN2xTB() Error: xtb not available"
-            match = re.search('xtb\s+version\s+(?P<version>[\d.]+)', proc.stdout)
-            if match:
-                return match.group('version')
+            with tempfile.TemporaryDirectory() as temp_dir: # tmpdir is a string
+                cmd = ['xtb', '--version']
+                proc = subprocess.run(cmd, cwd=temp_dir, capture_output=True, text=True)
+                assert proc.returncode == 0, "GFN2xTB() Error: xtb not available"
+                match = re.search('xtb\s+version\s+(?P<version>[\d.]+)', proc.stdout)
+                if match:
+                    return match.group('version')
             
         return None
     
@@ -265,109 +270,56 @@ $ cp -r xtb-dist/share      /usr/local/ """)
             return Wiberg_bond_orders
 
 
-    def cpx(self, verbose: bool = False) -> float | None:
-        """Runs cpx and returns Gsolv (kcal/mol)
-
-        Warning: 
-            Solvation energy obtained from `xtb --cpcmx water` differs from
-            `cpx --solvent water` (difference between gas.out and solv.out in terms of total energy).
-            There are other correction terms not clearly defined in the output files.
-            So, this method is not reliable and should be discarded
-
-        Returns:
-            float or None: Gsolv energy in kcal/mol or None.
-        """
-        with tempfile.TemporaryDirectory() as temp_dir: # tmpdir is a string
-            workdir = Path(temp_dir)
-            if verbose:
-                logger.info(f'xtb.cpx workdir= {temp_dir}')
-            
-            geometry_input_path = workdir / 'coord'
-            geometry_output_path = workdir / 'xtbtopo.mol'
-            gas_out_path = workdir / 'gas.out'
-            solv_out_path = workdir / 'solv.out'
-            wbo_path = workdir / 'wbo'
-         
-            with open(geometry_input_path, 'w') as f:
-                f.write(self.to_turbomole_coord())
-        
-            cmd = ['cpx']
-            options = ['--solvent', 'water']
-            
-            proc = subprocess.run(cmd + options, cwd=temp_dir, capture_output=True, text=True)
-            # cpx creates the following files:
-            # charges  gas.energy    solute_sigma.txt   solvent_sigma.txt   xtbtopo.mol
-            # coord    gas.out       solute_sigma3.txt  solvent_sigma3.txt
-            # error    solute.cosmo  solv.out           wbo
-
-            # example of solv.out
-            #  :::::::::::::::::::::::::::::::::::::::::::::::::::::
-            #  ::                     SUMMARY                     ::
-            #  :::::::::::::::::::::::::::::::::::::::::::::::::::::
-            #  :: total energy            -119.507131639760 Eh    ::
-            #  :: w/o Gsasa/hb/shift      -119.494560363045 Eh    ::
-            #  :: gradient norm              0.084154442395 Eh/a0 ::
-            #  :: HOMO-LUMO gap              2.966157362876 eV    ::
-            #  ::.................................................::
-            #  :: SCC energy              -121.121278922798 Eh    ::
-            #  :: -> isotropic ES            0.180705208303 Eh    ::
-            #  :: -> anisotropic ES          0.003924951393 Eh    ::
-            #  :: -> anisotropic XC          0.040710819025 Eh    ::
-            #  :: -> dispersion             -0.088336282215 Eh    ::
-            #  :: -> Gsolv                  -0.039236762590 Eh    ::
-            #  ::    -> Gelec               -0.026665485874 Eh    ::
-            #  ::    -> Gsasa               -0.012571276716 Eh    ::
-            #  ::    -> Ghb                  0.000000000000 Eh    ::
-            #  ::    -> Gshift               0.000000000000 Eh    ::
-            #  :: repulsion energy           1.614147283037 Eh    ::
-            #  :: add. restraining           0.000000000000 Eh    ::
-            #  :: total charge              -0.000000000000 e     ::
-            #  :::::::::::::::::::::::::::::::::::::::::::::::::::::
-
-            # example gas.out
-            # :::::::::::::::::::::::::::::::::::::::::::::::::::::
-            #  ::                     SUMMARY                     ::
-            #  :::::::::::::::::::::::::::::::::::::::::::::::::::::
-            #  :: total energy            -119.473726280382 Eh    ::
-            #  :: gradient norm              0.085445002241 Eh/a0 ::
-            #  :: HOMO-LUMO gap              2.562893747102 eV    ::
-            #  ::.................................................::
-            #  :: SCC energy              -121.087873563419 Eh    ::
-            #  :: -> isotropic ES            0.152557320965 Eh    ::
-            #  :: -> anisotropic ES          0.007343156635 Eh    ::
-            #  :: -> anisotropic XC          0.039625076440 Eh    ::
-            #  :: -> dispersion             -0.088605122696 Eh    ::
-            #  :: repulsion energy           1.614147283037 Eh    ::
-            #  :: add. restraining           0.000000000000 Eh    ::
-            #  :: total charge              -0.000000000000 e     ::
-            #  :::::::::::::::::::::::::::::::::::::::::::::::::::::
-
-            if proc.returncode == 0:
-                total_energy_solv = None
-                total_energy_gas = None
-                
-                with open(solv_out_path, 'r') as f:
-                    for line in f:
-                        if 'total energy' in line:
-                            m = re.search(r"total energy\s+(?P<solv>[-+]?\d*\.?\d+)\s+Eh", line)
-                            total_energy_solv = float(m.group('solv'))
-                with open(gas_out_path, 'r') as f:
-                    for line in f:
-                        if 'total energy' in line:
-                            m = re.search(r"total energy\s+(?P<gas>[-+]?\d*.?\d+)\s+Eh", line)
-                            total_energy_gas = float(m.group('gas'))
-                
-                if total_energy_solv and total_energy_gas:
-                    return (total_energy_solv - total_energy_gas) * hartree2kcalpermol
-        
-        return None
-
-
     def singlepoint(self, water: str | None = None, verbose: bool = False) -> SimpleNamespace:
         """Calculate single point energy.
         
         Total energy from xtb output in atomic units (Eh, hartree) is converted to kcal/mol.
 
+        Options:
+            ```sh
+            -c, --chrg INT
+                specify molecular charge as INT, overrides .CHRG file and xcontrol option
+            
+            --scc, --sp
+                performs a single point calculation
+            
+            --gfn INT
+                specify parametrisation of GFN-xTB (default = 2)
+            
+            --json
+                write xtbout.json file
+            
+            --alpb SOLVENT [STATE]
+                analytical linearized Poisson-Boltzmann (ALPB) model,
+                available solvents are acetone, acetonitrile, aniline, benzaldehyde,
+                benzene, ch2cl2, chcl3, cs2, dioxane, dmf, dmso, ether, ethylacetate, furane,
+                hexandecane, hexane, methanol, nitromethane, octanol, woctanol, phenol, toluene,
+                thf, water.
+                The solvent input is not case-sensitive. The Gsolv
+                reference state can be chosen as reference, bar1M, or gsolv (default).
+
+            -g, --gbsa SOLVENT [STATE]
+                generalized born (GB) model with solvent accessable surface (SASA) model,
+                available solvents are acetone, acetonitrile, benzene (only GFN1-xTB), CH2Cl2,
+                CHCl3, CS2, DMF (only GFN2-xTB), DMSO, ether, H2O, methanol,
+                n-hexane (only GFN2-xTB), THF and toluene.
+                The solvent input is not case-sensitive.
+                The Gsolv reference state can be chosen as reference, bar1M, or gsolv (default).
+
+            --cosmo SOLVENT/EPSILON
+                domain decomposition conductor-like screening model (ddCOSMO),
+                available solvents are all solvents that are available for alpb.
+                Additionally, the dielectric constant can be set manually or an ideal conductor
+                can be chosen by setting epsilon to infinity.
+
+            --tmcosmo SOLVENT/EPSILON
+                same as --cosmo, but uses TM convention for writing the .cosmo files.
+
+            --cpcmx SOLVENT
+                extended conduction-like polarizable continuum solvation model (CPCM-X),
+                available solvents are all solvents included in the Minnesota Solvation Database.
+            ```
+
         Args:
             water (str, optional) : water solvation model (choose 'gbsa' or 'alpb')
                 alpb: ALPB solvation model (Analytical Linearized Poisson-Boltzmann).
@@ -389,8 +341,7 @@ $ cp -r xtb-dist/share      /usr/local/ """)
                 geometry.write(self.to_xyz())
             
             cmd = ['xtb', geometry_input_path.as_posix()]
-            
-            options = ['--gfn', '2', '--json']
+            options = ['-c', str(self.charge), '--sp', '--gfn', '2', '--json']
             
             if water is not None and isinstance(water, str):
                 if water == 'gbsa':
@@ -408,7 +359,6 @@ $ cp -r xtb-dist/share      /usr/local/ """)
             # 'xtbout.json', 'xtbrestart', 'xtbtopo.mol', 'charges', and 'wbo' files will be 
             # created in the current working directory.
             proc = subprocess.run(cmd + options, cwd=temp_dir, capture_output=True, text=True)
-
             # if proc.returncode == 0:
             #     print("Standard Output:")
             #     print(proc.stdout)
@@ -438,6 +388,8 @@ $ cp -r xtb-dist/share      /usr/local/ """)
                 Wiberg_bond_orders = self.load_wbo(wbo_path)
 
                 return SimpleNamespace(
+                    natoms = self.natoms,
+                    charge = self.charge,
                     PE = datadict['total energy'] * hartree2kcalpermol,
                     Gsolv = Gsolv, 
                     charges = datadict['partial charges'], 
@@ -452,12 +404,29 @@ $ cp -r xtb-dist/share      /usr/local/ """)
     def optimize(self, water: str | None = None, verbose: bool = False) -> SimpleNamespace:
         """Optimize geometry.
 
-        Fortran runtime errror:
-            At line 852 of file ../src/optimizer.f90 (unit = 6, file = 'stdout')
-            Fortran runtime error: Missing comma between descriptors
-            (1x,"("f7.2"%)")
-                        ^
-            Error termination.
+        Options:
+            ```sh
+            -c, --chrg INT
+              specify molecular charge as INT, overrides .CHRG file and xcontrol option
+            -o, --opt [LEVEL]
+              call ancopt(3) to perform a geometry optimization, levels from crude, sloppy,
+              loose, normal (default), tight, verytight to extreme can be chosen
+            --gfn INT
+              specify parametrisation of GFN-xTB (default = 2)
+            --json
+              write xtbout.json file
+            ```
+
+        Notes:
+            Conda installed xtb has Fortran runtime error when optimizing geometry.
+            ```sh
+            Fortran runtime errror:
+                At line 852 of file ../src/optimizer.f90 (unit = 6, file = 'stdout')
+                Fortran runtime error: Missing comma between descriptors
+                (1x,"("f7.2"%)")
+                            ^
+                Error termination.
+            ```
 
         Args:
             water (str, optional) : water solvation model (choose 'gbsa' or 'alpb')
@@ -479,8 +448,7 @@ $ cp -r xtb-dist/share      /usr/local/ """)
                 geometry.write(self.to_xyz())
 
             cmd = ['xtb', geometry_input_path.as_posix()]
-
-            options = ['--opt', '--gfn', '2', '--json']
+            options = ['-c', str(self.charge), '-o', 'normal', '--gfn', '2', '--json']
 
             if water is not None and isinstance(water, str):
                 if water == 'gbsa':
@@ -503,6 +471,8 @@ $ cp -r xtb-dist/share      /usr/local/ """)
                 rdmol_opt = self.load_xyz(geometry_output_path)
             
                 return SimpleNamespace(
+                        natoms = self.natoms,
+                        charge = self.charge,
                         PE = datadict['total energy'] * hartree2kcalpermol,
                         charges = datadict['partial charges'],
                         wbo = Wiberg_bond_orders,

{rdworks-0.50.1.dist-info → rdworks-0.52.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdworks
-Version: 0.50.1
+Version: 0.52.1
 Summary: Routine tasks built on RDKit and other tools
 Author-email: Sung-Hun Bae <sunghun.bae@gmail.com>
 Maintainer-email: Sung-Hun Bae <sunghun.bae@gmail.com>

{rdworks-0.50.1.dist-info → rdworks-0.52.1.dist-info}/RECORD

@@ -1,13 +1,14 @@
-rdworks/__init__.py,sha256=cELiDVknzDSz59Afufwk8LssqIuPLWLsxO73NISKfLY,1391
-rdworks/conf.py,sha256=iQLb3Qg3pjGiiMVMJ5-d57BC1id3zxEhEGlhhrLrA_c,34162
+rdworks/__init__.py,sha256=nSkNkfvjtAeom2f5SYdS-XCnglYeC-wcGuGVubrv3nQ,1391
+rdworks/conf.py,sha256=eH_a3ywmmJiPtnvgk86ykurYOx879AHg80-Dn8z1X70,36379
 rdworks/descriptor.py,sha256=34T_dQ6g8v3u-ym8TLKbQtxIIV5TEo-d3pdedq3o-cg,2106
 rdworks/display.py,sha256=JR0gR26UpH-JCxVOaqXZCUj2MiGZSrx9Me87FncspVI,13469
 rdworks/ionized.py,sha256=_t-Ajssv1rytV4Y_KsSbxfnsBKqy-EusbhNUtaWcV6o,7681
 rdworks/matchedseries.py,sha256=A3ON4CUpQV159mu9VqgNiJ8uoQ9ePOry9d3ra4NCAgc,10377
-rdworks/mol.py,sha256=UPLLJbfn1cPhcedrGW7tL_bk1QpG3BfpjCOhop0tmBY,68663
+rdworks/microstates.py,sha256=T206JgeB3d23MX3sRCrxVj2arxlSILYecBTKaD1VcoE,5109
+rdworks/mol.py,sha256=-zjAsBETNUbP4_n8p6how40NhZB24icMYhas1kYPqCc,70064
 rdworks/mollibr.py,sha256=X4UBO6Ga-QmNS7RwUiaDYAx0Q5hnWs71yTkEpH02Qb4,37696
 rdworks/pka.py,sha256=NVJVfpcNEMlX5QRyLBgUM7GIT7VMjO-llAR4LWc8J2c,1656
-rdworks/readin.py,sha256=0bnVcZcAmSLqc6zu1mYcv0LdBv2agQfOpKGwpSRL9VE,11742
+rdworks/readin.py,sha256=b1BHchQMC5EgQd3C05n72t_aa_9u0iKQWyyIqjyfkPc,11809
 rdworks/rgroup.py,sha256=ivF2gzmRtt339rxEnkv2KfnCs0CUdBbnSje7Y54rtFI,57996
 rdworks/scaffold.py,sha256=60T5YacyxZsEpDo_J5Qxulm2YNQO4EQR8PcNUwjn1QU,22026
 rdworks/std.py,sha256=qOVS_lGogueLKh4rsbrsYIMR0c7z_xh6BqLEzD4X9sE,7938
@@ -65,9 +66,9 @@ rdworks/predefined/misc/reactive-part-2.xml,sha256=0vNTMwWrrQmxBpbgbyRHx8sVs83cq
 rdworks/predefined/misc/reactive-part-3.xml,sha256=LgWHSEbRTVmgBoIO45xbTo1xQJs0Xu51j3JnIapRYo4,3094
 rdworks/predefined/misc/reactive.xml,sha256=syedoQ6VYUfRLnxy99ObuDniJ_a_WhrWAJbTKFfJ6VY,11248
 rdworks/xtb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rdworks/xtb/wrapper.py,sha256=w_SX3q7D4_peHERFzONesG8c-a6UTRzfBLx313D8rNE,23638
-rdworks-0.50.1.dist-info/licenses/LICENSE,sha256=UOkJSBqYyQUvtCp7a-vdCANeEcLE2dnTie_eB1By5SY,1074
-rdworks-0.50.1.dist-info/METADATA,sha256=Rh6pJzHolql4Q3OJot3eO8OQ7K2R9nPqpPc3Vwt3l0Y,1967
-rdworks-0.50.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rdworks-0.50.1.dist-info/top_level.txt,sha256=05C98HbvBK2axUBogC_hAT_CdpOeQYGnQ6vRAgawr8s,8
-rdworks-0.50.1.dist-info/RECORD,,
+rdworks/xtb/wrapper.py,sha256=p_ddunnjtxe3F2yN7RC2mvSUDnw7fNBhGm1bZVMAWAE,21901
+rdworks-0.52.1.dist-info/licenses/LICENSE,sha256=UOkJSBqYyQUvtCp7a-vdCANeEcLE2dnTie_eB1By5SY,1074
+rdworks-0.52.1.dist-info/METADATA,sha256=M47Khc8DU4es8jrzYzp4x4ZyM6ap6NwHrmbJqw5lK5Y,1967
+rdworks-0.52.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rdworks-0.52.1.dist-info/top_level.txt,sha256=05C98HbvBK2axUBogC_hAT_CdpOeQYGnQ6vRAgawr8s,8
+rdworks-0.52.1.dist-info/RECORD,,