Vertex.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.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import org.openscience.cdk.interfaces.IAtomContainer;
 
import com.google.gson.Gson;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.fragspace.FragmentSpace;
import denoptim.graph.rings.RingClosingAttractor;
import denoptim.json.DENOPTIMgson;
import denoptim.logging.StaticLogger;
import denoptim.utils.GraphUtils;
import denoptim.utils.MutationType;
import denoptim.utils.Randomizer;
 
public abstract class Vertex implements Cloneable
{
    private DGraph owner;
 
    private long vertexId;
    
    protected int buildingBlockId = -99;
    
    public enum BBType {
        UNDEFINED, SCAFFOLD, FRAGMENT, CAP, NONE;
        
        private int i = -99;
        
        static {
            NONE.i = -1;
            SCAFFOLD.i = 0;
            FRAGMENT.i = 1;
            CAP.i = 2;
        }
        
        public static BBType parseInt(int i) {
            BBType bbt;
            switch (i)
            {
                case 0:
                    bbt = SCAFFOLD;
                    break;
                case 1:
                    bbt = FRAGMENT;
                    break;
                case 2:
                    bbt = CAP;
                    break;
                default:
                    bbt = UNDEFINED;
                    break;
            }
            return bbt;
        }
        
        public int toOldInt()
        {
            return i;
        }
    }
    
    /*
     * Building block type distinguished among types of building blocks:
     * scaffolds, fragments, and capping. 
     * Can be undefined, which is the default.
     */
    protected BBType buildingBlockType = Vertex.BBType.UNDEFINED;
 
    /*
     * Flag indicating that this as a ring closing vertex
     */
    private boolean isRCV;
    
    protected Map<Object, Object> properties;
    
    protected Set<String> uniquefyingPropertyKeys = new HashSet<String>();
 
    private List<MutationType> allowedMutationTypes = 
            new ArrayList<MutationType>(Arrays.asList(MutationType.values()));
    
    protected final VertexType vertexType;
    
    public enum VertexType {
        MolecularFragment,
        EmptyVertex,
        Template,
    }
 
//------------------------------------------------------------------------------
 
    public Vertex(VertexType vertexType)
    {
        this.vertexType = vertexType;
        vertexId = GraphUtils.getUniqueVertexIndex();
        isRCV = false;
    }
    
//------------------------------------------------------------------------------
 
    public Vertex(VertexType vertexType, long id)
    {
        this(vertexType);
        vertexId = id;
    }
    
//------------------------------------------------------------------------------
 
    public static Vertex newVertexFromLibrary(int bbId, 
            Vertex.BBType bbt, FragmentSpace fragSpace) 
                    throws DENOPTIMException
    {
        return newVertexFromLibrary(GraphUtils.getUniqueVertexIndex(), bbId, bbt,
                fragSpace);
    }
    
//------------------------------------------------------------------------------
 
    public static Vertex newVertexFromLibrary(long vertexId, int bbId, 
            Vertex.BBType bbt, FragmentSpace fragSpace) 
                    throws DENOPTIMException
    {   
        // The actual type of vertex
        // returned by this method depends on the what we get from the
        // FragmentSpace.getVertexFromLibrary call
        Vertex v = fragSpace.getVertexFromLibrary(bbt,bbId);
        v.setVertexId(vertexId);
        
        v.setAsRCV(v.getNumberOfAPs() == 1
                && RingClosingAttractor.RCAAPCLASSSET.contains(
                        v.getAttachmentPoints().get(0).getAPClass()));
        
        return v;
    }
 
//------------------------------------------------------------------------------
 
    public abstract List<AttachmentPoint> getAttachmentPoints();
    
//------------------------------------------------------------------------------
    
    public List<AttachmentPoint> getAPsWithAPClassStartingWith(
            String root)
    {
        List<AttachmentPoint> list = new ArrayList<AttachmentPoint>();
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            if (ap.getAPClass().toString().startsWith(root))
                list.add(ap);
        }
        return list;
    }
 
//------------------------------------------------------------------------------
    
    public void setAsRCV(boolean isRCV)
    {
        this.isRCV = isRCV;
    }
    
//------------------------------------------------------------------------------
 
    public void setVertexId(long vertexId2)
    {
        this.vertexId = vertexId2;
    }
 
//------------------------------------------------------------------------------
 
    public long getVertexId()
    {
        return vertexId;
    }
 
//------------------------------------------------------------------------------
 
    public int getBuildingBlockId()
    {
        return buildingBlockId;
    }
 
//------------------------------------------------------------------------------
 
    public void setBuildingBlockId(int buildingBlockId)
    {
        this.buildingBlockId = buildingBlockId;
    }
 
//------------------------------------------------------------------------------
 
    public Vertex.BBType getBuildingBlockType()
    {
        return buildingBlockType;
    }
    
//------------------------------------------------------------------------------
 
    public void setBuildingBlockType(Vertex.BBType buildingBlockType)
    {
        this.buildingBlockType = buildingBlockType;
    }
    
//------------------------------------------------------------------------------
 
    protected abstract void setSymmetricAPSets(List<SymmetricAPs> sAPs);
    
//------------------------------------------------------------------------------
 
    protected abstract void addSymmetricAPSet(SymmetricAPs symAPs);
 
//------------------------------------------------------------------------------
 
    public abstract List<SymmetricAPs> getSymmetricAPSets();
 
//------------------------------------------------------------------------------
 
    public SymmetricAPs getSymmetricAPs(AttachmentPoint ap)
    {
        for (SymmetricAPs symmetricSet : getSymmetricAPSets()) 
        {
            if (symmetricSet.contains(ap))
            {
                return symmetricSet;
            }
        }
        return new SymmetricAPs();
    }
 
//------------------------------------------------------------------------------
 
    public int getNumberOfAPs()
    {
        return getAttachmentPoints().size();
    }
 
//------------------------------------------------------------------------------
 
    public int getFreeAPCount()
    {
        int n = 0;
        for (AttachmentPoint ap : getAttachmentPoints()) 
        {
            if (ap.isAvailable())
                n++;
        }
        return n;
    }
    
//------------------------------------------------------------------------------
 
    public ArrayList<AttachmentPoint> getFreeAPThroughout()
    {
        ArrayList<AttachmentPoint> lst = 
                new ArrayList<AttachmentPoint>();
        for (AttachmentPoint ap : getAttachmentPoints()) 
        {
            if (ap.isAvailableThroughout())
                lst.add(ap);
        }
        return lst;
    }
 
//------------------------------------------------------------------------------
 
    public int getFreeAPCountThroughout()
    {
        return getFreeAPThroughout().size();
    }
    
//------------------------------------------------------------------------------
 
    public ArrayList<AttachmentPoint> getCappedAPs()
    {
        ArrayList<AttachmentPoint> lst = 
                new ArrayList<AttachmentPoint>();
        for (AttachmentPoint ap : getAttachmentPoints()) 
        {
            if (!ap.isAvailable())
            {
                AttachmentPoint linkedAP = ap.getLinkedAP();
                if (linkedAP.getOwner().getBuildingBlockType() == BBType.CAP)
                    lst.add(ap);
            }
        }
        return lst;
    }
    
//------------------------------------------------------------------------------
 
    public ArrayList<AttachmentPoint> getCappedAPsThroughout()
    {
        ArrayList<AttachmentPoint> lst = 
                new ArrayList<AttachmentPoint>();
        for (AttachmentPoint ap : getAttachmentPoints()) 
        {
            if (!ap.isAvailableThroughout())
            {
                AttachmentPoint linkedAP = ap.getLinkedAPThroughout();
                if (linkedAP.getOwner().getBuildingBlockType() == BBType.CAP)
                    lst.add(ap);
            }
        }
        return lst;
    }
 
//------------------------------------------------------------------------------
 
    public int getCappedAPCountThroughout()
    {
        return getCappedAPsThroughout().size();
    }
    
//------------------------------------------------------------------------------
 
    public boolean hasFreeAP()
    {
        for (AttachmentPoint ap : getAttachmentPoints()) 
        {
            if (ap.isAvailableThroughout())
                return true;
        }
        return false;
    }
    
//------------------------------------------------------------------------------
    
    protected int getUniqueAPIndex()
    {
        if (owner == null)
        {
            return getNumberOfAPs();
        } else {
            return owner.getUniqueAPIndex();
        }
    }
 
//------------------------------------------------------------------------------
 
    public boolean isRCV()
    {
        return isRCV;
    }
    
//------------------------------------------------------------------------------
 
    public boolean isAromaticBridge()
    {
        return getAllAPClasses()
            .stream()
            .anyMatch(apc -> APClass.APCAROMBRIDGES.contains(apc));
    }
    
//------------------------------------------------------------------------------
 
    public boolean isConnectedToAromaticBridge()
    {
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            if (ap.isAvailableThroughout())
                continue;
            
            AttachmentPoint linkedAp = ap.getLinkedAPThroughout();
            if (APClass.APCAROMBRIDGES.contains(linkedAp.getAPClass()))
                return true;
            Vertex rcv = linkedAp.getOwner();
            if (rcv.isRCV)
            {
                if (getGraphOwner().getRingsInvolvingVertex(rcv).size()==0)
                    continue;
                // Since it is an RCV, there can be only one ring involved.
                Ring r = getGraphOwner().getRingsInvolvingVertex(rcv).get(0);
                return r.getVertexAtPosition(r.getSize()-2).isAromaticBridge()
                        || r.getVertexAtPosition(1).isAromaticBridge();
            }
        }
        return false;
    }
 
//------------------------------------------------------------------------------
 
    public boolean hasSymmetricAP()
    {
        return !getSymmetricAPSets().isEmpty();
    }
 
//------------------------------------------------------------------------------
 
    @Override
    public String toString()
    {
        return vertexId  + "_" + (buildingBlockId + 1) + "_" 
                + buildingBlockType.toOldInt();
    }
 
//------------------------------------------------------------------------------
    
    public void cleanup()
    {
        if (getSymmetricAPSets() != null)
        {
            getSymmetricAPSets().clear();
        }
        if (getAttachmentPoints() != null)
        {
            getAttachmentPoints().clear();
        }
    }
    
//------------------------------------------------------------------------------
    
    @Override
    public abstract Vertex clone();
 
//------------------------------------------------------------------------------
    
    public boolean sameAs(Vertex other)
    {
        return sameAs(other, new StringBuilder());
    }
    
//------------------------------------------------------------------------------
    
    public boolean sameAs(Vertex other, StringBuilder reason)
    {
        if (this.getClass() == other.getClass())
        {
            if (this instanceof Fragment)
            {
                return ((Fragment) this).sameAs(
                        (Fragment) other, reason);
            } else if (this instanceof EmptyVertex) {
                return ((EmptyVertex) this).sameAs(
                        (EmptyVertex) other, reason);
            } else if (this instanceof Template) {
                return ((Template) this).sameAs(
                        (Template) other, reason);
            } else {
                System.err.println("WARNING: Unimplemented sameAs method for "
                        + "vertex subtype '" + this.getClass().getName() + "'");
            }
        } 
        return sameVertexFeatures(other, reason);
    }
    
//------------------------------------------------------------------------------
    
    public boolean sameVertexFeatures(Vertex other, StringBuilder reason)
    {   
        if (this.getBuildingBlockType() != other.getBuildingBlockType())
        {
            reason.append("Different building block type ("
                    + this.getBuildingBlockType()+":"
                    + other.getBuildingBlockType()+"); ");
            return false;
        }
        
        if (this.getBuildingBlockId() != other.getBuildingBlockId())
        {
            reason.append("Different molID ("+this.getBuildingBlockId()+":"
                    + other.getBuildingBlockId()+"); ");
            return false;
        }
        
        if (this.getNumberOfAPs() != other.getNumberOfAPs())
        {
            reason.append("Different number of APs ("
                    +this.getNumberOfAPs()+":"
                    +other.getNumberOfAPs()+"); ");
            return false;
        }
        
        // Order of APs must be the same
        for (int i=0; i<this.getNumberOfAPs(); i++)
        {
            AttachmentPoint apT = this.getAP(i);
            AttachmentPoint apO = other.getAP(i);
            if (!apT.sameAs(apO))
            {
                reason.append("Difference in AP "+i+": "+apT+" vs "+apO);
                return false;
            }
        }
        
        return true;
    }
 
//------------------------------------------------------------------------------
 
    public abstract int getHeavyAtomsCount();
 
//------------------------------------------------------------------------------
 
    public abstract boolean containsAtoms();
 
//------------------------------------------------------------------------------
 
    public abstract IAtomContainer getIAtomContainer();
 
//------------------------------------------------------------------------------
 
    public abstract IAtomContainer getIAtomContainer(Logger logger, 
            Randomizer rng, boolean removeUsedRCAs, boolean rebuild);
 
//-----------------------------------------------------------------------------
 
    public ArrayList<APClass> getAllAPClasses()
    {
        ArrayList<APClass> lst = new ArrayList<APClass>();
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            APClass apCls = ap.getAPClass();
            if (!lst.contains(apCls))
            {
                lst.add(apCls);
            }
        }
        return lst;
    }
    
//-----------------------------------------------------------------------------
 
    public ArrayList<APClass> getAllAvailableAPClasses()
    {
        ArrayList<APClass> lst = new ArrayList<APClass>();
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            if (!ap.isAvailable())
                continue;
            
            APClass apCls = ap.getAPClass();
            if (!lst.contains(apCls))
            {
                lst.add(apCls);
            }
        }
        return lst;
    }
    
//------------------------------------------------------------------------------
 
    public void resetGraphOwner()
    {
        this.owner = null;
    }
    
//------------------------------------------------------------------------------
 
    public void setGraphOwner(DGraph owner)
    {
        this.owner = owner;
    }
    
//------------------------------------------------------------------------------
 
    public DGraph getGraphOwner()
    {
        return owner;
    }
    
//------------------------------------------------------------------------------
 
    public List<Vertex> getMutationSites()
    {
        return getMutationSites(new ArrayList<MutationType>());
    }
 
//------------------------------------------------------------------------------
 
    public abstract List<Vertex> getMutationSites(
            List<MutationType> ignoredTypes);
 
//------------------------------------------------------------------------------
 
    public void setMutationTypes(List<MutationType> lst)
    {
        allowedMutationTypes = lst;
    }
    
//------------------------------------------------------------------------------
 
    protected List<MutationType> getUnfilteredMutationTypes()
    {
        return allowedMutationTypes;
    }
    
//------------------------------------------------------------------------------
    
    public boolean removeMutationType(MutationType mt)
    {
        return allowedMutationTypes.remove(mt);
    }
 
//------------------------------------------------------------------------------
 
    public List<MutationType> getMutationTypes()
    {
        return getMutationTypes(new ArrayList<MutationType>());
    }
    
//------------------------------------------------------------------------------
 
    public List<MutationType> getMutationTypes(List<MutationType> excludedTypes)
    {
        List<MutationType> filteredTypes = new ArrayList<MutationType>(
                allowedMutationTypes);
        if (owner != null)
        {
            // this vertex is part of a graph
            
            // Cannot add/change link on vertex that is not linked
            if (getChilddren().isEmpty())
            {
                filteredTypes.remove(MutationType.ADDLINK);
                filteredTypes.remove(MutationType.CHANGELINK);
            }
            
            // Cannot extend vertex that has no truly free AP, but can do it
            // on APs that are used by capping groups.
            if ((getFreeAPCountThroughout() + getCappedAPs().size()) == 0)
            {
                filteredTypes.remove(MutationType.EXTEND);
                filteredTypes.remove(MutationType.ADDRING);
                filteredTypes.remove(MutationType.ADDFUSEDRING);
            }
            
            // Cannot remove the only vertex of a graph
            if (owner.getVertexCount()==0)
                filteredTypes.remove(MutationType.DELETE);
            
            // Cannot start removal of chain from a branching vertex.
            long nonCap = getAttachmentPoints().size() 
                    - getCappedAPCountThroughout()
                    - getFreeAPCountThroughout();
            if (nonCap > 2)
                filteredTypes.remove(MutationType.DELETECHAIN);
        }
        
        if (isAromaticBridge() || isConnectedToAromaticBridge())
        {
            // So far we do not do any check to ensure that 
            // A) the change/additions/removal of a link retains aromaticity,
            // B) the other APs can be safely interchanged between links as long
            // as the APClass compatibility is respected.
            // Therefore, link editing is unsafe for building blocks of aromatic
            // systems. 
            filteredTypes.remove(MutationType.ADDLINK);
            filteredTypes.remove(MutationType.DELETELINK);
            filteredTypes.remove(MutationType.CHANGELINK);
            filteredTypes.remove(MutationType.CHANGEBRANCH);
        }
        
        if (getAttachmentPoints().size()-getFreeAPCountThroughout() < 2)
        {
            filteredTypes.remove(MutationType.DELETELINK);
        }
        
        if (BBType.SCAFFOLD == getBuildingBlockType())
        {
            filteredTypes.remove(MutationType.DELETECHAIN);
            filteredTypes.remove(MutationType.DELETELINK);
            filteredTypes.remove(MutationType.CHANGELINK);
            filteredTypes.remove(MutationType.CHANGEBRANCH);
            filteredTypes.remove(MutationType.DELETE);
        }
        
        filteredTypes.removeAll(excludedTypes);
        
        return filteredTypes;
    }
    
//------------------------------------------------------------------------------
 
    public AttachmentPoint getAP(int i) {
        return getAttachmentPoints().get(i);
    }
    
//------------------------------------------------------------------------------
 
    public AttachmentPoint getAPWithId(int i) 
    {
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            if (ap.getID()==i)
                return ap;
        }
        return null;
    }
    
//------------------------------------------------------------------------------
 
    public int getIndexOfAP(AttachmentPoint ap)
    {
        for (int i=0; i<getAttachmentPoints().size(); i++)
        {
            AttachmentPoint candAp = getAttachmentPoints().get(i);
            if (candAp == ap)
            {
                return i;
            }
        }
        return -1;
    }
    
//------------------------------------------------------------------------------
 
    public Edge getEdgeToParent() {
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            Edge user = ap.getEdgeUser();
            if (user == null)
                continue;
            
            if (ap == user.getTrgAP())
            {
                return user;
            }
        }
        return null;
    }
    
//------------------------------------------------------------------------------
 
    public Vertex getParent() 
    {
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            Edge user = ap.getEdgeUser();
            if (user == null)
                continue;
            
            if (ap == user.getTrgAP())
            {
                return user.getSrcAP().getOwner();
            }
        }
        return null;
    }
    
//------------------------------------------------------------------------------
 
    public ArrayList<AttachmentPoint> getAPsFromChildren() 
    {
        ArrayList<AttachmentPoint> apsOnChildren = 
                new ArrayList<AttachmentPoint>();
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            Edge user = ap.getEdgeUserThroughout();
            if (user == null)
                continue;
            
            if (ap == user.getSrcAPThroughout())
            {
                apsOnChildren.add(user.getTrgAPThroughout());
            }
        }
        return apsOnChildren;
    }
    
//------------------------------------------------------------------------------
 
    public ArrayList<Vertex> getChildrenThroughout() 
    {
        ArrayList<Vertex> children = new ArrayList<Vertex>();
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            Edge user = ap.getEdgeUserThroughout();
            if (user == null)
                continue;
            
            if (ap.isSrcInUserThroughout())
            {
                children.add(user.getTrgAP().getOwner());
            }
        }
        return children;
    }
    
//------------------------------------------------------------------------------
 
    public ArrayList<Vertex> getChilddren() 
    {
        ArrayList<Vertex> children = new ArrayList<Vertex>();
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            // NB: this is meant to NOT cross template boundaries, so that all
            // children do belong to the same graph.
            Edge user = ap.getEdgeUser();
            if (user == null)
                continue;
            
            if (ap == user.getSrcAP())
            {
                children.add(user.getTrgAP().getOwner());
            }
        }
        return children;
    }
    
//------------------------------------------------------------------------------
    
    public void setUniquefyingProperty(String key)
    {
        uniquefyingPropertyKeys.add(key);
    }
    
//------------------------------------------------------------------------------
    
    public Map<Object, Object> getProperties()
    {
        return properties;
    }
    
//------------------------------------------------------------------------------
    
    public boolean hasProperty(Object property)
    {
        if (properties==null)
            return false;
        
        return properties.containsKey(property);
    }
    
//------------------------------------------------------------------------------
    
    public Object getProperty(Object property)
    {
        if (properties == null)
        {
            return null;
        } else {
            return properties.get(property);
        }
    }
    
//-----------------------------------------------------------------------------
    
    public void setProperty(Object key, Object property)
    {
        if (properties == null)
        {
            properties = new HashMap<Object, Object>();
        }
        properties.put(key, property);
    }
    
//-----------------------------------------------------------------------------
    
    public void removeProperty(Object key)
    {
        if (properties == null)
            return;
        
        properties.remove(key);
    }
    
//------------------------------------------------------------------------------
    
    protected Map<Object, Object> copyStringBasedProperties()
    {
        if (properties==null)
            return null;
        
        Map<Object, Object> copy = new HashMap<Object, Object>();
        for (Object k : properties.keySet())
        {
            Object v = properties.get(k);
            if ((k instanceof String && v instanceof String)
                    || (uniquefyingPropertyKeys!=null 
                        && uniquefyingPropertyKeys.contains(k)))
            {
                copy.put(k,v);
            }
        }
        return copy;
    }
    
//-----------------------------------------------------------------------------
    
    public void setProperties(Map<Object, Object> properties)
    {
        this.properties = properties;
    }
    
//------------------------------------------------------------------------------
    
    public static Vertex fromJson(String json)
    {
        Gson gson = DENOPTIMgson.getReader();
        return gson.fromJson(json, Vertex.class);
    }
 
//------------------------------------------------------------------------------
    
    public VertexType getVertexType()
    {
        return VertexType.valueOf(vertexType.name());
    }
    
//------------------------------------------------------------------------------
 
    public static class DENOPTIMVertexDeserializer 
    implements JsonDeserializer<Vertex>
    {
        @Override
        public Vertex deserialize(JsonElement json, Type typeOfT,
                JsonDeserializationContext context) throws JsonParseException
        {
            JsonObject jsonObject = json.getAsJsonObject();
            
            if (!jsonObject.has("vertexType"))
            {
                String msg = "Missing 'vertexType': found a "
                        + "JSON string generated by a previous version and "
                        + "that is no longer compatible. "
                        + "Upgrade the JSON string by adding "
                        + "the member 'vertexType', which can be any of these:";
                for (VertexType v : VertexType.values())
                    msg = msg + " " + v;
                msg = msg + ". ";
                throw new JsonParseException(msg);
            }       
 
            // Deseralization differs for the types of vertices
            VertexType vt = context.deserialize(jsonObject.get("vertexType"),
                    VertexType.class);
            Vertex v = null;
            switch (vt)
            {
                case Template:
                {
                    v = Template.fromJson(jsonObject.toString());
                    break;
                }
                
                case MolecularFragment:
                {
                    v = Fragment.fromJson(jsonObject.toString());
                    break;
                }
                
                case EmptyVertex:
                {
                    v = EmptyVertex.fromJson(jsonObject.toString());
                    break;
                }
                
                default:
                {
                    return null;
                }
            }
            
            if (jsonObject.has("lstSymAPs"))
            {
                for (JsonElement elSet : jsonObject.get("lstSymAPs").getAsJsonArray())
                {
                    List<AttachmentPoint> aps = new ArrayList<AttachmentPoint>();
                    for (JsonElement elId : elSet.getAsJsonArray())
                    {
                        int id = context.deserialize(elId, Integer.class);
                        AttachmentPoint ap = v.getAPWithId(id);
                        if (ap==null)
                        {
                            String msg = "Failed to parse 'lstSymAPs'. It is "
                                    + "possible that the JSON input has been "
                                    + "writted by a previosu version of "
                                    + "DENOPTIM. If so, its syntax needs to be "
                                    + "upgraded.";
                            throw new JsonParseException(msg);
                        }
                        aps.add(ap);
                    }
                    v.addSymmetricAPSet(new SymmetricAPs(aps));
                }                
            }
            
            return v;
        }
    }
 
//------------------------------------------------------------------------------
 
    public String[] getPathIDs(AttachmentPoint apA,
            AttachmentPoint apB)
    {
        String a2b = this.getBuildingBlockId() + "/" 
                + this.getBuildingBlockType() + "/ap"
                + getIndexOfAP(apA) + "ap" + getIndexOfAP(apB) + "_";
        String b2a = this.getBuildingBlockId() + "/" 
                + this.getBuildingBlockType() + "/ap"
                + getIndexOfAP(apB) + "ap" + getIndexOfAP(apA) + "_";
        String[] pair = {a2b,b2a};
        return pair;
    }
    
//------------------------------------------------------------------------------
 
    public static Vertex convertIACToVertex(IAtomContainer iac, 
            Vertex.BBType bbt) throws DENOPTIMException
    {
        Vertex v = new Fragment(iac, bbt);
        v.setAsRCV(v.getNumberOfAPs() == 1
                && RingClosingAttractor.RCAAPCLASSSET.contains(
                        v.getAttachmentPoints().get(0).getAPClass()));
        return v;
    }
    
//------------------------------------------------------------------------------
    
    public static Vertex parseVertexFromSDFFormat(IAtomContainer mol,
            Gson reader, BBType bbt) throws DENOPTIMException
    {
        Vertex v = null;
        try
        {
            Object json = mol.getProperty(DENOPTIMConstants.VERTEXJSONTAG);
            if (json != null) {
                v = reader.fromJson(json.toString(), Vertex.class);
            } else {
                json = mol.getProperty(DENOPTIMConstants.GRAPHJSONTAG);
                if (json != null)
                {
                    StaticLogger.appLogger.log(Level.WARNING, "Attempt to "
                        + "read a vertex from "
                        + "a SDF file that contains a JSON definition of a "
                        + "graph. This should not be intentional, so we'll "
                        + "read the atom container ignoring the JSON "
                        + "definition of a graph.");
                }
                v = Vertex.convertIACToVertex(mol, bbt);
            }
        } catch (JsonSyntaxException | DENOPTIMException e)
        {
            throw new DENOPTIMException("Unable to parse IAtomContainer to "
                    + "create vertex. ",e);
        }
        v.setBuildingBlockType(bbt);
        return v;
    }
    
 
//------------------------------------------------------------------------------
    
    public boolean connectedTo(Vertex other)
    {
        return this.getParent() == other || this == other.getParent();
    }
 
//------------------------------------------------------------------------------
    
    public Edge getEdgeWith(Vertex other)
    {
        if (this.owner != null && other.owner !=null
                && this.owner == other.owner)
        {
            for (AttachmentPoint ap : getAttachmentPoints())
            {
                AttachmentPoint linkedAp = ap.getLinkedAP();
                if (linkedAp == null)
                    continue;
                if (linkedAp.getOwner()==other)
                    return ap.getEdgeUser();
            }
        }
        return null;
    }
    
//------------------------------------------------------------------------------
    
}