AttachmentPoint.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2019 Vishwesh Venkatraman <vishwesh.venkatraman@ntnu.no>
 *   and 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;
 
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
 
import javax.vecmath.Point3d;
 
import org.openscience.cdk.interfaces.IAtom;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.graph.Edge.BondType;
import denoptim.utils.GeneralUtils;
 
public class AttachmentPoint implements Cloneable,Comparable<AttachmentPoint>
{
    private int id;
    
    private int atomPositionNumber = -1;
    
    private int atomPositionNumberInMol = -1;
    
    private APClass apClass;
    
    private Point3d dirVec;
 
    private Vertex owner;
    
    private Edge user;
   
    private int cutId;
    
    private Map<Object, Object> properties;
    
    
//------------------------------------------------------------------------------
 
    public AttachmentPoint(Vertex owner) 
    {
        this(owner, -1, null, null);
    }
 
//------------------------------------------------------------------------------
 
    public AttachmentPoint(Vertex owner, int atomPositionNumber) 
    {
        this(owner, atomPositionNumber, null, null);
    }
    
//------------------------------------------------------------------------------
    
    private AttachmentPoint(Vertex owner, int atomPositionNumber, 
            Point3d dirVec) 
    {
        this(owner, atomPositionNumber, dirVec, null);
    }
 
//------------------------------------------------------------------------------
 
    //TODO: since APs can be on any vertex, and vertices are not required to
    // contain atoms, the information of which atom is an AP rooted should be
    // stored and managed by the implementation of vertex that do contain atoms.
    // The DENOPTIMFragment should thus be charged with keeping the reference to
    // the atom that holds the AP.
    
    
    public AttachmentPoint(Vertex owner, int atomPosNum, APClass apClass) 
    {
        this(owner, atomPosNum, null, apClass);
    }
    
//------------------------------------------------------------------------------
    
    //TODO: since APs can be on any vertex, and vertices are not required to
    // contain atoms, the information of which atom is an AP rooted should be
    // stored and managed by the implementation of vertex that do contain atoms.
    // The DENOPTIMFragment should thus be charged with keeping the reference to
    // the atom that holds the AP.
    
    public AttachmentPoint(Vertex owner, int atomPosNum, Point3d dirVec, 
            APClass apClass) 
    {
        this.owner = owner;
        id = owner.getUniqueAPIndex();
        this.atomPositionNumber = atomPosNum;
        this.apClass = apClass;
        if (dirVec != null)
        {
            this.dirVec = new Point3d(dirVec.x, dirVec.y, dirVec.z);
        }
    }
    
//------------------------------------------------------------------------------
    
    public AttachmentPoint(Vertex owner, String str)
            throws DENOPTIMException
    {
        this(owner);
        Object[] features = processSdfString(str);
        this.atomPositionNumber = (int) features[0];
        this.apClass = (APClass) features[1];
        this.dirVec = (Point3d) features[2];
    }
 
//-----------------------------------------------------------------------------
        
    public static Object[] processSdfString(String str) throws DENOPTIMException
    {
        Object[] features = new Object[3];
        try 
        {
            String[] parts = str.split(
                    Pattern.quote(DENOPTIMConstants.SEPARATORAPPROPAAP));
            
            //WARNING here we convert from 1-based to 0-based index
            features[0] = Integer.parseInt(parts[0])-1;
 
            String[] details = parts[1].split(
                    Pattern.quote(DENOPTIMConstants.SEPARATORAPPROPSCL));
            switch (details.length)
            {
                case 2:
                {
                    //OK, APClass:subclass but no direction vector and no bnd type
                    features[1] = APClass.make(details[0],Integer.parseInt(
                            details[1]));
                    break;
                }
                    
                case 3:
                {
                    //OK, APClass:subclass:direction_vector
                    // or APClass:subclass:BondType
                    features[1] = APClass.make(details[0],Integer.parseInt(
                            details[1]));
                    
                    String[] coord = details[2].split(
                            Pattern.quote(DENOPTIMConstants.SEPARATORAPPROPXYZ)); 
                    switch (coord.length)
                    {
                        case 1:
                            // OK, APClass:subclass:BondType
                            features[1] = APClass.make(details[0],Integer.parseInt(
                                    details[1]), BondType.valueOf(details[2]));
                            break;
                            
                        case 3:
                            //OK, APClass:subclass:direction_vector
                            features[1] = APClass.make(details[0],Integer.parseInt(
                                    details[1]));
                            features[2] = new Point3d(
                                    Double.parseDouble(coord[0]),
                                    Double.parseDouble(coord[1]),
                                    Double.parseDouble(coord[2]));
                            break;
                    }
                    break;
                }
                    
                case 4:
                {
                    //OK, new format that includes bond type
                    features[1] = APClass.make(details[0],
                            Integer.parseInt(details[1]),
                            BondType.valueOf(details[2]));
                    
                    String[] coord = details[3].split(
                            Pattern.quote(DENOPTIMConstants.SEPARATORAPPROPXYZ)); 
                    
                    if (coord.length == 3)
                    {
                        features[2] = new Point3d(Double.parseDouble(coord[0]),
                                Double.parseDouble(coord[1]),
                                Double.parseDouble(coord[2]));
                    }
                    break;
                }
                    
                default:
                    throw new DENOPTIMException("Unable to split APClass, "
                            + "subclass, and coordinates");
            }
        } catch (Throwable t) {
            t.printStackTrace();
            throw new DENOPTIMException("Cannot construct AP from string '" 
                        + str + "'",t);
        }
        return features;
    }
 
//------------------------------------------------------------------------------
 
    public int getID()
    {
        return id;
    }
    
//------------------------------------------------------------------------------
 
    public void setID(int id)
    {
        this.id = id;
    }
 
//------------------------------------------------------------------------------
 
    public int getAtomPositionNumber()
    {
        if (owner!=null && owner instanceof EmptyVertex)
            return -1;
        return atomPositionNumber;
    }
 
//------------------------------------------------------------------------------
 
    public void setAtomPositionNumber(int atomPositionNumber)
    {
        this.atomPositionNumber = atomPositionNumber;
    }
    
//------------------------------------------------------------------------------
 
    public int getAtomPositionNumberInMol()
    {
        if (owner!=null && owner instanceof EmptyVertex)
            return -1;
        return atomPositionNumberInMol;
    }
 
//------------------------------------------------------------------------------
 
    public void setAtomPositionNumberInMol(int atomPositionNumberInMol)
    {
        this.atomPositionNumberInMol = atomPositionNumberInMol;
    }
 
//------------------------------------------------------------------------------
    
    public BondType getBondType()
    {
        if (apClass == null)
            return APClass.DEFAULTBT;
        else
            return apClass.getBondType();
    }
    
//------------------------------------------------------------------------------
    
    public void setDirectionVector(Point3d dirVec)
    {
        if (dirVec == null)
            this.dirVec = null;
        else
            this.dirVec = new Point3d(dirVec.x, dirVec.y, dirVec.z);
    }
 
//------------------------------------------------------------------------------
 
    public void setAPClass(String apClass) throws DENOPTIMException
    {
        this.apClass = APClass.make(apClass);
    }
    
//------------------------------------------------------------------------------
 
    public void setAPClass(APClass apClass)
    {
        this.apClass = apClass;
    }
 
//------------------------------------------------------------------------------
 
    public APClass getAPClass()
    {
        return apClass;
    }
    
//------------------------------------------------------------------------------
 
    public Point3d getDirectionVector()
    {
        return dirVec;
    }
 
//------------------------------------------------------------------------------
 
    public int getCutId()
    {
        return cutId;
    }
 
//------------------------------------------------------------------------------
 
    public void setCutId(int id)
    {
        this.cutId = id;
    }
 
//------------------------------------------------------------------------------
 
    public boolean isAvailable()
    {
        return user == null;
    }
    
//------------------------------------------------------------------------------
 
    public boolean isAvailableThroughout()
    {
        if (user == null)
        {
            if (owner != null && owner.getGraphOwner() != null 
                    && owner.getGraphOwner().templateJacket != null)
            {
                AttachmentPoint apProjOnTemplateSurface =
                        owner.getGraphOwner().templateJacket
                        .getOuterAPFromInnerAP(this);
                if (apProjOnTemplateSurface != null)
                {
                    return apProjOnTemplateSurface.isAvailableThroughout();
                } else {
                    throw new IllegalStateException("Available AP inside a"
                            + "template should have a projection on the "
                            + "surface of the template, "
                            + "but it has none. "
                            + "Please, report this to the authors.");
                }
            } else {
                return true;
            }
        } else {
            return false;
        }
    }
 
//------------------------------------------------------------------------------
 
    public boolean isClassEnabled()
    {
        return apClass != null;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public int compareTo(AttachmentPoint other)
    {
        return Integer.compare(this.getID(), other.getID());
    }
    
//------------------------------------------------------------------------------
    
    public int comparePropertiesTo(AttachmentPoint other)
    {
        final int BEFORE = -1;
        final int EQUAL = 0;
        final int AFTER = 1;
 
        if (this == other)
            return EQUAL;
        
        if (this.sameAs(other))
            return EQUAL;
        
        //Compare source atom
        if (this.getAtomPositionNumber() < other.getAtomPositionNumber())
            return BEFORE;
        else if (this.getAtomPositionNumber() > other.getAtomPositionNumber())
            return AFTER;
 
        //Compare APClass
        if (this.getAPClass()!=null && other.getAPClass()!=null)
        {
            int res = this.apClass.compareTo(other.apClass);
            if (res != 0)
                return res;
        }
        
        //Compare Direction Vector if AtomID is equal
        if (this.getDirectionVector() != null 
                && other.getDirectionVector() != null)
        {
            Point3d thisVec = this.getDirectionVector();
            Point3d otherVec = other.getDirectionVector();
    
            if (thisVec.x < otherVec.x)
            {
                return BEFORE;
            } else if (thisVec.x > otherVec.x)
                return AFTER;
    
            if (thisVec.y < otherVec.y)
            {
                return BEFORE;
                
            } else if (thisVec.y > otherVec.y)
                return AFTER;
            
            if (thisVec.z < otherVec.z)
            {
                return BEFORE;
            } else if (thisVec.z > otherVec.z)
                return AFTER;
        }
        else
        {
            if (this.getDirectionVector() != null)
            {
                return AFTER;
            }
            else
            {
                if (other.getDirectionVector() != null)
                {
                    return BEFORE;
                }
            }
        }
        
        // We should have returned already
        System.err.println("DENOPTIMAttachmentPoint.comparePropertiesTo "
                + "inconsistent with sameAs. Please report this bug.");
        
        return EQUAL;
    }
 
//------------------------------------------------------------------------------
 
    public boolean sameAs(AttachmentPoint other)
    {
        return sameAs(other, new StringBuilder());
    }
    
//------------------------------------------------------------------------------
 
    public boolean sameAs(AttachmentPoint other, StringBuilder reason)
    {
        if (this.getAtomPositionNumber() != other.getAtomPositionNumber())
        {
            reason.append("Different source atom for APs ("
                    + this.getAtomPositionNumber() + ","
                    + other.getAtomPositionNumber() + ");");
            return false;
        }
        
        if (this.getIndexInOwner() != other.getIndexInOwner())
        {
            reason.append("Different index on list of APs ("
                    + this.getIndexInOwner() + ","
                    + other.getIndexInOwner() + ");");
            return false;
        }
        
        if (this.getAPClass()!=null && other.getAPClass()!=null)
        {
            if (!this.getAPClass().equals(other.getAPClass()))
            {
                reason.append("Different APClass ("
                        + this.getAPClass() + ","
                        + other.getAPClass() + ");");
                return false;
            }
        }
        
        return true;
    }
    
//------------------------------------------------------------------------------
    
    public AttachmentPoint clone()
    {   
        AttachmentPoint ap;
        if (apClass == null)
        {
            if (dirVec == null)
            {
                ap =new AttachmentPoint(
                        getOwner(),
                        atomPositionNumber
                );
            } else {
                ap = new AttachmentPoint(
                        getOwner(),
                        atomPositionNumber,
                        dirVec
                );
            }
        } else {
            if (dirVec == null) {
                ap = new AttachmentPoint(
                        getOwner(),
                        atomPositionNumber,
                        apClass.clone()
                );
            }
            ap = new AttachmentPoint(
                    getOwner(),
                    atomPositionNumber,
                    dirVec,
                    apClass.clone());
        }
        
        if (properties != null)
        {
            for (Object key : properties.keySet())
            {
                Object value = properties.get(key);
                if (!(key instanceof String) || !(value instanceof String))
                {
                    throw new IllegalArgumentException("Unable to clone "
                            + "non-string "
                            + "property of attachment point (key: '" + key 
                            + "'). Implement deep cloning of property " 
                            + properties.get(key).getClass().getName());
                }
                String keyStr = ((String) key) + "";
                String valueStr = ((String) value) + "";
                ap.setProperty(keyStr, valueStr);
            }
        }
        return ap;
    }
 
//------------------------------------------------------------------------------
 
    public String getSingleAPStringSDF(boolean isFirst, int srcAtmID)
    {
        StringBuilder sb = new StringBuilder();
        if (isFirst)
        {
            //WARNING! In the mol.property we use 1-to-n+1 instead of 0-to-n
            int atmIdx = atomPositionNumber + 1;
            if (srcAtmID>0)
            {
                atmIdx = srcAtmID;
            }
           
            sb.append(atmIdx);
            sb.append(DENOPTIMConstants.SEPARATORAPPROPAAP);
        }
        sb.append(apClass.toSDFString());
        if (dirVec != null)
        {
            sb.append(DENOPTIMConstants.SEPARATORAPPROPSCL);
            sb.append(GeneralUtils.getEnglishFormattedDecimal("###.####",dirVec.x));
            sb.append(DENOPTIMConstants.SEPARATORAPPROPXYZ);
            sb.append(GeneralUtils.getEnglishFormattedDecimal("###.####",dirVec.y));
            sb.append(DENOPTIMConstants.SEPARATORAPPROPXYZ);
            sb.append(GeneralUtils.getEnglishFormattedDecimal("###.####",dirVec.z));
        }
        return sb.toString();
    }
    
//------------------------------------------------------------------------------
 
    public String getSingleAPStringSDF(boolean isFirst)
    {
        return getSingleAPStringSDF(isFirst, -1);
    }
    
//------------------------------------------------------------------------------
 
    public String toStringNoId()
    {
        Map<String,Object> pars = new HashMap<String,Object>();
        pars.put("atomPositionNumber", atomPositionNumber);
        if (apClass != null)
        {
            pars.put("apClass",apClass);
        }
        if (dirVec != null)
        {
            pars.put("dirVec.x",dirVec.x);
            pars.put("dirVec.y",dirVec.y);
            pars.put("dirVec.z",dirVec.z);
        }
 
        return pars.toString();
    }
 
//------------------------------------------------------------------------------
 
    @Override
    public String toString()
    {
        Map<String,Object> pars = new HashMap<String,Object>();
        pars.put("atomPositionNumber", atomPositionNumber);
        pars.put("id", id);
        if (apClass != null)
        {
            pars.put("apClass",apClass);
        }
        if (dirVec != null)
        {
            pars.put("dirVec.x",dirVec.x);
            pars.put("dirVec.y",dirVec.y);
            pars.put("dirVec.z",dirVec.z);
        }
 
        return pars.toString();
    }
    
//-----------------------------------------------------------------------------
    
    public void setOwner(Vertex owner) {
        this.owner = owner;
    }
    
//-----------------------------------------------------------------------------
 
    public Vertex getOwner() {
        return owner;
    }
 
//-----------------------------------------------------------------------------
    
    public void setUser(Edge edge) {
        this.user = edge;
    }
 
//-----------------------------------------------------------------------------
    
    public Edge getEdgeUser() {
        return user;
    }
    
//------------------------------------------------------------------------------
 
    public Edge getEdgeUserThroughout()
    {
        if (user == null)
        {
            if (owner != null 
                    && owner.getGraphOwner() != null 
                    && owner.getGraphOwner().templateJacket != null
                    && owner.getGraphOwner().templateJacket
                    .getOuterAPFromInnerAP(this) != null)
            {
               return owner.getGraphOwner().templateJacket
                    .getOuterAPFromInnerAP(this).getEdgeUserThroughout();
            } 
        } 
        return user;
    }
    
//-----------------------------------------------------------------------------
    
    public AttachmentPoint getEmbeddedAP()
    {
        if (owner != null && owner instanceof Template)
        {
            AttachmentPoint embeddedAP = 
                    ((Template)owner).getInnerAPFromOuterAP(this);
            //NB: if embeddedAP has no further embedding it returns itself
            return embeddedAP.getEmbeddedAP();
        } else {
            return this;
        }
    }
    
//-----------------------------------------------------------------------------
     
    public AttachmentPoint getLinkedAP() 
    {
        if (user == null)
            return null;
        
        if (user.getSrcAP() == this)
        {
            return user.getTrgAP();
        } else if (user.getTrgAP() == this)
        {
            return user.getSrcAP();
        }
        return null;
    }
    
//-----------------------------------------------------------------------------
    
    public AttachmentPoint getLinkedAPThroughout() 
    {
        Edge user = getEdgeUserThroughout();
        if (user == null)
        {
            return null;
        }
        if (user.getSrcAPThroughout() == this.getEmbeddedAP() 
                || user.getSrcAP() == this)
        {
            return user.getTrgAP();
        } else if (user.getTrgAPThroughout() == this.getEmbeddedAP() 
                || user.getTrgAP() == this)
        {
            return user.getSrcAP();
        }
        return null;
    }
    
//-----------------------------------------------------------------------------
    
    public boolean isSrcInUserThroughout()
    {
        Edge user = getEdgeUserThroughout();
        if (user == null)
        {
            return false;
        }
        return user.getSrcAPThroughout() == this || user.getSrcAP() == this;
    }
    
//-----------------------------------------------------------------------------
    
    public boolean isSrcInUser()
    {
        return user != null && user.getSrcAP() == this;
    }
 
//-----------------------------------------------------------------------------
 
    public int getIndexInOwner()
    {
        if (owner == null)
        {
            return -1;
        }
        return owner.getIndexOfAP(this);
    }
    
//------------------------------------------------------------------------------
    
    public boolean hasSameSrcAtom(AttachmentPoint other)
    {
        AttachmentPoint deepThis = getEmbeddedAP();
        AttachmentPoint deepOther = other.getEmbeddedAP();
        Vertex deepOwnerT = deepThis.getOwner();
        Vertex deepOwnerO = deepOther.getOwner();
        
        if (deepOwnerT instanceof Fragment
                && deepOwnerO instanceof Fragment)
        {
            IAtom srcThis = ((Fragment) deepOwnerT).getAtomHoldingAP(
                    deepThis);
            IAtom srcOther = ((Fragment) deepOwnerO).getAtomHoldingAP(
                    deepOther);
            
            if (srcThis == srcOther)
            {
                return true;
            }
        }
        return false;
    }
    
//------------------------------------------------------------------------------
    
    public boolean hasConnectedSrcAtom(AttachmentPoint other)
    {
        AttachmentPoint deepThis = getEmbeddedAP();
        AttachmentPoint deepOther = other.getEmbeddedAP();
        Vertex deepOwnerT = deepThis.getOwner();
        Vertex deepOwnerO = deepOther.getOwner();
        
        if (deepOwnerT instanceof Fragment
                && deepOwnerO instanceof Fragment)
        {
            IAtom srcThis = ((Fragment) deepOwnerT).getAtomHoldingAP(
                    deepThis);
            IAtom srcOther = ((Fragment) deepOwnerO).getAtomHoldingAP(
                    deepOther);
            
            if (srcThis.getContainer() == srcOther.getContainer())
            {
                if (srcThis.getContainer().getConnectedAtomsList(srcThis)
                        .contains(srcOther))
                {
                    return true;
                }
            } else {
                // If the two atoms are not directly connected, they
                // might be connected via an edge in the graph.
                List<AttachmentPoint> apsOnSrcThis = 
                        ((Fragment)deepOwnerT).getAPsFromAtom(srcThis);
                List<AttachmentPoint> apsOnSrcOther = 
                        ((Fragment)deepOwnerT).getAPsFromAtom(srcOther);
                for (AttachmentPoint apOnSrcThis : apsOnSrcThis)
                {
                    // We ignore the connection deepThis-to-deepOther
                    if (apOnSrcThis.isAvailableThroughout() 
                            || apOnSrcThis==deepThis)
                        continue;
                    
                    AttachmentPoint linkedAP = 
                            apOnSrcThis.getLinkedAPThroughout().getEmbeddedAP();
                    for (AttachmentPoint apOnSrcOther : apsOnSrcOther)
                    {
                        if (apOnSrcOther.isAvailableThroughout() 
                                || apOnSrcOther==deepOther)
                            continue;
                        if (linkedAP==apOnSrcOther)
                        {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
 
//------------------------------------------------------------------------------
    
    public Map<Object,Object> getProperties()
    {
        return properties;
    }
    
//------------------------------------------------------------------------------
    
    public Object getProperty(Object description)
    {
        if (properties == null)
        {
            return null;
        } else {
            return properties.get(description);
        }
    }
    
//------------------------------------------------------------------------------
    
    public void setProperty(Object key, Object property)
    {
        if (properties == null)
        {
            properties = new HashMap<Object, Object>();
        }
        properties.put(key, property);
    }
 
//------------------------------------------------------------------------------
    
    // WARNING: here is a place where we still assume a fixed order of APs
    // In fact, the order in which we process the keys is given by the comparable
    // class Integer, i.e., the APs are reported in SDF following the ordering
    // of the respective source atoms.
    // To solve the issue of ordering we could drop the format in which we 
    // collect APs by source atom (i.e., 1#firstAP,second-AP) and allow for
    // a one-to-one (sorted) list of APs where "1#firstAP,second-AP" becomes
    // "1#firstAP 1#second-AP"
    
    public static String getAPDefinitionsForSDF(
            LinkedHashMap<Integer, List<AttachmentPoint>> apsPerIndex)
    {   
        String s = "";
        for (Integer ii : apsPerIndex.keySet())
        {
            //WARNING: here is the 1-based criterion implemented also for
            // fake atom IDs!
            int atmID = ii+1;
    
            List<AttachmentPoint> apsOnAtm = apsPerIndex.get(ii);
            
            boolean firstCL = true;
            for (int i = 0; i<apsOnAtm.size(); i++)
            {
                AttachmentPoint ap = apsOnAtm.get(i);
                
                //Build SDF property DENOPTIMConstants.APCVTAG
                String stingAPP = ""; //String Attachment Point Property
                if (firstCL)
                {
                    firstCL = false;
                    stingAPP = ap.getSingleAPStringSDF(true,atmID);
                } else {
                    stingAPP = DENOPTIMConstants.SEPARATORAPPROPAPS 
                            + ap.getSingleAPStringSDF(false,atmID);
                }
                s = s + stingAPP;
            }
            s = s + DENOPTIMConstants.SEPARATORAPPROPATMS;
        }
        return s;
    }
    
//-----------------------------------------------------------------------------
 
}