AtomOrganizer.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2019 Marco Foscato <marco.foscato@uib.no>
 * 
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.utils;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
import org.openscience.cdk.Bond;
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 denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.graph.APClass;
import denoptim.graph.Edge.BondType;
import denoptim.graph.Ring;
 
 
public class AtomOrganizer
{
//------------------------------------------------------------------------------    
    
//indexes of atoms bearing  AP
 
    //Flags per atoms
    private ArrayList<ArrayList<Boolean>> flags;
    //Alternative atom order
    private Map<Integer, ArrayList<Integer>> atomOrders;
    private Map<Integer, ArrayList<Integer>> oldToNewOrder;
    //layers
    private Map<Integer, Map<Integer, Set<Integer>>> layers;
    //layer index
    private int lidx;
    //Type of reordering scheme:
    // 1 => branch-oriented approach
    // 2 => layer-oriented approach
    private int scheme = 1;
 
//------------------------------------------------------------------------------
 
    public AtomOrganizer()
    {
        flags = new ArrayList<>();
        atomOrders = new HashMap<>();
        oldToNewOrder = new HashMap<>();
        lidx = 0;
        layers = new HashMap<>();
    }
 
//------------------------------------------------------------------------------
    
    public void setScheme(int scheme)
    {
        this.scheme = scheme;
    }
    
//------------------------------------------------------------------------------
    
    public ArrayList<Integer> getNewToOldOrder(int seed)
    {
        ArrayList<Integer> lst = new ArrayList<Integer>();
        for (Integer i : atomOrders.get(seed))
        {
            lst.add(i.intValue());
        }
        return lst;
    }
 
//------------------------------------------------------------------------------
    
    public ArrayList<Integer> getOldToNewOrder(int seed)
    {
        ArrayList<Integer> lst = new ArrayList<Integer>();
        for (Integer i : oldToNewOrder.get(seed))
        {
            lst.add(i.intValue());
        }
        return lst;
    }
 
//------------------------------------------------------------------------------
    public IAtomContainer reorderStartingFrom(int seed, IAtomContainer mol)
            throws DENOPTIMException {
        int flag = getFreeAtomsFlag(mol);
 
        //find new order of atoms using starting from 'seed'
        if (!atomOrders.containsKey(seed)) {
            //create all empty vectors of proper size
            ArrayList<Integer> reorderedAtms = new ArrayList<>(mol.getAtomCount());
            atomOrders.put(seed, reorderedAtms);
            ArrayList<Integer> pointer = new ArrayList<>(mol.getAtomCount());
            oldToNewOrder.put(seed, pointer);
            for (int i = 0; i < mol.getAtomCount(); i++) {
                oldToNewOrder.get(seed).add(i, -1);
            }
 
            //add atoms to new other
            switch (scheme) {
                case 1:
                    branchOrienterReordering(seed, flag, mol);
                    break;
                case 2:
                    layerOrientedReordering(seed, flag, mol);
                    break;
                default:
                    String str = "ERROR! Atom ordering: scheme not recognized";
                    throw new DENOPTIMException(str);
            }
 
            //delete temp vector of flags
            deleteAtomsFlag(flag);
        }
 
        return makeReorderedCopy(mol, 
                atomOrders.get(seed), 
                oldToNewOrder.get(seed));
    }
    
//------------------------------------------------------------------------------
 
    public static IAtomContainer makeReorderedCopy(IAtomContainer original,
            List<Integer> newToOldOrder, List<Integer> oldToNewOrder) 
                    throws DENOPTIMException
    {
        IChemObjectBuilder builder = SilentChemObjectBuilder.getInstance();
        IAtomContainer iac = builder.newAtomContainer();
        
        StringBuilder sbMolProp = new StringBuilder();
        for (int i = 0; i < original.getAtomCount(); i++) 
        {
            IAtom originalAtom = original.getAtom(newToOldOrder.get(i));
            IAtom atm = MoleculeUtils.makeSameAtomAs(originalAtom, true, true);
            String atmPropVID = " none";
            Object p = originalAtom.getProperty(DENOPTIMConstants.ATMPROPVERTEXID);
            if (p != null)
            {
                atmPropVID = " " + ((Long) p).longValue();
                atm.setProperty(DENOPTIMConstants.ATMPROPVERTEXID, 
                        ((Long) p).longValue());
            }
            sbMolProp.append(atmPropVID);            
 
            Object pVPath = originalAtom.getProperty(
                    DENOPTIMConstants.ATMPROPVERTEXPATH);
            if (pVPath != null)
            {
                atm.setProperty(DENOPTIMConstants.ATMPROPVERTEXPATH, 
                        pVPath.toString());
            }
            
            Object pAPCls = originalAtom.getProperty(
                    DENOPTIMConstants.RCAPROPAPCTORCA);
            if (pAPCls != null)
            {
                atm.setProperty(DENOPTIMConstants.RCAPROPAPCTORCA, 
                        (APClass) pAPCls);
            }
            
            Object pBndTyp = originalAtom.getProperty(
                    DENOPTIMConstants.RCAPROPCHORDBNDTYP);
            if (pBndTyp != null)
            {
                atm.setProperty(DENOPTIMConstants.RCAPROPCHORDBNDTYP, 
                        (BondType) pBndTyp);
            }
            
            Object pRing = originalAtom.getProperty(
                    DENOPTIMConstants.RCAPROPRINGUSER);
            if (pRing != null)
            {
                atm.setProperty(DENOPTIMConstants.RCAPROPRINGUSER, 
                        (Ring) pRing);
            }
            
            iac.addAtom(atm);
        }
        //NB: ATMPROPVERTEXID is integer when it's atom property, but it's string
        // when collected in a molecular property.
        iac.setProperty(DENOPTIMConstants.ATMPROPVERTEXID, 
                sbMolProp.toString().trim());
        
        Object e = original.getProperty(DENOPTIMConstants.MOLERRORTAG);
        if (e != null)
        {
            iac.setProperty(DENOPTIMConstants.MOLERRORTAG, 
                    e.toString().trim());
        }
        
        //Regenerate Bonds
        for (int i = 0; i < original.getBondCount(); i++) {
            try {
                IBond oldBnd = original.getBond(i);
                if (oldBnd.getAtomCount() != 2) {
                    String msg = "Multicenter bond not supported.";
                    throw new DENOPTIMException(msg);
                }
                int atm1 = original.indexOf(oldBnd.getAtom(0));
                int atm2 = original.indexOf(oldBnd.getAtom(1));
                int newatm1 = oldToNewOrder.get(atm1);
                int newatm2 = oldToNewOrder.get(atm2);
                IBond.Order order = oldBnd.getOrder();
                IBond.Stereo stereo = oldBnd.getStereo();
                IBond bnd = new Bond(iac.getAtom(newatm1), 
                        iac.getAtom(newatm2), order, stereo);
                iac.addBond(bnd);
            } catch (Throwable t) {
                String msg = "ERROR in making new bond";
                throw new DENOPTIMException(msg);
            }
        }
        
        return iac;
    }
    
//------------------------------------------------------------------------------
    
    private void branchOrienterReordering(int seed, int flag, IAtomContainer mol)
    {
        int ap = seed;
 
        //add the seed to the new list
        processAtom(seed, ap, flag);
 
        //add all other atoms
        exploreMolecule(seed, flag, mol, ap);
    }
 
//------------------------------------------------------------------------------
    private void exploreMolecule(int seed, int flag, IAtomContainer mol, int ap)
    {
        // Get the list of neighbours (connected atoms)
        List<IAtom> neighbourAtoms = mol.getConnectedAtomsList(mol.getAtom(seed));
 
        // Throw away atoms already done
        List<IAtom> purgedList = new ArrayList<>();
        for (IAtom connectedAtom : neighbourAtoms)
        {
            int atmidx = mol.indexOf(connectedAtom);
            if (!flags.get(flag).get(atmidx))
            {
                purgedList.add(connectedAtom);
            }
        }
 
        // In case nothing else to do
        if (purgedList.isEmpty())
        {
            return;
        }
 
        // Reorder according to priority
        if (purgedList.size() > 1)
        {
            purgedList = prioritizeAtomList(purgedList, mol);
        }
 
        // Add all the atoms connected
        for (IAtom connectedAtom : purgedList) {
            // Identify atom
            int atmidx = mol.indexOf(connectedAtom);
 
            // Use flag to avoid giving a bite on your own tail!
            if (flags.get(flag).get(atmidx)) {
                continue;
            }
 
            // Add to lists
            processAtom(atmidx, ap, flag);
        }
 
        // Move to the next level
        for (IAtom connectedAtom : purgedList) {
            //get atom
            //identify atom
            int atmidx = mol.indexOf(connectedAtom);
 
            // move to the next shell of atoms
            if (mol.getConnectedBondsCount(connectedAtom) > 1) {
                exploreMolecule(atmidx, flag, mol, ap);
            }
        }
    }
 
//------------------------------------------------------------------------------
    private void layerOrientedReordering(int seed, int flag, IAtomContainer mol)
    {
        // Set flag for detecting layers
        int lyflg = getFreeAtomsFlag(mol);
 
        // Set seed as center of all layers
        lidx = 0;
        int ap = seed;
        addAtomToLayer(seed, ap, lidx, lyflg);
 
        // Loop over layers to find new layers
        boolean goon = true;
        Map<Integer, Set<Integer>> layersOfAP = layers.get(ap);
        while (goon)
        {
            // Get atoms in this layer
            Set<Integer> atmInLyr = layersOfAP.get(lidx);
 
            // get connected atoms for all atoms in this layer checking flag
            for (int atmIdx : atmInLyr)
            {
                List<IAtom> neighbourAtoms = mol.getConnectedAtomsList(mol.getAtom(atmIdx));
                // Set layer lidx+1 to all connected atoms
                for (IAtom ngbAtm : neighbourAtoms)
                {
                    int ngbAtmIdx = mol.indexOf(ngbAtm);
                    if (!flags.get(lyflg).get(ngbAtmIdx))
                    {
                        int layerOfNgbAtm = lidx + 1;
                        addAtomToLayer(ngbAtmIdx, ap, layerOfNgbAtm, lyflg);
                    }
                }
            }
 
            // Update goon-condition
            goon = layersOfAP.containsKey(lidx + 1);
 
            // Update layer identifier
            lidx++;
        }
 
        // Explore layers and reorder atoms
        int numberOfLayers = layersOfAP.keySet().size();
        for (int i = 0; i < numberOfLayers; i++)
        {
            // Get atoms in this layer
            Set<Integer> idxInLyr = layersOfAP.get(i);
            List<IAtom> atmInLyr = new ArrayList<>();
            for (Integer idx : idxInLyr)
            {
                atmInLyr.add(mol.getAtom(idx));
            }
 
            // Get prioritized list of layer's members
            atmInLyr = prioritizeAtomList(atmInLyr, mol);
 
            // Report atoms to ordered list
            for (IAtom orderedAtm : atmInLyr) {
                // Identify atom
                int atmidx = mol.indexOf(orderedAtm);
 
                // Add to ordered lists
                processAtom(atmidx, ap, flag);
            }
        }
 
        //delete temp vector of flags
        deleteAtomsFlag(lyflg);
 
    }
 
//------------------------------------------------------------------------------
    private void addAtomToLayer(int atmidx, int ap, int layer, int doneFlag)
    {
        // Check existence of AP-related layers
        if (!layers.containsKey(ap))
        {
            Map<Integer, Set<Integer>> layersForAP = new HashMap<>();
            layers.put(ap, layersForAP);
        }
 
        // check existence of this layer in the list of layers
        if (!layers.get(ap).containsKey(layer))
        {
            Set<Integer> atmInLayer = new HashSet<>();
            layers.get(ap).put(layer, atmInLayer);
        }
 
        // Add atom to layer
        layers.get(ap).get(layer).add(atmidx);
 
        //Set the doneFlag to true ( = 'DONE')
        flags.get(doneFlag).set(atmidx, true);
    }
 
//------------------------------------------------------------------------------
    private void processAtom(int atmidx, int ap, int doneFlag)
    {
        //Set the doneFlag to true ( = 'DONE')
        flags.get(doneFlag).set(atmidx, true);
 
        //Add OLD atom index to the NEW ORDER pointer
        atomOrders.get(ap).add(atmidx);
 
        //get new index of this atom
        int newIdx = atomOrders.get(ap).size();
 
        //Add NEW atom index to the OLD ORDER pointer
        oldToNewOrder.get(ap).set(atmidx, newIdx-1);
    }
 
//------------------------------------------------------------------------------
    private List<IAtom> prioritizeAtomList(List<IAtom> inList, IAtomContainer mol)
    {
        List<IAtom> outList = new ArrayList<>();
 
        //make a list of connected ligands
        List<ConnectedLigand> ligList = new ArrayList<>();
        for (IAtom seed : inList)
        {
            ConnectedLigand lig = new ConnectedLigand(seed,
                    mol.getConnectedBondsCount(seed));
            ligList.add(lig);
        }
 
        ligList.sort(new ConnectedLigandComparator());
 
        for (ConnectedLigand connectedLigand : ligList) {
            IAtom a = connectedLigand.getAtom();
            outList.add(a);
        }
        return outList;
    }
 
//------------------------------------------------------------------------------
    private int getFreeAtomsFlag(IAtomContainer mol)
    {
        int freeFlag = -1;
        //create a vector with false entries
        int atoms = mol.getAtomCount();
        ArrayList<Boolean> flg = new ArrayList<>();
        for (int i = 0; i < atoms; i++)
        {
            flg.add(false);
        }
 
        //add the vector to the list of flags
        flags.add(flg);
        freeFlag = flags.indexOf(flg);
 
        return freeFlag;
    }
 
//------------------------------------------------------------------------------
    private void deleteAtomsFlag(int flagID)
    {
        flags.remove(flagID);
    }
 
//------------------------------------------------------------------------------
}