RingClosure.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2019 Marco Foscato <marco.foscato@uib.no>
 * 
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.graph.rings;
 
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;
 
import denoptim.constants.DENOPTIMConstants;
 
public class RingClosure
{
    private Point3d h1;
 
    private Point3d h2;
 
    private Point3d t1;
 
    private Point3d t2;
 
    private Vector3d h;
 
    private Vector3d t; 
 
    private double distH1T2;
 
    private double distH2T1;
 
    private double distH2T2;
 
    private double qscore = Double.NaN;
    
    private RingClosureParameters settings;
 
//-----------------------------------------------------------------------------
 
    public RingClosure(RingClosureParameters settings)
    {
        this.settings = settings;
    }
 
//-----------------------------------------------------------------------------
 
    public RingClosure(Point3d h1, Point3d h2, Point3d t1, Point3d t2)
    {
        this.h1 = h1;
        this.h2 = h2;
        this.t1 = t1;
        this.t2 = t2;
    }
 
//-----------------------------------------------------------------------------
 
    public void calculateDescriptors()
    {
        this.distH1T2 = h1.distance(t2);
        this.distH2T1 = h2.distance(t1);
        this.distH2T2 = h2.distance(t2);
        this.h = new Vector3d(h2.x-h1.x, h2.y-h1.y, h2.z-h1.z);
        this.t = new Vector3d(t2.x-t1.x, t2.y-t1.y, t2.z-t1.z);
        this.h.normalize();
        this.t.normalize();
    }
 
//-----------------------------------------------------------------------------
 
    public boolean isClosable(ArrayList<Double> clsablConds,Logger logger)
    {
        return isClosable(clsablConds.get(0), 
                          clsablConds.get(1),
                          clsablConds.get(2),
                          clsablConds.get(3),
                          clsablConds.get(4),
                          clsablConds.get(5),
                          clsablConds.get(6),
                          logger);
    }
 
//-----------------------------------------------------------------------------
 
    public boolean isClosable (double minDH1T2, double maxDH1T2,
                                double minDH2T1, double maxDH2T1,
                                double minDH2T2, double maxDH2T2,
                                double maxDotHT, Logger logger)
    {
        boolean res = false;
        this.distH1T2 = h1.distance(t2);
        this.distH2T1 = h2.distance(t1);
        this.distH2T2 = h2.distance(t2);
        if (logger.isLoggable(Level.FINEST))
        {
            StringBuilder sb = new StringBuilder();
            String NL = DENOPTIMConstants.EOL;
            sb.append("Values for evaluation of closability:");
            sb.append("  distH1T2: " + String.format("%8.4f",distH1T2));
            sb.append("  min: " + String.format("%8.4f",minDH1T2));
            sb.append("  max: " + String.format("%8.4f",maxDH1T2) + NL);
            sb.append("  distH2T1: " + String.format("%8.4f",distH2T1));
            sb.append("  min: " + String.format("%8.4f",minDH2T1));
            sb.append("  max: " + String.format("%8.4f",maxDH2T1) + NL);
            sb.append("  distH2T2: " + String.format("%8.4f",distH2T2));
            sb.append("  min: " + String.format("%8.4f",minDH2T2));
            sb.append("  max: " + String.format("%8.4f",maxDH2T2) + NL);
            h = new Vector3d(h2.x-h1.x, h2.y-h1.y, h2.z-h1.z);
            t = new Vector3d(t2.x-t1.x, t2.y-t1.y, t2.z-t1.z);
            h.normalize();
            t.normalize();
            sb.append("  dot:      " + String.format("%8.4f", h.dot(t)));
            sb.append("  max: " + String.format("%8.4f%n", maxDotHT));
            logger.log(Level.FINEST,sb.toString());
        }
 
        if (distH1T2 < maxDH1T2 && distH1T2 > minDH1T2 &&
            distH2T1 < maxDH2T1 && distH2T1 > minDH2T1 &&
            distH2T2 < maxDH2T2 && distH2T2 > minDH2T2)
        {
            h = new Vector3d(h2.x-h1.x, h2.y-h1.y, h2.z-h1.z);
            t = new Vector3d(t2.x-t1.x, t2.y-t1.y, t2.z-t1.z);
            h.normalize();
            t.normalize();
 
            if (h.dot(t) <= maxDotHT)
            {
                logger.log(Level.FINEST,"  CLOSABLE!");
                res = true;
            }
        }
        return res;
    }
 
//-----------------------------------------------------------------------------
 
    public double getRingClosureQuality()
    {
        if (Double.isNaN(qscore))
        {
            double lenH = h1.distance(h2);
            double lenT = t1.distance(t2);
            double optDistH1T2 = 0.0;
            double optDistH2T1 = 0.0;
            double optDistH1T1 = 0.0;
            double optDistH2T2 = 0.0;
            optDistH1T1 = (lenH + lenT) / 2.0;
            optDistH2T2 = optDistH1T1;
    
            qscore = Math.abs(h1.distance(t1) - optDistH1T1) +
                     Math.abs(h2.distance(t2) - optDistH2T2) +
                     Math.abs(h1.distance(t2) - optDistH1T2) +
                     Math.abs(h2.distance(t1) - optDistH2T1);        
        }
        return qscore;
    }
 
//-----------------------------------------------------------------------------
 
    public Point3d getPoint(int i)
    {
        if (i == 0)
            return h1;
        else if (i == 1)
            return h2;
        else if (i == 2)
            return t1;
        else if (i == 3)
            return t2;
        return null;
    }
 
//-----------------------------------------------------------------------------
 
    public ArrayList<Double> getClosabilityConditions(double etrxTol)
    {
        ArrayList<Double> clsablConds = new ArrayList<Double>();
 
        //Define conditions based on SrcAtom-to-RCA bonds and RC-strategy
        double lenH = h1.distance(h2);
        double lenT = t1.distance(t2);
        double distTolerance = (lenH + lenT) / 2.0;
        distTolerance = distTolerance * etrxTol * settings.getRCDistTolerance();
        double minDistH1T2 = -1.0;
        double minDistH2T1 = -1.0;
        double minDistH2T2 = -1.0;
        double maxDistH1T2 = 0.0;
        double maxDistH2T1 = 0.0;
        double maxDistH2T2 = 0.0;
        double maxDotProdHT = settings.getRCDotPrTolerance();
        maxDistH1T2 = distTolerance;
        maxDistH2T1 = distTolerance;
        maxDistH2T2 = lenH + lenT;
            
        //Collect conditions as a vector
        clsablConds.add(minDistH1T2);
        clsablConds.add(maxDistH1T2);
        clsablConds.add(minDistH2T1);
        clsablConds.add(maxDistH2T1);
        clsablConds.add(minDistH2T2);
        clsablConds.add(maxDistH2T2);
        clsablConds.add(maxDotProdHT);
 
        return clsablConds;
    }
 
//-----------------------------------------------------------------------------
 
    public RingClosure deepCopy()
    {
        Point3d nH1 = new Point3d(h1.x, h1.y, h1.z);
        Point3d nH2 = new Point3d(h2.x, h2.y, h2.z);
        Point3d nT1 = new Point3d(t1.x, t1.y, t1.z);
        Point3d nT2 = new Point3d(t2.x, t2.y, t2.z);
        RingClosure nRc = new RingClosure(nH1, nH2, nT1, nT2);
        return nRc;
    }
 
//-----------------------------------------------------------------------------
 
    public String toString()
    {
        String s = "RingClosure [" + h1 + " " + h2 + " " + t1 + " " + t2 + "]";
        return s;
    }
 
//-----------------------------------------------------------------------------
}