RandomCombOfRingsIterator.java

Go to the documentation of this file.

package denoptim.graph.rings;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
 
import org.openscience.cdk.interfaces.IAtomContainer;
 
import denoptim.exception.DENOPTIMException;
import denoptim.fragspace.FragmentSpace;
import denoptim.graph.DGraph;
import denoptim.graph.Fragment;
import denoptim.graph.Ring;
import denoptim.graph.Vertex;
import denoptim.graph.Edge.BondType;
 
public class RandomCombOfRingsIterator implements Iterator<List<Ring>>
{
    private IAtomContainer originalMol;
    
    private DGraph molGraph;
    
    private int maxRingClosures = -1;
    
    private FragmentSpace fragSpace;
    
    private RingClosureParameters settings;
    
//-----------------------------------------------------------------------------
    
    public RandomCombOfRingsIterator(IAtomContainer iac,
            DGraph molGraph, int maxRingClosures, FragmentSpace fragSpace, 
            RingClosureParameters rcParams) throws DENOPTIMException
    {
        this.settings = rcParams;
        this.fragSpace = fragSpace;
        this.maxRingClosures = maxRingClosures;
        this.originalMol = iac;
        this.molGraph = molGraph;
    }
 
//-----------------------------------------------------------------------------
    
    @Override
    public boolean hasNext()
    {
        return true;
    }
 
//-----------------------------------------------------------------------------
    
    @Override
    public List<Ring> next()
    {   
        RingSizeManager rsm = new RingSizeManager(fragSpace, settings);
        rsm.initialize(originalMol, molGraph);
        
        List<Vertex> wLstVrtI = rsm.getRSBiasedListOfCandidates();
        
        // Randomly choose the compatible combinations of RCAs and store them
        // as rings
        List<Ring> combOfRings = new ArrayList<Ring>();
        while (wLstVrtI.size() > 0)
        {
            // Termination criterion based on maximum number of rings per graph
            if (combOfRings.size() >= maxRingClosures)
                break;
            
            int vIdI = settings.getRandomizer().nextInt(wLstVrtI.size());
            Vertex vI = wLstVrtI.get(vIdI);
            wLstVrtI.removeAll(Collections.singleton(vI));
 
            // Create vector of possible choices for second RCV
            List<Vertex> wLstVrtJ = rsm.getRSBiasedListOfCandidates(vI); 
            while (wLstVrtJ.size() > 0)
            {
                int vIdJ = settings.getRandomizer().nextInt(wLstVrtJ.size());
                Vertex vJ = wLstVrtJ.get(vIdJ);
                wLstVrtJ.removeAll(Collections.singleton(vJ));
 
                PathSubGraph path = new PathSubGraph(vI, vJ, molGraph);
                // NB: closability is evaluated on the original
                if (PathClosabilityTools.isCloseable(path, originalMol, settings))
                {
                    ArrayList<Vertex> arrLst = new ArrayList<Vertex>();
                    arrLst.addAll(path.getVertecesPath());                    
                    Ring ring = new Ring(arrLst);
 
                    BondType bndTypI = vI.getEdgeToParent().getBondType();
                    BondType bndTypJ = vJ.getEdgeToParent().getBondType();
                    if (bndTypI != bndTypJ)
                    {
                        String s = "Attempt to close rings is not compatible "
                        + "to the different bond type specified by the "
                        + "head and tail APs: (" + bndTypI + "!=" 
                        + bndTypJ + " for vertices " + vI + " " 
                        + vJ + ")";
                        throw new IllegalArgumentException(s);
                    }
                    ring.setBondType(bndTypI);
 
                    combOfRings.add(ring);
 
                    wLstVrtI.removeAll(Collections.singleton(vJ));
 
                    // Update ring sizes according to the newly added bond
                    if (vI instanceof Fragment && vJ instanceof Fragment)
                    {
                        rsm.addRingClosingBond(vI,vJ);
                    }
                    rsm.setVertexAsDone(vJ);
                    break;
                }
            }
            rsm.setVertexAsDone(vI);
        }
        return combOfRings;
    }
 
//-----------------------------------------------------------------------------
    
}