Class StructureCalculator


  • public class StructureCalculator
    extends java.lang.Object
    Utility function based on the molecule's connections (groups, rings,...)
    • Constructor Detail

      • StructureCalculator

        public StructureCalculator()
    • Method Detail

      • getConnexComponents

        public static java.util.List<java.util.List<java.lang.Integer>> getConnexComponents​(Molecule3D mol)
        Returns a List of all Connex Components of the graph (List of List of Integer)
         Example:
         
          The following molecule:
        
                                  -- 3             
                   1 -- 2                 5 -- 6              7
                          -- 4
         will return 
          [[1,2,3,4],[5,6],[7]]
         
        Complexity: O(nAtoms) Memory: O(nAtoms)
      • getAtomToGroups

        public static int[] getAtomToGroups​(Molecule3D mol)
      • getAtomToGroups

        public static int[] getAtomToGroups​(Molecule3D mol,
                                            java.util.List<java.lang.Integer> seeds)
        For each molecule in mol one group is created. The group index starts with 1. The size of the array returned is equal to the number of atoms.
        Parameters:
        mol -
        seeds -
        Returns:
        a int[] array such as array[atom] = groupNo >=1
      • getLongestChain

        public static java.util.List<java.lang.Integer> getLongestChain​(Molecule3D mol,
                                                                        int atm)
        Return the longest molecular chain starting at atm
        Parameters:
        mol -
        atm -
        Returns:
        a List of Integer
      • getBackbones

        public static boolean[] getBackbones​(Molecule3D molecule)
      • getBackbones

        public static boolean[] getBackbones​(Molecule3D molecule,
                                             int minChain)
        Gets the backbone
        Parameters:
        molecule -
        Returns:
        an array of boolean
      • getNumberOfBondsBetweenAtoms

        public static int[][] getNumberOfBondsBetweenAtoms​(Molecule3D mol,
                                                           int maxBonds,
                                                           int[][] dist)
        Computes a matrix of distances between all the atoms in the graph. Complexity: O(m*n*maxBonds) m = number of bonds, n = number of atoms
        Parameters:
        mol -
        maxBonds -
        Returns:
        an array A[i][j] = nBonds if i and j are connected by less than maxBonds or -1 otherwise
      • getNumberOfAtomsBetweenBonds

        public static int[][] getNumberOfAtomsBetweenBonds​(Molecule3D mol,
                                                           int maxAtoms,
                                                           int[][] dist)
        Computes a matrix of distances between all the bonds in the graph. Complexity: O(m*n*maxBonds) m = number of bonds, n = number of atoms
        Parameters:
        mol -
        maxAtoms -
        Returns:
        an array B[i][j] = nAtoms if i and j are connected by less than maxAtoms or -1 otherwise
      • main

        public static void main​(java.lang.String[] args)
                         throws java.lang.Exception
        Throws:
        java.lang.Exception
      • getMaxValence

        public static int getMaxValence​(int atomicNo)
        Parameters:
        atomicNo -
        Returns:
      • getImplicitHydrogens

        public static int getImplicitHydrogens​(Molecule3D mol,
                                               int atm)
        Return the number of implicit hydrogens, ie. the number of hydrogens to add to fullfill the valence requirements (<0 if there are too many)
        Parameters:
        mol -
        atm -
        Returns:
      • getMaxFreeValence

        public static int getMaxFreeValence​(Molecule3D mol,
                                            int atm)
      • extractFragments

        public static java.util.List<Molecule3D> extractFragments​(Molecule3D mol)
        Return all connex components with more than 5 atoms
        Parameters:
        mol -
        Returns:
      • extractLigands

        public static java.util.List<Molecule3D> extractLigands​(Molecule3D mol)
        Return all ligands with more than 5 atoms
        Parameters:
        mol -
        Returns:
      • extractFragment

        public static <T extends Molecule3D> T extractFragment​(Molecule3D mol,
                                                               T res,
                                                               java.util.List<java.lang.Integer> atoms)
      • extractFragment

        public static <T extends Molecule3D> T extractFragment​(Molecule3D mol,
                                                               T res,
                                                               int[] atoms)
        Extract the Ligand from mol and copy it into res
        Parameters:
        mol -
        res -
        Returns:
      • getRings

        public static java.util.List<java.lang.Integer>[] getRings​(Molecule3D mol,
                                                                   java.util.List<int[]> allRings)
      • getRingsAccurate

        public static java.util.List<java.lang.Integer>[] getRingsAccurate​(Molecule3D mol,
                                                                           java.util.List<int[]> allRings)
        Find the smallest covering set of rings for the Molecule. This function considers the smallest subset of covering rings of any size. The complexity of this function is O(natoms * avgRingSize^nImbricatedRings) The memory required is O(nAtoms * nBonds)!!!!
        Parameters:
        mol -
        allRings - - a List ringNo -> atom No in the ring as int[] (output)
        Returns:
        a List[] atom -> List of rings the atom belongs to
      • getRingsFast

        public static java.util.List<java.lang.Integer>[] getRingsFast​(Molecule3D mol,
                                                                       java.util.List<int[]> allRings)
        Find the list of rings for the Molecule. This function considers all rings of size <=7 Complexity O(nAtoms) for the common structures O(nAtoms^nRings) at worse Memory O(nBonds)
        Parameters:
        mol -
        allRings - - a List ringNo -> atom No in the ring as int[]
        Returns:
        a List[] atom -> List of rings the atom belongs to
      • getInterMolecularInteractions

        public static java.util.List<int[]> getInterMolecularInteractions​(Molecule3D mol)
        Return a List of int[] representing all the atom-atom pairs having an intermolecular interactions (distance close to sum of VDW)
        Parameters:
        mol -
        Returns:
      • getAtomsOnPath

        public static int[] getAtomsOnPath​(Molecule3D mol,
                                           int a1,
                                           int a2)
        Finds on all atoms going on a path from a1 to a2. If a1 and a2 are in a small ring (<6), all atoms in the rings will be considered Complexity: O(m) m=allBonds
        Parameters:
        mol -
        a1 -
        a2 -
        Returns:
      • getValence

        public static int getValence​(Molecule3D mol,
                                     int atm)
      • getExplicitHydrogens

        public static final int getExplicitHydrogens​(Molecule3D mol,
                                                     int atm)
      • getStructureCenter

        public static int getStructureCenter​(Molecule3D lig,
                                             int[] rotatables,
                                             int[][] dists)
      • getStructureCenter

        public static int getStructureCenter​(Molecule3D lig,
                                             int a,
                                             int[] rotatables,
                                             int[][] dists)
        The Structure Center Atom is defined as the atom with the biggest no of rotatables bonds and the closest to the center
        Parameters:
        lig -
        Returns:
      • getBackbone

        public static java.util.List<java.lang.Integer> getBackbone​(Molecule3D lig,
                                                                    int a)
      • dfs

        public static int dfs​(Molecule3D lig,
                              int start,
                              java.util.Set<java.lang.Integer> seen)
      • dfs

        public static int dfs​(Molecule3D lig,
                              int start,
                              java.util.Set<java.lang.Integer> seen,
                              int depth,
                              boolean takeRingsAsWhole)
      • extractLigand

        public static Molecule3D extractLigand​(Molecule3D mol)
        Extract the Ligand from mol and copy it into res
        Parameters:
        mol -
        Returns:
      • replaceLigand

        public static void replaceLigand​(Molecule3D mol,
                                         Molecule3D lig,
                                         Coordinates center)
        Replaces the preoptimized ligand in mol
        Parameters:
        mol -
        lig -
      • deleteHydrogens

        public static boolean deleteHydrogens​(Molecule3D mol)
      • addHydrogens

        public static boolean addHydrogens​(Molecule3D mol)
        Add the missing hydrogens for the ligand
        Parameters:
        mol -
        Returns:
      • addHydrogens

        public static boolean addHydrogens​(Molecule3D mol,
                                           boolean alsoRigidAtoms)
        Adds the missing hydrogens (no optimization)
        Parameters:
        mol -
        Returns:
      • addHydrogensAroundLigand

        public static boolean addHydrogensAroundLigand​(Molecule3D mol,
                                                       double radius)
      • copyAtoms

        public static void copyAtoms​(Molecule3D mol,
                                     Molecule3D res,
                                     java.util.List<java.lang.Integer> atomsToBeAdded)
      • removeWater

        public static void removeWater​(Molecule3D mol)
      • removeWater

        public static void removeWater​(Molecule3D mol,
                                       boolean removeAlsoImportant)
      • removeWaterSalts

        public static void removeWaterSalts​(Molecule3D mol)
      • removeLigand

        public static void removeLigand​(Molecule3D mol)
      • markLigand

        public static int markLigand​(Molecule3D mol,
                                     int n)
        Marks a numbered ligand
        Parameters:
        mol -
        n - >=0
      • markLigands

        public static void markLigands​(Molecule3D mol)
        Find the most likely ligands (in term of size)
      • markLigand

        public static boolean markLigand​(Molecule3D mol)
        Find the most likely ligand (in term of size, rings, polar atoms) and mark it
        Parameters:
        mol -
      • getLigandRMSD

        public static double getLigandRMSD​(Molecule3D mol1,
                                           Molecule3D mol2)
        Gets the root mean square deviation between 2 positions. Only atomicNo>1 are considered
        Parameters:
        mol1 -
        mol2 -
        Returns:
      • vibrateLigand

        public static void vibrateLigand​(Molecule3D mol,
                                         double radius)
        Parameters:
        mol -
        radius - maximum moving range in Angstrom.
      • getAtomHashkey

        public static long getAtomHashkey​(Molecule3D mol,
                                          int a)
        Return a long representing the atom and its neighbours
        Parameters:
        mol -
        a -
        Returns:
      • makeProteinFlexible

        public static int makeProteinFlexible​(Molecule3D mol,
                                              Coordinates center,
                                              double radius,
                                              boolean keepBackboneRigid)
      • makeProteinRigid

        public static void makeProteinRigid​(Molecule3D mol)
      • getHDonorsAcceptors

        public static int[] getHDonorsAcceptors​(ExtendedMolecule m)
        Returns a array of 2 elements [number of donors, number of acceptors]
        Parameters:
        m -
        Returns:
      • isDonor

        public static boolean isDonor​(Molecule3D m,
                                      int a)
      • isAcceptor

        public static boolean isAcceptor​(Molecule3D m,
                                         int a)
      • flagBackbone

        public static void flagBackbone​(Molecule3D mol)
        Return a List of int[] representing all the atom-atom pairs having an intermolecular interactions (distance close to sum of VDW)
      • connected

        public static int connected​(Molecule3D mol,
                                    int a,
                                    int atomicNo,
                                    int bondOrder)
        Returns the rotatable bonds (sorted). A rotatable bond is defined here as a simple bond that is not inside a ring (and not connected to only hydrogen).
        Parameters:
        mol -
        Returns:
      • rotateBond

        public static void rotateBond​(Molecule3D mol,
                                      int a2,
                                      int a3,
                                      double angle)
        Make sure the parity of mol match the one from ref, otherwise fix it.
        Parameters:
        mol -
      • removeLonePairs

        public static boolean removeLonePairs​(Molecule3D mol)
      • getDistanceMatrix

        public static final double[][] getDistanceMatrix​(Molecule3D m1,
                                                         Molecule3D m2)
      • getOverlap

        public static final int[] getOverlap​(Molecule3D m1,
                                             Molecule3D m2)
        Parameters:
        m1 -
        m2 -
        Returns:
        an int[][] 0-> number of closer atom matching, 2->number of atom clashes
      • getMolecularPathCount

        public static int getMolecularPathCount​(Molecule3D mol,
                                                int length)
        Returns the number of paths of the given length (gives an idea of the number of branches)
        Parameters:
        mol -
        length -
        Returns:
      • getFragmentMatches

        public static java.util.List<int[]> getFragmentMatches​(Molecule3D fragment,
                                                               Molecule3D mol)
        Find all fragment occurences in mol (only the movable atoms are considered). Return a List of occurences list.get(n)[fragmentAtom] points to the n occurence of fragments and is equal to the matching atomIndex in mol
        Parameters:
        fragment -
        mol -
        Returns: