DENOPTIM/_denoptim_i_o_test_8java_source.html

package denoptim.io;


/*

 *   DENOPTIM

 *   Copyright (C) 2019 Vishwesh Venkatraman <vishwesh.venkatraman@ntnu.no>

 *   and 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 static org.junit.jupiter.api.Assertions.assertEquals;

import static org.junit.jupiter.api.Assertions.assertNotNull;

import static org.junit.jupiter.api.Assertions.assertThrows;

import static org.junit.jupiter.api.Assertions.assertTrue;


import java.io.BufferedReader;

import java.io.File;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Map;

import java.util.Set;


import javax.vecmath.Point3d;


import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.io.TempDir;

import org.openscience.cdk.Atom;

import org.openscience.cdk.CDKConstants;

import org.openscience.cdk.interfaces.IAtom;

import org.openscience.cdk.interfaces.IAtomContainer;

import org.openscience.cdk.interfaces.IChemObjectBuilder;

import org.openscience.cdk.silent.SilentChemObjectBuilder;


import denoptim.constants.DENOPTIMConstants;

import denoptim.exception.DENOPTIMException;

import denoptim.files.FileFormat;

import denoptim.files.FileUtils;

import denoptim.files.UndetectedFileFormatException;

import denoptim.fitness.FitnessParameters;

import denoptim.ga.EAUtils;

import denoptim.ga.Population;

import denoptim.graph.APClass;

import denoptim.graph.Candidate;

import denoptim.graph.CandidateLW;

import denoptim.graph.DGraph;

import denoptim.graph.Edge;

import denoptim.graph.Edge.BondType;

import denoptim.graph.EmptyVertex;

import denoptim.graph.Fragment;

import denoptim.graph.FragmentTest;

import denoptim.graph.Ring;

import denoptim.graph.SymmetricVertexes;

import denoptim.graph.Template;

import denoptim.graph.TemplateTest;

import denoptim.graph.Vertex;

import denoptim.graph.Vertex.BBType;

import denoptim.programs.RunTimeParameters.ParametersType;

import denoptim.programs.denovo.GAParameters;

import denoptim.programs.fragmenter.CuttingRule;


public class DenoptimIOTest

{


    private static final BondType BT = BondType.SINGLE;


    private final String SEP = System.getProperty("file.separator");

    private final String NL = System.getProperty("line.separator");


    @TempDir

    File tempDir;


//------------------------------------------------------------------------------


    @Test

    public void testReadAllAtomContainersFromCIF() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");

        String tmpFile = tempDir.getAbsolutePath() + SEP + "test.cif";


        String[] sourceCIFs = {"fromCOD.cif","multipleStructure.cif"};

        int[] expectedMols = new int[]{1, 3};

        int[][] expectedAtms = {{81}, {42,45,48}};

        int[][] expectedBnds = {{85}, {44,47,50}};


        for (int i=0; i<sourceCIFs.length; i++)

        {

            // Make a copy of the test file to read from file system

            BufferedReader reader = null;

            try {

                reader = new BufferedReader(

                        new InputStreamReader(getClass()

                                .getClassLoader().getResourceAsStream(

                                        sourceCIFs[i])));

                StringBuilder sb = new StringBuilder();

                String line = null;

                while ((line = reader.readLine()) != null)

                {

                    sb.append(line).append(NL);

                }

                DenoptimIO.writeData(tmpFile, sb.toString(), false);

            } finally {

                if (reader!=null)

                    reader.close();

            }

            List<IAtomContainer> mols = DenoptimIO.readAllAtomContainers(

                    new File(tmpFile));

            assertEquals(expectedMols[i], mols.size());

            for (int j=0; j<mols.size(); j++)

            {

                assertEquals(expectedAtms[i][j], mols.get(j).getAtomCount());

                assertEquals(expectedBnds[i][j], mols.get(j).getBondCount());

            }

        }

    }


//------------------------------------------------------------------------------


    @Test

    public void testIOEmptyVertex() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");


        EmptyVertex v = new EmptyVertex();

        v.addAP(APClass.make("myClass:0"));

        v.addAP(APClass.make("myClass:1"));

        v.addAP(APClass.make("myClass:2"));

        v.addAP(APClass.make("myClass:3"));


        ArrayList<Vertex> initVrtxs = new ArrayList<Vertex>();

        initVrtxs.add(v);


        File tmpFile = new File(tempDir.getAbsolutePath() + SEP + "test.sdf");

        DenoptimIO.writeVertexesToFile(tmpFile, FileFormat.VRTXSDF, initVrtxs);

        ArrayList<Vertex> readInVrtxs =

                DenoptimIO.readVertexes(tmpFile, BBType.UNDEFINED);

        assertEquals(1,readInVrtxs.size(),"Number of vertexes");

        StringBuilder sb = new StringBuilder();

        assertTrue(v.sameAs(readInVrtxs.get(0),sb),"Same vertex content: "

                + sb.toString());


        tmpFile = new File(tempDir.getAbsolutePath() + SEP + "test.json");

        DenoptimIO.writeVertexesToFile(tmpFile, FileFormat.VRTXJSON,

                initVrtxs);

        readInVrtxs = DenoptimIO.readVertexes(tmpFile, BBType.UNDEFINED);

        assertEquals(1,readInVrtxs.size(),"Number of vertexes");

        sb = new StringBuilder();

        assertTrue(v.sameAs(readInVrtxs.get(0),sb),"Same vertex content: "

                + sb.toString());

    }


//------------------------------------------------------------------------------


    @Test

    public void testIOMolFragment() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");


        Fragment v = FragmentTest.makeFragment();


        ArrayList<Vertex> initVrtxs = new ArrayList<Vertex>();

        initVrtxs.add(v);


        File tmpFile = new File(tempDir.getAbsolutePath() + SEP + "test.sdf");

        DenoptimIO.writeVertexesToFile(tmpFile, FileFormat.VRTXSDF, initVrtxs);

        ArrayList<Vertex> readInVrtxs =

                DenoptimIO.readVertexes(tmpFile, BBType.SCAFFOLD);

        assertEquals(1,readInVrtxs.size(),"Number of vertexes");

        StringBuilder sb = new StringBuilder();

        assertTrue(v.sameAs(readInVrtxs.get(0),sb),"Same vertex content: "

                + sb.toString());


        tmpFile = new File(tempDir.getAbsolutePath() + SEP + "test.json");

        DenoptimIO.writeVertexesToFile(tmpFile, FileFormat.VRTXJSON,

                initVrtxs);

        readInVrtxs = DenoptimIO.readVertexes(tmpFile, BBType.SCAFFOLD);

        assertEquals(1,readInVrtxs.size(),"Number of vertexes");

        sb = new StringBuilder();

        assertTrue(v.sameAs(readInVrtxs.get(0),sb),"Same vertex content: "

                + sb.toString());

    }


//------------------------------------------------------------------------------


    @Test

    public void testIOTemplate() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");


        Template v = TemplateTest.getTestAmideTemplate();


        ArrayList<Vertex> initVrtxs = new ArrayList<Vertex>();

        initVrtxs.add(v);


        File tmpFile = new File(tempDir.getAbsolutePath() + SEP + "test.sdf");

        DenoptimIO.writeVertexesToFile(tmpFile, FileFormat.VRTXSDF, initVrtxs);

        ArrayList<Vertex> readInVrtxs =

                DenoptimIO.readVertexes(tmpFile, BBType.UNDEFINED);

        assertEquals(1,readInVrtxs.size(),"Number of vertexes");

        StringBuilder sb = new StringBuilder();

        assertTrue(v.sameAs(readInVrtxs.get(0),sb),"Same vertex content: "

                + sb.toString());


        tmpFile = new File(tempDir.getAbsolutePath() + SEP + "test.json");

        DenoptimIO.writeVertexesToFile(tmpFile, FileFormat.VRTXJSON,

                initVrtxs);

        readInVrtxs = DenoptimIO.readVertexes(tmpFile, BBType.SCAFFOLD);

        assertEquals(1,readInVrtxs.size(),"Number of vertexes");

        sb = new StringBuilder();

        assertTrue(v.sameAs(readInVrtxs.get(0),sb),"Same vertex content: "

                + sb.toString());

    }


//------------------------------------------------------------------------------


    @Test

    public void testReadGenerationFromSummary() throws Exception {


        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");


        GAParameters settings = new GAParameters();

        settings.setPopulationSize(2);

        settings.setWorkingDirectory(tempDir.getAbsolutePath());

        settings.setParameters(new FitnessParameters());


        String genDir = EAUtils.getPathNameToGenerationFolder(26,settings);

        FileUtils.createDirectory(genDir);


        Candidate c1 = new Candidate(new DGraph());

        c1.setFitness(1.111);

        c1.setUID("111");

        c1.getGraph().setGraphId(1);

        String pathname = genDir + SEP + "M001.sdf";

        c1.setSDFFile(pathname);

        DenoptimIO.writeCandidateToFile(new File(pathname), c1, false);


        Candidate c2 = new Candidate(new DGraph());

        c2.setFitness(2.2);

        c2.setUID("222");

        c2.getGraph().setGraphId(2);

        pathname = genDir + SEP + "M002.sdf";

        c2.setSDFFile(pathname);

        DenoptimIO.writeCandidateToFile(new File(pathname), c2, false);


        Population pop = new Population(settings);

        pop.add(c1);

        pop.add(c2);

        String summary = EAUtils.getPathNameToGenerationDetailsFile(26,settings);

        EAUtils.outputPopulationDetails(pop, summary, settings, true);


        List<Candidate> cands = DenoptimIO.readGenerationFromSummary(

                new File(summary));


        assertEquals(2,cands.size());

        assertEquals("111",cands.get(0).getUID());

        assertEquals("222",cands.get(1).getUID());

        assertEquals(1,cands.get(0).getGraph().getGraphId());

        assertEquals(2,cands.get(1).getGraph().getGraphId());


        // We test also the possibility that the run folder has been moved, and

        // thus the pathname have to be made relative to the pathname of the

        // generation summary

        String newPath = tempDir.getAbsolutePath() + SEP + "otherPlace";

        FileUtils.createDirectory(newPath);

        org.apache.commons.io.FileUtils.copyDirectory(new File(genDir),

                new File(newPath));


        cands.clear();

        cands = DenoptimIO.readGenerationFromSummary(

                new File(summary));


        assertEquals(2,cands.size());

        assertEquals("111",cands.get(0).getUID());

        assertEquals("222",cands.get(1).getUID());

        assertEquals(1,cands.get(0).getGraph().getGraphId());

        assertEquals(2,cands.get(1).getGraph().getGraphId());

    }


//------------------------------------------------------------------------------


    @Test

    public void testReadLightWeightCandidate() throws Exception {


        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");

        String pathName = tempDir.getAbsolutePath() + SEP + "test.sdf";


        IChemObjectBuilder builder = SilentChemObjectBuilder.getInstance();

        IAtomContainer iac = builder.newAtomContainer();

        iac.addAtom(new Atom("C"));

        String uid = "mmyUiD";

        String name = "myName";

        double fitness = 999.123;

        String err = "myError";

        String msg = "myMSG";

        int level = 26;

        iac.setProperty(DENOPTIMConstants.UNIQUEIDTAG, uid);

        iac.setProperty(CDKConstants.TITLE, name);

        iac.setProperty(DENOPTIMConstants.FITNESSTAG, fitness);

        iac.setProperty(DENOPTIMConstants.MOLERRORTAG, err);

        iac.setProperty(DENOPTIMConstants.PROVENANCE, msg);

        iac.setProperty(DENOPTIMConstants.GRAPHLEVELTAG, level);


        DenoptimIO.writeSDFFile(pathName, iac, false);


        IAtomContainer iac2 = builder.newAtomContainer();

        iac.addAtom(new Atom("C"));

        String uid2 = "mmyUiD2";

        String name2 = "myName2";

        double fitness2 = 999.1232;

        String err2 = "myError2";

        String msg2 = "myMSG2";

        int level2 = 262;

        iac2.setProperty(DENOPTIMConstants.UNIQUEIDTAG, uid2);

        iac2.setProperty(CDKConstants.TITLE, name2);

        iac2.setProperty(DENOPTIMConstants.FITNESSTAG, fitness2);

        iac2.setProperty(DENOPTIMConstants.MOLERRORTAG, err2);

        iac2.setProperty(DENOPTIMConstants.PROVENANCE, msg2);

        iac2.setProperty(DENOPTIMConstants.GRAPHLEVELTAG, level2);


        DenoptimIO.writeSDFFile(pathName, iac2, true);


        List<CandidateLW> cands = DenoptimIO.readLightWeightCandidate(

                new File(pathName));


        assertEquals(2,cands.size(), "number of candidates in file");

        assertEquals(uid,cands.get(0).getUid(), "UID 1st");

        assertEquals(uid2,cands.get(1).getUid(), "UID 2nd");

        assertEquals(name,cands.get(0).getName(), "name 1st");

        assertEquals(name2,cands.get(1).getName(), "name 2nd");

        assertTrue(0.001 > Math.abs(fitness- cands.get(0).getFitness()),

                "fitness 1st");

        assertTrue(0.001 > Math.abs(fitness2 - cands.get(1).getFitness()),

                "fitness 2nd");

    }


//------------------------------------------------------------------------------


    @Test

    public void testSerializeDeserializeDENOPTIMGraphs() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");

        String jsonFile = tempDir.getAbsolutePath() + SEP + "graph.json";


        DGraph graph = new DGraph();

        EmptyVertex v0 = new EmptyVertex(0);

        buildVertexAndConnectToGraph(v0, 3, graph);


        EmptyVertex v1 = new EmptyVertex(1);

        buildVertexAndConnectToGraph(v1, 2, graph);

        graph.addEdge(new Edge(v0.getAP(0), v1.getAP(0),BT));


        EmptyVertex v2 = new EmptyVertex(2);

        buildVertexAndConnectToGraph(v2, 2, graph);

        graph.addEdge(new Edge(v1.getAP(1), v2.getAP(0),BT));


        EmptyVertex v3 = new EmptyVertex(3);

        buildVertexAndConnectToGraph(v3, 1, graph);

        graph.addEdge(new Edge(v2.getAP(1), v3.getAP(0),BT));


        EmptyVertex v4 = new EmptyVertex(4);

        buildVertexAndConnectToGraph(v4, 3, graph);

        graph.addEdge(new Edge(v0.getAP(1), v4.getAP(0),BT));


        EmptyVertex v5 = new EmptyVertex(5);

        buildVertexAndConnectToGraph(v5, 1, graph);

        graph.addEdge(new Edge(v4.getAP(1), v5.getAP(0),BT));


        EmptyVertex v6 = new EmptyVertex(6);

        buildVertexAndConnectToGraph(v6, 1, graph);

        graph.addEdge(new Edge(v0.getAP(2), v6.getAP(0),BT));


        EmptyVertex v7 = new EmptyVertex(7);

        buildVertexAndConnectToGraph(v7, 1, graph);

        graph.addEdge(new Edge(v4.getAP(2), v7.getAP(0),BT));


        graph.addRing(new Ring(new ArrayList<>(

                Arrays.asList(v5, v4, v0, v1, v2, v3))));


        graph.addRing(new Ring(new ArrayList<>(

                Arrays.asList(v6, v0, v4, v7))));


        SymmetricVertexes ss1 = new SymmetricVertexes();

        ss1.add(v3);

        ss1.add(v5);

        graph.addSymmetricSetOfVertices(ss1);


        SymmetricVertexes ss2 = new SymmetricVertexes();

        ss2.add(v6);

        ss2.add(v7);

        graph.addSymmetricSetOfVertices(ss2);


        String json = graph.toJson();


        DenoptimIO.writeData(jsonFile, json, false);

        DGraph graphJ = DenoptimIO.readDENOPTIMGraphsFromJSONFile(

                jsonFile).get(0);

        assertNotNull(graphJ,"Graph read from JSON file is null");


        StringBuilder reason = new StringBuilder();

        assertTrue(graph.sameAs(graphJ, reason));

    }


//------------------------------------------------------------------------------


    @Test

    public void testReadAllAPClasses() throws Exception {

        Fragment frag = new Fragment();

        IAtom atmC = new Atom("C");

        atmC.setPoint3d(new Point3d(0.0, 0.0, 1.0));

        IAtom atmH = new Atom("H");

        atmH.setPoint3d(new Point3d(0.0, 1.0, 1.0));

        frag.addAtom(atmC);

        frag.addAtom(atmH);

        frag.addAPOnAtom(atmC, APClass.make("classAtmC:5"),

                new Point3d(1.0, 0.0, 0.0));

        frag.addAPOnAtom(atmC, APClass.make("classAtmC:5"),

                new Point3d(1.0, 1.0, 0.0));

        frag.addAPOnAtom(atmC, APClass.make("otherClass:0"),

                new Point3d(-1.0, 0.0, 0.0));

        frag.addAPOnAtom(atmH, APClass.make("classAtmH:1"),

                new Point3d(1.0, 2.0, 2.0));

        frag.projectAPsToProperties();


        Fragment frag2 = new Fragment();

        IAtom atmO = new Atom("O");

        atmO.setPoint3d(new Point3d(0.0, 0.0, 1.0));

        IAtom atmH2 = new Atom("N");

        atmH.setPoint3d(new Point3d(0.0, 1.0, 1.0));

        frag2.addAtom(atmO);

        frag2.addAtom(atmH2);

        frag2.addAPOnAtom(atmO, APClass.make("apClassO:5"),

                new Point3d(1.0, 0.0, 0.0));

        frag2.addAPOnAtom(atmO, APClass.make("apClassO:6"),

                new Point3d(1.0, 1.0, 0.0));

        frag2.addAPOnAtom(atmO, APClass.make("apClassObis:0"),

                new Point3d(-1.0, 0.0, 0.0));

        frag2.addAPOnAtom(atmH2, APClass.make("classAtmH:1"),

                new Point3d(1.0, 2.0, 2.0));

        frag2.projectAPsToProperties();


        ArrayList<Vertex> frags = new ArrayList<Vertex>();

        frags.add(frag);

        frags.add(frag2);


        String tmpFile = FileUtils.getTempFolder()

                + System.getProperty("file.separator") + "frag.sdf";

        DenoptimIO.writeVertexesToSDF(new File(tmpFile), frags, false);


        Set<APClass> allAPC = DenoptimIO.readAllAPClasses(new File(tmpFile));


        assertEquals(6, allAPC.size(), "Size did not match");

        assertTrue(allAPC.contains(APClass.make("apClassObis:0")),

                "Contains APClass (1)");

        assertTrue(allAPC.contains(APClass.make("otherClass:0")),

                "Contains APClass (2)");

    }


//------------------------------------------------------------------------------


    @Test

    public void testAppendToJSON() throws Exception

    {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");

        String pathName = tempDir.getAbsolutePath() + SEP + "vertexes.json";


        Fragment frag = new Fragment();

        frag.addAtom(new Atom("C",new Point3d(0.0, 0.0, 1.0)));

        frag.addAtom(new Atom("C",new Point3d(0.0, 1.0, 1.0)));

        frag.addAPOnAtom(frag.getAtom(0), APClass.make("classAtmC:5"),

                new Point3d(1.0, 0.0, 0.0));

        frag.addAPOnAtom(frag.getAtom(1), APClass.make("classAtmC:5"),

                new Point3d(1.0, 1.0, 0.0));

        frag.projectAPsToProperties();


        Fragment frag2 = new Fragment();

        frag2.addAtom(new Atom("O",new Point3d(0.0, 0.0, 1.0)));

        frag2.addAPOnAtom(frag2.getAtom(0), APClass.make("Other:0"),

                new Point3d(1.0, 0.0, 0.0));

        frag2.projectAPsToProperties();


        ArrayList<Vertex> frags = new ArrayList<Vertex>();

        frags.add(frag);

        frags.add(frag2);


        DenoptimIO.writeVertexesToFile(new File(pathName), FileFormat.VRTXJSON,

                frags);


        Fragment frag3 = new Fragment();

        frag3.addAtom(new Atom("N",new Point3d(1.0, 0.0, 1.0)));

        frag3.addAPOnAtom(frag3.getAtom(0), APClass.make("Other:0"),

                new Point3d(1.0, 0.0, 0.0));

        frag3.projectAPsToProperties();


        ArrayList<Vertex> frags2 = new ArrayList<Vertex>();

        frags2.add(frag3);


        DenoptimIO.writeVertexesToFile(new File(pathName), FileFormat.VRTXJSON,

                frags2, true);


        ArrayList<Vertex> frags3 = DenoptimIO.readDENOPTIMVertexesFromJSONFile(

                pathName);


        assertEquals(3,frags3.size());

        assertEquals("C",frags3.get(0).getIAtomContainer().getAtom(0).getSymbol());

        assertEquals("O",frags3.get(1).getIAtomContainer().getAtom(0).getSymbol());

        assertEquals("N",frags3.get(2).getIAtomContainer().getAtom(0).getSymbol());

    }


//------------------------------------------------------------------------------


    private void buildVertexAndConnectToGraph(EmptyVertex v, int apCount,

                                              DGraph graph)

                                                      throws DENOPTIMException {

        for (int atomPos = 0; atomPos < apCount; atomPos++) {

            v.addAP();

        }

        graph.addVertex(v);

    }


//------------------------------------------------------------------------------


    @Test

    public void testDetectFileFormat() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");

        String pathName = tempDir.getAbsolutePath() + SEP + "graph.sdf";

        File file = new File(pathName);

        final File ffile = new File(pathName);


        DenoptimIO.writeData(pathName, "dummy text", false);

        assertThrows(UndetectedFileFormatException.class,

                () -> FileUtils.detectFileFormat(ffile));


        DenoptimIO.writeData(pathName,

                "> <" + DENOPTIMConstants.APSTAG + ">"+ NL

                + "> <" + DENOPTIMConstants.VERTEXJSONTAG + ">", false);

        assertTrue(FileFormat.VRTXSDF == FileUtils.detectFileFormat(file),

                "Vertex SDF");


        DenoptimIO.writeData(pathName,

                "> <" + DENOPTIMConstants.APSTAG + ">"+ NL

                + "> <" + DENOPTIMConstants.GRAPHJSONTAG + ">", false);

        assertTrue(FileFormat.GRAPHSDF == FileUtils.detectFileFormat(file),

                "Graph SDF");


        DenoptimIO.writeData(pathName, "> <" + DENOPTIMConstants.GRAPHJSONTAG

                + ">", false);

        assertTrue(FileFormat.GRAPHSDF == FileUtils.detectFileFormat(file),

                "Graph SDF");


        pathName = tempDir.getAbsolutePath() + SEP + "filename";

        file = new File(pathName);


        DenoptimIO.writeData(pathName, ParametersType.CEBL_PARAMS.getKeywordRoot()

                + "SOMETING", false);

        assertTrue(FileFormat.FSE_PARAM == FileUtils.detectFileFormat(file),

                "FSE params");


        DenoptimIO.writeData(pathName, ParametersType.GA_PARAMS.getKeywordRoot()

                + "SOMETING", false);

        assertTrue(FileFormat.GA_PARAM == FileUtils.detectFileFormat(file),

                "GA params");


        DenoptimIO.writeData(pathName, "RCN SOMETING", false);

        assertTrue(FileFormat.COMP_MAP == FileUtils.detectFileFormat(file),

                "Compatibility Matrix (1)");


        DenoptimIO.writeData(pathName, "CAP SOMETING", false);

        assertTrue(FileFormat.COMP_MAP == FileUtils.detectFileFormat(file),

                "Compatibility Matrix (3)");


        File txtFile = new File(pathName+ ".txt");

        DenoptimIO.writeData(txtFile.getAbsolutePath(),

                DENOPTIMConstants.GAGENSUMMARYHEADER, false);

        assertTrue(FileFormat.GENSUMMARY == FileUtils.detectFileFormat(txtFile),

                "Generation summary");


        String dirName = tempDir.getAbsolutePath() + SEP + "blabla1234";

        String subDirName = dirName + SEP+DENOPTIMConstants.FSEIDXNAMEROOT+"0";


        FileUtils.createDirectory(dirName);

        FileUtils.createDirectory(subDirName);

        assertTrue(FileFormat.FSE_RUN == FileUtils.detectFileFormat(

                new File(dirName)), "FSE output folder");


        dirName = tempDir.getAbsolutePath() + SEP + "blabla5678";

        subDirName = dirName + SEP+DENOPTIMConstants.GAGENDIRNAMEROOT+"0";

        FileUtils.createDirectory(dirName);

        FileUtils.createDirectory(subDirName);

        assertTrue(FileFormat.GA_RUN == FileUtils.detectFileFormat(

                new File(dirName)), "GA output folder");

    }


//------------------------------------------------------------------------------


    @Test

    public void testReadCuttingRulsedDefault() throws Exception {

        List<CuttingRule> defaultCuttingRules = new ArrayList<CuttingRule>();

        BufferedReader reader = null;

        try {

            reader = new BufferedReader(

                    new InputStreamReader(getClass()

                            .getClassLoader().getResourceAsStream(

                                    "data/cutting_rules")));

            DenoptimIO.readCuttingRules(reader, defaultCuttingRules,

                    "bundled jar");

        } finally {

            if (reader!=null)

                reader.close();

        }

        assertTrue(defaultCuttingRules.size() > 100);

    }


//------------------------------------------------------------------------------


    @Test

    public void testIOCuttingRules() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");


        CuttingRule ctrA = new CuttingRule("myRuleA",

                "AAA", "{$([*]@C)}", "!@#", -123, null);

        CuttingRule ctrB = new CuttingRule("myRuleB",

                "{$([*]@B)}", "BBB", "-", 1, null);


        ArrayList<CuttingRule> cutRules = new ArrayList<CuttingRule>();

        cutRules.add(ctrA);

        cutRules.add(ctrB);


        File tmpFile = new File(tempDir.getAbsolutePath() + SEP + "cutRule");

        DenoptimIO.writeCuttingRules(tmpFile, cutRules);


        ArrayList<CuttingRule> readInCutRules = new ArrayList<CuttingRule>();

        DenoptimIO.readCuttingRules(tmpFile, readInCutRules);


        assertEquals(cutRules.size(), readInCutRules.size());

    }


//------------------------------------------------------------------------------


    @Test

    public void testReadCSDFormulae() throws Exception {

        assertTrue(this.tempDir.isDirectory(),"Should be a directory ");

        String txtFile = tempDir.getAbsolutePath() + SEP + "formulae.txt";


        String text = "REFCODE: MOL000001" + NL

                + "Chemical" + NL

                + "  Formula:           H2 O" + NL

                + NL

                + "REFCODE: BLABLA" + NL

                + "Chemical" + NL

                + "  Formula:           ABC" + NL

                + NL

                + "REFCODE: A" + NL

                + "Chemical" + NL

                + "  Formula:           H2 O" + NL;


        DenoptimIO.writeData(txtFile, text, false);

        Map<String, String> data = DenoptimIO.readCSDFormulae(new File(txtFile));

        assertEquals(3, data.size());

        assertTrue(data.keySet().contains("MOL000001"));

        assertTrue(data.keySet().contains("BLABLA"));

        assertTrue(data.keySet().contains("A"));

    }

}

denoptim.constants.DENOPTIMConstants
General set of constants used in DENOPTIM.
Definition: DENOPTIMConstants.java:49

denoptim.constants.DENOPTIMConstants.VERTEXJSONTAG
static final String VERTEXJSONTAG
SDF tag containing vertex encoding in JSON format.
Definition: DENOPTIMConstants.java:298

denoptim.constants.DENOPTIMConstants.PROVENANCE
static final String PROVENANCE
SDF tag containing provenance data for a graph.
Definition: DENOPTIMConstants.java:303

denoptim.constants.DENOPTIMConstants.APSTAG
static final String APSTAG
SDF tag defining attachment points.
Definition: DENOPTIMConstants.java:308

denoptim.constants.DENOPTIMConstants.GRAPHLEVELTAG
static final String GRAPHLEVELTAG
SDF tag defining the graph generating level in an FSE run.
Definition: DENOPTIMConstants.java:343

denoptim.constants.DENOPTIMConstants.GAGENSUMMARYHEADER
static final String GAGENSUMMARYHEADER
Header of text files collection generation details.
Definition: DENOPTIMConstants.java:220

denoptim.constants.DENOPTIMConstants.UNIQUEIDTAG
static final String UNIQUEIDTAG
SDF tag containing the unique identifier of a candidate.
Definition: DENOPTIMConstants.java:328

denoptim.constants.DENOPTIMConstants.GAGENDIRNAMEROOT
static final String GAGENDIRNAMEROOT
Prefix for generation folders.
Definition: DENOPTIMConstants.java:215

denoptim.constants.DENOPTIMConstants.GRAPHJSONTAG
static final String GRAPHJSONTAG
SDF tag containing graph encoding in JSON format.
Definition: DENOPTIMConstants.java:293

denoptim.constants.DENOPTIMConstants.MOLERRORTAG
static final String MOLERRORTAG
SDF tag containing errors during execution of molecule specific tasks.
Definition: DENOPTIMConstants.java:313

denoptim.constants.DENOPTIMConstants.FSEIDXNAMEROOT
static final String FSEIDXNAMEROOT
Prefix for graph indexing files.
Definition: DENOPTIMConstants.java:227

denoptim.constants.DENOPTIMConstants.FITNESSTAG
static final String FITNESSTAG
SDF tag containing the fitness of a candidate.
Definition: DENOPTIMConstants.java:318

denoptim.exception.DENOPTIMException
Definition: DENOPTIMException.java:26

denoptim.files.FileUtils
Definition: FileUtils.java:58

denoptim.files.FileUtils.createDirectory
static boolean createDirectory(String fileName)
Creates a directory.
Definition: FileUtils.java:231

denoptim.files.FileUtils.detectFileFormat
static FileFormat detectFileFormat(File inFile)
Inspects a file/folder and tries to detect if there is one of the data sources that is recognized by ...
Definition: FileUtils.java:399

denoptim.files.FileUtils.getTempFolder
static String getTempFolder()
Looks for a writable location where to put temporary files and returns an absolute pathname to the fo...
Definition: FileUtils.java:204

denoptim.files.UndetectedFileFormatException
Exception thrown when the format of a file is not recognized.
Definition: UndetectedFileFormatException.java:28

denoptim.fitness.FitnessParameters
Settings defining the calculation of fitness.
Definition: FitnessParameters.java:36

denoptim.ga.EAUtils
Helper methods for the genetic algorithm.
Definition: EAUtils.java:93

denoptim.ga.EAUtils.outputPopulationDetails
static void outputPopulationDetails(Population population, String filename, GAParameters settings, boolean printpathNames)
Write out summary for the current GA population.
Definition: EAUtils.java:1226

denoptim.ga.EAUtils.getPathNameToGenerationFolder
static String getPathNameToGenerationFolder(int genID, GAParameters settings)
Definition: EAUtils.java:1449

denoptim.ga.EAUtils.getPathNameToGenerationDetailsFile
static String getPathNameToGenerationDetailsFile(int genID, GAParameters settings)
Definition: EAUtils.java:1465

denoptim.ga.Population
A collection of candidates.
Definition: Population.java:48

denoptim.ga.Population.add
boolean add(Candidate c)
Definition: Population.java:87

denoptim.graph.APClass
Definition: APClass.java:41

denoptim.graph.APClass.make
static APClass make(String ruleAndSubclass)
Creates an APClass if it does not exist already, or returns the reference to the existing instance.
Definition: APClass.java:136

denoptim.graph.Candidate
A candidate is the combination of a denoptim graph with molecular representation and may include also...
Definition: Candidate.java:40

denoptim.graph.Candidate.setSDFFile
void setSDFFile(String molFile)
Definition: Candidate.java:445

denoptim.graph.Candidate.getGraph
DGraph getGraph()
Definition: Candidate.java:544

denoptim.graph.Candidate.setFitness
void setFitness(double fitness)
Definition: Candidate.java:480

denoptim.graph.Candidate.setUID
void setUID(String uid)
Definition: Candidate.java:466

denoptim.graph.DGraph
Container for the list of vertices and the edges that connect them.
Definition: DGraph.java:102

denoptim.graph.DGraph.toJson
String toJson()
Produces a string that represents this graph and that adheres to the JSON format.
Definition: DGraph.java:6660

denoptim.graph.DGraph.setGraphId
void setGraphId(int id)
Definition: DGraph.java:258

denoptim.graph.DGraph.sameAs
boolean sameAs(DGraph other, StringBuilder reason)
Compare this and another graph ignoring the vertex IDs.
Definition: DGraph.java:3665

denoptim.graph.DGraph.addSymmetricSetOfVertices
void addSymmetricSetOfVertices(SymmetricVertexes symSet)
Adds a symmetric set of vertices to this graph.
Definition: DGraph.java:661

denoptim.graph.DGraph.addRing
void addRing(Ring ring)
Definition: DGraph.java:1030

denoptim.graph.DGraph.addEdge
void addEdge(Edge edge)
Adds the edge to the list of edges belonging to this graph.
Definition: DGraph.java:1021

denoptim.graph.Edge
This class represents the edge between two vertices.
Definition: Edge.java:38

denoptim.graph.EmptyVertex
An empty vertex has the behaviors of a vertex, but has no molecular structure.
Definition: EmptyVertex.java:45

denoptim.graph.EmptyVertex.sameAs
boolean sameAs(EmptyVertex other, StringBuilder reason)
Compares this and another vertex ignoring vertex IDs.
Definition: EmptyVertex.java:328

denoptim.graph.EmptyVertex.addAP
void addAP()
Adds an attachment point with no APClass or other attribute.
Definition: EmptyVertex.java:298

denoptim.graph.Fragment
Class representing a continuously connected portion of chemical object holding attachment points.
Definition: Fragment.java:61

denoptim.graph.Fragment.sameAs
boolean sameAs(Fragment other, StringBuilder reason)
Compares this and another fragment ignoring vertex IDs.
Definition: Fragment.java:967

denoptim.graph.Fragment.addAPOnAtom
AttachmentPoint addAPOnAtom(IAtom srcAtm, APClass apc, Point3d vector)
Add an attachment point to the specifies atom.
Definition: Fragment.java:424

denoptim.graph.Fragment.addAtom
void addAtom(IAtom atom)
Definition: Fragment.java:836

denoptim.graph.Fragment.getAtom
IAtom getAtom(int number)
Definition: Fragment.java:843

denoptim.graph.Fragment.projectAPsToProperties
void projectAPsToProperties()
Finds the DENOPTIMAttachmentPoint objects defined as properties of the atoms in this container,...
Definition: Fragment.java:693

denoptim.graph.FragmentTest
Unit test for DENOPTIMFragment.
Definition: FragmentTest.java:47

denoptim.graph.FragmentTest.makeFragment
static Fragment makeFragment()
Definition: FragmentTest.java:157

denoptim.graph.Ring
This class represents the closure of a ring in a spanning tree.
Definition: Ring.java:40

denoptim.graph.SymmetricSet.add
boolean add(T item)
Adds an item to this list, if not already present.
Definition: SymmetricSet.java:55

denoptim.graph.SymmetricVertexes
A collection of Vertexs that are related by a relation that we call "symmetry", even though this clas...
Definition: SymmetricVertexes.java:18

denoptim.graph.Template
Definition: Template.java:80

denoptim.graph.Template.sameAs
boolean sameAs(Template other, StringBuilder reason)
Compares this and another template ignoring vertex IDs.
Definition: Template.java:956

denoptim.graph.TemplateTest
Unit test for DENOPTIMTemplate.
Definition: TemplateTest.java:56

denoptim.graph.TemplateTest.getTestAmideTemplate
static Template getTestAmideTemplate()
Builds a template object meant for tests.
Definition: TemplateTest.java:456

denoptim.graph.Vertex.getAP
AttachmentPoint getAP(int i)
Get attachment point i on this vertex.
Definition: Vertex.java:920

denoptim.io.DenoptimIO
Utility methods for input/output.
Definition: DenoptimIO.java:113

denoptim.io.DenoptimIO.writeVertexesToFile
static File writeVertexesToFile(File file, FileFormat format, List< Vertex > vertexes)
Writes vertexes to file.
Definition: DenoptimIO.java:386

denoptim.io.DenoptimIO.readCSDFormulae
static LinkedHashMap< String, String > readCSDFormulae(File file)
Read molecular formula from TXT data representation produced by Cambridge Structural Database tools (...
Definition: DenoptimIO.java:2341

denoptim.io.DenoptimIO.readGenerationFromSummary
static List< Candidate > readGenerationFromSummary(File file)
Reads a FileFormat#GENSUMMARY file and searches all the files defining each member of the population.
Definition: DenoptimIO.java:237

denoptim.io.DenoptimIO.writeSDFFile
static void writeSDFFile(String fileName, IAtomContainer mol)
Writes IAtomContainer to SDF file.
Definition: DenoptimIO.java:534

denoptim.io.DenoptimIO.readDENOPTIMVertexesFromJSONFile
static ArrayList< Vertex > readDENOPTIMVertexesFromJSONFile(String fileName)
Reads a list of Vertexes from a JSON file.
Definition: DenoptimIO.java:1809

denoptim.io.DenoptimIO.readCuttingRules
static void readCuttingRules(BufferedReader reader, List< CuttingRule > cutRules, String source)
Read cutting rules from a stream.
Definition: DenoptimIO.java:2399

denoptim.io.DenoptimIO.writeCandidateToFile
static void writeCandidateToFile(File file, Candidate candidate, boolean append)
Writes one candidate item to file.
Definition: DenoptimIO.java:1459

denoptim.io.DenoptimIO.writeCuttingRules
static void writeCuttingRules(File file, List< CuttingRule > cutRules)
Writes a formatted text file that collects cutting rule.
Definition: DenoptimIO.java:2534

denoptim.io.DenoptimIO.readAllAPClasses
static Set< APClass > readAllAPClasses(File fragLib)
Definition: DenoptimIO.java:1114

denoptim.io.DenoptimIO.readDENOPTIMGraphsFromJSONFile
static ArrayList< DGraph > readDENOPTIMGraphsFromJSONFile(String fileName)
Reads a list of DGraphs from a JSON file.
Definition: DenoptimIO.java:1875

denoptim.io.DenoptimIO.readLightWeightCandidate
static List< CandidateLW > readLightWeightCandidate(File file)
Read only selected data from a GA produced items.
Definition: DenoptimIO.java:769

denoptim.io.DenoptimIO.readVertexes
static ArrayList< Vertex > readVertexes(File file, Vertex.BBType bbt)
Reads Vertexes from any file that can contain such items.
Definition: DenoptimIO.java:2243

denoptim.io.DenoptimIO.writeData
static void writeData(String fileName, String data, boolean append)
Write text-like data file.
Definition: DenoptimIO.java:738

denoptim.io.DenoptimIO.readAllAtomContainers
static List< IAtomContainer > readAllAtomContainers(File file)
Returns a single collection with all atom containers found in a file of any format.
Definition: DenoptimIO.java:282

denoptim.io.DenoptimIO.writeVertexesToSDF
static void writeVertexesToSDF(File file, List< Vertex > vertexes, boolean append)
Write a list of vertexes to file.
Definition: DenoptimIO.java:513

denoptim.io.DenoptimIOTest
Unit test for input/output.
Definition: DenoptimIOTest.java:81

denoptim.io.DenoptimIOTest.BT
static final BondType BT
Definition: DenoptimIOTest.java:83

denoptim.io.DenoptimIOTest.NL
final String NL
Definition: DenoptimIOTest.java:86

denoptim.io.DenoptimIOTest.testReadLightWeightCandidate
void testReadLightWeightCandidate()
Definition: DenoptimIOTest.java:296

denoptim.io.DenoptimIOTest.testSerializeDeserializeDENOPTIMGraphs
void testSerializeDeserializeDENOPTIMGraphs()
Definition: DenoptimIOTest.java:353

denoptim.io.DenoptimIOTest.testAppendToJSON
void testAppendToJSON()
Definition: DenoptimIOTest.java:474

denoptim.io.DenoptimIOTest.testReadAllAPClasses
void testReadAllAPClasses()
Definition: DenoptimIOTest.java:419

denoptim.io.DenoptimIOTest.testIOTemplate
void testIOTemplate()
Definition: DenoptimIOTest.java:201

denoptim.io.DenoptimIOTest.tempDir
File tempDir
Definition: DenoptimIOTest.java:89

denoptim.io.DenoptimIOTest.SEP
final String SEP
Definition: DenoptimIOTest.java:85

denoptim.io.DenoptimIOTest.testIOCuttingRules
void testIOCuttingRules()
Definition: DenoptimIOTest.java:629

denoptim.io.DenoptimIOTest.testReadCSDFormulae
void testReadCSDFormulae()
Definition: DenoptimIOTest.java:653

denoptim.io.DenoptimIOTest.testDetectFileFormat
void testDetectFileFormat()
Definition: DenoptimIOTest.java:536

denoptim.io.DenoptimIOTest.testReadAllAtomContainersFromCIF
void testReadAllAtomContainersFromCIF()
Definition: DenoptimIOTest.java:94

denoptim.io.DenoptimIOTest.testIOEmptyVertex
void testIOEmptyVertex()
Definition: DenoptimIOTest.java:137

denoptim.io.DenoptimIOTest.buildVertexAndConnectToGraph
void buildVertexAndConnectToGraph(EmptyVertex v, int apCount, DGraph graph)
Definition: DenoptimIOTest.java:524

denoptim.io.DenoptimIOTest.testReadCuttingRulsedDefault
void testReadCuttingRulsedDefault()
Definition: DenoptimIOTest.java:609

denoptim.io.DenoptimIOTest.testReadGenerationFromSummary
void testReadGenerationFromSummary()
Definition: DenoptimIOTest.java:231

denoptim.io.DenoptimIOTest.testIOMolFragment
void testIOMolFragment()
Definition: DenoptimIOTest.java:171

denoptim.programs.RunTimeParameters.setParameters
void setParameters(RunTimeParameters otherParams)
Definition: RunTimeParameters.java:800

denoptim.programs.denovo.GAParameters
Parameters for genetic algorithm.
Definition: GAParameters.java:46

denoptim.programs.denovo.GAParameters.setPopulationSize
void setPopulationSize(int size)
Definition: GAParameters.java:631

denoptim.programs.denovo.GAParameters.setWorkingDirectory
void setWorkingDirectory(String pathName)
Definition: GAParameters.java:513

denoptim.programs.fragmenter.CuttingRule
A cutting rule with three SMARTS queries (atom 1, bond, atom2) and options.
Definition: CuttingRule.java:32

denoptim.files.FileFormat
File formats identified by DENOPTIM.
Definition: FileFormat.java:32

denoptim.files.FileFormat.GENSUMMARY
GENSUMMARY
Definition: FileFormat.java:41

denoptim.files.FileFormat.GA_RUN
GA_RUN
Definition: FileFormat.java:36

denoptim.files.FileFormat.VRTXJSON
VRTXJSON
Definition: FileFormat.java:35

denoptim.files.FileFormat.FSE_PARAM
FSE_PARAM
Definition: FileFormat.java:38

denoptim.files.FileFormat.COMP_MAP
COMP_MAP
Definition: FileFormat.java:38

denoptim.files.FileFormat.GRAPHSDF
GRAPHSDF
Definition: FileFormat.java:35

denoptim.files.FileFormat.VRTXSDF
VRTXSDF
Definition: FileFormat.java:35

denoptim.files.FileFormat.GA_PARAM
GA_PARAM
Definition: FileFormat.java:38

denoptim.files.FileFormat.FSE_RUN
FSE_RUN
Definition: FileFormat.java:36

denoptim.graph.Edge.BondType
Possible chemical bond types an edge can represent.
Definition: Edge.java:303

denoptim.graph.Edge.BondType.SINGLE
SINGLE
Definition: Edge.java:305

denoptim.graph.Vertex.BBType
The type of building block.
Definition: Vertex.java:86

denoptim.graph.Vertex.BBType.UNDEFINED
UNDEFINED
Definition: Vertex.java:87

denoptim.graph.Vertex.BBType.SCAFFOLD
SCAFFOLD
Definition: Vertex.java:87

denoptim.programs.RunTimeParameters.ParametersType
Identifier of the type of parameters.
Definition: RunTimeParameters.java:123

denoptim.programs.RunTimeParameters.ParametersType.CEBL_PARAMS
CEBL_PARAMS
Parameters pertaining the combinatorial exploration by layer.
Definition: RunTimeParameters.java:127

denoptim.programs.RunTimeParameters.ParametersType.GA_PARAMS
GA_PARAMS
Parameters pertaining the genetic algorithm.
Definition: RunTimeParameters.java:132