Fragment.java

Go to the documentation of this file.

package denoptim.graph;
 
/*
 *   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/>.
 */
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
 
import javax.vecmath.Point3d;
 
import org.jgrapht.graph.DefaultUndirectedGraph;
import org.openscience.cdk.interfaces.IAtom;
import org.openscience.cdk.interfaces.IAtomContainer;
import org.openscience.cdk.interfaces.IBond;
import org.openscience.cdk.interfaces.IChemObjectBuilder;
import org.openscience.cdk.silent.SilentChemObjectBuilder;
 
import com.google.gson.Gson;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.graph.Edge.BondType;
import denoptim.graph.rings.RingClosingAttractor;
import denoptim.json.DENOPTIMgson;
import denoptim.utils.MathUtils;
import denoptim.utils.MoleculeUtils;
import denoptim.utils.MutationType;
import denoptim.utils.Randomizer;
 
public class Fragment extends Vertex
{
    private List<AttachmentPoint> lstAPs;
 
    private List<SymmetricAPs> lstSymAPs;
    
    private IAtomContainer mol;
    
    private DefaultUndirectedGraph<FragIsomorphNode,FragIsomorphEdge> 
        jGraphFragIsomorphism;
 
    
//-----------------------------------------------------------------------------
 
    public Fragment()
    {
        super(VertexType.MolecularFragment);
        this.lstAPs = new ArrayList<AttachmentPoint>();
        this.lstSymAPs = new ArrayList<SymmetricAPs>();
        IChemObjectBuilder builder = SilentChemObjectBuilder.getInstance();
        this.mol = builder.newAtomContainer();
    }
    
//------------------------------------------------------------------------------
 
    public Fragment(long vertexId)
    {
        super(VertexType.MolecularFragment, vertexId);
        this.lstAPs = new ArrayList<AttachmentPoint>();
        this.lstSymAPs = new ArrayList<SymmetricAPs>();
        IChemObjectBuilder builder = SilentChemObjectBuilder.getInstance();
        this.mol = builder.newAtomContainer();
    }
    
//-----------------------------------------------------------------------------
 
    public Fragment(long l, IAtomContainer mol, BBType bbt)
            throws DENOPTIMException
    {     
        super (VertexType.MolecularFragment, l);
        
        this.setBuildingBlockType(bbt);
        
        this.lstAPs = new ArrayList<AttachmentPoint>();
        this.lstSymAPs = new ArrayList<SymmetricAPs>();
        
        this.mol = MoleculeUtils.makeSameAs(mol);
        MoleculeUtils.setZeroImplicitHydrogensToAllAtoms(this.mol);
 
        Object prop = mol.getProperty(DENOPTIMConstants.APSTAG);
        if (prop != null)
        {
            projectPropertyToAP(prop.toString());
        }
        
        List<SymmetricAPs> simAP = identifySymmetryRelatedAPSets(this.mol, 
                getAttachmentPoints());
        setSymmetricAPSets(simAP);
        
        this.setAsRCV(getNumberOfAPs() == 1
                && RingClosingAttractor.RCAAPCLASSSET.contains(
                        getAttachmentPoints().get(0).getAPClass()));
        
        Object isomorph = mol.getProperty(DENOPTIMConstants.ISOMORPHICFAMILYID);
        if (isomorph != null)
        {
            this.setProperty(DENOPTIMConstants.ISOMORPHICFAMILYID, 
                    isomorph.toString());
        }
    }
 
//------------------------------------------------------------------------------
 
    public Fragment(long vertexId, IAtomContainer mol, BBType bbt, boolean isRCV)
            throws DENOPTIMException {
        this(vertexId, mol, bbt);
        this.setAsRCV(isRCV);
    }
 
//-----------------------------------------------------------------------------
 
    public Fragment(IAtomContainer mol, BBType bbt)
            throws DENOPTIMException
    {       
        this(-1,mol,bbt);
    }
    
//------------------------------------------------------------------------------
    
    public boolean is3D()
    {
        double maxDist = 0.0;
        Point3d origin = new Point3d(0,0,0);
        for (IAtom atm : atoms())
        {
            Point3d p = atm.getPoint3d();
            if (p==null)
                return false;
            double dist = MathUtils.distance(origin, p);
            if (dist > maxDist)
            {
                maxDist = dist;
            }
        }
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            Point3d p = ap.getDirectionVector();
            if (p==null)
                return false;
            double dist = MathUtils.distance(origin, p);
            if (dist > maxDist)
            {
                maxDist = dist;
            }
        }
        
        return maxDist > 0.001;
    }
    
//------------------------------------------------------------------------------
    
    private void updateSymmetryRelations()
    {
        setSymmetricAPSets(identifySymmetryRelatedAPSets(mol, 
                getAttachmentPoints()));
    }
    
//------------------------------------------------------------------------------
    
    private static List<SymmetricAPs> identifySymmetryRelatedAPSets(
            IAtomContainer mol, List<AttachmentPoint> daps)
    {
        List<SymmetricAPs> lstCompatible = new ArrayList<>();
        for (int i=0; i<daps.size()-1; i++)
        {
            AttachmentPoint apI = daps.get(i);
            SymmetricAPs ss = new SymmetricAPs();
            ss.add(apI);
            
            boolean alreadyFound = false;
            for (SymmetricAPs previousSS : lstCompatible)
            {
                if (previousSS.contains(apI))
                {
                    alreadyFound = true;
                    break;
                }
            }
            if (alreadyFound)
            {
                continue;
            }
        
            for (int j=i+1; j<daps.size(); j++)
            {
                AttachmentPoint apJ = daps.get(j);
                if (atomsAreCompatible(mol, apI.getAtomPositionNumber(),
                                    apJ.getAtomPositionNumber()))
                {
                    // check if reactions are compatible w.r.t. symmetry
                    if (apI.getAPClass()!=null && apJ.getAPClass()!=null 
                            && apI.getAPClass().compareTo(apJ.getAPClass()) == 0)
                    {
                        ss.add(apJ);
                    }
                }
            }
            
            if (ss.size() > 1)
            {
                lstCompatible.add(ss);
            }
        }
        
        return lstCompatible;
    }
 
//------------------------------------------------------------------------------
 
    private static boolean atomsAreCompatible(IAtomContainer mol, int a1, int a2)
    {
        // check atom types
        IAtom atm1 = mol.getAtom(a1);
        IAtom atm2 = mol.getAtom(a2);
 
        if (atm1.getSymbol().compareTo(atm2.getSymbol()) != 0)
            return false;
 
        // check connected bonds
        if (mol.getConnectedBondsCount(atm1)!=mol.getConnectedBondsCount(atm2))
            return false;
 
        // check connected atoms
        if (mol.getConnectedBondsCount(atm1)!=mol.getConnectedBondsCount(atm2))
            return false;
 
        List<IAtom> la1 = mol.getConnectedAtomsList(atm2);
        List<IAtom> la2 = mol.getConnectedAtomsList(atm2);
 
        int k = 0;
        for (int i=0; i<la1.size(); i++)
        {
            IAtom b1 = la1.get(i);
            for (int j=0; j<la2.size(); j++)
            {
                IAtom b2 = la2.get(j);
                if (b1.getSymbol().compareTo(b2.getSymbol()) == 0)
                {
                    k++;
                    break;
                }
            }
        }
 
        return k == la1.size();
    }
 
//------------------------------------------------------------------------------
 
    public void addAP(int atomPositionNumber) {
        APClass apc = null;
        addAP(atomPositionNumber, null, apc);
    }
 
//------------------------------------------------------------------------------
 
    public void addAP(int atomPositionNumber, APClass apClass) {
        addAP(atomPositionNumber, null, apClass);
    }
 
//------------------------------------------------------------------------------
 
    public AttachmentPoint addAP(int atomPositionNumber, Point3d dirVec, 
            APClass apClass) 
    {
        AttachmentPoint ap = new AttachmentPoint(this,
                atomPositionNumber, dirVec, apClass);
        getAttachmentPoints().add(ap);
        
        IAtom srcAtm = mol.getAtom(atomPositionNumber);
        
        ArrayList<AttachmentPoint> apList = new ArrayList<>();
        if (getAPCountOnAtom(srcAtm) > 0) {
            apList = getAPsFromAtom(srcAtm);
        }
        apList.add(ap);
        srcAtm.setProperty(DENOPTIMConstants.ATMPROPAPS, apList);
        
        updateSymmetryRelations();
        
        return ap;
    }
    
//-----------------------------------------------------------------------------
 
    public void addAP(int srcAtmId, APClass apc, Point3d vector) 
    {
        IAtom srcAtm = mol.getAtom(srcAtmId);
        addAPOnAtom(srcAtm, apc, vector);
    }
    
//-----------------------------------------------------------------------------
 
    public AttachmentPoint addAPOnAtom(IAtom srcAtm, APClass apc, 
            Point3d vector)
    {
        int atmId = mol.indexOf(srcAtm);
        return this.addAP(atmId, new Point3d(vector.x, vector.y, vector.z), apc);
    }
    
//-----------------------------------------------------------------------------
    
    public void removeAP(AttachmentPoint ap)
    {
        if (!getAttachmentPoints().contains(ap))
            return;
        
        IAtom srcAtm = mol.getAtom(ap.getAtomPositionNumber());
        
        ArrayList<AttachmentPoint> apList = new ArrayList<>();
        if (getAPCountOnAtom(srcAtm) > 0) {
            apList = getAPsFromAtom(srcAtm);
        }
        apList.remove(ap);
 
        getAttachmentPoints().remove(ap);
        srcAtm.setProperty(DENOPTIMConstants.ATMPROPAPS, apList);
        
        updateSymmetryRelations();
    }
 
//-----------------------------------------------------------------------------
    
    @SuppressWarnings("unchecked")
    public ArrayList<AttachmentPoint> getAPsFromAtom(IAtom srcAtm)
    {
        ArrayList<AttachmentPoint> apsOnAtm = new ArrayList<AttachmentPoint>();
        Object prop = srcAtm.getProperty(DENOPTIMConstants.ATMPROPAPS);
        if (prop!=null)
        {
            apsOnAtm = (ArrayList<AttachmentPoint>) prop;
        }
        return apsOnAtm;
    }
    
//-----------------------------------------------------------------------------
 
    public int getAPCountOnAtom(int srcAtmId)
    {
        IAtom srcAtm = mol.getAtom(srcAtmId);
        return getAPCountOnAtom(srcAtm);
    }
 
//-----------------------------------------------------------------------------
 
    public int getAPCountOnAtom(IAtom srcAtm)
    {
        int num = 0;
        if (srcAtm.getProperty(DENOPTIMConstants.ATMPROPAPS) != null)
        {
            ArrayList<AttachmentPoint> apsOnAtm = 
                    getAPsFromAtom(srcAtm);
            num = apsOnAtm.size();
        }
        return num;
    }
    
//-----------------------------------------------------------------------------
    
    public void updateAPs()
    {
        for (int atmId = 0; atmId<mol.getAtomCount(); atmId++)
        {
            IAtom srcAtm = mol.getAtom(atmId);
            if (srcAtm.getProperty(DENOPTIMConstants.ATMPROPAPS) != null)
            {
                List<AttachmentPoint> apsOnAtm = getAPsFromAtom(srcAtm);
                for (int i = 0; i < apsOnAtm.size(); i++)
                {
                    AttachmentPoint ap = apsOnAtm.get(i);
                    ap.setAtomPositionNumber(atmId);
                }
            }
        }
        updateSymmetryRelations();
    }
 
//-----------------------------------------------------------------------------
    
    public List<AttachmentPoint> getCurrentAPs()
    {
        updateAPs();
        
        lstAPs.clear();
        
        for (IAtom srcAtm : mol.atoms())
        {
            if (srcAtm.getProperty(DENOPTIMConstants.ATMPROPAPS) != null)
            {
                ArrayList<AttachmentPoint> apsOnAtm = 
                        getAPsFromAtom(srcAtm);
                lstAPs.addAll(apsOnAtm);
            }
        }
 
        //Reorder according to DENOPTIMAttachmentPoint priority
        lstAPs.sort(new AttachmentPointComparator());
        
        return lstAPs;
    }
    
//-----------------------------------------------------------------------------
    
    public void projectPropertyToAP() throws DENOPTIMException
    {
        String allAtomsProp = "";    
        if (getProperty(DENOPTIMConstants.APSTAG) == null)
        {
            return;
        }
        allAtomsProp = getProperty(DENOPTIMConstants.APSTAG).toString();
        projectPropertyToAP(allAtomsProp);
    }
        
//-----------------------------------------------------------------------------
    
    public void projectPropertyToAP(String allAtomsProp) throws DENOPTIMException
    {
        lstAPs.clear();
        if (allAtomsProp.trim().equals(""))
        {
            return;
        }
        
        // Cleanup current APs in atom objects
        for (int ii=0 ; ii<mol.getAtomCount(); ii++)
        {
            IAtom atm = mol.getAtom(ii);        
            atm.removeProperty(DENOPTIMConstants.ATMPROPAPS);
        }
       
        // Collect all the APs as objects
        String[] atomsProp = allAtomsProp.split(
                DENOPTIMConstants.SEPARATORAPPROPATMS);
        for (int i = 0; i< atomsProp.length; i++)
        {
            String onThisAtm = atomsProp[i];
            if (onThisAtm.contains(DENOPTIMConstants.SEPARATORAPPROPAPS))
            {
                String[] moreAPonThisAtm = onThisAtm.split(
                        DENOPTIMConstants.SEPARATORAPPROPAPS);
                
                AttachmentPoint ap = 
                        new AttachmentPoint(this, moreAPonThisAtm[0]);
                
                int atmID = ap.getAtomPositionNumber();
                //WARNING the atmID is already 0-based
                lstAPs.add(ap);
                for (int j = 1; j<moreAPonThisAtm.length; j++ )
                {
                    //WARNING here we have to switch to 1-based enumeration
                    // because we import from SDF string
                    AttachmentPoint apMany = 
                            new AttachmentPoint(this, atmID+1
                                    + DENOPTIMConstants.SEPARATORAPPROPAAP
                                    + moreAPonThisAtm[j]);
                    lstAPs.add(apMany);
                }
            } 
            else 
            {
                AttachmentPoint ap = 
                        new AttachmentPoint(this, onThisAtm);
                lstAPs.add(ap);
            }
        }
 
        projectListAPToAtomProperties();
 
        updateSymmetryRelations();
    }
    
//-----------------------------------------------------------------------------
    
    public void projectListAPToAtomProperties()
    {
        // Write attachment points in the atoms
        for (int i = 0; i < lstAPs.size(); i++)
        {
            AttachmentPoint ap = lstAPs.get(i);
            int atmID = ap.getAtomPositionNumber();
            
            IAtom atm = mol.getAtom(atmID);
            if (atm.getProperty(DENOPTIMConstants.ATMPROPAPS) != null)
            {
                ArrayList<AttachmentPoint> oldAPs = 
                        getAPsFromAtom(atm);
                oldAPs.add(ap);
                atm.setProperty(DENOPTIMConstants.ATMPROPAPS,oldAPs);
            } 
            else
            {
                ArrayList<AttachmentPoint> aps = 
                        new ArrayList<AttachmentPoint>();
                aps.add(ap);
                
                atm.setProperty(DENOPTIMConstants.ATMPROPAPS,aps);
            }
        }
    }
 
//-----------------------------------------------------------------------------
    
    public void projectAPsToProperties()
    {
        
        // Prepare the string-representation of unused APs on this graph
        LinkedHashMap<Integer,List<AttachmentPoint>> apsPerAtom =
                new LinkedHashMap<>();
        for (IAtom atm : mol.atoms())
        {   
            if (atm.getProperty(DENOPTIMConstants.ATMPROPAPS) == null)
            {
                continue;
            }
            int atmID = mol.indexOf(atm);
            ArrayList<AttachmentPoint> apsOnAtm = 
                    getAPsFromAtom(atm);
            for (AttachmentPoint ap : apsOnAtm)
            {
                if (apsPerAtom.containsKey(atmID))
                {
                    apsPerAtom.get(atmID).add(ap);
                } else {
                    List<AttachmentPoint> lst = 
                            new ArrayList<AttachmentPoint>();
                    lst.add(ap);
                    apsPerAtom.put(atmID,lst);
                }
            }
        }
        //WARNING! In the mol.property we use 1-to-n+1 instead of 0-to-n
        setProperty(DENOPTIMConstants.APSTAG, 
                AttachmentPoint.getAPDefinitionsForSDF(apsPerAtom));
    }
 
//-----------------------------------------------------------------------------
 
    @Override
    public Fragment clone()
    {   
        Fragment clone = new Fragment();
        clone.setVertexId(this.getVertexId());
        try
        {
            clone.mol = MoleculeUtils.makeSameAs(mol);
        } catch (DENOPTIMException e1)
        {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        
        // WARNING: here we are not recovering all info from APs: we take only
        // some info. This can be improved...
        for (AttachmentPoint ap : lstAPs)
        {
            AttachmentPoint cAp = new AttachmentPoint(clone,
                    ap.getAtomPositionNumber(),
                    ap.getDirectionVector(),
                    ap.getAPClass());
            cAp.setCutId(ap.getCutId());
            cAp.setID(ap.getID());
            clone.lstAPs.add(cAp);
        }
        
        clone.projectListAPToAtomProperties();
        
        clone.setBuildingBlockId(this.getBuildingBlockId());
        clone.setBuildingBlockType(this.getBuildingBlockType());
 
        clone.setMutationTypes(this.getUnfilteredMutationTypes());
        
        List<SymmetricAPs> cLstSymAPs = new ArrayList<SymmetricAPs>();
        for (SymmetricAPs symAPs : this.getSymmetricAPSets())
        {
            SymmetricAPs cSymAPs = new SymmetricAPs();
            for (AttachmentPoint ap : symAPs)
            {
                cSymAPs.add(clone.getAP(ap.getIndexInOwner()));
            }
            cLstSymAPs.add(cSymAPs);
        }
        clone.setSymmetricAPSets(cLstSymAPs);
        
        clone.setAsRCV(this.isRCV());
        clone.setProperties(this.copyStringBasedProperties());
        if (uniquefyingPropertyKeys!=null)
            clone.uniquefyingPropertyKeys.addAll(uniquefyingPropertyKeys);
        return clone;
    }
 
//-----------------------------------------------------------------------------
 
    @Override
    public IAtomContainer getIAtomContainer()
    {
        this.projectAPsToProperties();
        for (int atmPos=0; atmPos<mol.getAtomCount(); atmPos++)
        {
            IAtom atm = mol.getAtom(atmPos);
            atm.setProperty(DENOPTIMConstants.ATMPROPVERTEXID, getVertexId());
            atm.setProperty(DENOPTIMConstants.ATMPROPORIGINALATMID, atmPos);
        }
        mol.setProperty(DENOPTIMConstants.APSTAG, 
                getProperty(DENOPTIMConstants.APSTAG));
        mol.setProperty(DENOPTIMConstants.VERTEXJSONTAG,this.toJson());
        mol.setProperty(DENOPTIMConstants.ISOMORPHICFAMILYID,
                getProperty(DENOPTIMConstants.ISOMORPHICFAMILYID));
        return mol;
    }
    
//------------------------------------------------------------------------------
    
    @Override
    public IAtomContainer getIAtomContainer(Logger logger, 
            Randomizer rng, boolean removeUsedRCAs, boolean rebuild)
    {
        return getIAtomContainer();
    }
    
//-----------------------------------------------------------------------------
 
    public Iterable<IAtom> atoms()
    {
        return mol.atoms();
    }
    
//-----------------------------------------------------------------------------
 
    public Iterable<IBond> bonds()
    {
        return mol.bonds();
    }
 
//-----------------------------------------------------------------------------
 
    public void addAtom(IAtom atom)
    {
        mol.addAtom(atom);
    }   
    
//-----------------------------------------------------------------------------
 
    public IAtom getAtom(int number)
    {
        return mol.getAtom(number);
    }
 
//-----------------------------------------------------------------------------
 
    public int indexOf(IAtom atom)
    {
        return mol.indexOf(atom);
    }
    
//-----------------------------------------------------------------------------
 
    public int getAtomCount()
    {
        return mol.getAtomCount();
    }
    
//-----------------------------------------------------------------------------
 
    public int getBondCount()
    {
        return mol.getBondCount();
    }
    
//-----------------------------------------------------------------------------
 
    public void addBond(IBond bond)
    {
        mol.addBond(bond);
    }
    
//-----------------------------------------------------------------------------
    
    public IBond removeBond(int position)
    {
        return mol.removeBond(position);
    }
 
//-----------------------------------------------------------------------------
   
    public IBond removeBond(IAtom atom1, IAtom atom2)
    {
       return mol.removeBond(atom1, atom2);
    }
    
//-----------------------------------------------------------------------------
    
    public void removeBond(IBond bond)
    {
        mol.removeBond(bond);
    }
    
//-----------------------------------------------------------------------------
    
    public void removeAtom(IAtom atom)
    {
        removeAtoms(Arrays.asList(atom));
    }
    
//-----------------------------------------------------------------------------
    
    public void removeAtoms(Collection<IAtom> atoms)
    {
        for (IAtom atom : atoms)
            mol.removeAtom(atom);
        
        lstAPs.clear();
        
        for (int atmId = 0; atmId<mol.getAtomCount(); atmId++)
        {
            IAtom srcAtm = mol.getAtom(atmId);
            if (srcAtm.getProperty(DENOPTIMConstants.ATMPROPAPS) != null)
            {
                ArrayList<AttachmentPoint> apsOnAtm = getAPsFromAtom(srcAtm);
                for (int i = 0; i < apsOnAtm.size(); i++)
                {
                    AttachmentPoint ap = apsOnAtm.get(i);
                    ap.setAtomPositionNumber(atmId);
                }
                lstAPs.addAll(apsOnAtm);
            }
        }
 
        //Reorder according to DENOPTIMAttachmentPoint priority
        lstAPs.sort(new AttachmentPointComparator());
        
        updateSymmetryRelations();
    }
    
//-----------------------------------------------------------------------------
    
    public List<IAtom> getConnectedAtomsList(IAtom atom)
    {
        return mol.getConnectedAtomsList(atom);
    }
    
//-----------------------------------------------------------------------------
    
    public int getConnectedAtomsCount(IAtom atom)
    {
        return mol.getConnectedBondsCount(atom);
    }
    
//------------------------------------------------------------------------------
    
    public boolean sameAs(Fragment other, StringBuilder reason)
    {
        if (this.containsAtoms() && other.containsAtoms())
        {
            if (this.mol.getAtomCount() != other.mol.getAtomCount())
            {
                reason.append("Different atom count (" + this.mol.getAtomCount()
                        + ":" + other.mol.getAtomCount() + "); ");
            }
            if (this.mol.getBondCount() != other.mol.getBondCount())
            {
                reason.append("Different bond count (" + this.mol.getBondCount()
                        + ":" + other.mol.getBondCount() + "); ");
            }
        }
        return sameVertexFeatures(other, reason);
    }
    
//------------------------------------------------------------------------------
    
    public DefaultUndirectedGraph<FragIsomorphNode,FragIsomorphEdge> 
        getJGraphFragIsomorphism()
    {
        if (jGraphFragIsomorphism != null)
        {
            return jGraphFragIsomorphism;
        }
        jGraphFragIsomorphism = new DefaultUndirectedGraph<>(
                FragIsomorphEdge.class);
        
        Map<IAtom,FragIsomorphNode> atmToNode = 
                new HashMap<IAtom,FragIsomorphNode>();
        Set<IAtom> ignoredDu = new HashSet<IAtom>();
        for (IAtom atm : mol.atoms())
        {
            if (DENOPTIMConstants.DUMMYATMSYMBOL.equals(
                    MoleculeUtils.getSymbolOrLabel(atm))
                    && mol.getConnectedBondsCount(atm)<2)
            {
                //Ignore Du on linearities
                ignoredDu.add(atm);
                continue;
            }
            FragIsomorphNode node = new FragIsomorphNode(atm);
            atmToNode.put(atm,node);
            jGraphFragIsomorphism.addVertex(node);
        }
        for (IBond bnd : mol.bonds())
        {
            if (bnd.getAtomCount() > 2)
            {
                throw new IllegalArgumentException("Cannot handle bonds that involve "
                        + "more than two atoms");
            }
            if (ignoredDu.contains(bnd.getAtom(0)) 
                    || ignoredDu.contains(bnd.getAtom(0)))
            {
                //Ignore Du on linearities
                continue;
            }
 
            FragIsomorphEdge edge = new FragIsomorphEdge(bnd);
            jGraphFragIsomorphism.addEdge(atmToNode.get(bnd.getAtom(0)), 
                    atmToNode.get(bnd.getAtom(1)), edge);
        }
        for (AttachmentPoint ap : getAttachmentPoints())
        {
            FragIsomorphNode node = new FragIsomorphNode(ap);
            jGraphFragIsomorphism.addVertex(node);
            FragIsomorphEdge edge = new FragIsomorphEdge();
            jGraphFragIsomorphism.addEdge(atmToNode.get(mol.getAtom(
                    ap.getAtomPositionNumber())), node, edge);
        }
        
        return jGraphFragIsomorphism;
    }
    
//------------------------------------------------------------------------------
    
    public boolean isIsomorphicTo(Vertex other)
    {
        if (!(other instanceof Fragment))
        {
            return false;
        }
        Fragment otherFrag = (Fragment) other;
          
        // NB: do not add a comparison of #atoms or #bonds because they may be
        // different as a result of a different number of dummy atoms placed
        // on linearities. Such atoms are not considered when checking for 
        // isomorphism so, de facto, fragments can be isomorphic and have a 
        // different number of atoms and bonds.
         
        if (this.getAttachmentPoints().size() 
                != otherFrag.getAttachmentPoints().size())
        {
            return false;
        }
  
        FragmentIsomorphismInspector fii = new FragmentIsomorphismInspector(
                this, otherFrag); 
        return fii.isomorphismExists();
    }
    
//------------------------------------------------------------------------------
 
    public int getHeavyAtomsCount()
    {
        return MoleculeUtils.getHeavyAtomCount(mol);
    }
 
//------------------------------------------------------------------------------
 
    public boolean containsAtoms()
    {
        if (mol.getAtomCount() > 0)
            return true;
        else
            return false;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public String toString()
    {
        return getVertexId() + "_" + (getBuildingBlockId() + 1) + "_" +
                getBuildingBlockType().toOldInt();
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public List<AttachmentPoint> getAttachmentPoints()
    {
        return lstAPs;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    protected void setSymmetricAPSets(List<SymmetricAPs> sAPs)
    {
        this.lstSymAPs = sAPs;
    }
  
//-----------------------------------------------------------------------------
 
    @Override
    protected void addSymmetricAPSet(SymmetricAPs symAPs)
    {
        if (this.lstSymAPs==null)
        {
            this.lstSymAPs = new ArrayList<SymmetricAPs>();
        }
        this.lstSymAPs.add(symAPs);
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public List<SymmetricAPs> getSymmetricAPSets()
    {
        return lstSymAPs;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public List<Vertex> getMutationSites(List<MutationType> ignoredTypes)
    {
        List<Vertex> lst = new ArrayList<Vertex>();
        switch (getBuildingBlockType())
        {
            case CAP:
                break;
                
            default:
                if (getMutationTypes(ignoredTypes).size()>0)
                    lst.add(this);
                break;
        }
        return lst;
    }
    
//------------------------------------------------------------------------------
    
    public String toJson()
    {    
        Gson gson = DENOPTIMgson.getWriter();
        String jsonOutput = gson.toJson(this);
        return jsonOutput;
    }
    
//------------------------------------------------------------------------------
    
    public static Fragment fromJson(String json)
    {
        Gson gson = DENOPTIMgson.getReader();
        Fragment returnedFrag = gson.fromJson(json, 
                Fragment.class);
        
        for (AttachmentPoint ap : returnedFrag.getAttachmentPoints())
        {
            ap.setOwner(returnedFrag);
        }
        
        returnedFrag.projectListAPToAtomProperties();
 
        return returnedFrag;
    }
 
//------------------------------------------------------------------------------
    
    public IAtom getAtomHoldingAP(AttachmentPoint ap)
    {
        if (ap.getOwner() != this)
            return null;
       
        return mol.getAtom(ap.getAtomPositionNumber());
    }
    
//------------------------------------------------------------------------------
 
}