Class EvaluableFlexibleOverlap

  • All Implemented Interfaces:
    Evaluable

    public class EvaluableFlexibleOverlap
    extends java.lang.Object
    implements Evaluable
    Author:
    JW, Oktober 2019 functionality for optimizing PheSA overlap (Pharmacophore+Shape) allowing for molecular flexibility
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      EvaluableFlexibleOverlap clone()  
      PheSAAlignment getAlignment()  
      double[] getCartState()  
      double getFGValue​(double[] grad)
      inspired by: 10.1021/acs.jcim.7b00618 (Reflex3D) objective function: f = -T + lambda *strain^2 A is the fixed reference molecule, whereas B is flexible aligned on A3 where T is the shape Tanimoto : T = O_AB/(O_BB+O_AA-O_AB): with O_AB being the shape overlap between molecules A and B and O_AA and O_BB the self overlaps next we calculate the derivate of the shape tanimoto with respect to the cartesian coordinates: dT/dx we use the product rule: T = u*v dT/dx = du/dx*v+u*dv/dx u = O_AB and v = (O_BB+O_AA-O_AB)^-1 du/dx = dO_AB/dx for v we use the chain rule: dv/dx = -(dO_BB/dx-dO_AB/dx)*(O_AA+O_BB-O_AB)^-2 dT/dx=dO_AB/dx * 1/(O_AA+O_BB-O_AB)-O_AB*(dO_BB/dx-dO_AB/dx)*(O_AA+O_BB-O_AB)^-2 and the strain term: s = lambda*strain^2 with strain = e-c (e: potential energy, c: energy cutoff) using the chain rule: ds/dx = 2*lambda*(e-c)*de/dx
      double getFGValuePP​(double[] grad)  
      double getFGValueSelfPP​(double[] grad, ShapeVolume molVol, boolean rigid)  
      double getFGValueShape​(double[] grad)
      calculates the gradient of the overlap function with respect to the cartesian coordinates of the atoms the overlap between molecules A and B is expressed as a sum over the atom-atom overlaps Vij pi 3/2 alpha_i*alpha_j*Rij^2 Vij = p_i*p_j*(---------------) * exp( - -------------------- ) alpha_i + alpha_j alpha_i + alpha_j alpha_i*alpha_j*Rij^2 = a*exp(- --------------------------) alpha_i + alpha_j Rij^2 = (xi-xj)^2 we therefore need the derivative of Vij with respect to the atomic coordinates of atom j (molecule B) we use the chain rule: d[e^u(x)]/dx = e^u(x)*du(x)/dx with u(x) = -c*Rij^2 and c=(alpha_i*alpha_j)/(alpha_i+alpha_j) u(x) = -c*(xi^2-2xi*xj+xj^2) du(x)/dx=-c*(-2xi+2xj) dVij = -Vij*(alpha_i*alpha_j)/(alpha_i+alpha_j) * (2xj - 2xi)
      double getFGValueShapeSelf​(double[] grad, ShapeVolume molGauss, boolean rigid)  
      Conformer getFitConf()  
      double getGradientContribution​(Gaussian3D refAt, Gaussian3D fitAt, double[] grad, boolean rigid)  
      double[] getState()  
      double[] getState​(double[] v)  
      void setE0​(double e0)  
      void setInitialState()  
      void setState​(double[] v)  
      void updateLigandCoordinates()  
      • Methods inherited from class java.lang.Object

        equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Method Detail

      • setInitialState

        public void setInitialState()
      • setState

        public void setState​(double[] v)
        Specified by:
        setState in interface Evaluable
      • getState

        public double[] getState​(double[] v)
      • setE0

        public void setE0​(double e0)
      • getState

        public double[] getState()
        Specified by:
        getState in interface Evaluable
      • updateLigandCoordinates

        public void updateLigandCoordinates()
      • getFGValue

        public double getFGValue​(double[] grad)
        inspired by: 10.1021/acs.jcim.7b00618 (Reflex3D) objective function: f = -T + lambda *strain^2 A is the fixed reference molecule, whereas B is flexible aligned on A3 where T is the shape Tanimoto : T = O_AB/(O_BB+O_AA-O_AB): with O_AB being the shape overlap between molecules A and B and O_AA and O_BB the self overlaps next we calculate the derivate of the shape tanimoto with respect to the cartesian coordinates: dT/dx we use the product rule: T = u*v dT/dx = du/dx*v+u*dv/dx u = O_AB and v = (O_BB+O_AA-O_AB)^-1 du/dx = dO_AB/dx for v we use the chain rule: dv/dx = -(dO_BB/dx-dO_AB/dx)*(O_AA+O_BB-O_AB)^-2 dT/dx=dO_AB/dx * 1/(O_AA+O_BB-O_AB)-O_AB*(dO_BB/dx-dO_AB/dx)*(O_AA+O_BB-O_AB)^-2 and the strain term: s = lambda*strain^2 with strain = e-c (e: potential energy, c: energy cutoff) using the chain rule: ds/dx = 2*lambda*(e-c)*de/dx
        Specified by:
        getFGValue in interface Evaluable
      • getFGValueShape

        public double getFGValueShape​(double[] grad)
        calculates the gradient of the overlap function with respect to the cartesian coordinates of the atoms the overlap between molecules A and B is expressed as a sum over the atom-atom overlaps Vij pi 3/2 alpha_i*alpha_j*Rij^2 Vij = p_i*p_j*(---------------) * exp( - -------------------- ) alpha_i + alpha_j alpha_i + alpha_j alpha_i*alpha_j*Rij^2 = a*exp(- --------------------------) alpha_i + alpha_j Rij^2 = (xi-xj)^2 we therefore need the derivative of Vij with respect to the atomic coordinates of atom j (molecule B) we use the chain rule: d[e^u(x)]/dx = e^u(x)*du(x)/dx with u(x) = -c*Rij^2 and c=(alpha_i*alpha_j)/(alpha_i+alpha_j) u(x) = -c*(xi^2-2xi*xj+xj^2) du(x)/dx=-c*(-2xi+2xj) dVij = -Vij*(alpha_i*alpha_j)/(alpha_i+alpha_j) * (2xj - 2xi)
      • getFGValuePP

        public double getFGValuePP​(double[] grad)
      • getFGValueShapeSelf

        public double getFGValueShapeSelf​(double[] grad,
                                          ShapeVolume molGauss,
                                          boolean rigid)
      • getGradientContribution

        public double getGradientContribution​(Gaussian3D refAt,
                                              Gaussian3D fitAt,
                                              double[] grad,
                                              boolean rigid)
      • getFGValueSelfPP

        public double getFGValueSelfPP​(double[] grad,
                                       ShapeVolume molVol,
                                       boolean rigid)
      • getCartState

        public double[] getCartState()