firecode 1.0.0__py3-none-any.whl

firecode/modify_settings.py

@@ -0,0 +1,186 @@
+# 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.
+
+'''
+
+def run_setup():
+    '''
+    Invoked by the command
+    > python -m firecode -s (--setup)
+
+    Guides the user in setting up the calculation options
+    contained in the settings.py file.
+    '''
+
+    import os
+    os.chdir(os.path.dirname(os.path.realpath(__file__)))
+    from firecode.settings import DEFAULT_LEVELS, DEFAULT_FF_LEVELS, COMMANDS
+
+    properties = {
+        'FF_OPT_BOOL':False,
+        'FF_CALC':None,
+        'NEW_FF_DEFAULT':None,
+        'CALCULATOR':None,
+        'NEW_DEFAULT':None,
+        'NEW_COMMAND':None,
+        'PROCS':1,
+        'MEM_GB':1,
+    }
+
+    def ask(text, accepted=('y','n'), default='n'):
+        text = '--> ' + text
+        if accepted is None:
+            answer = input(text)
+            print()
+            return answer
+        answer = None
+        while answer not in accepted:
+            answer = input(text)
+            answer = answer if answer != '' else default
+        print()
+        return answer
+
+    tag_dict = {
+        'mop':'MOPAC',
+        'orca':'ORCA',
+        'gau':'GAUSSIAN',
+        'xtb':'XTB',
+    }
+
+    print('\FIRECODE setup:\n')
+
+    #########################################################################################
+
+    answer = ask('What Force Field calculator would you like to use?\n- XTB -> xtb\n- Gaussian -> gau\n'
+                 '- None -> none\n\nAnswer [xtb]/gau/none: ', accepted=('xtb', 'gau', 'none'), default='xtb')
+
+    if answer == 'xtb':
+        properties['FF_OPT_BOOL'] = True
+        properties['FF_CALC'] = 'XTB'
+
+    elif answer != 'none':
+        properties['FF_OPT_BOOL'] = True
+        properties['FF_CALC'] = tag_dict[answer]
+
+        answer = ask((f'The default level for {properties["FF_CALC"]} force field calculations is \'{DEFAULT_FF_LEVELS[properties["FF_CALC"]]}\'. ' +
+                       'If you would like to change it, type it here, otherwise press enter : '), accepted=None)
+        if answer != '':
+            properties['NEW_FF_DEFAULT'] = answer
+
+    #########################################################################################
+
+    answer = ask('What main calculator would you like to use?\n- MOPAC -> mop\n- ORCA -> orca\n- Gaussian -> gau\n- XTB -> xtb\n\nAnswer mop/orca/gau/[xtb]: ',
+                accepted=('mop','orca','gau','xtb'), default='xtb')
+
+    properties['CALCULATOR'] = tag_dict[answer]
+
+    #########################################################################################
+
+    answer = ask((f'The default level for {properties["CALCULATOR"]} calculations is \'{DEFAULT_LEVELS[properties["CALCULATOR"]]}\'. ' +
+                'If you would like to change it, type it here, otherwise press enter : '), accepted=None)
+    if answer != '':
+        properties['NEW_DEFAULT'] = answer
+
+    #########################################################################################
+
+    if properties['CALCULATOR'] != 'XTB':
+        answer = ask((f'Current command to call {properties["CALCULATOR"]} is {COMMANDS[properties["CALCULATOR"]]}. ' +
+                    'If you would like to change it, type it here, otherwise press enter : '), accepted=None)
+        if answer != '':
+            properties['NEW_COMMAND'] = answer
+
+    #########################################################################################
+    
+    properties['PROCS'] = ask(f'How many cores should {properties['CALCULATOR']} jobs run on? [4] : ',
+                                accepted=[str(n) for n in range(1,100)], default=4)
+
+    #########################################################################################
+
+    # if properties['CALCULATOR'] in ('GAUSSIAN', 'ORCA'):
+    properties['MEM_GB'] = int(ask('How much memory per core should a GAUSSIAN/ORCA job have, in GBs? [4] : ',
+                                accepted=[str(n) for n in range(1,1000)], default='4'))
+
+    #########################################################################################
+
+    rank = {
+        'MOPAC':1,
+        'ORCA':2,
+        'GAUSSIAN':3,
+        'XTB':4,
+    }
+
+    q = "\'"
+
+    with open('settings.py', 'r') as f:
+        lines = f.readlines()
+
+    old_lines = lines.copy()
+
+    for _l, line in enumerate(old_lines):
+
+        if 'FF_OPT_BOOL =' in line:
+            lines[_l] = 'FF_OPT_BOOL = ' + str(properties['FF_OPT_BOOL']) + '\n'
+            FF_OPT_BOOL = properties['FF_OPT_BOOL']
+
+        if 'FF_CALC =' in line:
+            lines[_l] = 'FF_CALC = ' + q + str(properties['FF_CALC']) + q + '\n'
+            FF_CALC = properties['FF_CALC']
+
+        elif 'CALCULATOR =' in line:
+            lines[_l] = 'CALCULATOR = ' + q + properties['CALCULATOR'] + q + '\n'
+            CALCULATOR = properties['CALCULATOR']
+
+        elif 'DEFAULT_LEVELS = {' in line:
+            if properties['NEW_DEFAULT'] is not None:
+                lines[_l+rank[properties['CALCULATOR']]] = ' '*4 + q + properties['CALCULATOR'] + q + ':' + q + properties['NEW_DEFAULT'] + q + ',\n'
+                DEFAULT_LEVELS[CALCULATOR] = properties['NEW_DEFAULT']
+
+        elif 'DEFAULT_FF_LEVELS = {' in line:
+            if properties['NEW_FF_DEFAULT'] is not None:
+                lines[_l+rank[properties['FF_CALC']]] = ' '*4 + q + properties['FF_CALC'] + q + ':' + q + properties['NEW_FF_DEFAULT'] + q + ',\n'
+                DEFAULT_FF_LEVELS[FF_CALC] = properties['NEW_FF_DEFAULT']
+
+        elif 'COMMANDS = {' in line:
+            if properties['NEW_COMMAND'] is not None:
+                lines[_l+rank[properties['CALCULATOR']]] = ' '*4 + q + properties['CALCULATOR'] + q + ':' + q + properties['NEW_COMMAND'] + q + ',\n'
+
+        elif 'PROCS =' in line:
+            lines[_l] = 'PROCS = ' + str(properties['PROCS']) + '\n'
+            PROCS = properties['PROCS']
+
+        elif 'MEM_GB =' in line:
+            lines[_l] = 'MEM_GB = ' + str(properties['MEM_GB']) + '\n'
+            MEM_GB = properties['MEM_GB']
+
+    with open('settings.py', 'w') as f:
+        f.write(''.join(lines))
+
+    print('\nfirecode setup performed correctly.')
+
+    ff = f'{FF_CALC}/{DEFAULT_FF_LEVELS[FF_CALC]}' if FF_OPT_BOOL else 'Turned off'
+    opt = f'{CALCULATOR}/{DEFAULT_LEVELS[CALCULATOR]}'
+    s = f'  FF      : {ff}\n  OPT     : {opt}\n  PROCS   : {PROCS}'
+    s += f'\n  MEM     : {MEM_GB} GB'
+
+    print(s)
+
+if __name__ == '__main__':
+    run_setup()

firecode/mprof.py

@@ -0,0 +1,65 @@
+if __name__ == '__main__':
+    # ## Let's use malloc to see if we have a memory leak
+
+    # %%
+
+    from firecode.embedder import Embedder
+
+    embedder = Embedder(r'C:\Users\Nik\Desktop\debug\malloc\input', stamp='debug')
+    # embedder = Embedder(r'/mnt/c/Users/Nik/Desktop/debug/malloc/input', stamp='debug')
+    embedder.objects[0].atomcoords.shape
+
+    # %%
+    # does not seem to leak in the conformational search, maybe it does in the augmentation part
+    from firecode.embedder import RunEmbedding
+    import numpy as np
+    mol = embedder.objects[0]
+
+    # embedder.options.ff_calc = 'XTB'
+    # embedder.options.ff_level = 'GFN-FF'
+
+    re = RunEmbedding(embedder)
+    re.structures = np.array(embedder.objects[0].atomcoords)
+    re.atomnos = mol.atomnos
+    re.constrained_indices = np.array([[] for _ in re.structures])
+    re.energies = np.array([0 ,0])
+
+    re.structures.shape
+
+    # %%
+
+    # re.csearch_augmentation(text='warmup', max_structs=100)
+
+    # # %%
+    # tracemalloc.start()
+    # s = tracemalloc.take_snapshot()
+
+    # ############################################################
+
+    # try:
+    #     # re.csearch_augmentation(text='tracemalloc', max_structs=100)
+    #     re.csearch_augmentation_routine()
+    # except KeyboardInterrupt:
+    #     pass
+
+    # ############################################################
+
+    # lines = []
+    # top_stats = tracemalloc.take_snapshot().compare_to(s, 'lineno')
+    # for stat in top_stats[:5]:
+    #     lines.append(str(stat))
+    # print("\n".join(lines))
+
+
+    # %%
+    # from memory_profiler import profile
+
+    # @profile
+    def wrapper(*args, **kwargs):
+        return re.csearch_augmentation_routine()
+        
+    try:
+        # re.csearch_augmentation(text='tracemalloc', max_structs=100)
+        wrapper()
+    except KeyboardInterrupt:
+        pass

firecode/multiembed.py

@@ -0,0 +1,148 @@
+import os
+import time
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from itertools import permutations
+from shutil import copy, rmtree
+
+import numpy as np
+
+from firecode.errors import InputError, ZeroCandidatesError
+from firecode.utils import (cartesian_product, suppress_stdout_stderr,
+                          time_to_string, timing_wrapper)
+
+
+def multiembed_dispatcher(embedder):
+    '''
+    Calls the appropriate multiembed subfunction
+    based on embedder attributes.
+    '''
+    
+    if len(embedder.objects) == 2:
+        return multiembed_bifunctional(embedder)
+    
+    raise InputError('The multiembed requested is currently unavailable.')
+
+
+def multiembed_bifunctional(embedder):
+    '''
+    Run multiple concurrent bifunctional cyclical embeds
+    exploring all relative arrangement of each pair of
+    reactive_indices between the two molecules.
+    '''
+    
+    mol1, mol2 = embedder.objects
+
+    # get every possible combination of indices in the two molecules
+    pairs = cartesian_product(mol1.reactive_indices, mol2.reactive_indices)
+
+    # get every arrangement of interacting pairs not insisting on the same atom twice
+    arrangements = [((ix_1, ix_2), (iy_1, iy_2)) for ((ix_1, ix_2), (iy_1, iy_2)) in permutations(pairs, 2) if ix_1 != iy_1 and ix_2 != iy_2]
+
+    structures_out, constr_ids, processes = [], [], []
+
+    embedder.t_start_run = time.perf_counter()
+    embedder.log()
+
+    max_workers = embedder.avail_cpus or 1
+    embedder.log(f'--> Multiembed: running {len(arrangements)} embeds on {max_workers} threads')
+
+    with ProcessPoolExecutor(max_workers=max_workers) as executor:
+
+        # for each arrangement, perform a dedicated embed 
+        for i, arrangement in enumerate(arrangements):
+
+            process = executor.submit(
+                                        timing_wrapper,
+                                        run_child_embedder,
+                                        mol1.filename,
+                                        mol2.filename,
+                                        constrained_indices=arrangement,
+                                        i=i,
+                                        options=embedder.options,
+                                    )
+            processes.append(process)  
+
+        for i, process in enumerate(as_completed(processes)):
+
+            (structures, constrained_indices), elapsed = process.result()
+
+            embedder.log(f'--> Child process {i+1:3}/{len(arrangements):3}: generated {len(structures):4} candidates in {time_to_string(elapsed, verbose=True)}.')
+
+            if len(structures) > 0:
+                structures_out.append(structures)
+                constr_ids.append(constrained_indices)
+
+    structures_out = np.concatenate(structures_out)
+
+    embedder.log(f'\n--> Multiembed completed: generated {len(structures_out)} candidates in {time_to_string(time.perf_counter() - embedder.t_start_run, verbose=True)}.')
+    
+    # only get interaction constraints, as the internal will be added later during refinement
+    embedder.constrained_indices = np.concatenate(constr_ids)
+
+    return structures_out
+
+def run_child_embedder(
+                        mol1_name,
+                        mol2_name,
+                        constrained_indices,
+                        i,
+                        options,
+                    ):
+
+    from firecode.embedder import Embedder, RunEmbedding
+
+    start_dir = os.getcwd()
+    foldername = f'firecode_embed{i+1}'
+    (ix_1, ix_2), (iy_1, iy_2) = constrained_indices
+
+    # create a dedicated folder
+    if not os.path.isdir(os.path.join(os.getcwd(), foldername)):
+        os.mkdir(foldername)
+
+    # copy structure files into it
+    copy(os.path.join(os.getcwd(), mol1_name),
+            os.path.join(os.getcwd(), foldername))
+    copy(os.path.join(os.getcwd(), mol2_name),
+            os.path.join(os.getcwd(), foldername))
+
+    os.chdir(foldername)
+    child_name = f'embed{i+1}_input.txt'
+
+    with open(child_name, 'w') as f:
+        extra = ''
+        extra += ' debug' if options.debug else ''
+        extra += ' simpleorbitals' if options.simpleorbitals else ''
+        extra += f' shrink={options.shrink_multiplier}' if options.shrink else ''
+
+        f.write(f'noopt rigid{extra}\n')
+        f.write(f'{mol1_name} {ix_1}x {iy_1}y\n')
+        f.write(f'{mol2_name} {ix_2}x {iy_2}y\n')
+
+    with suppress_stdout_stderr():
+
+        child_name = os.path.join(os.getcwd(), child_name)
+        child_embedder = Embedder(child_name, f'embed{i+1}')
+        child_embedder = RunEmbedding(child_embedder)
+
+        child_embedder._set_reactive_atoms_cumnums()
+        child_embedder.write_mol_info()
+        child_embedder.log(f'\n--> FIRECODE multiembed child process - arrangement {i+1}')
+        child_embedder.t_start_run = time.perf_counter()
+
+        try:
+            child_embedder.generate_candidates()
+            child_embedder.compenetration_refining()
+            child_embedder.fitness_refining()
+            child_embedder.similarity_refining(rmsd=False, verbose=True)
+            child_embedder.write_structures('unoptimized', energies=False)
+
+        except ZeroCandidatesError:
+            child_embedder.structures = []
+
+        child_embedder.log(f'\n--> Child process terminated ({time_to_string(time.perf_counter() - child_embedder.t_start_run, verbose=True)})')
+
+        os.chdir(start_dir)
+        if not options.debug:
+            rmtree(os.path.join(os.getcwd(), foldername))
+
+    return child_embedder.structures, child_embedder.constrained_indices

firecode/nci.py

@@ -0,0 +1,186 @@
+# 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.
+
+'''
+from itertools import combinations
+
+import numpy as np
+
+from firecode.algebra import norm_of
+from firecode.parameters import nci_dict
+from firecode.pt import pt
+from firecode.graph_manipulations import is_phenyl
+
+
+def get_nci(coords, atomnos, constrained_indices, ids):
+    '''
+    Returns a list of guesses for intermolecular non-covalent
+    interactions between molecular fragments/atoms. Used to get
+    a hint of the most prominent NCIs that drive stereo/regio selectivity.
+    '''
+    nci = []
+    print_list = []
+    
+    symbols = [pt[i].symbol for i in atomnos]
+    constrained_indices = constrained_indices.ravel()
+
+    print_list, nci = _get_nci_atomic_pairs(coords, symbols, constrained_indices, ids)
+    # Initialize with atomic pairs NCIs
+
+    # Start checking group contributions
+    aromatic_centers = _get_aromatic_centers(coords, symbols, ids)
+    # print(f'structure has {len(aromatic_centers)} phenyl rings')
+
+    # checking phenyl-atom pairs and phenyl-phenyl pairs
+    pl, nc = _get_nci_aromatic_rings(coords, symbols, ids, aromatic_centers)
+    print_list += pl
+    nci += nc
+
+    return nci, print_list
+
+def _get_nci_atomic_pairs(coords, symbols, constrained_indices, ids):
+    '''
+    '''
+    print_list = []
+    nci = []
+
+    cum_ids = np.cumsum(ids)
+
+    for i1, _ in enumerate(coords):
+    # check atomic pairs (O-H, N-H, ...)
+
+        start_of_next_mol = cum_ids[next(i for i,n in enumerate(cum_ids) if i1 < n)]
+        # ensures that we are only taking into account intermolecular NCIs
+
+        for i2, _ in enumerate(coords[start_of_next_mol:]):
+            i2 += start_of_next_mol
+
+            if (i1 not in constrained_indices) and (i2 not in constrained_indices):
+                # ignore atoms involved in constraints
+
+                    s = ''.join(sorted([symbols[i1], symbols[i2]]))
+                    # print(f'Checking pair {i1}/{i2}')
+
+                    if s in nci_dict:
+                        threshold, nci_type = nci_dict[s]
+                        dist = norm_of(coords[i1]-coords[i2])
+
+                        if dist < threshold:
+
+                            print_list.append(nci_type + f' ({round(dist, 2)} A, indices {i1}/{i2})')
+                            # string to be printed in log
+
+                            nci.append((nci_type, i1, i2))
+                            # tuple to be used in identifying the NCI
+
+    return print_list, nci
+
+def _get_nci_aromatic_rings(coords, symbols, ids, aromatic_centers):
+    '''
+    '''
+    cum_ids = np.cumsum(ids)
+    print_list, nci = [], []
+
+    for owner, center in aromatic_centers:
+        for i, atom in enumerate(coords):
+
+            if i < cum_ids[0]:
+                atom_owner = 0
+            else:
+                atom_owner = next(i for i,n in enumerate(np.cumsum(ids)) if i < n)
+
+            if atom_owner != owner:
+            # if this atom belongs to a molecule different than the one that owns the phenyl
+
+                s = ''.join(sorted(['Ph', symbols[i]]))
+                if s in nci_dict:
+
+                    threshold, nci_type = nci_dict[s]
+                    dist = norm_of(center - atom)
+
+                    if dist < threshold:
+
+                        print_list.append(nci_type + f' ({round(dist, 2)} A, atom {i}/ring)')
+                        # string to be printed in log
+
+                        nci.append((nci_type, i, 'ring'))
+                        # tuple to be used in identifying the NCI
+
+    # checking phenyl-phenyl pairs
+    for i, owner_center in enumerate(aromatic_centers):
+        owner1, center1 = owner_center
+        for owner2, center2 in aromatic_centers[i+1:]:
+            if owner1 != owner2:
+            # if this atom belongs to a molecule different than owner
+
+                    threshold, nci_type = nci_dict['PhPh']
+                    dist = norm_of(center1 - center2)
+
+                    if dist < threshold:
+
+                        print_list.append(nci_type + f' ({round(dist, 2)} A, ring/ring)')
+                        # string to be printed in log
+
+                        nci.append((nci_type, 'ring', 'ring'))
+                        # tuple to be used in identifying the NCI
+    return print_list, nci
+
+def _get_aromatic_centers(coords, symbols, ids):
+    '''
+    '''
+    cum_ids = np.cumsum(ids)
+    masks = []
+
+    for mol, _ in enumerate(ids):
+
+        if mol == 0:
+            mol_mask = slice(0, cum_ids[0])
+            filler = 0
+        else:
+            mol_mask = slice(cum_ids[mol-1], cum_ids[mol])
+            filler = cum_ids[mol-1]
+
+        aromatics_indices = np.array([i+filler for i, s in enumerate(symbols[mol_mask]) if s in ('C','N')])
+
+        if len(aromatics_indices) > 5:
+        # only check for phenyls in molecules with more than 5 C/N atoms
+
+            masks.append(list(combinations(aromatics_indices, 6)))
+            # all possible combinations of picking 6 C/N atoms from this molecule
+
+    aromatic_centers = []
+
+    if masks:
+
+        masks = np.concatenate(masks)
+
+        for mask in masks:
+
+            if is_phenyl(coords[mask]):
+
+                center = np.mean(coords[mask], axis=0)
+
+                owner = next(i for i,n in enumerate(np.cumsum(ids)) if np.all(mask < n))
+                # index of the molecule that owns that phenyl ring
+
+                aromatic_centers.append((owner, center))
+
+    return aromatic_centers