firecode 1.0.0__py3-none-any.whl

firecode/calculators/_gaussian.py

@@ -0,0 +1,98 @@
+# coding=utf-8
+'''
+FIRECODE: Filtering Refiner and Embedder for Conformationally Dense Ensembles
+Copyright (C) 2021-2024 Nicolò Tampellini
+
+SPDX-License-Identifier: LGPL-3.0-or-later
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see
+https://www.gnu.org/licenses/lgpl-3.0.en.html#license-text.
+
+'''
+
+import sys
+from subprocess import DEVNULL, STDOUT, check_call
+
+from firecode.settings import COMMANDS, MEM_GB
+from firecode.solvents import get_solvent_line
+from firecode.utils import clean_directory, pt, read_xyz
+
+
+def gaussian_opt(coords, atomnos, constrained_indices=None, method='PM6', procs=1, solvent=None, title='temp', read_output=True, **kwargs):
+    '''
+    This function writes a Gaussian .inp file, runs it with the subprocess
+    module and reads its output.
+
+    :params coords: array of shape (n,3) with cartesian coordinates for atoms.
+    :params atomnos: array of atomic numbers for atoms.
+    :params constrained_indices: array of shape (n,2), with the indices
+                                 of atomic pairs to be constrained.
+    :params method: string, specifiyng the first line of keywords for the MOPAC input file.
+    :params title: string, used as a file name and job title for the mopac input file.
+    :params read_output: Whether to read the output file and return anything.
+    '''
+
+    s = ''
+
+    if MEM_GB is not None:
+        if MEM_GB < 1:
+            s += f'%mem={int(1000*MEM_GB)}MB\n'
+        else:
+            s += f'%mem={MEM_GB}GB\n'
+
+    if procs > 1:
+        s += f'%nprocshared={procs}\n'
+
+    s = '# opt ' if constrained_indices is not None else '# opt=modredundant '
+    s += method
+    
+    if solvent is not None:
+        s += ' ' + get_solvent_line(solvent, 'GAUSSIAN', method)
+    
+    s += '\n\nGaussian input generated by FIRECODE\n\n0 1\n'
+
+    for i, atom in enumerate(coords):
+        s += '%s     % .6f % .6f % .6f\n' % (pt[atomnos[i]].symbol, atom[0], atom[1], atom[2])
+
+    s += '\n'
+
+    if constrained_indices is not None:
+
+        for a, b in constrained_indices:
+            s += 'B %s %s F\n' % (a+1, b+1) # Gaussian numbering starts at 1
+
+    s = ''.join(s)
+    with open(f'{title}.com', 'w') as f:
+        f.write(s)
+    
+    try:
+        check_call(f'{COMMANDS["GAUSSIAN"]} {title}.com'.split(), stdout=DEVNULL, stderr=STDOUT)
+
+    except KeyboardInterrupt:
+        print('KeyboardInterrupt requested by user. Quitting.')
+        sys.exit()
+
+    if read_output:
+
+        try:
+            data = read_xyz(f'{title}.out')
+            opt_coords = data.atomcoords[0]
+            energy = data.scfenergies[-1] * 23.060548867 # eV to kcal/mol
+
+            clean_directory((f'{title}.com',))
+
+            return opt_coords, energy, True
+
+        except FileNotFoundError:
+            return None, None, False

firecode/calculators/_mopac.py

@@ -0,0 +1,242 @@
+# coding=utf-8
+'''
+FIRECODE: Filtering Refiner and Embedder for Conformationally Dense Ensembles
+Copyright (C) 2021-2024 Nicolò Tampellini
+
+SPDX-License-Identifier: LGPL-3.0-or-later
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see
+https://www.gnu.org/licenses/lgpl-3.0.en.html#license-text.
+
+'''
+
+import os
+import sys
+from subprocess import DEVNULL, STDOUT, check_call
+
+import numpy as np
+
+from firecode.algebra import dihedral, norm, norm_of, vec_angle
+from firecode.errors import MopacReadError
+from firecode.pt import pt
+from firecode.numba_functions import scramble
+from firecode.settings import COMMANDS
+from firecode.solvents import get_solvent_line
+
+
+def read_mop_out(filename):
+    '''
+    Reads a MOPAC output looking for optimized coordinates and energy.
+    :params filename: name of MOPAC filename (.out extension)
+    :return coords, energy: array of optimized coordinates and absolute energy, in kcal/mol
+    '''
+    coords = []
+    with open(filename, 'r') as f:
+        while True:
+            line = f.readline()
+
+            if 'Too many variables. By definition, at least one force constant is exactly zero' in line:
+                success = False
+                return None, 1E10, success
+
+            if not line:
+                break
+            
+            if 'SCF FIELD WAS ACHIEVED' in line:
+                while True:
+                    line = f.readline()
+                    if not line:
+                        break
+
+                    if 'FINAL HEAT OF FORMATION' in line:
+                        energy = float(line.split()[5])
+                        # in kcal/mol
+
+                    if 'CARTESIAN COORDINATES' in line:
+                        line = f.readline()
+                        line = f.readline()
+                        while line != '\n':
+                            splitted = line.split()
+                            # symbols.append(splitted[1])
+                            coords.append([float(splitted[2]),
+                                            float(splitted[3]),
+                                            float(splitted[4])])
+                                        
+                            line = f.readline()
+                            if not line:
+                                break
+                        break
+                break
+
+    coords = np.array(coords)
+
+    if coords.shape[0] != 0:
+        success = True
+        return coords, energy, success
+    
+    raise MopacReadError(f'Cannot read file {filename}: maybe a badly specified MOPAC keyword?')
+
+def mopac_opt(coords, atomnos, constrained_indices=None, method='PM7', solvent=None, title='temp', read_output=True, **kwargs):
+    '''
+    This function writes a MOPAC .mop input, runs it with the subprocess
+    module and reads its output. Coordinates used are mixed
+    (cartesian and internal) to be able to constrain the reactive atoms
+    distances specified in constrained_indices.
+
+    :params coords: array of shape (n,3) with cartesian coordinates for atoms
+    :params atomnos: array of atomic numbers for atoms
+    :params constrained_indices: array of shape (n,2), with the indices
+                                 of atomic pairs to be constrained
+    :params method: string, specifiyng the first line of keywords for the MOPAC input file.
+    :params title: string, used as a file name and job title for the mopac input file.
+    :params read_output: Whether to read the output file and return anything.
+    '''
+
+    constrained_indices_list = constrained_indices.ravel() if constrained_indices is not None else []
+    constrained_indices = constrained_indices if constrained_indices is not None else []
+
+    if solvent is not None:
+        method += ' ' + get_solvent_line(solvent, 'MOPAC', method)
+
+    order = []
+    s = [method + '\n' + title + '\n\n']
+    for i, num in enumerate(atomnos):
+        if i not in constrained_indices:
+            order.append(i)
+            s.append(' {} {} 1 {} 1 {} 1\n'.format(pt[num].symbol, coords[i][0], coords[i][1], coords[i][2]))
+
+    free_indices = list(set(range(len(atomnos))) - set(constrained_indices_list))
+    # print('free indices are', free_indices, '\n')
+
+    if len(constrained_indices_list) == len(set(constrained_indices_list)):
+    # block pairs of atoms if no atom is involved in more than one distance constrain
+
+        for a, b in constrained_indices:
+            
+            order.append(b)
+            order.append(a)
+
+            c, d = np.random.choice(free_indices, 2)
+            while c == d:
+                c, d = np.random.choice(free_indices, 2)
+            # indices of reference atoms, from unconstraind atoms set
+
+            dist = norm_of(coords[a] - coords[b]) # in Angstrom
+            # print(f'DIST - {dist} - between {a} {b}')
+
+            angle = vec_angle(norm(coords[a] - coords[b]), norm(coords[c] - coords[b]))
+            # print(f'ANGLE - {angle} - between {a} {b} {c}')
+
+            d_angle = dihedral([coords[a],
+                                coords[b],
+                                coords[c],
+                                coords[d]])
+            d_angle += 360 if d_angle < 0 else 0
+            # print(f'D_ANGLE - {d_angle} - between {a} {b} {c} {d}')
+
+            list_len = len(s)
+            s.append(' {} {} 1 {} 1 {} 1\n'.format(pt[atomnos[b]].symbol, coords[b][0], coords[b][1], coords[b][2]))
+            s.append(' {} {} 0 {} 1 {} 1 {} {} {}\n'.format(pt[atomnos[a]].symbol, dist, angle, d_angle, list_len, free_indices.index(c)+1, free_indices.index(d)+1))
+            # print(f'Blocked bond between mopac ids {list_len} {list_len+1}\n')
+
+    elif len(set(constrained_indices_list)) == 3:
+    # three atoms, the central bound to the other two
+    # OTHERS[0]: cartesian
+    # CENTRAL: internal (self, others[0], two random)
+    # OTHERS[1]: internal (self, central, two random)
+        
+        central = max(set(constrained_indices_list), key=lambda x: list(constrained_indices_list).count(x))
+        # index of the atom that is constrained to two other
+
+        others = list(set(constrained_indices_list) - {central})
+
+    # OTHERS[0]
+
+        order.append(others[0])
+        s.append(' {} {} 1 {} 1 {} 1\n'.format(pt[atomnos[others[0]]].symbol, coords[others[0]][0], coords[others[0]][1], coords[others[0]][2]))
+        # first atom is placed in cartesian coordinates, the other two have a distance constraint and are expressed in internal coordinates
+
+    #CENTRAL
+
+        order.append(central)
+        c, d = np.random.choice(free_indices, 2)
+        while c == d:
+            c, d = np.random.choice(free_indices, 2)
+        # indices of reference atoms, from unconstraind atoms set
+
+        dist = norm_of(coords[central] - coords[others[0]]) # in Angstrom
+
+        angle = vec_angle(norm(coords[central] - coords[others[0]]), norm(coords[others[0]] - coords[c]))
+
+        d_angle = dihedral([coords[central],
+                            coords[others[0]],
+                            coords[c],
+                            coords[d]])
+        d_angle += 360 if d_angle < 0 else 0
+
+        list_len = len(s)
+        s.append(' {} {} 0 {} 1 {} 1 {} {} {}\n'.format(pt[atomnos[central]].symbol, dist, angle, d_angle, list_len-1, free_indices.index(c)+1, free_indices.index(d)+1))
+
+    #OTHERS[1]
+
+        order.append(others[1])
+        c1, d1 = np.random.choice(free_indices, 2)
+        while c1 == d1:
+            c1, d1 = np.random.choice(free_indices, 2)
+        # indices of reference atoms, from unconstraind atoms set
+
+        dist1 = norm_of(coords[others[1]] - coords[central]) # in Angstrom
+
+        angle1 = np.arccos(norm(coords[others[1]] - coords[central]) @ norm(coords[others[1]] - coords[c1]))*180/np.pi # in degrees
+
+        d_angle1 = dihedral([coords[others[1]],
+                             coords[central],
+                             coords[c1],
+                             coords[d1]])
+        d_angle1 += 360 if d_angle < 0 else 0
+
+        list_len = len(s)
+        s.append(' {} {} 0 {} 1 {} 1 {} {} {}\n'.format(pt[atomnos[others[1]]].symbol, dist1, angle1, d_angle1, list_len-1, free_indices.index(c1)+1, free_indices.index(d1)+1))
+
+    else:
+        raise NotImplementedError('The constraints provided for MOPAC optimization are not yet supported')
+
+
+    s = ''.join(s)
+    with open(f'{title}.mop', 'w') as f:
+        f.write(s)
+    
+    try:
+        check_call(f'{COMMANDS["MOPAC"]} {title}.mop'.split(), stdout=DEVNULL, stderr=STDOUT)
+    except KeyboardInterrupt:
+        print('KeyboardInterrupt requested by user. Quitting.')
+        sys.exit()
+
+    os.remove(f'{title}.mop')
+    # delete input, we do not need it anymore
+
+    if read_output:
+
+        inv_order = [order.index(i) for i, _ in enumerate(order)]
+        # undoing the atomic scramble that was needed by the mopac input requirements
+
+        opt_coords, energy, success = read_mop_out(f'{title}.out')
+        os.remove(f'{title}.out')
+
+        opt_coords = scramble(opt_coords, inv_order) if opt_coords is not None else coords
+        # If opt_coords is None, that is if TS seeking crashed,
+        # sets opt_coords to the old coords. If not, unscrambles
+        # coordinates read from mopac output.
+
+        return opt_coords, energy, success

firecode/calculators/_openbabel.py

@@ -0,0 +1,154 @@
+# coding=utf-8
+'''
+FIRECODE: Filtering Refiner and Embedder for Conformationally Dense Ensembles
+Copyright (C) 2021-2024 Nicolò Tampellini
+
+SPDX-License-Identifier: LGPL-3.0-or-later
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see
+https://www.gnu.org/licenses/lgpl-3.0.en.html#license-text.
+
+'''
+
+# VERSION 0.4.4:
+# THIS MODULE IS NOT INTERFACED WITH THE MAIN PROGRAM EMBEDDER ANYMORE.
+# IT IS LEFT HERE AS AN EXTERNAL UTILITY TOOL AND FOR POTENTIAL FUTURE
+# USE AS A FASTER, LESS ROBUST ALTERNATIVE TO THE XTB FF IMPLEMENTATION.
+
+from firecode.utils import clean_directory, scramble_check, write_xyz, read_xyz
+from firecode.algebra import norm, norm_of
+from openbabel import openbabel as ob
+
+def openbabel_opt(
+                    structure,
+                    atomnos,
+                    constrained_indices,
+                    constrained_distances=None,
+                    tight_constraint=True,
+                    graphs=None,
+                    check=False,
+                    method='UFF',
+                    nsteps=1000,
+                    title='temp_ob',
+                    **kwargs,
+                ):
+        '''
+        tight_constraint: False uses the native implementation,
+                          True uses a more accurate recursive one 
+        return : MM-optimized structure (UFF/MMFF94)
+        '''
+
+        assert not check or graphs is not None, 'Either provide molecular graphs or do not check for scrambling.'
+        assert method in ('UFF', 'MMFF94', 'Ghemical', 'GAFF'), 'OpenBabel implements only the UFF, MMFF94, Ghemical and GAFF Force Fields.'
+
+        # If we have any target distance to impose,
+        # the most accurate way to do it is to manually
+        # move the second atom and then freeze both atom
+        # in place during optimization. If we would have
+        # to move the second atom too much we do that in
+        # small steps of 0.2 A, recursively, to avoid having
+        # openbabel come up with weird bonding topologies,
+        # ending in scrambling.
+
+        if constrained_distances is not None and tight_constraint:
+            for target_d, (a, b) in zip(constrained_distances, constrained_indices):
+                d = norm_of(structure[b] - structure[a])
+                delta = d - target_d
+
+                if abs(delta) > 0.2:
+                    sign = (d > target_d)
+                    recursive_c_d = [d + 0.2 * sign for d in constrained_distances]
+
+                    structure, _, _ = openbabel_opt(
+                                                    structure,
+                                                    atomnos,
+                                                    constrained_indices,
+                                                    constrained_distances=recursive_c_d,
+                                                    tight_constraint=True, 
+                                                    graphs=graphs,
+                                                    check=check,
+                                                    method=method,
+                                                    nsteps=nsteps,
+                                                    title=title,
+                                                    **kwargs,
+                                                )
+
+                d = norm_of(structure[b] - structure[a])
+                delta = d - target_d
+                structure[b] -= norm(structure[b] - structure[a]) * delta
+
+        filename=f'{title}_in.xyz'
+
+        with open(filename, 'w') as f:
+            write_xyz(structure, atomnos, f)
+        # input()
+        outname = f'{title}_out.xyz'
+
+        # Standard openbabel molecule load
+        conv = ob.OBConversion()
+        conv.SetInAndOutFormats('xyz','xyz')
+        mol = ob.OBMol()
+        conv.ReadFile(mol, filename)
+        i = 0
+
+        # Define constraints
+        constraints = ob.OBFFConstraints()
+
+        for i, (a, b) in enumerate(constrained_indices):
+
+            # Adding a distance constraint does not lead to accurate results,
+            # so the backup solution is to freeze the atoms in place
+            if tight_constraint:
+                constraints.AddAtomConstraint(int(a+1))
+                constraints.AddAtomConstraint(int(b+1))
+
+            else:
+                if constrained_distances is None:
+                    first_atom = mol.GetAtom(int(a+1))
+                    length = first_atom.GetDistance(int(b+1))
+                else:
+                    length = constrained_distances[i]
+                
+                constraints.AddDistanceConstraint(int(a+1), int(b+1), length)       # Angstroms
+
+                # constraints.AddAngleConstraint(1, 2, 3, 120.0)      # Degrees
+                # constraints.AddTorsionConstraint(1, 2, 3, 4, 180.0) # Degrees
+
+        # Setup the force field with the constraints
+        forcefield = ob.OBForceField.FindForceField(method)
+        forcefield.Setup(mol, constraints)
+
+        # Set the strictness of the constraint
+        forcefield.SetConstraints(constraints)
+
+        # Do a nsteps conjugate gradient minimization
+        # (or less if converges) and save the coordinates to mol.
+        forcefield.ConjugateGradients(nsteps)
+        forcefield.GetCoordinates(mol)
+        energy = forcefield.Energy() * 0.2390057361376673 # kJ/mol to kcal/mol
+
+        # Write the mol to a file
+        conv.WriteFile(mol,outname)
+        conv.CloseOutFile()
+
+        opt_coords = read_xyz(outname).atomcoords[0]
+
+        clean_directory((f'{title}_in.xyz', f'{title}_out.xyz'))
+        
+        if check:
+            success = scramble_check(opt_coords, atomnos, constrained_indices, graphs)
+        else:
+            success = True
+
+        return opt_coords, energy, success

firecode/calculators/_orca.py

@@ -0,0 +1,129 @@
+# coding=utf-8
+'''
+FIRECODE: Filtering Refiner and Embedder for Conformationally Dense Ensembles
+Copyright (C) 2021-2024 Nicolò Tampellini
+
+SPDX-License-Identifier: LGPL-3.0-or-later
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see
+https://www.gnu.org/licenses/lgpl-3.0.en.html#license-text.
+
+'''
+
+import sys
+from subprocess import STDOUT, check_call
+
+from firecode.settings import COMMANDS, MEM_GB
+from firecode.solvents import get_solvent_line
+from firecode.utils import clean_directory, pt, read_xyz
+
+
+def orca_opt(coords,
+             atomnos,
+             constrained_indices=None,
+             method='PM3',
+             charge=0,
+             procs=1,
+             maxiter=None,
+             mem=MEM_GB,
+             solvent=None,
+             title='temp',
+             read_output=True,
+             **kwargs):
+    '''
+    This function writes an ORCA .inp file, runs it with the subprocess
+    module and reads its output.
+
+    :params coords: array of shape (n,3) with cartesian coordinates for atoms.
+    :params atomnos: array of atomic numbers for atoms.
+    :params constrained_indices: array of shape (n,2), with the indices
+                                 of atomic pairs to be constrained.
+    :params method: string, specifiyng the first line of keywords for the MOPAC input file.
+    :params title: string, used as a file name and job title for the mopac input file.
+    :params read_output: Whether to read the output file and return anything.
+    '''
+
+    s = '! %s Opt\n\n# ORCA input generated by FIRECODE\n\n' % (method)
+
+    if solvent is not None:
+        s += '\n' + get_solvent_line(solvent, 'ORCA', method) + '\n'
+
+    if procs > 1:
+        s += f'%pal nprocs {procs} end\n\n'
+
+    s += f'%maxcore {mem*1000}\n\n'
+
+    if constrained_indices is not None:
+        s += f'%{""}geom\nConstraints\n'
+        # weird f-string to prevent python misinterpreting %
+
+        for a, b in constrained_indices:
+            s += '  {B %s %s C}\n' % (a, b)
+
+        s += '  end\nend\n\n'
+
+    if maxiter is not None:
+        s += f'%{""}geom\n  MaxIter {maxiter}\nend\n'
+        # weird f-string to prevent python misinterpreting %
+
+    s += f'*xyz {charge} 1\n'
+
+    for i, atom in enumerate(coords):
+        s += '%s     % .6f % .6f % .6f\n' % (pt[atomnos[i]].symbol, atom[0], atom[1], atom[2])
+
+    s += '*\n'
+
+    s = ''.join(s)
+    with open(f'{title}.inp', 'w') as f:
+        f.write(s)
+    
+    try:
+        with open(f"{title}.out", "w") as f:
+            check_call(f'{COMMANDS["ORCA"]} {title}.inp \"--oversubscribe\"'.split(), stdout=f, stderr=STDOUT)
+
+    except KeyboardInterrupt:
+        print('KeyboardInterrupt requested by user. Quitting.')
+        sys.exit()
+
+    if read_output:
+
+        try:
+            opt_coords = read_xyz(f'{title}.xyz').atomcoords[0]
+            energy = read_orca_property(f'{title}_property.txt')
+
+            clean_directory((f'{title}.inp',))
+
+            return opt_coords, energy, True
+
+        except FileNotFoundError:
+            return None, None, False
+
+def read_orca_property(filename):
+    '''
+    Read energy from ORCA property output file
+    '''
+    energy = None
+
+    with open(filename, 'r') as f:
+
+        while True:
+            line = f.readline()
+
+            if not line:
+                break
+
+            if 'SCF Energy:' in line:
+                energy = float(line.split()[2])
+
+    return energy