molSimplify 1.7.4__py3-none-any.whl

molSimplify/Informatics/coulomb_analyze.py

@@ -0,0 +1,67 @@
+import numpy as np
+
+from molSimplify.Classes.atom3D import atom3D
+from molSimplify.Classes.globalvars import globalvars
+from molSimplify.Scripts.geometry import distance
+from molSimplify.utils.decorators import deprecated
+
+
+@deprecated('Use the correctly spelled version create_coulomb_matrix instead.')
+def create_columb_matrix(mol):
+    return create_coulomb_matrix(mol)
+
+
+def create_coulomb_matrix(mol):
+    # create Coulomb matrix from mol3D information
+    index_set = list(range(0, mol.natoms))
+    # fetch the database of nuclear charges
+    globs = globalvars()
+    amassdict = globs.amass()
+    A = np.zeros((mol.natoms, mol.natoms))
+    # main build
+    for i in index_set:
+        Zi = float(amassdict[mol.getAtom(i).symbol()][1])
+        for j in index_set:
+            if i == j:
+                A[i, j] = 0.5*np.power(Zi, (2.4))
+            else:
+                Zj = float(amassdict[mol.getAtom(j).symbol()][1])
+                this_dist = distance(mol.getAtom(i).coords(), mol.getAtom(j).coords())
+                if this_dist != 0.0:
+                    A[i, j] = Zi*Zj/float(this_dist)
+                else:
+                    A[i, j] = 0
+    # sort by columns in increasing order
+    weights = []
+    for col in A.T:
+        weights.append(np.linalg.norm(col))
+    sort_weights = (np.argsort(weights))[::-1]
+    A = A[:, sort_weights]
+    # sort by rows in increasing order
+    weights = []
+    for row in A:
+        weights.append(np.linalg.norm(row))
+    sort_weights = (np.argsort(weights))[::-1]
+    A = A[sort_weights, :]
+    return A
+
+
+def pad_mol(mol, target_atoms):
+    # adds placeholder atoms
+    # with zero nuclear charge
+    # located at the origin
+    # in order to get consistent size
+    # coulomb matrix
+    this_natoms = mol.natoms
+    blank_atom = atom3D(Sym='X')  # placeholder type
+    blank_atom.frozen = False
+    safe_stop = False
+    counter = 0
+    while this_natoms < target_atoms and not safe_stop:
+        mol.addAtom(blank_atom)
+        this_natoms = mol.natoms
+        counter += 1
+        if counter > target_atoms:
+            safe_stop = True
+            print('error padding mol')
+    return mol

molSimplify/Informatics/decoration_manager.py

@@ -0,0 +1,193 @@
+# Written by JP Janet for HJK Group
+# Dpt of Chemical Engineering, MIT
+
+# molS modules
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Scripts.geometry import (checkcolinear,
+                                          distance,
+                                          norm,
+                                          rotate_around_axis,
+                                          rotation_params,
+                                          vecangle,
+                                          vecdiff)
+from molSimplify.Scripts.io import getlicores, lig_load
+
+# FF dependence
+##########################################
+# ##### ligand decoration function #######
+##########################################
+
+
+def decorate_ligand(ligand_to_decorate: mol3D, decoration, decoration_index,
+                    debug: bool = False) -> mol3D:
+    # This function is useful for functionalization. Adding functional groups to a base ligand.
+
+    # structgen depends on decoration_manager, and decoration_manager depends on structgen.ffopt
+    # Thus, this import needs to be placed here to avoid a circular dependence
+    from molSimplify.Scripts.structgen import ffopt
+
+    # INPUT
+    #   - ligand_to_decorate: mol3D ligand
+    #   - set ligand_to_decorate.ob_dict to False or empty dictionary first to avoid potential error
+    #   - decoration: list of smiles/decorations
+    #   - decoration_index: list of ligand atoms to replace
+    #   - debug: debugging flag for additional prints
+    # OUTPUT
+    #   - merged_ligand: built ligand
+
+    lig = ligand_to_decorate
+    # reorder to ensure highest atom index
+    # removed first
+    sort_order = [i[0] for i in sorted(enumerate(decoration_index), key=lambda x:x[1])]
+    sort_order = sort_order[::-1]  # reverse
+
+    decoration_index = [decoration_index[i] for i in sort_order]
+    decoration = [decoration[i] for i in sort_order]
+    if debug:
+        print(('decoration_index  is  ' + str(decoration_index)))
+    licores = getlicores()
+    if not isinstance(lig, mol3D):
+        lig, emsg = lig_load(lig, licores)
+    else:
+        lig.convert2OBMol()
+        lig.charge = lig.OBMol.GetTotalCharge()
+    lig.convert2mol3D()  # convert to mol3D
+
+    # create new ligand
+    merged_ligand = mol3D()
+    merged_ligand.copymol3D(lig)
+    for i, dec in enumerate(decoration):
+        print(('** decoration number ' + str(i) + ' attaching ' + dec + ' at site '+str(decoration_index[i])
+               + '**\n'))
+        dec, emsg = lig_load(dec, licores)
+        # dec.OBMol.AddHydrogens()
+        dec.convert2mol3D()  # convert to mol3D
+        if debug:
+            print(i)
+            print(decoration_index)
+
+            print((merged_ligand.getAtom(decoration_index[i]).symbol()))
+            print((merged_ligand.getAtom(decoration_index[i]).coords()))
+            merged_ligand.writexyz('basic.xyz')
+        Hs = dec.getHsbyIndex(0)
+        if len(Hs) > 0 and (not len(dec.cat)):
+            dec.deleteatom(Hs[0])
+            dec.charge = dec.charge - 1
+
+        if len(dec.cat) > 0:
+            decind = dec.cat[0]
+        else:
+            decind = 0
+        dec.alignmol(dec.getAtom(decind), merged_ligand.getAtom(decoration_index[i]))
+        r1 = dec.getAtom(decind).coords()
+        r2 = dec.centermass()  # center of mass
+        rrot = r1
+        decb = mol3D()
+        decb.copymol3D(dec)
+        ####################################
+        # center of mass of local environment (to avoid bad placement of bulky ligands)
+        auxmol = mol3D()
+        for at in dec.getBondedAtoms(decind):
+            auxmol.addAtom(dec.getAtom(at))
+        if auxmol.natoms > 0:
+            r2 = auxmol.centermass()  # overwrite global with local centermass
+            ####################################
+            # rotate around axis and get both images
+            theta, u = rotation_params(merged_ligand.centermass(), r1, r2)
+            dec = rotate_around_axis(dec, rrot, u, theta)
+            if debug:
+                dec.writexyz('dec_ARA' + str(i) + '.xyz')
+            decb = rotate_around_axis(decb, rrot, u, theta-180)
+            if debug:
+                decb.writexyz('dec_ARB' + str(i) + '.xyz')
+            d1 = distance(dec.centermass(), merged_ligand.centermass())
+            d2 = distance(decb.centermass(), merged_ligand.centermass())
+            dec = dec if (d2 < d1) else decb  # pick best one
+        #####################################
+        # check for linear molecule
+        auxm = mol3D()
+        for at in dec.getBondedAtoms(decind):
+            auxm.addAtom(dec.getAtom(at))
+        if auxm.natoms > 1:
+            r0 = dec.getAtom(decind).coords()
+            r1 = auxm.getAtom(0).coords()
+            r2 = auxm.getAtom(1).coords()
+            if checkcolinear(r1, r0, r2):
+                theta, urot = rotation_params(r1, merged_ligand.getAtom(decoration_index[i]).coords(), r2)
+                theta = vecangle(vecdiff(r0, merged_ligand.getAtom(decoration_index[i]).coords()), urot)
+                dec = rotate_around_axis(dec, r0, urot, theta)
+
+        # get the default distance between atoms in question
+        connection_neighbours = merged_ligand.getAtom(merged_ligand.getBondedAtomsnotH(decoration_index[i])[0])
+        new_atom = dec.getAtom(decind)
+        target_distance = connection_neighbours.rad + new_atom.rad
+        position_to_place = vecdiff(new_atom.coords(), connection_neighbours.coords())
+        old_dist = norm(position_to_place)
+        missing = (target_distance - old_dist)/2
+        dec.translate([missing*position_to_place[j] for j in [0, 1, 2]])
+
+        r1 = dec.getAtom(decind).coords()
+        u = vecdiff(r1, merged_ligand.getAtom(decoration_index[i]).coords())
+        dtheta = 2
+        optmax = -9999
+        totiters = 0
+        decb = mol3D()
+        decb.copymol3D(dec)
+        # check for minimum distance between atoms and center of mass distance
+        while totiters < 180:
+            dec = rotate_around_axis(dec, r1, u, dtheta)
+            d0 = dec.mindist(merged_ligand)  # try to maximize minimum atoms distance
+            d0cm = dec.distance(merged_ligand)  # try to maximize center of mass distance
+            iteropt = d0cm+d0  # optimization function
+            if (iteropt > optmax):  # if better conformation, keep
+                decb = mol3D()
+                decb.copymol3D(dec)
+                optmax = iteropt
+            totiters += 1
+        dec = decb
+        if debug:
+            dec.writexyz('dec_aligned' + str(i) + '.xyz')
+            print(('natoms before delete ' + str(merged_ligand.natoms)))
+            print(('obmol before delete at  ' + str(decoration_index[i]) + ' is ' + str(merged_ligand.OBMol.NumAtoms())))
+        # store connectivity for deleted H
+        BO_mat = merged_ligand.populateBOMatrix()
+        row_deleted = BO_mat[decoration_index[i]]
+        bonds_to_add = []
+
+        # find where to put the new bonds ->>> Issue here.
+        for j, els in enumerate(row_deleted):
+            if els > 0:
+                # if there is a bond with an atom number
+                # before the deleted atom, all is fine
+                # else, we subtract one as the row will be be removed
+                if j < decoration_index[i]:
+                    bond_partner = j
+                else:
+                    bond_partner = j - 1
+                if len(dec.cat) > 0:
+                    bonds_to_add.append((bond_partner, (merged_ligand.natoms-1)+dec.cat[0], els))
+                else:
+                    bonds_to_add.append((bond_partner, merged_ligand.natoms-1, els))
+
+        # perform delete
+        merged_ligand.deleteatom(decoration_index[i])
+
+        merged_ligand.convert2OBMol()
+        if debug:
+            merged_ligand.writexyz('merged del ' + str(i) + '.xyz')
+        # merge and bond
+        merged_ligand.combine(dec, bond_to_add=bonds_to_add)
+        merged_ligand.convert2OBMol()
+
+        if debug:
+            merged_ligand.writexyz('merged' + str(i) + '.xyz')
+            merged_ligand.printxyz()
+            print('************')
+
+    merged_ligand.convert2OBMol()
+    merged_ligand, _ = ffopt('MMFF94', merged_ligand, [], 0, [], False, [], 100)
+    BO_mat = merged_ligand.populateBOMatrix()
+    if debug:
+        merged_ligand.writexyz('merged_relaxed.xyz')
+        print(BO_mat)
+    return merged_ligand

molSimplify/Informatics/geo_analyze.py

@@ -0,0 +1,88 @@
+# Written JP Janet
+# for HJK Group
+# Dpt of Chemical Engineering, MIT
+
+##########################################################
+######## Defines class for postprocessing    #############
+########     geometries for octahedral    ################
+################      TM complexs          ###############
+##########################################################
+from molSimplify.Classes.ligand import ligand_breakdown, ligand_assign_consistent
+from molSimplify.Scripts.geometry import distance
+
+def getOctBondDistances(mol):
+    ## This function gets
+    ## ax and equatorial
+    ## min and max bond lengths
+    liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+    ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list, ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list, built_ligand_list = ligand_assign_consistent(
+        mol, liglist, ligdents, ligcons, False, False)
+    ax_dist = list()
+    eq_dist = list()
+    for ax_ligs in ax_con_list:
+        tempList = list()
+        for conatms in ax_ligs:
+            tempList.append(distance(mol.getAtom(mol.findMetal()[0]).coords(), mol.getAtom(conatms).coords()))
+        ax_dist.append(tempList)
+    for eq_ligs in eq_con_list:
+        tempList = list()
+        for conatms in eq_ligs:
+            tempList.append(distance(mol.getAtom(mol.findMetal()[0]).coords(), mol.getAtom(conatms).coords()))
+        eq_dist.append(tempList)
+    return ax_dist, eq_dist
+
+
+def getLigFormulae(mol):
+    ## This function gets
+    ## ax and equatorial
+    ## ligand names for octahedral complexes
+    axnames = []
+    eqnames = []
+    liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+    ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list, ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list, built_ligand_list = ligand_assign_consistent(
+        mol, liglist, ligdents, ligcons, False, False)
+    for axl in ax_ligand_list:
+        axnames.append(axl.mol.make_formula())
+    for eql in eq_ligand_list:
+        eqnames.append(eql.mol.make_formula())
+    return axnames, eqnames
+
+
+def maximum_ML_dist(mol):
+    core = mol.getAtom(mol.findMetal()[0]).coords()
+    max_dist = 0
+    for atom_inds in mol.getBondedAtomsSmart(mol.findMetal()[0]):
+        dist = distance(core, mol.getAtom(atom_inds).coords())
+        if (dist > max_dist):
+            max_dist = dist
+    return max_dist
+
+
+def maximum_any_dist(mol):
+    core = mol.getAtom(mol.findMetal()[0])
+    max_dist = 0
+    for atoms in mol.getAtoms():
+        dist = distance(core.coords(), atoms.coords())
+        if (dist > max_dist):
+            max_dist = dist
+    return max_dist
+
+
+def minimum_ML_dist(mol):
+    core = mol.getAtom(mol.findMetal()[0]).coords()
+    min_dist = 1000
+    for atom_inds in mol.getBondedAtomsSmart(mol.findMetal()[0]):
+        dist = distance(core, mol.getAtom(atom_inds).coords())
+        if (dist < min_dist) and (dist > 0):
+            min_dist = dist
+    return min_dist
+
+
+def mean_ML_dist(mol):
+    core = mol.getAtom(mol.findMetal()[0]).coords()
+    mean_dist = 0.0
+    for atom_inds in mol.getBondedAtomsSmart(mol.findMetal()[0]):
+        dist = distance(core, mol.getAtom(atom_inds).coords())
+        mean_dist += float(dist)
+    mean_dist = mean_dist / float(len(mol.getBondedAtomsSmart(mol.findMetal()[0])))
+    return mean_dist

molSimplify/Informatics/geometrics.py

@@ -0,0 +1,56 @@
+
+import numpy as np
+import json
+from importlib_resources import files as resource_files
+from molSimplify.Classes.mol3D import mol3D
+
+
+def get_percentile_csd_geometrics(geometrics_csd, geodict, geotype, maxdent,
+                                  metrics=['oct_angle_devi_max', 'max_del_sig_angle',
+                                           'dist_del_all', 'dist_del_all_relative'],
+                                  path2metric="molSimplify/Informatics/geometrics_csd.json"):
+    '''
+    Obtain the percentile rank of a geometric dict compared to the entire CSD complexes.
+    geometrics_csd: dict, {"geotype": "metric": [each complex's metric]}. If not specified as a dict, it will be loaded by path2metric.
+    geodict: dict, geometric dict for a complex. Obtained by IsStructure().
+    geotype: str, type of geometry
+    metrics: list, a list of geometric considered.
+    path2metric: str, the molSimplify path to load geometrics_csd if geometrics_csd is not specified
+    '''
+    jsonpath = resource_files("molSimplify").joinpath(path2metric)
+    if not isinstance(geometrics_csd, dict):
+        print("loading csd geometrics...")
+        with open(jsonpath, "r") as f:
+            geometrics_csd = json.load(f)
+    percentile_dict = {}
+    for k in metrics:
+        percentile_dict[k] = [round(geodict[k], 2),
+                              round(sum(np.abs(geometrics_csd[geotype]["all"][k]) < geodict[k]) / float(len(geometrics_csd[geotype]["all"][k])) * 100),
+                              round(sum(np.abs(geometrics_csd[geotype][str(maxdent)][k]) < geodict[k]) / float(len(geometrics_csd[geotype][str(maxdent)][k])) * 100 + 1e-4)]
+    return percentile_dict
+
+
+def get_percentile_from_mol2(mol2string,
+                             geometrics_csd,
+                             metrics=['oct_angle_devi_max', 'max_del_sig_angle',
+                                      'dist_del_all', 'dist_del_all_relative'],
+                             path2metric="molSimplify/Informatics/geometrics_csd.json"):
+    '''
+    Get the geometric percentile rank given a mol2string.
+    mol2string: str, str in the mol2 file
+    geometrics_csd: dict, {"geotype": "metric": [each complex's metric]}. If not specified as a dict, it will be loaded by path2metric.
+    metrics: list, a list of geometric considered.
+    path2metric: str, the molSimplify path to load geometrics_csd if geometrics_csd is not specified
+    '''
+    mol = mol3D()
+    mol.readfrommol2(mol2string, readstring=True)
+    eqsym, maxdent, ligdents, homoleptic, ligsymmetry = mol.get_symmetry_denticity()
+    results = mol.get_geometry_type()
+    geotype = results['geometry']
+    if geotype in ["sandwich", "edge"]:
+        print("cannot deal with sandwich or edge compounds now.")
+        d = {}
+        for k in metrics:
+            d[k] = False
+        return d
+    return get_percentile_csd_geometrics(geometrics_csd=geometrics_csd, geodict=results['summary'][geotype], geotype=geotype, maxdent=maxdent, metrics=metrics, path2metric=path2metric)

molSimplify/Informatics/graph_analyze.py

@@ -0,0 +1,163 @@
+# Written by JP Janet for HJK Group
+# Dpt of Chemical Engineering, MIT
+
+# #########################################################
+# ###### This script is a collection of helper ############
+# #######  routines that convert a molecule    #############
+# #######   in mol3D form to a truncated graph #############
+# #########################################################
+# import modules
+from molSimplify.Classes.globalvars import globalvars
+from molSimplify.Classes.mol3D import mol3D
+import numpy as np
+
+
+def obtain_truncation(mol, con_atoms, hops):
+    # # this function truncates a ligand to a certain number of
+    # # hops from the core
+    # Inputs:
+    #       mol - mol3D class to truncate
+    #       con_atoms - index of atoms that connect to metal
+    #       hops - int, number of hops to truncate
+    trunc_mol = mol3D(use_atom_specific_cutoffs=mol.use_atom_specific_cutoffs)
+    # metal_ind = mol.findMetal()[0]
+    # trunc_mol.addAtom(mol.getAtom(metal_ind))
+    added_list = list()
+    # added_list.append(metal_ind)
+    for connections in con_atoms:
+        hopped = 0
+        active_set = [connections]
+        while hopped < hops:
+            hopped += 1
+            new_active_set = list()
+            for this_atom in active_set:
+                # add all connection atoms
+                if this_atom not in added_list:
+                    trunc_mol.addAtom(mol.getAtom(this_atom))
+                    added_list.append(this_atom)
+                # prepare all atoms attached to this connection
+                this_atoms_neighbors = mol.getBondedAtomsSmart(this_atom)
+                for bound_atoms in this_atoms_neighbors:
+                    if (bound_atoms not in added_list):
+                        trunc_mol.addAtom(mol.getAtom(bound_atoms))
+                        added_list.append(bound_atoms)
+                    [new_active_set.append(element) for element in this_atoms_neighbors]
+            active_set = new_active_set
+    if len(mol.graph):
+        delete_inds = [x for x in range(mol.natoms) if x not in added_list]
+        sort_inds = np.argsort(added_list)
+        trunc_mol.atoms = [trunc_mol.atoms[x] for x in sort_inds]
+        trunc_mol.graph = np.delete(np.delete(mol.graph, delete_inds, 0), delete_inds, 1)
+    if mol.bo_dict:
+        save_bo_dict = mol.get_bo_dict_from_inds(added_list)
+        trunc_mol.bo_dict = save_bo_dict
+    return trunc_mol
+
+
+def obtain_truncation_metal(mol, hops):
+    # # this function truncates a ligand to a certain number of
+    # # hops from the core
+    # Inputs:
+    #       mol - mol3D class to truncate
+    #       con_atoms - index of atoms that connect to metal
+    #       hops - int, number of hops to truncate
+    trunc_mol = mol3D(use_atom_specific_cutoffs=mol.use_atom_specific_cutoffs)
+    metal_ind = mol.findMetal()[0]
+    trunc_mol.addAtom(mol.getAtom(metal_ind))
+    added_list = list()
+    added_list.append(metal_ind)
+    hopped = 0
+    active_set = [metal_ind]
+    while hopped < hops:
+        hopped += 1
+        new_active_set = list()
+        for this_atom in active_set:
+            # add all connection atoms
+            if this_atom not in added_list:
+                trunc_mol.addAtom(mol.getAtom(this_atom))
+                added_list.append(this_atom)
+            # prepare all atoms attached to this connection
+            this_atoms_neighbors = mol.getBondedAtomsSmart(this_atom)
+            for bound_atoms in this_atoms_neighbors:
+                if (bound_atoms not in added_list):
+                    trunc_mol.addAtom(mol.getAtom(bound_atoms))
+                    added_list.append(bound_atoms)
+                [new_active_set.append(element) for element in this_atoms_neighbors]
+        active_set = new_active_set
+    sort_inds = np.argsort(added_list)
+    mapping_sub2mol = {}
+    for ii, ind in enumerate(sort_inds):
+        mapping_sub2mol.update({ind: added_list[ii]})
+    trunc_mol.mapping_sub2mol = mapping_sub2mol
+    if len(mol.graph):
+        delete_inds = [x for x in range(mol.natoms) if x not in added_list]
+        trunc_mol.atoms = [trunc_mol.atoms[x] for x in sort_inds]
+        trunc_mol.graph = np.delete(np.delete(mol.graph, delete_inds, 0), delete_inds, 1)
+    if mol.bo_dict:
+        save_bo_dict = mol.get_bo_dict_from_inds(added_list)
+        trunc_mol.bo_dict = save_bo_dict
+    return trunc_mol
+
+
+def create_graph(mol):
+    if not len(mol.graph):
+        # create connectivity matrix from mol3D information
+        index_set = range(0, mol.natoms)
+        A = np.zeros((mol.natoms, mol.natoms))
+        for i in index_set:
+            this_bonded_atoms = mol.getBondedAtomsSmart(i)
+            for j in index_set:
+                if j in this_bonded_atoms:
+                    A[i, j] = 1
+    else:
+        A = mol.graph
+    return A
+
+
+def get_lig_EN(mol, connection_atoms):
+    # calculate the maximum abs electronegativity
+    # difference between connection atom an all
+    # neighbors
+    max_EN = 0
+    globs = globalvars()
+    for atoms in connection_atoms:
+        this_atoms_neighbors = mol.getBondedAtomsSmart(atoms)
+        for bound_atoms in this_atoms_neighbors:
+            this_EN = float(globs.endict()[mol.getAtom(atoms).symbol()]) - float(
+                globs.endict()[mol.getAtom(bound_atoms).symbol()])
+            if (abs(this_EN) >= max_EN):
+                max_EN = this_EN
+    return max_EN
+
+
+def remove_diagonals(matrix):
+    n = matrix.shape[0]
+    for i in range(0, n):
+        matrix[i, i] = 0
+    return matrix
+
+
+def kier(mol):
+    copy_mol = mol3D()
+    copy_mol.copymol3D(mol)
+    copy_mol.deleteHs()
+    A = create_graph(copy_mol)
+    n = A.shape[0]
+    twopath = A * A
+    remove_diagonals(twopath)
+    p2 = twopath.sum() / 2
+
+    if (p2 != 0):
+        two_kappa = ((np.power(n, 3) - 5 * np.power(n, 2) + 8 * n - 4)
+                     / (np.power(p2, 2)))
+    else:
+        two_kappa = 0
+    return (two_kappa)
+
+
+def get_truncated_kier(ligand, connection_atoms):
+    # three hop truncation
+    trunc_mol = obtain_truncation(ligand, connection_atoms, 3)
+    # trunc_mol.writexyz('trunc.xyz')
+    this_kier = kier(trunc_mol)
+    return this_kier