molSimplify 1.7.4__py3-none-any.whl

molSimplify/Informatics/MOF/atomic.py

@@ -0,0 +1,267 @@
+"""
+Elemental information.
+"""
+MASS = {
+    "H": 1.00794,
+    "He": 4.002602,
+    "Li": 6.941,
+    "Be": 9.012182,
+    "B": 10.811,
+    "C": 12.0107,
+    "N": 14.0067,
+    "O": 15.9994,
+    "F": 18.9984032,
+    "Ne": 20.1797,
+    "Na": 22.98976928,
+    "Mg": 24.3050,
+    "Al": 26.9815386,
+    "Si": 28.0855,
+    "P": 30.973762,
+    "S": 32.065,
+    "Cl": 35.453,
+    "Ar": 39.948,
+    "K": 39.0983,
+    "Ca": 40.078,
+    "Sc": 44.955912,
+    "Ti": 47.867,
+    "V": 50.9415,
+    "Cr": 51.9961,
+    "Mn": 54.938045,
+    "Fe": 55.845,
+    "Co": 58.933195,
+    "Ni": 58.6934,
+    "Cu": 63.546,
+    "Zn": 65.38,
+    "Ga": 69.723,
+    "Ge": 72.64,
+    "As": 74.92160,
+    "Se": 78.96,
+    "Br": 79.904,
+    "Kr": 83.798,
+    "Rb": 85.4678,
+    "Sr": 87.62,
+    "Y": 88.90585,
+    "Zr": 91.224,
+    "Nb": 92.90638,
+    "Mo": 95.96,
+    "Tc": 98,
+    "Ru": 101.07,
+    "Rh": 102.90550,
+    "Pd": 106.42,
+    "Ag": 107.8682,
+    "Cd": 112.411,
+    "In": 114.818,
+    "Sn": 118.710,
+    "Sb": 121.760,
+    "Te": 127.60,
+    "I": 126.90447,
+    "Xe": 131.293,
+    "Cs": 132.9054519,
+    "Ba": 137.327,
+    "La": 138.90547,
+    "Ce": 140.116,
+    "Pr": 140.90765,
+    "Nd": 144.242,
+    "Pm": 145,
+    "Sm": 150.36,
+    "Eu": 151.964,
+    "Gd": 157.25,
+    "Tb": 158.92535,
+    "Dy": 162.500,
+    "Ho": 164.93032,
+    "Er": 167.259,
+    "Tm": 168.93421,
+    "Yb": 173.054,
+    "Lu": 174.9668,
+    "Hf": 178.49,
+    "Ta": 180.94788,
+    "W": 183.84,
+    "Re": 186.207,
+    "Os": 190.23,
+    "Ir": 192.217,
+    "Pt": 195.084,
+    "Au": 196.966569,
+    "Hg": 200.59,
+    "Tl": 204.3833,
+    "Pb": 207.2,
+    "Bi": 208.98040,
+    "Po": 209,
+    "At": 210,
+    "Rn": 222,
+    "Fr": 223,
+    "Ra": 226,
+    "Ac": 227,
+    "Th": 232.03806,
+    "Pa": 231.03588,
+    "U": 238.02891,
+    "Np": 237,
+    "Pu": 244,
+    "Am": 243,
+    "Cm": 247,
+    "Bk": 247,
+    "Cf": 251,
+    "Es": 252,
+    "Fm": 257,
+    "Md": 258,
+    "No": 259,
+    "Lr": 262,
+    "Rf": 265,
+    "Db": 268,
+    "Sg": 271,
+    "Bh": 272,
+    "Hs": 270,
+    "Mt": 276,
+    "Ds": 281,
+    "Rg": 280,
+    "Cn": 285,
+    "Uut": 284,
+    "Uuq": 289,
+    "Uup": 288,
+    "Uuh": 293,
+    "Uuo": 294}
+
+# If this is a nice list we can just .index or [slice] to get atomic numbers
+ATOMIC_NUMBER = [
+    "ZERO", "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg",
+    "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn",
+    "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb",
+    "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In",
+    "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd", "Pm",
+    "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta",
+    "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At",
+    "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk",
+    "Cf", "Es", "Fm", "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt",
+    "Ds", "Rg", "Cn", "Uut", "Uuq", "Uup", "Uuh", "Uuo"]
+
+
+COVALENT_RADII = {
+    # Covalent radii revisited -- DOI:10.1039/B801115J
+    "H": 0.31,
+    "He": 0.28,
+    "Li": 1.28,
+    "Be": 0.96,
+    "B": 0.84,
+    "C": 0.76,  # for sp3; sp2 = 0.73; sp = 0.69
+    "C_1": 0.69,
+    "C_2": 0.73,
+    "C_R": 0.73,
+    "C_3": 0.76,
+    "N": 0.71,
+    "O": 0.66,
+    "F": 0.57,
+    "Ne": 0.58,
+    "Na": 1.66,
+    "Mg": 1.41,
+    "Al": 1.21,
+    "Si": 1.11,
+    "P": 1.07,
+    "S": 1.05,
+    "Cl": 1.02,
+    "Ar": 1.06,
+    "K": 2.03,
+    "Ca": 1.76,
+    "Sc": 1.7,
+    "Ti": 1.6,
+    "V": 1.53,
+    "Cr": 1.39,
+    "Mn": 1.61,  # low spin = 1.39
+    "Fe": 1.52,  # low spin = 1.32
+    "Co": 1.5,  # low spin = 1.26
+    "Ni": 1.24,
+    "Cu": 1.32,
+    "Zn": 1.22,
+    "Ga": 1.22,
+    "Ge": 1.2,
+    "As": 1.19,
+    "Se": 1.2,
+    "Br": 1.2,
+    "Kr": 1.16,
+    "Rb": 2.2,
+    "Sr": 1.95,
+    "Y": 1.9,
+    "Zr": 1.5,  # 1.75  !! temporarily added to correct the UIO cluster bonding problem
+    "Nb": 1.64,
+    "Mo": 1.54,
+    "Tc": 1.47,
+    "Ru": 1.46,
+    "Rh": 1.42,
+    "Pd": 1.39,
+    "Ag": 1.45,
+    "Cd": 1.44,
+    "In": 1.42,
+    "Sn": 1.39,
+    "Sb": 1.39,
+    "Te": 1.38,
+    "I": 1.39,
+    "Xe": 1.4,
+    "Cs": 2.44,
+    "Ba": 2.15,
+    "La": 2.07,
+    "Ce": 2.04,
+    "Pr": 2.03,
+    "Nd": 2.01,
+    "Pm": 1.99,
+    "Sm": 1.98,
+    "Eu": 1.98,
+    "Gd": 1.96,
+    "Tb": 1.94,
+    "Dy": 1.92,
+    "Ho": 1.92,
+    "Er": 1.89,
+    "Tm": 1.9,
+    "Yb": 1.87,
+    "Lu": 1.87,
+    "Hf": 1.75,
+    "Ta": 1.7,
+    "W": 1.62,
+    "Re": 1.51,
+    "Os": 1.44,
+    "Ir": 1.41,
+    "Pt": 1.36,
+    "Au": 1.36,
+    "Hg": 1.32,
+    "Tl": 1.45,
+    "Pb": 1.46,
+    "Bi": 1.48,
+    "Po": 1.4,
+    "At": 1.5,
+    "Rn": 1.5,
+    "Fr": 2.6,
+    "Ra": 2.21,
+    "Ac": 2.15,
+    "Th": 2.06,
+    "Pa": 2,
+    "U": 1.96,
+    "Np": 1.9,
+    "Pu": 1.87,
+    "Am": 1.8,
+    "Cm": 1.69,
+}
+METALS = [3, 4, 11, 12, 13, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+          37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 55, 56, 57,
+          58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+          75, 76, 77, 78, 79, 80, 81, 82, 83, 87, 88, 89, 90, 91, 92, 93, 94,
+          95, 96, 97, 98, 99, 100, 101, 102, 103]
+
+# keeping track of some different groups of atoms.
+organic = set(["H", "C", "N", "O", "S"])
+non_metals = set(["H", "He", "C", "N", "O", "F", "Ne",
+                  "P", "S", "Cl", "Ar", "Se", "Br", "Kr",
+                  "I", "Xe", "Rn"])
+noble_gases = set(["He", "Ne", "Ar", "Kr", "Xe", "Rn"])
+metalloids = set(["B", "Si", "Ge", "As", "Sb", "Te", "At"])
+lanthanides = set(["La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu",
+                   "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu"])
+actinides = set(["Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk",
+                 "Cf", "Es", "Fm", "Md", "No", "Lr"])
+transition_metals = set(["Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni",
+                         "Cu", "Zn", "Y", "Zr", "Nb", "Mo", "Tc", "Ru",
+                         "Rh", "Pd", "Ag", "Cd", "Hf", "Ta", "W", "Re",
+                         "Os", "Ir", "Pt", "Ir", "Pt", "Au", "Hg", "Rf",
+                         "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn"])
+alkali = set(["Li", "Na", "K", "Rb", "Cs", "Fr"])
+alkaline_earth = set(["Be", "Mg", "Ca", "Sr", "Ba", "Ra"])
+main_group = set(["Al", "Ga", "Ge", "In", "Sn", "Sb", "Tl", "Pb", "Bi",
+                  "Po", "At", "Cn", "Uut", "Fl", "Uup", "Lv", "Uus"])
+
+metals = main_group | alkaline_earth | alkali | transition_metals | metalloids | lanthanides

molSimplify/Informatics/MOF/cluster_extraction.py

@@ -0,0 +1,388 @@
+from molSimplify.Scripts.cellbuilder_tools import import_from_cif
+from molSimplify.Classes.mol3D import mol3D
+import os
+import copy
+import numpy as np
+from scipy import sparse
+import molSimplify.Informatics.MOF.PBC_functions as pbc_funs
+import networkx as nx
+
+#### NOTE: In addition to molSimplify's dependencies, this portion requires
+#### pymatgen to be installed. The RACs are intended to be computed
+#### on the primitive cell of the material. You can compute them
+#### using the commented out snippet of code if necessary.
+
+# Example usage is given at the bottom of the script.
+
+'''<<<< CODE TO COMPUTE PRIMITIVE UNIT CELLS >>>>'''
+#########################################################################################
+# This MOF RAC generator assumes that pymatgen is installed.                            #
+# Pymatgen is used to get the primitive cell.                                           #
+#########################################################################################
+
+
+def get_primitive(datapath, writepath):
+    from pymatgen.io.cif import CifParser
+    s = CifParser(datapath, occupancy_tolerance=1).get_structures()[0]
+    sprim = s.get_primitive_structure()
+    sprim.to("cif", writepath)
+
+
+'''<<<< END OF CODE TO COMPUTE PRIMITIVE UNIT CELLS >>>>'''
+
+#########################################################################################
+# The RAC functions here average over the different SBUs or linkers present. This is    #
+# because one MOF could have multiple different linkers or multiple SBUs, and we need   #
+# the vector to be of constant dimension so we can correlate the output property.       #
+#########################################################################################
+
+def make_MOF_SBU_RACs(SBUlist, SBU_subgraph, molcif, depth, name,cell,anchoring_atoms, sbupath=False, connections_list=False, connections_subgraphlist=False):
+    n_sbu = len(SBUlist)
+    print(SBUlist)
+    G=nx.from_numpy_matrix(molcif.graph)
+    cycles = nx.minimum_cycle_basis(G) # gets all closed rings in graph
+    subcycle_list = []
+    for cycle in cycles:
+        skip_row = False
+        for element in cycle:
+            if molcif.getAtom(element).ismetal():
+                skip_row = True
+                break
+        if not skip_row:
+            subcycle_list.append(cycle)
+
+    """""""""
+    Loop over all SBUs as identified by subgraphs. Then create the mol3Ds for each SBU.
+    """""""""
+    for i, SBU in enumerate(SBUlist):
+        atoms_in_sbu = []
+        SBU_mol = mol3D()
+        for val in SBU:
+            atoms_in_sbu.append(val)
+            SBU_mol.addAtom(molcif.getAtom(val))
+        # SBU_mol.graph = SBU_subgraph[i].todense()
+
+        """""""""
+        For each linker connected to the SBU, find the lc atoms for the lc-RACs.
+        """""""""
+        for j, linker in enumerate(connections_list):
+            if len(set(SBU).intersection(linker))>0:
+                #### This means that the SBU and linker are connected.
+                temp_mol = mol3D()
+                link_list = []
+                for jj, val2 in enumerate(linker):
+                    if val2 in anchoring_atoms:
+                        link_list.append(jj)
+                    # This builds a mol object for the linker --> even though it is in the SBU section.
+                    temp_mol.addAtom(molcif.getAtom(val2))
+
+                temp_mol.graph = connections_subgraphlist[j].todense()
+                """""""""
+                If heteroatom functional groups exist (anything that is not C or H, so methyl is missed, also excludes anything lc, so carboxylic metal-coordinating oxygens skipped),
+                compile the list of atoms
+                """""""""
+                functional_atoms = []
+                for jj in range(len(temp_mol.graph)):
+                    if jj not in link_list:
+                        if not set({temp_mol.atoms[jj].sym}) & set({"C","H"}):
+                            functional_atoms.append(jj)
+        # At this point, we look at the cycles for the graph, then add atoms if they are part of a cycle
+        for cycle in subcycle_list:
+            if (len(set(SBU).intersection(cycle))>0) and (len(set(SBU_mol.findMetal()).intersection(cycle))==0):
+                for atom in cycle:
+                    atoms_in_sbu.append(atom)
+                    SBU_mol.addAtom(molcif.getAtom(atom))
+                    for ringatom_connected_atoms in molcif.getBondedAtoms(atom):
+                        if molcif.getAtom(int(ringatom_connected_atoms)).symbol()=='H':
+                            atoms_in_sbu.append(ringatom_connected_atoms)
+                            SBU_mol.addAtom(molcif.getAtom(ringatom_connected_atoms))
+
+        # This part gets the subgraph and reassigns it, because we added atoms to the SBU
+        tempgraph= molcif.graph[np.ix_(atoms_in_sbu,atoms_in_sbu)]
+        SBU_mol.graph = tempgraph
+        SBU_mol_cart_coords=np.array([atom.coords() for atom in  SBU_mol.atoms])
+        SBU_mol_atom_labels=[atom.sym for atom in  SBU_mol.atoms]
+        SBU_mol_adj_mat = np.array(SBU_mol.graph)
+        ###### WRITE THE SBU MOL TO THE PLACE
+        if sbupath and not os.path.exists(sbupath+"/"+str(name)+str(i)+'.xyz'):
+            xyzname = sbupath+"/"+str(name)+"_sbu_"+str(i)+".xyz"
+            SBU_mol_fcoords_connected = pbc_funs.XYZ_connected(cell , SBU_mol_cart_coords , SBU_mol_adj_mat )
+            pbc_funs.writeXYZandGraph(xyzname , SBU_mol_atom_labels , cell , SBU_mol_fcoords_connected,SBU_mol_adj_mat)
+    return None, None, None, None
+
+def make_MOF_linker_RACs(linkerlist, linker_subgraphlist, molcif, depth, name, cell, linkerpath=False):
+    #### This function makes full scope linker RACs for MOFs ####
+    nlink = len(linkerlist)
+    for i, linker in enumerate(linkerlist):
+        linker_mol = mol3D()
+        for val in linker:
+            linker_mol.addAtom(molcif.getAtom(val))
+        linker_mol.graph = linker_subgraphlist[i].todense()
+        linker_mol_cart_coords=np.array([atom.coords() for atom in  linker_mol.atoms])
+        linker_mol_atom_labels=[atom.sym for atom in  linker_mol.atoms]
+        linker_mol_adj_mat = np.array(linker_mol.graph)
+        ###### WRITE THE LINKER MOL TO THE PLACE
+        if linkerpath and not os.path.exists(linkerpath+"/"+str(name)+str(i)+".xyz"):
+            xyzname = linkerpath+"/"+str(name)+"_linker_"+str(i)+".xyz"
+            linker_mol_fcoords_connected = pbc_funs.XYZ_connected(cell, linker_mol_cart_coords, linker_mol_adj_mat)
+            pbc_funs.writeXYZandGraph(xyzname, linker_mol_atom_labels, cell, linker_mol_fcoords_connected, linker_mol_adj_mat)
+    return None, None
+
+
+def get_MOF_descriptors(data, depth, path=False, xyzpath = False):
+    if not path:
+        print('Need a directory to place all of the linker, SBU, and ligand objects. Exiting now.')
+        raise ValueError('Base path must be specified in order to write descriptors.')
+    else:
+        if path.endswith('/'):
+            path = path[:-1]
+        if not os.path.isdir(path+'/ligands'):
+            os.mkdir(path+'/ligands')
+        if not os.path.isdir(path+'/linkers'):
+            os.mkdir(path+'/linkers')
+        if not os.path.isdir(path+'/sbus'):
+            os.mkdir(path+'/sbus')
+        if not os.path.isdir(path+'/xyz'):
+            os.mkdir(path+'/xyz')
+        if not os.path.isdir(path+'/logs'):
+            os.mkdir(path+'/logs')
+    ligandpath = path+'/ligands'
+    linkerpath = path+'/linkers'
+    sbupath = path+'/sbus'
+    logpath = path+"/logs"
+
+    """""""""
+    Input cif file and get the cell parameters and adjacency matrix. If overlap, do not featurize.
+    Simultaneously prepare mol3D class for MOF for future RAC featurization (molcif)
+    """""""""
+
+    cpar, allatomtypes, fcoords = pbc_funs.readcif(data)
+    cell_v = pbc_funs.mkcell(cpar)
+    cart_coords = pbc_funs.fractional2cart(fcoords, cell_v)
+    name = os.path.basename(data).strip(".cif")
+    if len(cart_coords) > 2000:
+        print("Too large cif file, skipping it for now...")
+        tmpstr = "Failed to featurize %s: large primitive cell\n"%(name)
+        pbc_funs.write2file(path, "/FailedStructures.log", tmpstr)
+        return None, None
+    distance_mat = pbc_funs.compute_distance_matrix3(cell_v, cart_coords)
+    try:
+        adj_matrix, _ = pbc_funs.compute_adj_matrix(distance_mat, allatomtypes)
+    except NotImplementedError:
+        tmpstr = "Failed to featurize %s: atomic overlap\n" % (name)
+        pbc_funs.write2file(path, "/FailedStructures.log", tmpstr)
+        return None, None
+
+    pbc_funs.writeXYZandGraph(xyzpath, allatomtypes, cell_v, fcoords, adj_matrix.todense())
+    molcif, _, _, _, _ = import_from_cif(data, True)
+    molcif.graph = adj_matrix.todense()
+
+    """""""""
+    check number of connected components.
+    if more than 1: it checks if the structure is interpenetrated. Fails if no metal in one of the connected components (identified by the graph).
+    This includes floating solvent molecules.
+    """""""""
+
+    n_components, labels_components = sparse.csgraph.connected_components(csgraph=adj_matrix, directed=False, return_labels=True)
+    metal_list = set([at for at in molcif.findMetal(transition_metals_only=False)])
+    # print('##### METAL LIST', metal_list, [molcif.getAtom(val).symbol() for val in list(metal_list)])
+    # print('##### METAL LIST', metal_list, [val.symbol() for val in molcif.atoms])
+    if not len(metal_list) > 0:
+        tmpstr = "Failed to featurize %s: no metal found\n" % (name)
+        pbc_funs.write2file(path, "/FailedStructures.log", tmpstr)
+        return None, None
+
+    for comp in range(n_components):
+        inds_in_comp = [i for i in range(len(labels_components)) if labels_components[i] == comp]
+        if not set(inds_in_comp) & metal_list:
+            tmpstr = "Failed to featurize %s: solvent molecules\n" % (name)
+            pbc_funs.write2file(path, "/FailedStructures.log", tmpstr)
+            return None, None
+
+    if n_components > 1:
+        print("structure is interpenetrated")
+        tmpstr = "%s found to be an interpenetrated structure\n" % (name)
+        pbc_funs.write2file(logpath,"/%s.log" % name, tmpstr)
+
+    """""""""
+    step 1: metallic part
+        removelist = metals (1) + atoms only connected to metals (2) + H connected to (1+2)
+        SBUlist = removelist + 1st coordination shell of the metals
+    removelist = set()
+    Logs the atom types of the connecting atoms to the metal in logpath.
+    """""""""
+    SBUlist = set()
+    metal_list = set([at for at in molcif.findMetal(transition_metals_only=False)])
+    # print('##### METAL LIST2', metal_list, [molcif.getAtom(val).symbol() for val in list(metal_list)])
+    # print('##### all LIST2', metal_list, [val.symbol() for val in molcif.atoms])
+    [SBUlist.update(set([metal])) for metal in molcif.findMetal(transition_metals_only=False)] #Remove all metals as part of the SBU
+    [SBUlist.update(set(molcif.getBondedAtomsSmart(metal))) for metal in molcif.findMetal(transition_metals_only=False)]
+    removelist = set()
+    [removelist.update(set([metal])) for metal in molcif.findMetal(transition_metals_only=False)] #Remove all metals as part of the SBU
+    for metal in removelist:
+        bonded_atoms = set(molcif.getBondedAtomsSmart(metal))
+        bonded_atoms_types = set([str(allatomtypes[at]) for at in set(molcif.getBondedAtomsSmart(metal))])
+        cn = len(bonded_atoms)
+        cn_atom = ",".join([at for at in bonded_atoms_types])
+        tmpstr = "atom %i with type of %s found to have %i coordinates with atom types of %s\n" % (metal, allatomtypes[metal], cn, cn_atom)
+        pbc_funs.write2file(logpath, "/%s.log" % name, tmpstr)
+    [removelist.update(set([atom])) for atom in SBUlist if all((molcif.getAtom(val).ismetal() or molcif.getAtom(val).symbol().upper() == 'H') for val in molcif.getBondedAtomsSmart(atom))]
+    """""""""
+    adding hydrogens connected to atoms which are only connected to metals. In particular interstitial OH, like in UiO SBU.
+    """""""""
+    for atom in SBUlist:
+        for val in molcif.getBondedAtomsSmart(atom):
+            if molcif.getAtom(val).symbol().upper() == 'H':
+                removelist.update(set([val]))
+
+    """""""""
+    At this point:
+    The remove list only removes metals and things ONLY connected to metals or hydrogens.
+    Thus the coordinating atoms are double counted in the linker.
+
+    step 2: organic part
+        removelist = linkers are all atoms - the removelist (assuming no bond between
+        organiclinkers)
+    """""""""
+    allatoms = set(range(0, adj_matrix.shape[0]))
+    linkers = allatoms - removelist
+    linker_list, linker_subgraphlist = pbc_funs.get_closed_subgraph(linkers.copy(), removelist.copy(), adj_matrix)
+    connections_list = copy.deepcopy(linker_list)
+    connections_subgraphlist = copy.deepcopy(linker_subgraphlist)
+    linker_length_list = [len(linker_val) for linker_val in linker_list]
+    adjmat = adj_matrix.todense()
+    """""""""
+    find all anchoring atoms on linkers and ligands (lc identification)
+    """""""""
+    anc_atoms = set()
+    for linker in linker_list:
+        for atom_linker in linker:
+            bonded2atom = np.nonzero(adj_matrix[atom_linker,:])[1]
+            if set(bonded2atom) & metal_list:
+                anc_atoms.add(atom_linker)
+    """""""""
+    step 3: linker or ligand ?
+    checking to find the anchors and #SBUs that are connected to an organic part
+    anchor <= 1 -> ligand
+    anchor > 1 and #SBU > 1 -> linker
+    else: walk over the linker graph and count #crossing PBC
+        if #crossing is odd -> linker
+        else -> ligand
+    """""""""
+    initial_SBU_list, initial_SBU_subgraphlist = pbc_funs.get_closed_subgraph(removelist.copy(), linkers.copy(), adj_matrix)
+    templist = linker_list[:]
+    tempgraphlist = linker_subgraphlist[:]
+    long_ligands = False
+    max_min_linker_length, min_max_linker_length = (0, 100)
+    for ii, atoms_list in reversed(list(enumerate(linker_list))):  # Loop over all linker subgraphs
+        linkeranchors_list = set()
+        linkeranchors_atoms = set()
+        sbuanchors_list = set()
+        sbu_connect_list = set()
+        """""""""
+        Here, we are trying to identify what is actually a linker and what is a ligand.
+        To do this, we check if something is connected to more than one SBU. Set to
+        handle cases where primitive cell is small, ambiguous cases are recorded.
+        """""""""
+        for iii, atoms in enumerate(atoms_list): #loop over all atoms in a linker
+            connected_atoms = np.nonzero(adj_matrix[atoms,:])[1]
+            for kk, sbu_atoms_list in enumerate(initial_SBU_list): #loop over all SBU subgraphs
+                for sbu_atoms in sbu_atoms_list: #Loop over SBU
+                    if sbu_atoms in connected_atoms:
+                        linkeranchors_list.add(iii)
+                        linkeranchors_atoms.add(atoms)
+                        sbuanchors_list.add(sbu_atoms)
+                        sbu_connect_list.add(kk) #Add if unique SBUs
+        min_length, max_length = pbc_funs.linker_length(linker_subgraphlist[ii].todense(), linkeranchors_list)
+
+        if len(linkeranchors_list) >= 2:  # linker, and in one ambigous case, could be a ligand.
+            if len(sbu_connect_list) >= 2:  # Something that connects two SBUs is certain to be a linker
+                max_min_linker_length = max(min_length, max_min_linker_length)
+                min_max_linker_length = min(max_length, min_max_linker_length)
+                continue
+            else:
+                # check number of times we cross PBC :
+                # TODO: we still can fail in multidentate ligands!
+                linker_cart_coords = np.array([
+                    at.coords() for at in [molcif.getAtom(val) for val in atoms_list]])
+                linker_adjmat = np.array(linker_subgraphlist[ii].todense())
+                pr_image_organic = pbc_funs.ligand_detect(cell_v,linker_cart_coords,linker_adjmat,linkeranchors_list)
+                sbu_temp = linkeranchors_atoms.copy()
+                sbu_temp.update({val for val in initial_SBU_list[list(sbu_connect_list)[0]]})
+                sbu_temp = list(sbu_temp)
+                sbu_cart_coords = np.array([
+                    at.coords() for at in [molcif.getAtom(val) for val in sbu_temp]])
+                sbu_adjmat = pbc_funs.slice_mat(adj_matrix.todense(),sbu_temp)
+                pr_image_sbu = pbc_funs.ligand_detect(cell_v,sbu_cart_coords,sbu_adjmat,set(range(len(linkeranchors_list))))
+                if not (len(np.unique(pr_image_sbu, axis=0))==1 and len(np.unique(pr_image_organic, axis=0))==1): # linker
+                    max_min_linker_length = max(min_length,max_min_linker_length)
+                    min_max_linker_length = min(max_length,min_max_linker_length)
+                    tmpstr = str(name)+','+' Anchors list: '+str(sbuanchors_list) \
+                            +','+' SBU connectlist: '+str(sbu_connect_list)+' set to be linker\n'
+                    pbc_funs.write2file(ligandpath,"/ambiguous.txt",tmpstr)
+                    continue
+                else: #  all anchoring atoms are in the same unitcell -> ligand
+                    removelist.update(set(templist[ii])) # we also want to remove these ligands
+                    SBUlist.update(set(templist[ii])) # we also want to remove these ligands
+                    linker_list.pop(ii)
+                    linker_subgraphlist.pop(ii)
+                    tmpstr = str(name)+','+' Anchors list: '+str(sbuanchors_list) \
+                            +','+' SBU connectlist: '+str(sbu_connect_list)+' set to be ligand\n'
+                    pbc_funs.write2file(ligandpath,"/ambiguous.txt",tmpstr)
+                    tmpstr = str(name)+str(ii)+','+' Anchors list: '+ \
+                            str(sbuanchors_list)+','+' SBU connectlist: '+str(sbu_connect_list)+'\n'
+                    pbc_funs.write2file(ligandpath,"/ligand.txt",tmpstr)
+        else: #definite ligand
+            pbc_funs.write2file(logpath,"/%s.log"%name,"found ligand\n")
+            removelist.update(set(templist[ii])) # we also want to remove these ligands
+            SBUlist.update(set(templist[ii])) # we also want to remove these ligands
+            linker_list.pop(ii)
+            linker_subgraphlist.pop(ii)
+            tmpstr = str(name)+','+' Anchors list: '+str(sbuanchors_list) \
+         +','+' SBU connectlist: '+str(sbu_connect_list)+'\n'
+            pbc_funs.write2file(ligandpath,"/ligand.txt",tmpstr)
+
+    tmpstr = str(name) + ", (min_max_linker_length,max_min_linker_length): " + \
+                str(min_max_linker_length) + " , " +str(max_min_linker_length) + "\n"
+    pbc_funs.write2file(logpath,"/%s.log"%name,tmpstr)
+    if min_max_linker_length < 3:
+        pbc_funs.write2file(linkerpath,"/short_ligands.txt",tmpstr)
+    if min_max_linker_length > 2:
+        # for N-C-C-N ligand ligand
+        if max_min_linker_length == min_max_linker_length:
+            long_ligands = True
+        elif min_max_linker_length > 3:
+            long_ligands = True
+
+    """""""""
+    In the case of long linkers, add second coordination shell without further checks. In the case of short linkers, start from metal
+    and grow outwards using the include_extra_shells function
+    """""""""
+    linker_length_list = [len(linker_val) for linker_val in linker_list]
+    if len(set(linker_length_list)) != 1:
+        pbc_funs.write2file(linkerpath,"/uneven.txt",str(name)+'\n')
+    if not min_max_linker_length < 2: # treating the 2 atom ligands differently! Need caution
+        if long_ligands:
+            tmpstr = "\nStructure has LONG ligand\n\n"
+            pbc_funs.write2file(logpath,"/%s.log"%name,tmpstr)
+            [[SBUlist.add(val) for val in  molcif.getBondedAtomsSmart(zero_first_shell)] for zero_first_shell in SBUlist.copy()] #First account for all of the carboxylic acid type linkers, add in the carbons.
+        truncated_linkers = allatoms - SBUlist
+        SBU_list, SBU_subgraphlist = pbc_funs.get_closed_subgraph(SBUlist, truncated_linkers, adj_matrix)
+        if not long_ligands:
+            tmpstr = "\nStructure has SHORT ligand\n\n"
+            pbc_funs.write2file(logpath,"/%s.log"%name,tmpstr)
+            SBU_list , SBU_subgraphlist = pbc_funs.include_extra_shells(SBU_list,SBU_subgraphlist,molcif ,adj_matrix)
+    else:
+        tmpstr = "Structure %s has extreamly short ligands, check the outputs\n"%name
+        pbc_funs.write2file(ligandpath,"/ambiguous.txt",tmpstr)
+        tmpstr = "Structure has extreamly short ligands\n"
+        pbc_funs.write2file(logpath,"/%s.log"%name,tmpstr)
+        tmpstr = "Structure has extreamly short ligands\n"
+        pbc_funs.write2file(logpath,"/%s.log"%name,tmpstr)
+        truncated_linkers = allatoms - removelist
+        SBU_list, SBU_subgraphlist = pbc_funs.get_closed_subgraph(removelist, truncated_linkers, adj_matrix)
+        SBU_list, SBU_subgraphlist = pbc_funs.include_extra_shells(SBU_list,SBU_subgraphlist,molcif ,adj_matrix)
+        SBU_list, SBU_subgraphlist = pbc_funs.include_extra_shells(SBU_list,SBU_subgraphlist,molcif ,adj_matrix)
+    descriptor_names, descriptors, lc_descriptor_names, lc_descriptors = make_MOF_SBU_RACs(SBU_list, SBU_subgraphlist, molcif, depth, name , cell_v,anc_atoms, sbupath, connections_list, connections_subgraphlist)
+    lig_descriptor_names, lig_descriptors = make_MOF_linker_RACs(linker_list, linker_subgraphlist, molcif, depth, name, cell_v, linkerpath)
+    return None, None