firecode 1.0.0__py3-none-any.whl

firecode/rmsd.py

@@ -0,0 +1,74 @@
+import numba as nb
+import numpy as np
+
+from firecode.algebra import get_alignment_matrix, norm_of
+
+
+@nb.njit
+def np_mean_along_axis(axis, arr):
+    '''
+    Workaround to specify axis parameters to
+    numba functions, adapted from
+    https://github.com/numba/numba/issues/1269
+    
+    '''
+    assert arr.ndim == 2
+    assert axis in [0, 1]
+    if axis == 0:
+        result = np.empty(arr.shape[1], dtype=np.float64)
+        for i in range(len(result)):
+            result[i] = np.mean(arr[:, i])
+    else:
+        result = np.empty(arr.shape[0], dtype=np.float64)
+        for i in range(len(result)):
+            result[i] = np.mean(arr[i, :])
+    return result
+
+@nb.njit
+def rmsd_and_max_numba(p, q, center=False):
+    '''
+    Returns a tuple with the RMSD between p and q
+    and the maximum deviation of their positions
+
+    '''
+
+    if center:
+        # p -= p.mean(axis=0)
+        # q -= q.mean(axis=0)
+        p -= np_mean_along_axis(0, p)
+        q -= np_mean_along_axis(0, q)
+    
+    # get alignment matrix
+    rot_mat = get_alignment_matrix(p, q)
+
+    # Apply it to p
+    p = np.ascontiguousarray(p) @ rot_mat
+
+    # Calculate deviations
+    diff = p - q
+
+    # Calculate RMSD
+    rmsd = np.sqrt((diff * diff).sum() / len(diff))
+
+    # # Calculate max deviation
+    # max_delta = np.linalg.norm(diff, axis=1).max()
+    max_delta = max([norm_of(v) for v in diff])
+
+    return rmsd, max_delta
+
+def _rmsd_similarity(ref, structures, rmsd_thr=0.5) -> bool:
+    '''
+    Simple, RMSD similarity eval function.
+
+    '''
+
+    # iterate over target structures
+    for structure in structures:
+        
+        # compute RMSD and max deviation
+        rmsd_value, maxdev_value = rmsd_and_max_numba(ref, structure)
+
+        if rmsd_value < rmsd_thr and maxdev_value < 2 * rmsd_thr:
+            return True
+            
+    return False

firecode/settings.py

@@ -0,0 +1,75 @@
+# 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.
+
+'''
+
+# IF YOU MANUALLY EDIT THIS FILE, BE SURE NOT TO
+# CHANGE IDENTATION/WHITESPACES/NEWLINES!
+
+FF_OPT_BOOL = True
+# Whether to run Force Field optimization
+# prior to the final one.
+
+FF_CALC = 'XTB'
+# Calculator to perform Force Field optimizations.
+# Possibilites are:
+# 'GAUSSIAN' : FF methods supported by Gaussian (UFF, MMFF)
+# 'XTB' : GFN-FF method
+
+DEFAULT_FF_LEVELS = {
+    ### DO NOT REMOVE
+    ### THESE TWO LINES
+    'GAUSSIAN':'UFF',
+    'XTB':'GFN-FF',
+}
+# Default levels used to run calculations, overridden by FFLEVEL keyword
+
+CALCULATOR = 'XTB'
+# Calculator used to run geometry optimization.
+# Possibilites are:
+# 'MOPAC' : Semiempirical MOPAC2016 (PM7, PM6-DH3, ...)
+# 'ORCA' : All methods supported by ORCA
+# 'GAUSSIAN' : All methods supported by Gaussian
+# 'XTB' : All methods supported by XTB
+# 'AIMNET2' : wB97M-D3
+
+DEFAULT_LEVELS = {
+    'MOPAC':'PM7',
+    'ORCA':'PM3',
+    'GAUSSIAN':'PM6',
+    'XTB':'GFN2-xTB',
+    'AIMNET2':'wB97M-D3',
+}
+# Default levels used to run calculations, overridden by LEVEL keyword
+
+COMMANDS = {
+    'MOPAC':'MOPAC2016.exe',
+    'ORCA':'/vast/palmer/apps/avx.grace/software/ORCA/5.0.4-gompi-2020b/bin/orca',
+    'GAUSSIAN':'g09.exe',
+    'XTB':'xtb',
+}
+# Command with which calculators will be called from the command line
+
+PROCS = 0
+# Number of processors (cores) per job to be used by XTB, ORCA and/or Gaussian (0 is auto)
+
+MEM_GB = 8
+# Memory allocated for each job (Gaussian/ORCA)

firecode/solvents.py

@@ -0,0 +1,126 @@
+# 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
+
+xtb_solvents = [
+    'acetone',
+    'acetonitrile',
+    'aniline',
+    'benzaldehyde',
+    'benzene',
+    'ch2cl2',
+    'chcl3',
+    'cs2',
+    'dioxane',
+    'dmf',
+    'dmso',
+    'ether',
+    'ethylacetate',
+    'furane',
+    'hexadecane',
+    'hexane',
+    'methanol',
+    'nitromethane',
+    'octanol',
+    'octanolwet',
+    'phenol',
+    'toluene',
+    'thf',
+    'water',
+
+    'none', # This is required for the ASE get_calc function
+]
+
+xtb_solvents = xtb_solvents + ['' for _ in range(3-len(xtb_solvents)%3)]
+gap = 18
+xtb_supported = ''.join([(f'{xtb_solvents[i]}{" "*(gap-len(xtb_solvents[i]))}'
+                          f'{xtb_solvents[i+1]}{" "*(gap-len(xtb_solvents[i+1]))}'
+                          f'{xtb_solvents[i+2]}\n')
+                          for i, _ in enumerate(xtb_solvents) if i%3==0])
+
+epsilon_dict = {
+    'aceticacid':6.15,
+    'acetone':20.7,
+    'acetonitrile':37.5,
+    'aniline':7.06,
+    'benzaldehyde':17.9,
+    'benzene':2.28,
+    'chloroform':4.8,
+    'cs2':2.63,
+    'ch2cl2':8.93,
+    'dioxane':2.25,
+    'dmf':36.71,
+    'dmso':46.68,
+    'et2o':4.27,
+    'dimethylether':6.18,
+    'ethanol':24.3,
+    'methanol':32.63,
+    'ethylacetate':6.02,
+    'furan':2.94,
+    'hexadecane':2.05,
+    'octanol':10.30,
+    'phenol':12.4,
+    'toluene':2.38,
+    'thf':7.58,
+    'water':80.1,
+}
+
+solvent_synonyms = {
+    'ch3cooh':'aceticacid',
+    'ch3cn':'acetonitrile',
+    'ch3cl':'chloroform',
+    'dcm':'ch2cl2',
+    'dichloromethane':'ch2cl2',
+    'carbondisuphide':'cs2',
+    'carbondisulfide':'cs2',
+    'diethylether':'et2o',
+    'etoh':'ethanol',
+    'ch3oh':'methanol',
+    'meoh':'methanol',
+    'h2o':'water',
+}
+
+new_theory_level = {
+    'MOPAC':lambda theory_level, solvent: f'EPS={epsilon_dict[solvent]}',
+    'GAUSSIAN':lambda theory_level, solvent: f'scrf=(cpcm,solvent={solvent})',
+    'ORCA':lambda theory_level, solvent: f'! CPCM\n%cpcm\nepsilon {epsilon_dict[solvent]}\nend',
+    # 'XTB':lambda theory_level, _: '',
+}
+
+def get_solvent_line(solvent, calculator, theory_level):
+
+    if solvent is None:
+        return ''
+
+    if solvent in solvent_synonyms:
+        solvent = solvent_synonyms[solvent]
+
+    if solvent not in epsilon_dict:
+        print(f'Solvent \'{solvent}\' not recognized. Implemented solvents are:')
+        for s in epsilon_dict:
+            print('    '+s)
+        print('Please note that not all solvents will work with all calculators.')
+        sys.exit()
+
+    return new_theory_level[calculator](theory_level, solvent)

firecode/tests/C2F2H4.xyz

@@ -0,0 +1,10 @@
+8
+	Energy:       0.3670310
+C         -1.18817       -0.16528       -0.05121
+C          0.33126       -0.22526       -0.05522
+H         -1.52420        0.87833        0.12518
+F         -1.68941       -0.98039        0.94728
+H         -1.57901       -0.50941       -1.03192
+F          0.82329        0.20835        1.16236
+H          0.72954        0.42644       -0.86122
+H          0.66732       -1.26825       -0.23524

firecode/tests/C2H4.xyz

@@ -0,0 +1,8 @@
+6
+Title
+C         -1.08800       -0.88350       -0.00000
+H         -0.55280       -1.81000       -0.00000
+H         -2.15800       -0.88370        0.00000
+C         -0.41070        0.29030        0.00000
+H         -0.94590        1.21690       -0.00000
+H          0.65930        0.29060        0.00000

firecode/tests/CH3Cl.xyz

@@ -0,0 +1,7 @@
+5
+Title
+C          3.04350        0.27540        0.00000
+H          3.40010       -0.73340        0.00000
+H          3.40020        0.77980       -0.87370
+H          1.97350        0.27540        0.00000
+Cl         3.63020        1.10500        1.43700

firecode/tests/HCOOH.xyz

@@ -0,0 +1,7 @@
+5
+Title
+C          0.49280       -0.05800        0.00000
+O          0.84090       -0.61220        1.03830
+H          0.74900       -0.46260       -1.00190
+O         -0.26980        1.15180        0.00000
+H         -0.44140        1.42240        0.90490

firecode/tests/HCOOOH.xyz

@@ -0,0 +1,8 @@
+6
+HCOOOH.out	Energy:     -59.7233800
+C          0.53505       -0.19559       -0.07404
+O          0.68928       -0.94130        0.86030
+H          0.84623       -0.32774       -1.11185
+O         -0.08470        1.00585        0.03772
+O         -0.53234        1.31557        1.35825
+H         -0.24162        0.53875        1.91661

firecode/tests/chelotropic.txt

@@ -0,0 +1,3 @@
+DIST(A=2.5,B=2.5) SADDLE
+C2H4.xyz 0A 3B
+HCOOOH.xyz 4AB

firecode/tests/cyclical.txt

@@ -0,0 +1,3 @@
+DIST(A=2.2,B=2.3) BYPASS
+C2H4.xyz 0A 3B
+C2H4.xyz 0B 3A

firecode/tests/dihedral.txt

@@ -0,0 +1,2 @@
+KCAL=0
+scan> C2F2H4.xyz 3 0 1 5

firecode/tests/string.txt

@@ -0,0 +1,3 @@
+SOLVENT=methanol DIST(A=2.5)
+CH3Cl.xyz 0A
+HCOOH.xyz 3A

firecode/tests/trimolecular.txt

@@ -0,0 +1,9 @@
+DIST(A=2.5,x=2,y=2.5,C=1) SHRINK NCI ROTRANGE=10 STEPS=1
+CH3Cl.xyz 0A 4y
+HCOOH.xyz 1A 4x 0C 2C
+HCOOH.xyz 1x 4y
+
+# Trimolecular SN2
+# A is O-Cl reacting pair
+# x is the intra-acid hydrogen bond
+# y is the H-Cl hydrogen bond

firecode/tests.py

@@ -0,0 +1,151 @@
+# 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
+
+def run_tests():
+    
+    import os
+    import time
+    from subprocess import CalledProcessError
+
+    os.chdir(os.path.dirname(os.path.realpath(__file__)))
+
+    from firecode.settings import (CALCULATOR, COMMANDS, DEFAULT_FF_LEVELS,
+                                 DEFAULT_LEVELS, FF_CALC, FF_OPT_BOOL, PROCS)
+
+    if CALCULATOR not in ('MOPAC','ORCA','GAUSSIAN','XTB'):
+        raise Exception(f'{CALCULATOR} is not a valid calculator. Use MOPAC, ORCA, GAUSSIAN or XTB.')
+
+    import numpy as np
+    from ase.atoms import Atoms
+    from ase.optimize import LBFGS
+
+    from firecode.ase_manipulations import get_ase_calc
+    from firecode.optimization_methods import Opt_func_dispatcher
+    from firecode.utils import (HiddenPrints, clean_directory, loadbar, read_xyz,
+                              run_command, time_to_string)
+
+    os.chdir('tests')
+
+    t_start_run = time.perf_counter()
+
+    data = read_xyz('C2H4.xyz')
+
+    dispatcher = Opt_func_dispatcher()
+
+    if CALCULATOR == 'AIMNET2':
+        dispatcher.load_aimnet2_calc(DEFAULT_LEVELS[CALCULATOR])
+
+    ##########################################################################
+
+    print('\nRunning tests for FIRECODE. Settings used:')
+    print(f'{CALCULATOR=}')
+
+    if CALCULATOR != 'XTB':
+        print(f'{CALCULATOR} COMMAND = {COMMANDS[CALCULATOR]}')
+
+    print('\nTesting calculator...')
+
+    ##########################################################################
+
+    dispatcher.opt_funcs_dict[CALCULATOR](data.atomcoords[0],
+                               data.atomnos,
+                               method=DEFAULT_LEVELS[CALCULATOR],
+                               procs=PROCS,
+                               read_output=False)
+
+    print(f'{CALCULATOR} raw calculator works.')
+
+    ##########################################################################
+
+    atoms = Atoms('HH', positions=np.array([[0, 0, 0], [0, 0, 1]]))
+    atoms.calc = get_ase_calc((CALCULATOR, DEFAULT_LEVELS[CALCULATOR], PROCS, None))
+    LBFGS(atoms, logfile=None).run()
+
+    clean_directory()
+    print(f'{CALCULATOR} ASE calculator works.')
+    
+    ##########################################################################
+
+    print(f'\n{FF_OPT_BOOL=}')
+    ff = f'on. Calculator is {FF_CALC}. Checking its status.' if FF_OPT_BOOL else 'off.'
+    print(f'Force Field optimization is turned {ff}')
+
+    if FF_OPT_BOOL:
+        if FF_CALC != 'OB': # 'XTB', 'GAUSSIAN'
+            dispatcher.opt_funcs_dict[FF_CALC](data.atomcoords[0],
+                                    data.atomnos,
+                                    method=DEFAULT_FF_LEVELS[FF_CALC],
+                                    procs=PROCS,
+                                    read_output=False)
+
+        print(f'{FF_CALC} FF raw calculator works.')
+
+        ##########################################################################
+        
+        if FF_CALC != 'OB':
+            atoms.calc = get_ase_calc((FF_CALC, DEFAULT_FF_LEVELS[FF_CALC], PROCS, None))
+            LBFGS(atoms, logfile=None).run()
+
+            clean_directory()
+            print(f'{FF_CALC} ASE calculator works.')
+
+    print('\nNo installation faults detected with the current settings. Running tests.')
+
+    ##########################################################################
+
+    tests = []
+    for f in os.listdir():
+        if f.endswith('.txt'):
+            tests.append(os.path.realpath(f))
+
+    # os.chdir(os.path.dirname(os.getcwd()))
+    # os.chdir('firecode')
+    # # Back to ./firecode
+
+    times = []
+    for i, f in enumerate(tests):
+        name = f.split('\\')[-1].split('/')[-1][:-4] # trying to make it work for either Win, Linux (and Mac?)
+        loadbar(i, len(tests), f'Running firecode tests ({name}): ')
+        
+        t_start = time.perf_counter()
+        try:
+            with HiddenPrints():
+                run_command(f'python -m firecode {f} -n {name}')
+
+        except CalledProcessError as error:
+            print('\n\n--> An error occurred:\n')
+            print(error.stderr.decode("utf-8"))
+            sys.exit()
+                    
+        t_end = time.perf_counter()
+        times.append(t_end-t_start)
+
+    loadbar(len(tests), len(tests), f'Running firecode tests ({name}): ')    
+
+    print()
+    for i, f in enumerate(tests):
+        print('    {:25s}{} s'.format(f.split('\\')[-1].split('/')[-1][:-4], round(times[i], 3)))
+
+    print(f'\nfirecode tests completed with no errors. ({time_to_string(time.perf_counter() - t_start_run)})\n')