XoverSite.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2022 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.ga;
 
import java.util.ArrayList;
import java.util.List;
 
import denoptim.exception.DENOPTIMException;
import denoptim.graph.AttachmentPoint;
import denoptim.graph.DGraph;
import denoptim.graph.Template;
import denoptim.graph.Vertex;
import denoptim.utils.CrossoverType;
 
public class XoverSite implements Cloneable
{
    private List<Vertex> subGraphA = null;
    
    private List<AttachmentPoint> needyAPsOnA = null;
 
    private List<Vertex> subGraphB = null;
    
    private List<AttachmentPoint> needyAPsOnB = null;
    
    private CrossoverType xoverType = null;
    
//------------------------------------------------------------------------------
    
    public XoverSite()
    {
        subGraphA = new ArrayList<Vertex>();
        subGraphB = new ArrayList<Vertex>();
        needyAPsOnA = new ArrayList<AttachmentPoint>();
        needyAPsOnB = new ArrayList<AttachmentPoint>();
    }
 
//------------------------------------------------------------------------------
    
    public XoverSite(List<Vertex> subGraphA, 
            List<Vertex> subGraphB,
            CrossoverType xoverType)
    {
        this.subGraphA = new ArrayList<Vertex>(subGraphA);
        this.subGraphB = new ArrayList<Vertex>(subGraphB);
        DGraph gA = subGraphA.get(0).getGraphOwner();
        this.needyAPsOnA = gA.getInterfaceAPs(subGraphA);
        DGraph gB = subGraphB.get(0).getGraphOwner();
        this.needyAPsOnB = gB.getInterfaceAPs(subGraphB);
        this.xoverType = xoverType;
    }
 
//------------------------------------------------------------------------------
    
    public XoverSite(List<Vertex> subGraphA, 
            List<AttachmentPoint> needyAPsOnA,
            List<Vertex> subGraphB, 
            List<AttachmentPoint> needyAPsOnB,
            CrossoverType xoverType)
    {
        this.subGraphA = new ArrayList<Vertex>(subGraphA);
        this.subGraphB = new ArrayList<Vertex>(subGraphB);
        this.needyAPsOnA = new ArrayList<AttachmentPoint>(needyAPsOnA);
        this.needyAPsOnB = new ArrayList<AttachmentPoint>(needyAPsOnB);
        this.xoverType = xoverType;
    }
 
//------------------------------------------------------------------------------
    
    public XoverSite createMirror()
    {
        XoverSite mirror = new XoverSite();
        mirror.subGraphA = new ArrayList<Vertex>(this.subGraphB);
        mirror.subGraphB = new ArrayList<Vertex>(this.subGraphA);
        mirror.needyAPsOnA = new ArrayList<AttachmentPoint>(
                this.needyAPsOnB);
        mirror.needyAPsOnB = new ArrayList<AttachmentPoint>(
                this.needyAPsOnA);
        mirror.xoverType = xoverType;
        return mirror;
    }
    
//------------------------------------------------------------------------------
    
    public XoverSite clone()
    {
        XoverSite clone = new XoverSite();
        clone.subGraphA = new ArrayList<Vertex>(this.subGraphA);
        clone.subGraphB = new ArrayList<Vertex>(this.subGraphB);
        clone.needyAPsOnA = new ArrayList<AttachmentPoint>(
                this.needyAPsOnA);
        clone.needyAPsOnB = new ArrayList<AttachmentPoint>(
                this.needyAPsOnB);
        clone.xoverType = xoverType;
        return clone;
    }
 
//------------------------------------------------------------------------------
    
    public List<Vertex> getA()
    {
        return subGraphA;
    }
    
//------------------------------------------------------------------------------
    
    public List<Vertex> getB()
    {
        return subGraphB;
    }
    
//------------------------------------------------------------------------------
    
    public List<AttachmentPoint> getAPsNeedingMappingA()
    {
        return needyAPsOnA;
    }
    
//------------------------------------------------------------------------------
    
    public List<AttachmentPoint> getAPsNeedingMappingB()
    {
        return needyAPsOnB;
    }
    
//------------------------------------------------------------------------------
 
    public CrossoverType getType()
    {
        return xoverType;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public boolean equals(Object o)
    {
        if (! (o instanceof XoverSite))
            return false;
        XoverSite other = (XoverSite) o;
        return this.xoverType==other.xoverType
                && this.subGraphA.equals(other.subGraphA) 
                && this.subGraphB.equals(other.subGraphB)
                && this.needyAPsOnA.equals(other.needyAPsOnA)
                && this.needyAPsOnB.equals(other.needyAPsOnB);
    }
 
//------------------------------------------------------------------------------
    
    public XoverSite projectToClonedGraphs() throws DENOPTIMException
    {
        DGraph gA = subGraphA.get(0).getGraphOwner(); 
        DGraph gB = subGraphB.get(0).getGraphOwner();
        List<Template> embeddingPathA = gA.getEmbeddingPath();
        List<Template> embeddingPathB = gB.getEmbeddingPath();
        
        DGraph cloneOutermostGraphA, cloneA;
        DGraph cloneOutermostGraphB, cloneB;
        if (embeddingPathA.size()==0) 
        {
            cloneOutermostGraphA = gA.clone();
            cloneA = cloneOutermostGraphA;
        } else {
            cloneOutermostGraphA = embeddingPathA.get(0)
                    .getGraphOwner().clone();
            cloneA = DGraph.getEmbeddedGraphInClone(cloneOutermostGraphA, 
                    embeddingPathA.get(0).getGraphOwner(), embeddingPathA);
        }
        if (embeddingPathB.size()==0) 
        {
            cloneOutermostGraphB = gB.clone();
            cloneB = cloneOutermostGraphB;
        } else {
            cloneOutermostGraphB = embeddingPathB.get(0)
                    .getGraphOwner().clone();
            cloneB = DGraph.getEmbeddedGraphInClone(cloneOutermostGraphB, 
                    embeddingPathB.get(0).getGraphOwner(), embeddingPathB);
        }
        
        cloneA.renumberGraphVertices();
        cloneB.renumberGraphVertices();
        List<Vertex> refsOnCloneA = new ArrayList<Vertex>();
        List<AttachmentPoint> needyOnCloneA = 
                new ArrayList<AttachmentPoint>();
        for (Vertex vA : subGraphA)
        {
            Vertex vCloneA = cloneA.getVertexAtPosition(
                    vA.getGraphOwner().indexOf(vA));
            refsOnCloneA.add(vCloneA);
            for (AttachmentPoint ap : vA.getAttachmentPoints())
            {
                if (needyAPsOnA.contains(ap))
                {
                    needyOnCloneA.add(vCloneA.getAP(ap.getIndexInOwner()));
                }
            }
        }
        List<Vertex> refsOnCloneB = new ArrayList<Vertex>();
        List<AttachmentPoint> needyOnCloneB = 
                new ArrayList<AttachmentPoint>();
        for (Vertex vB : subGraphB)
        {
            Vertex vCloneB = cloneB.getVertexAtPosition(
                    vB.getGraphOwner().indexOf(vB));
            refsOnCloneB.add(vCloneB);
            for (AttachmentPoint ap : vB.getAttachmentPoints())
            {
                if (needyAPsOnB.contains(ap))
                {
                    needyOnCloneB.add(vCloneB.getAP(ap.getIndexInOwner()));
                }
            }
        }
        XoverSite xos = new XoverSite(refsOnCloneA, needyOnCloneA,
                refsOnCloneB, needyOnCloneB, xoverType);
        return xos;
    }
    
//------------------------------------------------------------------------------
 
    public String toString()
    {
        return "[XoverSite-" + xoverType + ": "+subGraphA+", "+subGraphB+"]";
    }
    
//------------------------------------------------------------------------------
 
}