FragmentIsomorphismInspector.java

Go to the documentation of this file.

package denoptim.graph;
 
import java.io.File;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
 
import org.jgrapht.GraphMapping;
import org.jgrapht.alg.isomorphism.VF2GraphIsomorphismInspector;
 
import denoptim.exception.DENOPTIMException;
import denoptim.io.DenoptimIO;
 
public class FragmentIsomorphismInspector
{
    private int timeout;
    
    private Fragment fragA;
 
    private Fragment fragB;
    
    protected boolean reportTimeoutIncidents = true;
    
    VF2GraphIsomorphismInspector<FragIsomorphNode, FragIsomorphEdge> vf2;
 
//------------------------------------------------------------------------------
    
    public FragmentIsomorphismInspector(Fragment fragA, Fragment fragB)
    {
        this(fragA, fragB, 60000);
    }
    
//------------------------------------------------------------------------------
    
    public FragmentIsomorphismInspector(Fragment fragA, Fragment fragB,
            int timeout)
    {
        this.timeout = timeout;
        Comparator<FragIsomorphNode> vComp = new Comparator<FragIsomorphNode>() 
        {
            @Override
            public int compare(FragIsomorphNode n1, FragIsomorphNode n2)
            {
                return n1.label.compareTo(n2.label);
            }
        };
        
        Comparator<FragIsomorphEdge> eComp = new Comparator<FragIsomorphEdge>() 
        {
            @Override
            public int compare(FragIsomorphEdge e1, FragIsomorphEdge e2)
            {
                return e1.label.compareTo(e2.label);
            }
        };
        
        vf2 = new VF2GraphIsomorphismInspector<>(
                        fragA.getJGraphFragIsomorphism(), 
                        fragB.getJGraphFragIsomorphism(), vComp, eComp);
        this.fragA = fragA;
        this.fragB = fragB;
    }
    
//------------------------------------------------------------------------------
    
    public boolean isomorphismExists()
    {
        boolean result = false;
        final ExecutorService service = Executors.newSingleThreadExecutor();
        Future<Boolean> future = null;
        try {
            future = service.submit(() -> {
                return vf2.isomorphismExists();
            });
            result = future.get(timeout, TimeUnit.MILLISECONDS);
        } catch (final TimeoutException e) {
            if (reportTimeoutIncidents)
            {
                String fileName = "denoptim_isomorphism_timedout_case.sdf";
                File file = new File(fileName);
                System.err.println("WARNING: timeout reached when attempting "
                    + "detection of isomerism between fragments saved to '"
                    + file.getAbsolutePath() + "'. "
                    + "When timeout is reaches, fragments are"
                    + "considered to be non-isomorphic.");
                List<Vertex> frags = new ArrayList<Vertex>();
                frags.add(fragA);
                frags.add(fragB);
                try
                {
                    DenoptimIO.writeVertexesToSDF(new File(fileName), frags, true);
                } catch (DENOPTIMException e1)
                {
                    System.err.println("WARNING: could not write to '" 
                            + fileName + "'. Reporting fragments to STDERR:."
                            + System.getProperty("line.separator") 
                            + fragA.toJson()
                            + System.getProperty("line.separator") 
                            + fragB.toJson());
                }
            }
            future.cancel(true);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        } finally {
            service.shutdown();
        }
        return result;
    }
    
//------------------------------------------------------------------------------
    
    public Iterator<GraphMapping<FragIsomorphNode, FragIsomorphEdge>> getMappings()
    {
        Iterator<GraphMapping<FragIsomorphNode, FragIsomorphEdge>> mapping = null;
        final ExecutorService service = Executors.newSingleThreadExecutor();
        Future<Iterator<GraphMapping<FragIsomorphNode, FragIsomorphEdge>>> fut =
                null;
        try {
            fut = service.submit(() -> {
                return vf2.getMappings();
            });
            mapping = fut.get(timeout, TimeUnit.MILLISECONDS);
        } catch (final TimeoutException e) {
            if (reportTimeoutIncidents)
            {
                String fileName = "denoptim_isomorphism_timedout_case.sdf";
                File file = new File(fileName);
                System.err.println("WARNING: timeout reached when attempting "
                    + "detection of isomerism between fragments saved to '"
                    + file.getAbsolutePath() + "'. "
                    + "When timeout is reaches, fragments are"
                    + "considered to be non-isomorphic.");
                List<Vertex> frags = new ArrayList<Vertex>();
                frags.add(fragA);
                frags.add(fragB);
                try
                {
                    DenoptimIO.writeVertexesToSDF(new File(fileName), frags, true);
                } catch (DENOPTIMException e1)
                {
                    System.err.println("WARNING: could not write to '" 
                            + fileName + "'. Reporting fragments to STDERR:."
                            + System.getProperty("line.separator") 
                            + fragA.toJson()
                            + System.getProperty("line.separator") 
                            + fragB.toJson());
                }
            }
            fut.cancel(true);
        } catch (final Exception e) {
            throw new RuntimeException(e);
        } finally {
            service.shutdown();
        }
        return mapping;
    }
    
//------------------------------------------------------------------------------    
    
}