molSimplify 1.7.4__py3-none-any.whl

molSimplify/Informatics/graph_racs.py

@@ -0,0 +1,288 @@
+import numpy as np
+import networkx as nx
+import operator
+from typing import Callable, List, Optional, Tuple
+from molSimplify.Classes.mol2D import Mol2D
+from molSimplify.Classes.globalvars import amassdict, endict
+
+
+def racs_property_vector(mol: Mol2D, node: int) -> np.ndarray:
+    """Calculates the property vector for a given node (atom) in a molecular graph.
+
+    Parameters
+    ----------
+    mol : Mol2D
+        molecular graph
+    node : int
+        index of the node
+
+    Returns
+    -------
+    np.ndarray
+        property vector of the node
+    """
+    output = np.zeros(5)
+    symbol = mol.nodes[node]["symbol"]
+    Z = amassdict[symbol][1]
+    # property (i): nuclear charge Z
+    output[0] = Z
+    # property (ii): Pauling electronegativity chi
+    output[1] = endict[symbol]
+    # property (iii): topology T, coordination number
+    output[2] = len(list(mol.neighbors(node)))
+    # property (iv): identity
+    output[3] = 1.0
+    # property (v): covalent radius S
+    output[4] = amassdict[symbol][2]
+    return output
+
+
+def atom_centered_AC(
+    mol: Mol2D,
+    starting_node: int,
+    depth: int = 3,
+    operation: Callable[[np.ndarray, np.ndarray], np.ndarray] = operator.mul,
+    property_fun: Callable[[Mol2D, int], np.ndarray] = racs_property_vector,
+) -> np.ndarray:
+    """Calculates atom-centered autocorrelation vectors for a given node in a molecular graph.
+
+    Parameters
+    ----------
+    mol : Mol2D
+        molecular graph
+    starting_node : int
+        index of the starting node
+    depth : int, optional
+        depth of the RACs, by default 3
+    operation : Callable[[np.ndarray, np.ndarray], np.ndarray], optional
+        correlation operation, e.g. operator.mul or operator.sub for product and difference RACs,
+        by default operator.mul
+    property_fun : Callable[[Mol2D, int], np.ndarray], optional
+        function that calculates the atomic property vector, by default racs_property_vector
+
+    Returns
+    -------
+    np.ndarray
+        atom-centered autocorrelation vector
+    """
+    # Generate all paths from the starting node to all possible nodes
+    lengths = nx.single_source_shortest_path_length(
+        mol, source=starting_node, cutoff=depth
+    )
+    p_i = property_fun(mol, starting_node)
+    output = np.zeros((depth + 1, len(p_i)))
+    for node, d_ij in lengths.items():
+        p_j = property_fun(mol, node)
+        output[d_ij] += operation(p_i, p_j)
+    return output
+
+
+def multi_centered_AC(
+    mol: Mol2D,
+    depth: int = 3,
+    operation: Callable[[np.ndarray, np.ndarray], np.ndarray] = operator.mul,
+    property_fun: Callable[[Mol2D, int], np.ndarray] = racs_property_vector
+) -> np.ndarray:
+    """Calculates the full-scope autocorrelation vector on molecular graph.
+
+    Parameters
+    ----------
+    mol : Mol2D
+        molecular graph
+    depth : int, optional
+        depth of the RACs, by default 3
+    operation : Callable[[np.ndarray, np.ndarray], np.ndarray], optional
+        correlation operation, e.g. operator.mul or operator.sub for product and difference RACs,
+        by default operator.mul
+    property_fun : Callable[[Mol2D, int], np.ndarray], optional
+        function that calculates the atomic property vector, by default racs_property_vector
+
+    Returns
+    -------
+    np.ndarray
+        full-scope autocorrelation vector
+    """
+    n_props = len(property_fun(mol, list(mol.nodes.keys())[0]))
+    output = np.zeros((depth + 1, n_props))
+    # Generate all pairwise path lengths
+    lengths = nx.all_pairs_shortest_path_length(mol, cutoff=depth)
+    for node_i, lengths_i in lengths:
+        p_i = property_fun(mol, node_i)
+        for node_j, d_ij in lengths_i.items():
+            p_j = property_fun(mol, node_j)
+            output[d_ij] += operation(p_i, p_j)
+    return output
+
+
+def octahedral_racs(
+    mol: Mol2D,
+    depth: int = 3,
+    equatorial_connecting_atoms: Optional[List[int]] = None,
+    property_fun: Callable[[Mol2D, int], np.ndarray] = racs_property_vector,
+) -> np.ndarray:
+    # Following J. Phys. Chem. A 2017, 121, 8939 there are 6 start/scope
+    # combinations for product ACs and 3 for difference ACs.
+    n_props = len(property_fun(mol, list(mol.nodes.keys())[0]))
+    output = np.zeros((6 + 3, depth + 1, n_props))
+
+    # start = f, scope = all, product
+    output[0] = multi_centered_AC(mol, depth=depth, property_fun=property_fun)
+    # start = mc, scope = all, product
+    output[1] = atom_centered_AC(mol, 0, depth=depth, property_fun=property_fun)
+
+    # For the other scopes the graph has to be subdivided into individual
+    # ligand graphs. Make these changes on a copy of the graph:
+    subgraphs = mol.copy()
+    # First find all connecting atoms of the first metal:
+    metals = mol.find_metal()
+    if len(metals) != 1:
+        raise ValueError("Currently only supports mononuclear TMCs.")
+    metal = metals[0]
+    connecting_atoms = sorted(list(subgraphs.neighbors(metal)))
+    # Assert that we are removing 6 edges
+    if len(connecting_atoms) != 6:
+        raise ValueError(
+            "First metal in the graph does not have 6 neighbors "
+            "as expected for an octahedral complex."
+        )
+    # Then cut the graph by removing all connections to the metal atom
+    subgraphs.remove_edges_from([(metal, c) for c in connecting_atoms])
+
+    if equatorial_connecting_atoms is None:
+        # Assume the first 4 connecting atoms belong to the equatorial ligands
+        # and the other two are axial.
+        equatorial_connecting_atoms = connecting_atoms[:4]
+        axial_connecting_atoms = connecting_atoms[4:]
+    else:
+        axial_connecting_atoms = [
+            c for c in connecting_atoms if c not in equatorial_connecting_atoms
+        ]
+        if len(equatorial_connecting_atoms) != 4 or len(axial_connecting_atoms) != 2:
+            raise ValueError(
+                "The provided equatorial connecting atoms "
+                f"{equatorial_connecting_atoms} are not "
+                "consistent with the neighbors of the first "
+                f"metal in the graph {connecting_atoms}"
+            )
+
+    # Build lists of connecting atom and ligand
+    # subgraph tuples by first finding set of nodes for the component that the
+    # connecting atom c comes from (using nx.node_conncted_component()) and
+    # then constructing a subgraph using this node set.
+    axial_ligands = [
+        (c, subgraphs.subgraph(nx.node_connected_component(subgraphs, c)))
+        for c in axial_connecting_atoms
+    ]
+    equatorial_ligands = [
+        (c, subgraphs.subgraph(nx.node_connected_component(subgraphs, c)))
+        for c in equatorial_connecting_atoms
+    ]
+
+    # Note that the ligand centered RACs are averaged over the involved
+    # ligands.
+    # start = lc, scope = ax, product
+    output[2] = np.mean(
+        [
+            atom_centered_AC(g, c, depth=depth, property_fun=property_fun)
+            for (c, g) in axial_ligands
+        ],
+        axis=0,
+    )
+
+    # start = lc, scope = eq, product
+    output[3] = np.mean(
+        [
+            atom_centered_AC(g, c, depth=depth, property_fun=property_fun)
+            for (c, g) in equatorial_ligands
+        ],
+        axis=0,
+    )
+
+    output[4] = np.mean(
+        [
+            multi_centered_AC(g, depth=depth, property_fun=property_fun)
+            for (_, g) in axial_ligands
+        ],
+        axis=0,
+    )
+    output[5] = np.mean(
+        [
+            multi_centered_AC(g, depth=depth, property_fun=property_fun)
+            for (_, g) in equatorial_ligands
+        ],
+        axis=0,
+    )
+
+    # Finally calculate the difference ACs the same way:
+    # start = mc, scope = all, difference
+    output[6] = atom_centered_AC(
+        mol, 0, depth=depth, operation=operator.sub, property_fun=property_fun
+    )
+    # start = lc, scope = ax, difference
+    output[7] = np.mean(
+        [
+            atom_centered_AC(
+                g, c, depth=depth, operation=operator.sub, property_fun=property_fun
+            )
+            for (c, g) in axial_ligands
+        ],
+        axis=0,
+    )
+
+    # start = lc, scope = eq, difference
+    output[8] = np.mean(
+        [
+            atom_centered_AC(
+                g, c, depth=depth, operation=operator.sub, property_fun=property_fun
+            )
+            for (c, g) in equatorial_ligands
+        ],
+        axis=0,
+    )
+
+    return output
+
+
+def ligand_racs(
+    mol: Mol2D,
+    depth: int = 3,
+    full_scope: bool = True,
+    property_fun: Callable[[Mol2D, int], np.ndarray] = racs_property_vector,
+) -> np.ndarray:
+
+    # First cut the molecular graph into subgraphs for the metal and the ligands
+    subgraphs = mol.copy()
+    # First find all connecting atoms of the first metal:
+    metals = mol.find_metal()
+    if len(metals) != 1:
+        raise ValueError("Currently only supports mononuclear TMCs.")
+    metal = metals[0]
+    connecting_atoms = sorted(list(subgraphs.neighbors(metal)))
+
+    n_ligands = len(connecting_atoms)
+    n_props = len(property_fun(mol, list(mol.nodes.keys())[0]))
+    n_scopes = 4 if full_scope else 2
+    output = np.zeros((n_ligands, n_scopes, depth + 1, n_props))
+
+    # Then cut the graph by removing all connections to the metal atom
+    subgraphs.remove_edges_from([(metal, c) for c in connecting_atoms])
+    # Build list of tuples for all connecting atoms and corresponding ligand subgraphs
+    # TODO: I am sure there is a better way of doing this than looping over all subgraphs
+    ligand_graphs: List[Tuple[int, Mol2D]] = []
+    for c in connecting_atoms:
+        for gi in nx.connected_components(subgraphs):
+            if c in gi:
+                ligand_graphs.append((c, subgraphs.subgraph(gi)))
+                break
+
+    # Actual calculation of the RACs
+    for i, (c, g) in enumerate(ligand_graphs):
+        # starting with connecting atom centered product RACs
+        output[i, 0] = atom_centered_AC(g, c, depth=depth, operation=operator.mul, property_fun=property_fun)
+        output[i, 1] = atom_centered_AC(g, c, depth=depth, operation=operator.sub, property_fun=property_fun)
+        # Add full scope RACs if requested
+        if full_scope:
+            output[i, 2] = multi_centered_AC(g, depth=depth, operation=operator.mul, property_fun=property_fun)
+            output[i, 3] = multi_centered_AC(g, depth=depth, operation=operator.sub, property_fun=property_fun)
+
+    return output

molSimplify/Informatics/jupyter_vis.py

@@ -0,0 +1,172 @@
+"""
+Py3Dmol install: (works in both Python2/3 conda environments)
+conda install -c rmg py3dmol
+Some Documentation: https://pypi.org/project/py3Dmol/
+3DMol.js backend: http://3dmol.csb.pitt.edu/index.html
+"""
+import math as m
+import numpy as np
+
+import py3Dmol
+
+from molSimplify.Classes.mol3D import mol3D
+
+
+def type_convert(structures):
+    """Handle multiple types of structures passed. List of xyz, mol2 files,
+    or list of xyz, mol2strings.
+
+    Parameters
+    ----------
+    structures : list
+        Structures you want visualized: can either be a list or individual:
+        mol2 strings, mol2 files, xyz strings, xyz files, or mol3D objects
+    """
+    outlist = []
+    if not isinstance(structures, str):
+        # Convert other array-like arguments to a list.
+        structures = list(structures)
+    if isinstance(structures, list):
+        for i, x in enumerate(structures):
+            if isinstance(x, mol3D):
+                outlist.append(x)
+                continue
+            mol = mol3D()
+            # mol2string
+            if 'TRIPOS' in x:
+                mol.readfrommol2(x, readstring=True)
+            # Xyz filename
+            elif x[-4:] == '.xyz':
+                mol.readfromxyz(x)
+            # mol2 filename
+            elif x[-5:] == '.mol2':
+                mol.readfrommol2(x)
+            # checking for number at start of string -> indicates xyz string
+            elif (len(x.split('\n')) > 3) & (x.split('\n')[0].replace(' ', '').isnumeric()):
+                mol.readfromstring(x)
+            # checking for similar file without header
+            elif (len(x.split('\n')[0].split()) == 4) and x.split('\n')[0].split()[0]:
+                mol.readfromstring(x)
+            else:
+                raise ValueError('Not Recognized Structure Type for index: ' + str(i))
+            outlist.append(mol)
+    elif isinstance(structures, str):
+        x = structures
+        mol = mol3D()
+        # mol2string
+        if 'TRIPOS' in x:
+            mol.readfrommol2(x, readstring=True)
+        # Xyz filename
+        elif x[-4:] == '.xyz':
+            mol.readfromxyz(x)
+        # mol2 filename
+        elif x[-5:] == '.mol2':
+            mol.readfrommol2(x)
+        # checking for number at start of string -> indicates xyz string
+        elif (len(x.split('\n')) > 3) & (x.split('\n')[0].replace(' ', '').isnumeric()):
+            mol.readfromstring(x)
+        # checking for similar file without header
+        elif (len(x.split('\n')[0].split()) == 4) and x.split('\n')[0].split()[0]:
+            mol.readfromstring(x)
+        else:
+            raise ValueError('Not Recognized Structure Type Passed')
+        outlist.append(mol)
+    elif isinstance(structures, mol3D):
+        outlist = structures
+    else:
+        raise ValueError('Not Recognized Structure Type Passed')
+    return outlist
+
+
+def view_structures(structures, w=400, h=400, columns=2,
+                    representation='stick', labelsize=18,
+                    labels=False, readstring=True):
+    """
+    py3Dmol view atoms object(s)
+    xyz_names = xyz files that will be rendered in a tiled format in jupyter (list,str)
+    w = width of frame (or subframes) in pixels (int)
+    h = height of frame (or subframes) in pixels (int)
+    cols = number of columns in subframe (int)
+    representation = how the molecule will be viewed (str)
+    labelsize = size of the data label (in Points) (int)
+    labels = turn labels on/off (bool)
+    """
+    mol3Ds = type_convert(structures)
+    if len(mol3Ds) == 1:
+        view_ats = py3Dmol.view(width=w, height=h)
+        mol = mol3Ds[0]
+        label = False
+        if isinstance(labels, str):
+            label = labels
+        elif isinstance(labels, list):
+            label = labels[0]
+        elif isinstance(labels, bool):
+            if labels:
+                label = mol.make_formula(latex=False)
+
+        metal_atom_index = mol.findMetal()  # will be empty list if no metals
+        coords = mol.coords()
+        if metal_atom_index:  # Take advantage of empty list
+            label_posits = mol.getAtomCoords(metal_atom_index[0])
+        else:
+            label_posits = mol.centersym()  # Put it at the geometric center of the molecule.
+        view_ats.addModel(coords, 'xyz')  # Add the molecule
+        view_ats.setStyle({representation: {'colorscheme': 'Jmol'}})
+        if label:
+            view_ats.addLabel(
+                "{}".format(label),
+                {'position': {'x': '{}'.format(label_posits[0]),
+                 'y': '{}'.format(label_posits[1]), 'z': '{}'.format(label_posits[2])},
+                 'backgroundColor': "'black'", 'backgroundOpacity': '0.3',
+                 'fontOpacity': '1', 'fontSize': '{}'.format(labelsize),
+                 'fontColor': "white", 'inFront': 'true'})
+        view_ats.zoomTo()
+        view_ats.show()
+    elif len(mol3Ds) < 50:
+        rows = int(m.ceil(float(len(mol3Ds))/columns))
+        w = w*columns
+        h = h*rows
+        # Initialize Layout
+        view_ats = py3Dmol.view(width=w, height=h, linked=False, viewergrid=(rows, columns))
+        # Check for labels and populate
+        if isinstance(labels, bool):
+            if labels:
+                label = [x.make_formula(latex=False) for x in mol3Ds]
+            else:
+                label = []
+        elif isinstance(labels, list) or isinstance(labels, np.ndarray):
+            if (len(labels) != len(mol3Ds)):
+                print('Wrong amount of labels passed, defaulting to chemical formulas.')
+                label = [x.make_formula(latex=False) for x in mol3Ds]
+            else:  # Force them all to be strings.
+                label = [str(x) for x in labels]
+        else:
+            raise ValueError('What sort of labels are wanting? Not recognized.')
+        x, y = 0, 0  # Subframe position
+        for i, item in enumerate(mol3Ds):
+            mol = item
+            coords = mol.coords()
+            metal_atom_index = mol.findMetal()
+            if metal_atom_index:
+                label_posits = mol.getAtomCoords(metal_atom_index[0])
+            else:
+                label_posits = mol.centersym()
+            view_ats.addModel(coords, 'xyz', viewer=(x, y))
+            view_ats.setStyle({representation: {'colorscheme': 'Jmol'}}, viewer=(x, y))
+            if len(label) > 0:
+                view_ats.addLabel(
+                    "{}".format(label[i]),
+                    {'position': {'x': '{}'.format(label_posits[0]),
+                     'y': '{}'.format(label_posits[1]), 'z': '{}'.format(label_posits[2])},
+                     'backgroundColor': "'black'", 'backgroundOpacity': '0.5',
+                     'fontOpacity': '1', 'fontSize': '{}'.format(labelsize),
+                     'fontColor': "white", 'inFront': 'true'}, viewer=(x, y))
+            view_ats.zoomTo(viewer=(x, y))
+            if y+1 < columns:  # Fill in columns
+                y += 1
+            else:
+                x += 1
+                y = 0
+        view_ats.show()
+    else:
+        raise ValueError('Warning. Passing this many structures WILL cause your kernel to crash.')