DENOPTIM/_fragment_space_test_8java_source.html

package denoptim.fragspace;


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

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


/*

 *   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/>.

 */


import java.io.File;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Random;

import java.util.Set;

import java.util.function.Supplier;

import java.util.stream.Collectors;

import java.util.stream.IntStream;


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.DefaultChemObjectBuilder;

import org.openscience.cdk.PseudoAtom;

import org.openscience.cdk.interfaces.IAtom;

import org.openscience.cdk.interfaces.IAtomContainer;

import org.openscience.cdk.interfaces.IChemObjectBuilder;

import org.openscience.cdk.silent.Bond;


import denoptim.exception.DENOPTIMException;

import denoptim.files.FileUtils;

import denoptim.graph.APClass;

import denoptim.graph.AttachmentPoint;

import denoptim.graph.DGraph;

import denoptim.graph.Edge;

import denoptim.graph.Edge.BondType;

import denoptim.graph.Fragment;

import denoptim.graph.Ring;

import denoptim.graph.SymmetricAPs;

import denoptim.graph.Template;

import denoptim.graph.Vertex;

import denoptim.graph.Vertex.BBType;

import denoptim.graph.rings.RingClosingAttractor;

import denoptim.io.DenoptimIO;

import denoptim.molecularmodeling.ThreeDimTreeBuilder;

import denoptim.utils.GraphUtils;

import denoptim.utils.MoleculeUtils;


public class FragmentSpaceTest

{

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


    @TempDir

    static File tempDir;


    private final Random rng = new Random();


    private static final int APSUBRULE = 0;


    private static final String RULAPCS = "apc-S";

    private static final String RULAPC1 = "apc-1";

    private static final String RULAPC2 = "apc-2";

    private static final String RULAPC3 = "apc-3";

    private static final String RULAPC4 = "apc-4";

    private static final String RULAPC5 = "a_p_c-5";

    private static final String RULAPC6 = "a_p_c-6";

    private static final String RULAPCC1 = "cap-1";

    private static final String RULAPCC2 = "cap-2";


    private static final BBType BBTFRAG = BBType.FRAGMENT;


    private static APClass APCS;

    private static APClass APC1;

    private static APClass APC2;

    private static APClass APC3;

    private static APClass APC4;

    private static APClass APC5;

    private static APClass APC6;

    private static APClass APCC1;

    private static APClass APCC2;


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


    private FragmentSpaceParameters buildFragmentSpace() throws DENOPTIMException

    {

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


        try

        {

            APCS = APClass.make(RULAPCS, APSUBRULE, BondType.SINGLE);

            APC1 = APClass.make(RULAPC1, APSUBRULE, BondType.SINGLE);

            APC2 = APClass.make(RULAPC2, APSUBRULE, BondType.SINGLE);

            APC3 = APClass.make(RULAPC3, APSUBRULE, BondType.SINGLE);

            APC4 = APClass.make(RULAPC4, APSUBRULE, BondType.SINGLE);

            APC5 = APClass.make(RULAPC5, APSUBRULE, BondType.SINGLE);

            APC6 = APClass.make(RULAPC6, APSUBRULE, BondType.DOUBLE);

            APCC1 = APClass.make(RULAPCC1, APSUBRULE, BondType.SINGLE);

            APCC2 = APClass.make(RULAPCC2, APSUBRULE, BondType.SINGLE);

        } catch (DENOPTIMException e)

        {

            //This will not happen

        }


        String rootName = tempDir.getAbsolutePath() + SEP;


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

        Fragment frg1 = new Fragment();

        Atom a1 = new Atom("C", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a2 = new Atom("C", new Point3d(new double[]{1.0, 1.1, 2.2}));

        Atom a3 = new Atom("C", new Point3d(new double[]{2.0, 1.1, 2.2}));

        frg1.addAtom(a1);

        frg1.addAtom(a2);

        frg1.addAtom(a3);

        frg1.addBond(new Bond(a1, a2));

        frg1.addBond(new Bond(a2, a3));

        frg1.addAPOnAtom(a3, APC1, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg1.addAPOnAtom(a3, APC1, new Point3d(new double[]{0.0, 0.0, 3.3}));

        frg1.addAPOnAtom(a3, APC2, new Point3d(new double[]{0.0, 0.0, 1.1}));

        frg1.addAPOnAtom(a1, APC3, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1.projectAPsToProperties();

        fragLib.add(frg1);


        Fragment frg2 = new Fragment();

        Atom a21 = new Atom("N", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a22 = new Atom("H", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg2.addAtom(a21);

        frg2.addAtom(a22);

        frg2.addBond(new Bond(a21, a22));

        frg2.addAPOnAtom(a22, APC2, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg2.addAPOnAtom(a22, APC2, new Point3d(new double[]{0.0, 0.0, 3.3}));

        frg2.projectAPsToProperties();

        fragLib.add(frg2);


        Fragment frg3 = new Fragment();

        Atom a31 = new Atom("P", new Point3d(new double[]{0.0, 1.1, 2.2}));

        frg3.addAtom(a31);

        frg3.addAPOnAtom(a31, APC1, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg3.addAPOnAtom(a31, APC2, new Point3d(new double[]{0.0, 0.0, 3.3}));

        frg3.addAPOnAtom(a31, APC3, new Point3d(new double[]{0.0, 0.0, 1.1}));

        frg3.projectAPsToProperties();

        fragLib.add(frg3);


        Fragment frg8 = new Fragment();

        Atom a81 = new Atom("C", new Point3d(new double[]{0.0, 1.1, -2.2}));

        Atom a82 = new Atom("C", new Point3d(new double[]{1.0, 1.1, -2.2}));

        Atom a83 = new Atom("C", new Point3d(new double[]{2.0, 1.1, -2.2}));

        frg8.addAtom(a81);

        frg8.addAtom(a82);

        frg8.addAtom(a83);

        frg8.addBond(new Bond(a81, a82));

        frg8.addBond(new Bond(a82, a83));

        frg8.addAPOnAtom(a83, APC4, new Point3d(new double[]{0.0, 2.2, -3.3}));

        frg8.addAPOnAtom(a83, APC4, new Point3d(new double[]{0.0, 0.0, -3.3}));

        frg8.addAPOnAtom(a83, APC6, new Point3d(new double[]{0.0, 0.0, -1.1}));

        frg8.addAPOnAtom(a82, APC5, new Point3d(new double[]{1.0, 0.1, -2.2}));

        frg8.addAPOnAtom(a82, APC5, new Point3d(new double[]{1.0, 0.1, -1.2}));

        frg8.addAPOnAtom(a82, APC5, new Point3d(new double[]{1.0, 2.1, -2.2}));

        frg8.addAPOnAtom(a81, APC5, new Point3d(new double[]{3.0, 0.0, -3.3}));

        frg8.projectAPsToProperties();

        fragLib.add(frg8);


        String fragLibFile = rootName + "frags.sdf";

        DenoptimIO.writeVertexesToSDF(new File(fragLibFile), fragLib, false);


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

        Fragment scaf0 = new Fragment();

        Atom a41 = new Atom("O", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a42 = new Atom("C", new Point3d(new double[]{1.0, 1.1, 2.2}));

        Atom a43 = new Atom("Ru", new Point3d(new double[]{2.0, 1.1, 2.2}));

        scaf0.addAtom(a41);

        scaf0.addAtom(a42);

        scaf0.addAtom(a43);

        scaf0.addBond(new Bond(a41, a42));

        scaf0.addBond(new Bond(a42, a43));

        scaf0.addAPOnAtom(a43, APCS, new Point3d(new double[]{0.0, 2.2, 3.3}));

        scaf0.addAPOnAtom(a43, APCS, new Point3d(new double[]{0.0, 0.0, 3.3}));

        scaf0.addAPOnAtom(a43, APCS, new Point3d(new double[]{0.0, 0.0, 1.1}));

        scaf0.addAPOnAtom(a41, APCS, new Point3d(new double[]{3.0, 0.0, 3.3}));

        scaf0.projectAPsToProperties();

        scaffLib.add(scaf0);


        Fragment scaf1 = new Fragment();

        Atom a51 = new Atom("Zn", new Point3d(new double[]{5.0, 1.1, 2.2}));

        scaf1.addAtom(a51);

        scaf1.addAPOnAtom(a51, APCS, new Point3d(new double[]{5.0, 2.2, 3.3}));

        scaf1.addAPOnAtom(a51, APCS, new Point3d(new double[]{5.0, 0.0, 3.3}));

        scaf1.addAPOnAtom(a51, APCS, new Point3d(new double[]{5.0, 0.0, 1.1}));

        scaf1.projectAPsToProperties();

        scaffLib.add(scaf1);


        String scaffLibFile = rootName + "scaff.sdf";

        DenoptimIO.writeVertexesToSDF(new File(scaffLibFile), scaffLib, false);


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

        Fragment cap1 = new Fragment();

        Atom a61 = new Atom("H", new Point3d(new double[]{10.0, 1.1, 2.2}));

        cap1.addAtom(a61);

        cap1.addAPOnAtom(a61, APCC1, new Point3d(new double[]{13.0, 0.0, 3.3}));

        cap1.projectAPsToProperties();

        cappLib.add(cap1);


        Fragment cap2 = new Fragment();

        Atom a71 = new Atom("Cl", new Point3d(new double[]{10.0, 1.1, 2.2}));

        cap2.addAtom(a71);

        cap2.addAPOnAtom(a71, APCC2, new Point3d(new double[]{13.0, 0.0, 3.3}));

        cap2.projectAPsToProperties();

        cappLib.add(cap2);


        String capLibFile = rootName + "caps.sdf";

        DenoptimIO.writeVertexesToSDF(new File(capLibFile), cappLib, false);


        HashMap<APClass,ArrayList<APClass>> cpMap =

                new HashMap<APClass,ArrayList<APClass>>();

        ArrayList<APClass> lst1 = new ArrayList<APClass>();

        lst1.add(APC1);

        lst1.add(APC2);

        cpMap.put(APCS, lst1);

        ArrayList<APClass> lst2 = new ArrayList<APClass>();

        lst2.add(APC2);

        cpMap.put(APC1, lst2);

        ArrayList<APClass> lst3 = new ArrayList<APClass>();

        lst3.add(APC2);

        lst3.add(APC3);

        cpMap.put(APC2, lst3);


        HashMap<APClass,APClass> capMap = new HashMap<APClass,APClass>();

        capMap.put(APCS, APCC2);

        capMap.put(APC1, APCC1);

        capMap.put(APC2, APCC1);


        HashSet<APClass> ends = new HashSet<APClass>();

        ends.add(APC3);


        String cpmFile = rootName + "cpm.dat";

        DenoptimIO.writeCompatibilityMatrix(cpmFile, cpMap, capMap,ends);


        /*

        //Just in case one day we want to have also an RC-CPMap

        HashMap<APClass,ArrayList<APClass>> rcCpMap =

                new HashMap<APClass,ArrayList<APClass>>();

        */


        FragmentSpaceParameters fsp = new FragmentSpaceParameters();

        new FragmentSpace(fsp, scaffLibFile, fragLibFile,

                capLibFile, cpmFile);

        return fsp;

    }


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


    @Test

    public void testSymmetry() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        assertTrue(fsp.getFragmentSpace().isDefined(),"FragmentSpace is defined");

        Vertex v = Vertex.newVertexFromLibrary(

                GraphUtils.getUniqueVertexIndex(),3,BBType.FRAGMENT,

                fsp.getFragmentSpace());


        assertEquals(2,v.getSymmetricAPSets().size(),

                "Number of symmetric sets of APs");


        Map<APClass,Integer> expectedCount = new HashMap<APClass,Integer>();

        expectedCount.put(APC4, 2);

        expectedCount.put(APC5, 3);

        for (SymmetricAPs ss : v.getSymmetricAPSets())

        {

            APClass apc = ss.get(0).getAPClass();

            assertEquals(expectedCount.get(apc),ss.size(),

                    "Number of APs in symmetric set for APClass "+apc);

        }

    }


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


    @Test

    public void testGetFragsWithAPClass() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");

        ArrayList<IdFragmentAndAP> l = fs.getFragsWithAPClass(APC2);

        assertEquals(4,l.size(),"Wrong size of AP IDs with given APClass.");


        int i = -1;

        for (IdFragmentAndAP id : l)

        {

            i++;

            Vertex v = Vertex.newVertexFromLibrary(-1,

                    id.getVertexMolId(), id.getVertexMolType(), fs);

            assertEquals(APC2, v.getAP(id.getApId()).getAPClass(),

                    "APClass of "+i);

        }

    }


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


    @Test

    public void testGetVerticesWithAPClass() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");

        ArrayList<Vertex> lst = fs.getVerticesWithAPClass(APC2);

        assertEquals(4,lst.size(),"Wrong size of AP IDs with given APClass.");


        for (Vertex v : lst)

        {

            assertTrue( v.getAllAPClasses().contains(APC2));

        }

    }


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


    @Test

    public void testGetVerticesWithAPClasses() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");


        Set<APClass> query = new HashSet<APClass>();

        query.add(APC2);

        query.add(APC1);

        List<Vertex> lst = fs.getVerticesWithAPClasses(query);

        assertEquals(2, lst.size());

        for (APClass apc : query)

        {

            for (Vertex v : lst)

            {

                assertTrue(v.getAllAPClasses().contains(apc));

            }

        }

    }


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


    @Test

    public void testGetVerticesWithAPFingerprint() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");


        // Add vertex to get more results

        Fragment frg1b = new Fragment();

        Atom a1b = new Atom("C", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a2b = new Atom("C", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg1b.addAtom(a1b);

        frg1b.addAtom(a2b);

        frg1b.addBond(new Bond(a1b, a2b));

        frg1b.addAPOnAtom(a1b, APC1, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg1b.addAPOnAtom(a1b, APC1, new Point3d(new double[]{0.0, 0.0, 3.3}));

        frg1b.addAPOnAtom(a2b, APC2, new Point3d(new double[]{0.0, 0.0, 1.1}));

        frg1b.addAPOnAtom(a2b, APC2, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1b.projectAPsToProperties();

        fs.appendVertexToLibrary(frg1b, BBTFRAG, fs.getFragmentLibrary());


        Fragment frg1c = new Fragment();

        Atom a1c = new Atom("C", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a2c = new Atom("C", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg1c.addAtom(a1c);

        frg1c.addAtom(a2c);

        frg1c.addBond(new Bond(a1c, a2c));

        frg1c.addAPOnAtom(a1c, APC1, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg1c.addAPOnAtom(a2c, APC2, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1c.projectAPsToProperties();

        fs.appendVertexToLibrary(frg1c, BBTFRAG, fs.getFragmentLibrary());


        Fragment frg1d = new Fragment();

        Atom a1d = new Atom("C", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a2d = new Atom("C", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg1d.addAtom(a1d);

        frg1d.addAtom(a2d);

        frg1d.addBond(new Bond(a1d, a2d));

        frg1d.addAPOnAtom(a1d, APCS, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg1d.addAPOnAtom(a2d, APC2, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1d.addAPOnAtom(a1d, APC2, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1d.addAPOnAtom(a1d, APC1, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1d.projectAPsToProperties();

        fs.appendVertexToLibrary(frg1d, BBTFRAG, fs.getFragmentLibrary());


        Fragment frg1 = new Fragment();

        Atom a1 = new Atom("C", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a2 = new Atom("C", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg1.addAtom(a1);

        frg1.addAtom(a2);

        frg1.addBond(new Bond(a1, a2));

        frg1.addAPOnAtom(a1, APC1, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg1.addAPOnAtom(a2, APC2, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1.addAPOnAtom(a1, APC2, new Point3d(new double[]{3.0, 0.0, 3.3}));

        frg1.projectAPsToProperties();

        fs.appendVertexToLibrary(frg1, BBTFRAG, fs.getFragmentLibrary());


        Map<APClass,Integer> query = new HashMap<APClass,Integer>();

        query.put(APC2,2);

        query.put(APC1,1);

        List<Vertex> lst = fs.getVerticesWithAPFingerprint(query);

        assertEquals(3, lst.size());


        for (Vertex v : lst)

        {

            for (APClass apc : query.keySet())

            {

                assertTrue(query.get(apc) <= v.getAttachmentPoints().stream()

                        .filter(ap -> ap.getAPClass().equals(apc))

                        .count());

            }

        }

    }


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


    @Test

    public void testGetFragsWithAPClassStartingWith() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");

        List<Vertex> lst = fs.getVerticesWithAPClassStartingWith(

                RULAPC5.substring(0, 4));

        assertEquals(1, lst.size(),"Wrong size of AP IDs with given APClass.");


        int counter = 0;

        for (Vertex v : lst)

        {

            for (APClass apc : v.getAllAPClasses())

            {

                if (apc.toString().startsWith(RULAPC5.substring(0, 4)))

                    counter++;

            }

        }

        assertEquals(2, counter);

    }


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


    @Test

    public void testGetFragAPsCompatibleWithClass() throws Exception

    {


        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");

        ArrayList<IdFragmentAndAP> lst = fs.getFragAPsCompatibleWithClass(APC1);


        assertEquals(4,lst.size(),"Size of compatible APs list is wrong.");


        int i = -1;

        for (IdFragmentAndAP id : lst)

        {

            i++;

            Vertex v = Vertex.newVertexFromLibrary(-1,

                    id.getVertexMolId(), id.getVertexMolType(), fs);

            AttachmentPoint ap = v.getAP(id.getApId());

            assertTrue(APC1.isCPMapCompatibleWith(ap.getAPClass(), fs),

                    "Incompatible choice at "+i);

        }

    }


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


    @Test

    public void testGetFragAPsCompatibleWithTheseAPs() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");

        IdFragmentAndAP src1 = new IdFragmentAndAP(-1,2,BBTFRAG,0,-1,-1);

        IdFragmentAndAP src2 = new IdFragmentAndAP(-1,2,BBTFRAG,1,-1,-1);

        ArrayList<IdFragmentAndAP> srcAPs = new ArrayList<IdFragmentAndAP>();

        srcAPs.add(src1);

        srcAPs.add(src2);

        Vertex src1V = Vertex.newVertexFromLibrary(-1,

                src1.getVertexMolId(), src1.getVertexMolType(), fs);

        APClass src1APC = src1V.getAP(src1.getApId()).getAPClass();

        Vertex src2V = Vertex.newVertexFromLibrary(-1,

                src2.getVertexMolId(), src2.getVertexMolType(), fs);

        APClass src2APC = src2V.getAP(src2.getApId()).getAPClass();


        /*

        System.out.println("SRC1 "+fs.getAPClassForFragment(src1)+" => "

        +fs.getCompatibleAPClasses(fs.getAPClassForFragment(src1)));

        System.out.println("SRC2 "+fs.getAPClassForFragment(src2)+" => "

        +fs.getCompatibleAPClasses(fs.getAPClassForFragment(src2)));

        System.out.println("Frags with SRC1: "+fs.getFragAPsCompatibleWithClass(

                fs.getAPClassForFragment(src1)));

        System.out.println("Frags with SRC2: "+fs.getFragAPsCompatibleWithClass(

                fs.getAPClassForFragment(src2)));

        */


        ArrayList<IdFragmentAndAP> lst = fs.getFragAPsCompatibleWithTheseAPs(

                srcAPs);


        assertEquals(4,lst.size(),"Size of compatible APs list is wrong.");


        int i = -1;

        for (IdFragmentAndAP id : lst)

        {

            i++;

            Vertex v = Vertex.newVertexFromLibrary(-1,

                    id.getVertexMolId(), id.getVertexMolType(), fs);

            AttachmentPoint ap = v.getAP(id.getApId());

            assertTrue(src1APC.isCPMapCompatibleWith(ap.getAPClass(), fs)

                    || src2APC.isCPMapCompatibleWith(ap.getAPClass(), fs),

                    "Incompatible choice at "+i);

        }

    }


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


    @Test

    public void testGetFragmentsCompatibleWithTheseAPs() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        FragmentSpace fs = fsp.getFragmentSpace();

        assertTrue(fs.isDefined(),"FragmentSpace is defined");

        IdFragmentAndAP src1 = new IdFragmentAndAP(-1,2,BBTFRAG,0,-1,-1);

        IdFragmentAndAP src2 = new IdFragmentAndAP(-1,2,BBTFRAG,1,-1,-1);

        ArrayList<IdFragmentAndAP> srcAPs = new ArrayList<IdFragmentAndAP>();

        srcAPs.add(src1);

        srcAPs.add(src2);


        ArrayList<Vertex> lst = fs.getFragmentsCompatibleWithTheseAPs(

                srcAPs);


        assertEquals(3,lst.size(),"Wrong number of compatible fragments.");

    }


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


    @Test

    public void testGetRCVsForAPClass() throws Exception

    {

        APClass rcvP = APClass.RCACLASSPLUS;

        APClass rcvM = APClass.RCACLASSMINUS;


        APClass apcA = APClass.make("A",0);

        APClass apcB = APClass.make("B",0);


        HashMap<APClass,ArrayList<APClass>> cpMap =

                new HashMap<APClass,ArrayList<APClass>>();

        ArrayList<APClass> lstA = new ArrayList<APClass>();

        lstA.add(rcvP);

        cpMap.put(apcA, lstA);

        ArrayList<APClass> lstB = new ArrayList<APClass>();

        lstB.add(rcvP);

        lstB.add(rcvM);

        cpMap.put(apcB, lstB);


        HashMap<APClass,ArrayList<APClass>> rcCPMap =

                new HashMap<APClass,ArrayList<APClass>>();

        ArrayList<APClass> lstC = new ArrayList<APClass>();

        lstC.add(apcB);

        rcCPMap.put(apcA, lstC);


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


        Fragment frg2 = new Fragment();

        Atom a21 = new Atom("N", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a22 = new Atom("H", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg2.addAtom(a21);

        frg2.addAtom(a22);

        frg2.addBond(new Bond(a21, a22));

        frg2.addAP(1, apcB, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg2.addAP(1, apcA, new Point3d(new double[]{0.0, 0.0, 3.3}));

        fragments.add(frg2);


        Fragment rcv1 = new Fragment();

        Atom at1 = new PseudoAtom(RingClosingAttractor.RCALABELPERAPCLASS.get(rcvP),

                new Point3d());

        rcv1.addAtom(at1);

        rcv1.addAP(0, rcvP, new Point3d(1.0, 0, 0));

        rcv1.setAsRCV(true);

        fragments.add(rcv1);


        Fragment rcv2 = new Fragment();

        Atom at2 = new PseudoAtom(RingClosingAttractor.RCALABELPERAPCLASS.get(rcvM),

                new Point3d());

        rcv2.addAtom(at2);

        rcv2.addAP(0, rcvM, new Point3d(-1.0, 0, 0));

        rcv2.setAsRCV(true);

        fragments.add(rcv2);


        Fragment rcv3 = new Fragment();

        Atom at3 = new PseudoAtom(RingClosingAttractor.RCALABELPERAPCLASS.get(rcvM),

                new Point3d());

        rcv3.addAtom(at3);

        rcv3.addAP(0, rcvM, new Point3d(-2.0, 0, 0));

        rcv3.setAsRCV(true);

        fragments.add(rcv3);


        HashMap<APClass,APClass> capMap = new HashMap<APClass,APClass>();

        HashSet<APClass> forbEnds = new HashSet<APClass>();


        FragmentSpaceParameters fsp = new FragmentSpaceParameters();

        FragmentSpace fs = new FragmentSpace(fsp,

                new ArrayList<Vertex>(), // scaffolds

                fragments,

                new ArrayList<Vertex>(), // caps

                cpMap, capMap, forbEnds, cpMap);

        fs.setAPclassBasedApproach(true);


        List<Vertex> rcvs1 = fs.getRCVsForAPClass(apcA);

        assertEquals(1, rcvs1.size());

        assertEquals(rcvP, rcvs1.get(0).getAP(0).getAPClass());

        List<Vertex> rcvs2 = fs.getRCVsForAPClass(apcB);

        assertEquals(3, rcvs2.size());

        int countP = 0;

        int countM = 0;

        for (Vertex rcv : rcvs2)

        {

            if (rcvP == rcv.getAP(0).getAPClass())

                countP++;

            else

                countM++;

        }

        assertEquals(1, countP);

        assertEquals(2, countM);

        List<Vertex> rcvs3 = fs.getRCVsForAPClass(APClass.make("C",0));

        assertEquals(0, rcvs3.size());

    }


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


    @Test

    public void testGetRCVsWithAPClass() throws Exception

    {

        APClass rcvP = APClass.RCACLASSPLUS;

        APClass rcvM = APClass.RCACLASSMINUS;


        APClass apcA = APClass.make("A",0);

        APClass apcB = APClass.make("B",0);


        HashMap<APClass,ArrayList<APClass>> cpMap =

                new HashMap<APClass,ArrayList<APClass>>();

        ArrayList<APClass> lstA = new ArrayList<APClass>();

        lstA.add(rcvP);

        cpMap.put(apcA, lstA);

        ArrayList<APClass> lstB = new ArrayList<APClass>();

        lstB.add(rcvP);

        lstB.add(rcvM);

        cpMap.put(apcB, lstB);


        HashMap<APClass,ArrayList<APClass>> rcCPMap =

                new HashMap<APClass,ArrayList<APClass>>();

        ArrayList<APClass> lstC = new ArrayList<APClass>();

        lstC.add(apcB);

        rcCPMap.put(apcA, lstC);


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


        Fragment frg2 = new Fragment();

        Atom a21 = new Atom("N", new Point3d(new double[]{0.0, 1.1, 2.2}));

        Atom a22 = new Atom("H", new Point3d(new double[]{1.0, 1.1, 2.2}));

        frg2.addAtom(a21);

        frg2.addAtom(a22);

        frg2.addBond(new Bond(a21, a22));

        frg2.addAP(1, apcB, new Point3d(new double[]{0.0, 2.2, 3.3}));

        frg2.addAP(1, apcA, new Point3d(new double[]{0.0, 0.0, 3.3}));

        fragments.add(frg2);


        Fragment rcv1 = new Fragment();

        Atom at1 = new PseudoAtom(RingClosingAttractor.RCALABELPERAPCLASS.get(rcvP),

                new Point3d());

        rcv1.addAtom(at1);

        rcv1.addAP(0, rcvP, new Point3d(1.0, 0, 0));

        rcv1.setAsRCV(true);

        fragments.add(rcv1);


        Fragment rcv2 = new Fragment();

        Atom at2 = new PseudoAtom(RingClosingAttractor.RCALABELPERAPCLASS.get(rcvM),

                new Point3d());

        rcv2.addAtom(at2);

        rcv2.addAP(0, rcvM, new Point3d(-1.0, 0, 0));

        rcv2.setAsRCV(true);

        fragments.add(rcv2);


        HashMap<APClass,APClass> capMap = new HashMap<APClass,APClass>();

        HashSet<APClass> forbEnds = new HashSet<APClass>();


        FragmentSpaceParameters fsp = new FragmentSpaceParameters();

        FragmentSpace fs = new FragmentSpace(fsp,

                new ArrayList<Vertex>(), // scaffolds

                fragments,

                new ArrayList<Vertex>(), // caps

                cpMap, capMap, forbEnds, cpMap);

        fs.setAPclassBasedApproach(true);


        List<Vertex> rcvs1 = fs.getRCVsWithAPClass(rcvP);

        assertEquals(1, rcvs1.size());

        assertTrue(rcv1.sameAs(rcvs1.get(0)));


        List<Vertex> rcvs2 = fs.getRCVsWithAPClass(rcvM);

        assertEquals(1, rcvs2.size());

        assertTrue(rcv2.sameAs(rcvs2.get(0)));

    }


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


    @Test

    public void testFusedRingAddedToFragmentLibrary() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        fsp.fragmentLibFile = "dummyFilename_DenoptimTest_Frag";

        fsp.scaffoldLibFile = "dummyFilename_DenoptimTest_Scaff";

        FragmentSpace fs = fsp.getFragmentSpace();


        TestCase testCase = getTestCase();


        List<Vertex> fragLib = fs.getFragmentLibrary();

        fragLib.clear();


        fs.addFusedRingsToFragmentLibrary(testCase.graph);


        //Cleanup tmp files

        FileUtils.deleteFile(fsp.getPathnameToAppendedFragments());

        FileUtils.deleteFile(fsp.getPathnameToAppendedScaffolds());


        assertEquals(1, fragLib.size());

        Vertex actual = fragLib.get(0);

        StringBuilder sb = new StringBuilder();

        assertTrue(testCase.expected.sameAs(actual, sb),

                "Problem is "+sb.toString());

    }


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


    @Test

    public void testFusedRingAddedToScaffoldLibrary() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        fsp.fragmentLibFile = "dummyFilename_DenoptimTest_Frag";

        fsp.scaffoldLibFile = "dummyFilename_DenoptimTest_Scaff";

        FragmentSpace fs = fsp.getFragmentSpace();

        TestCase testCase = getTestCase();

        testCase.graph.getVertexList().get(0)

                .setBuildingBlockType(BBType.SCAFFOLD);

        testCase.expected.setBuildingBlockType(BBType.SCAFFOLD);

        testCase.expected.getInnerGraph().getVertexList().get(0)

                .setBuildingBlockType(BBType.SCAFFOLD);


        List<Vertex> scaffLib = fs.getScaffoldLibrary();

        scaffLib.clear();


        fs.addFusedRingsToFragmentLibrary(testCase.graph);


        //Cleanup tmp files

        FileUtils.deleteFile(fsp.getPathnameToAppendedFragments());

        FileUtils.deleteFile(fsp.getPathnameToAppendedScaffolds());


        assertEquals(1, scaffLib.size());

        Vertex actual = scaffLib.get(0);

        assertTrue(testCase.expected.sameAs(actual, new StringBuilder()));

    }


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


    @Test

    public void testFusedRingOnlyAddedOnce() throws DENOPTIMException

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        fsp.fragmentLibFile = "dummyFilename_DenoptimTest_Frag";

        fsp.scaffoldLibFile = "dummyFilename_DenoptimTest_Scaff";

        FragmentSpace fs = fsp.getFragmentSpace();

        TestCase testCase = getTestCase();

        final int TRY_ADDING = 10;

        List<DGraph> sameGraphs = IntStream

                .range(0, TRY_ADDING)

                .mapToObj(i -> testCase.graph.clone())

                .peek(t -> t.renumberGraphVertices())

                .collect(Collectors.toList());


        List<Vertex> fragLib = fs.getFragmentLibrary();

        fragLib.clear();


        for (DGraph g : sameGraphs) {

            fs.addFusedRingsToFragmentLibrary(g);

        }


        //Cleanup tmp files

        FileUtils.deleteFile(fsp.getPathnameToAppendedFragments());

        FileUtils.deleteFile(fsp.getPathnameToAppendedScaffolds());


        assertEquals(1, fragLib.size());

    }


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


    private TestCase getTestCase() throws DENOPTIMException

    {

        DGraph g = new DGraph();

        Vertex c1 = getCarbonVertex(), c2 = getCarbonVertex(),

                c3 = getCarbonVertex(), c4 = getCarbonVertex(),

                c5 = getCarbonVertex();


        Vertex rcv14 = getRCV(), rcv41 = getRCV(), rcv45 = getRCV(),

                rcv54 = getRCV();


        g.addVertex(c1);

        g.appendVertexOnAP(c1.getAP(0), c2.getAP(0));

        g.appendVertexOnAP(c1.getAP(1), rcv14.getAP(0));

        g.appendVertexOnAP(c2.getAP(1), c3.getAP(0));

        g.appendVertexOnAP(c2.getAP(2), c5.getAP(0));

        g.appendVertexOnAP(c2.getAP(3), c4.getAP(0));

        g.appendVertexOnAP(c4.getAP(1), rcv41.getAP(0));

        g.appendVertexOnAP(c4.getAP(2), rcv45.getAP(0));

        g.appendVertexOnAP(c5.getAP(1), rcv54.getAP(0));


        Ring r124 = new Ring(Arrays.asList(rcv14, c1, c2, c4,

                rcv41));

        Ring r425 = new Ring(Arrays.asList(rcv45, c4, c2, c5,

                rcv54));

        g.addRing(r124);

        g.addRing(r425);


        g.renumberGraphVertices();


        Template t = getExpectedTemplate(g, c3);


        return new TestCase(g, t);

    }


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


    private Template getExpectedTemplate(DGraph g,

            Vertex c3) throws DENOPTIMException {

        DGraph innerGraph = g.clone();

        innerGraph.renumberGraphVertices();

        Vertex c3Inner = innerGraph.getVertexAtPosition(g

                .indexOfVertexWithID(c3.getVertexId()));

        innerGraph.removeVertex(c3Inner);


        Template t = new Template(BBType.FRAGMENT);

        t.setInnerGraph(innerGraph);

        t.setBuildingBlockId(0);

        return t;

    }


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


    private Fragment getCarbonVertex() throws DENOPTIMException

    {

        IChemObjectBuilder builder = DefaultChemObjectBuilder.getInstance();

        IAtom carbon = builder.newAtom();

        carbon.setSymbol("C");

        IAtomContainer mol = builder.newAtomContainer();

        mol.addAtom(carbon);

        Fragment v = new Fragment(

                GraphUtils.getUniqueVertexIndex(),

                mol,

                BBType.FRAGMENT);

        for (int i = 0; i < 4; i++) {

            v.addAP(0, APC1, getRandomVector());

        }

        return v;

    }


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


    private Vertex getRCV() throws DENOPTIMException

    {

        IChemObjectBuilder builder = DefaultChemObjectBuilder

                .getInstance();

        IAtomContainer dummyMol = builder.newAtomContainer();

        IAtom dummyAtom = builder.newAtom();

        dummyMol.addAtom(dummyAtom);

        Fragment rcv = new Fragment(

                GraphUtils.getUniqueVertexIndex(),

                dummyMol,

                BBType.FRAGMENT,

                true);

        rcv.addAP(0, APC1, getRandomVector());

        return rcv;

    }


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


    private Point3d getRandomVector() {

        int precision = 10 * 10 * 10 * 10;


        Supplier<Double> randomCoord = () ->

                (double) (Math.round(rng.nextDouble() * (double) precision)) /

                        ((double) precision);


        return new Point3d(randomCoord.get(), randomCoord.get(),

                randomCoord.get());

    }


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


    private static final class TestCase {

        final DGraph graph;

        final Template expected;


        TestCase(DGraph g, Template expected) {

            this.graph = g;

            this.expected = expected;

        }

    }


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


    @Test

    public void testUseWholeMolGeometryForExtractedTemplates() throws Exception

    {

        FragmentSpaceParameters fsp = buildFragmentSpace();

        fsp.fragmentLibFile = "dummyFilename_DenoptimTest_Frag";

        fsp.scaffoldLibFile = "dummyFilename_DenoptimTest_Scaff";

        FragmentSpace fs = fsp.getFragmentSpace();

        Fragment scaf = new Fragment();

        IAtom s1 = new Atom("C", new Point3d(0,0,0));

        scaf.addAtom(s1);

        scaf.addAPOnAtom(s1, APC2, new Point3d(1,1,0));

        scaf.addAPOnAtom(s1, APC3, new Point3d(1,-1,0));

        scaf.addAPOnAtom(s1, APC4, new Point3d(-1,-1,0));

        scaf.projectAPsToProperties();


        fs.appendVertexToLibrary(scaf, BBType.SCAFFOLD, fs.getScaffoldLibrary());

        int sId = fs.getScaffoldLibrary().size() - 1;


        Fragment frg = new Fragment();

        IAtom a1 = new Atom("C", new Point3d(0,0,0));

        IAtom a2 = new Atom("C", new Point3d(0,0,1));

        IAtom a3 = new Atom("C", new Point3d(0,0,2));

        frg.addAtom(a1);

        frg.addAtom(a2);

        frg.addAtom(a3);

        frg.addBond(new Bond(a1, a2));

        frg.addBond(new Bond(a2, a3));

        frg.addAPOnAtom(a1, APC2, new Point3d(1,1,2));

        frg.addAPOnAtom(a2, APC3, new Point3d(1,-1,0));

        frg.addAPOnAtom(a3, APC4, new Point3d(-1,-1,0));

        frg.projectAPsToProperties();


        fs.appendVertexToLibrary(frg, BBTFRAG, fs.getFragmentLibrary());

        int bbId = fs.getFragmentLibrary().size() - 1;


        Fragment rcv = new Fragment();

        IAtom a4 = new PseudoAtom("ATN", new Point3d(0,0,0));

        rcv.addAtom(a4);

        rcv.addAPOnAtom(a4, APClass.make("ATneutral",0), new Point3d(1,0,0));

        rcv.projectAPsToProperties();

        rcv.setAsRCV(true);


        fs.appendVertexToLibrary(rcv, BBTFRAG, fs.getFragmentLibrary());

        int rcvId = fs.getFragmentLibrary().size() - 1;


        DGraph wholeGraph = new DGraph();

        Vertex v1 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v2 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v3 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v4 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v5 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v6 = fs.getVertexFromLibrary(BBType.SCAFFOLD,sId);

        Vertex v7 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v8 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v9 = fs.getVertexFromLibrary(BBTFRAG, bbId);

        Vertex v10 = fs.getVertexFromLibrary(BBTFRAG, rcvId);

        Vertex v11 = fs.getVertexFromLibrary(BBTFRAG, rcvId);

        Vertex v12 = fs.getVertexFromLibrary(BBTFRAG, rcvId);

        Vertex v13 = fs.getVertexFromLibrary(BBTFRAG, rcvId);

        Vertex c1 = fs.getVertexFromLibrary(BBType.CAP, 0);

        Vertex c2 = fs.getVertexFromLibrary(BBType.CAP, 0);

        Vertex c3 = fs.getVertexFromLibrary(BBType.CAP, 0);

        Vertex c4 = fs.getVertexFromLibrary(BBType.CAP, 0);


        // Disordered... just for the fun of it. Still, do not change it further

        // as we need to wholeMol to be created consistently

        wholeGraph.addVertex(v7);

        wholeGraph.addVertex(v8);

        wholeGraph.addVertex(v9);

        wholeGraph.addVertex(v6);

        wholeGraph.addVertex(v1);

        wholeGraph.addVertex(v2);

        wholeGraph.addVertex(v3);

        wholeGraph.addVertex(v4);

        wholeGraph.addVertex(v5);

        wholeGraph.addVertex(v10);

        wholeGraph.addVertex(v11);

        wholeGraph.addVertex(v12);

        wholeGraph.addVertex(v13);

        wholeGraph.addVertex(c1);

        wholeGraph.addVertex(c2);

        wholeGraph.addVertex(c3);

        wholeGraph.addVertex(c4);

        wholeGraph.addEdge(new Edge(v6.getAP(0),v4.getAP(1),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v6.getAP(1),v10.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v4.getAP(0),v2.getAP(1),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v2.getAP(0),v3.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v3.getAP(1),v11.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v2.getAP(2),v1.getAP(2),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v6.getAP(2),v9.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v9.getAP(1),v5.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v5.getAP(1),v7.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v5.getAP(2),v8.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v7.getAP(1),v12.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v8.getAP(2),v13.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v3.getAP(2),c1.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v4.getAP(2),c2.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v7.getAP(2),c3.getAP(0),BondType.SINGLE));

        wholeGraph.addEdge(new Edge(v8.getAP(1),c4.getAP(0),BondType.SINGLE));


        wholeGraph.addRing(v10, v11, BondType.DOUBLE);

        wholeGraph.addRing(v12, v13, BondType.DOUBLE);


        ThreeDimTreeBuilder tb3d = new ThreeDimTreeBuilder(fsp.getLogger(),

                fsp.getRandomizer());

        IAtomContainer wholeMol = tb3d.convertGraphTo3DAtomContainer(

                wholeGraph.clone(), true);


        double r = 10;

        for (int i=0; i<wholeMol.getAtomCount(); i++)

        {

            IAtom atm = wholeMol.getAtom(i);

            if (atm instanceof PseudoAtom)

                ((PseudoAtom) atm).setLabel("Du");

            else

                atm.setSymbol("P");

            atm.setPoint3d(new Point3d(r*Math.cos(Math.toRadians(360/34 * i)),

                    r*Math.sin(Math.toRadians(360/34 * i)),0));

        }


        int szScafLibPre = fs.getScaffoldLibrary().size();

        int szFragLibPre = fs.getFragmentLibrary().size();


        String scafFile = tempDir.getAbsolutePath() + SEP + "newScaf.sdf";

        String fragFile = tempDir.getAbsolutePath() + SEP + "newFrag.sdf";

        fsp.scaffoldLibFile = scafFile;

        fsp.fragmentLibFile = fragFile;


        fs.addFusedRingsToFragmentLibrary(wholeGraph, true, true, wholeMol);


        // NB: in here there is cloning of template with mol representation

        assertEquals(szScafLibPre+1,fs.getScaffoldLibrary().size(),

                "Size scaffolds library");

        assertEquals(szFragLibPre+1,fs.getFragmentLibrary().size(),

                "Size fragments library");


        Vertex newScaff = fs.getVertexFromLibrary(

                BBType.SCAFFOLD,szScafLibPre); // szScafLibPre+1-1

        assertEquals(4,newScaff.getAttachmentPoints().size(),

                "#APs on new scaffold");

        int nP = 0;

        for (IAtom a : newScaff.getIAtomContainer().atoms())

        {

            if ("P".equals(MoleculeUtils.getSymbolOrLabel(a)))

                nP++;

        }

        assertEquals(10,nP,"#P in new scaffold");


        Vertex newFrag = fs.getVertexFromLibrary(

                BBType.FRAGMENT,szFragLibPre); // szFragLibPre+1-1

        assertEquals(3,newFrag.getAttachmentPoints().size(),

                "#APs on new fragment");

        nP = 0;

        for (IAtom a : newFrag.getIAtomContainer().atoms())

        {

            if ("P".equals(MoleculeUtils.getSymbolOrLabel(a)))

                nP++;

        }

        assertEquals(9,nP,"#P in new fragment");


        //Cleanup tmp files

        FileUtils.deleteFile(fsp.getPathnameToAppendedFragments());

        FileUtils.deleteFile(fsp.getPathnameToAppendedScaffolds());

    }


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

}

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

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

denoptim.files.FileUtils.deleteFile
static void deleteFile(String fileName)
Delete the file.
Definition: FileUtils.java:256

denoptim.fragspace.FragmentSpace
Class defining a space of building blocks.
Definition: FragmentSpace.java:68

denoptim.fragspace.FragmentSpace.getFragmentsCompatibleWithTheseAPs
ArrayList< Vertex > getFragmentsCompatibleWithTheseAPs(ArrayList< IdFragmentAndAP > srcAPs)
Searches for all building blocks that are compatible with the given list of APs.
Definition: FragmentSpace.java:1133

denoptim.fragspace.FragmentSpace.appendVertexToLibrary
void appendVertexToLibrary(Vertex v, Vertex.BBType bbt, ArrayList< Vertex > library)
Takes a vertex and add it to a given library.
Definition: FragmentSpace.java:1597

denoptim.fragspace.FragmentSpace.getFragAPsCompatibleWithTheseAPs
ArrayList< IdFragmentAndAP > getFragAPsCompatibleWithTheseAPs(ArrayList< IdFragmentAndAP > srcAPs)
Searches for all APs that are compatible with the given list of APs.
Definition: FragmentSpace.java:1298

denoptim.fragspace.FragmentSpace.isDefined
boolean isDefined()
Checks for valid definition of this fragment space.
Definition: FragmentSpace.java:451

denoptim.fragspace.FragmentSpace.getVertexFromLibrary
Vertex getVertexFromLibrary(Vertex.BBType bbType, int bbIdx)
Returns a clone of the requested building block.
Definition: FragmentSpace.java:539

denoptim.fragspace.FragmentSpace.setAPclassBasedApproach
void setAPclassBasedApproach(boolean useAPC)
Set the fragment space to behave according to APClass-based approach.
Definition: FragmentSpace.java:473

denoptim.fragspace.FragmentSpace.getFragsWithAPClass
ArrayList< IdFragmentAndAP > getFragsWithAPClass(APClass apc)
Returns the list of attachment points with the given class.
Definition: FragmentSpace.java:975

denoptim.fragspace.FragmentSpace.getVerticesWithAPClassStartingWith
List< Vertex > getVerticesWithAPClassStartingWith(String root)
Extracts vertexes from the collection of vertexes defined by this FragmentSpace.
Definition: FragmentSpace.java:1103

denoptim.fragspace.FragmentSpace.getRCVsWithAPClass
List< Vertex > getRCVsWithAPClass(APClass apc)
Searches for all building blocks that are ring-closing vertexes and hold an AP with the given class.
Definition: FragmentSpace.java:1172

denoptim.fragspace.FragmentSpace.getFragAPsCompatibleWithClass
ArrayList< IdFragmentAndAP > getFragAPsCompatibleWithClass(APClass aPC1)
Returns the list of attachment points found in the fragment space and that are compatible with a give...
Definition: FragmentSpace.java:1398

denoptim.fragspace.FragmentSpace.addFusedRingsToFragmentLibrary
void addFusedRingsToFragmentLibrary(DGraph graph)
Extracts a system of one or more fused rings and adds them to the fragment space if not already prese...
Definition: FragmentSpace.java:1629

denoptim.fragspace.FragmentSpace.getVerticesWithAPClass
ArrayList< Vertex > getVerticesWithAPClass(APClass apc)
Returns the list of vertexes with attachment points of the given class.
Definition: FragmentSpace.java:1005

denoptim.fragspace.FragmentSpace.getVerticesWithAPClasses
List< Vertex > getVerticesWithAPClasses(Set< APClass > apcs)
Returns the list of vertexes with at least one attachment point of each of the given classes.
Definition: FragmentSpace.java:1032

denoptim.fragspace.FragmentSpace.getScaffoldLibrary
ArrayList< Vertex > getScaffoldLibrary()
Definition: FragmentSpace.java:733

denoptim.fragspace.FragmentSpace.getFragmentLibrary
ArrayList< Vertex > getFragmentLibrary()
Definition: FragmentSpace.java:740

denoptim.fragspace.FragmentSpace.getRCVsForAPClass
List< Vertex > getRCVsForAPClass(APClass apc)
Searches for all building blocks that are ring-closing vertexes and are compatible with the given AP.
Definition: FragmentSpace.java:1207

denoptim.fragspace.FragmentSpace.getVerticesWithAPFingerprint
List< Vertex > getVerticesWithAPFingerprint(Map< APClass, Integer > apcCounts)
Returns the list of vertexes that have the specified number of AttachmentPoints with the given APClas...
Definition: FragmentSpace.java:1070

denoptim.fragspace.FragmentSpaceParameters
Parameters defining the fragment space.
Definition: FragmentSpaceParameters.java:39

denoptim.fragspace.FragmentSpaceParameters.getPathnameToAppendedFragments
String getPathnameToAppendedFragments()
Definition: FragmentSpaceParameters.java:187

denoptim.fragspace.FragmentSpaceParameters.getFragmentSpace
FragmentSpace getFragmentSpace()
Definition: FragmentSpaceParameters.java:203

denoptim.fragspace.FragmentSpaceParameters.getPathnameToAppendedScaffolds
String getPathnameToAppendedScaffolds()
Definition: FragmentSpaceParameters.java:195

denoptim.fragspace.FragmentSpaceTest.TestCase
Definition: FragmentSpaceTest.java:942

denoptim.fragspace.FragmentSpaceTest.TestCase.graph
final DGraph graph
Definition: FragmentSpaceTest.java:943

denoptim.fragspace.FragmentSpaceTest.TestCase.expected
final Template expected
Definition: FragmentSpaceTest.java:944

denoptim.fragspace.FragmentSpaceTest.TestCase.TestCase
TestCase(DGraph g, Template expected)
Definition: FragmentSpaceTest.java:946

denoptim.fragspace.FragmentSpaceTest
Unit test for fragment space.
Definition: FragmentSpaceTest.java:75

denoptim.fragspace.FragmentSpaceTest.testGetVerticesWithAPClasses
void testGetVerticesWithAPClasses()
Definition: FragmentSpaceTest.java:341

denoptim.fragspace.FragmentSpaceTest.testGetFragAPsCompatibleWithTheseAPs
void testGetFragAPsCompatibleWithTheseAPs()
Definition: FragmentSpaceTest.java:489

denoptim.fragspace.FragmentSpaceTest.testGetVerticesWithAPClass
void testGetVerticesWithAPClass()
Definition: FragmentSpaceTest.java:324

denoptim.fragspace.FragmentSpaceTest.RULAPCS
static final String RULAPCS
Definition: FragmentSpaceTest.java:85

denoptim.fragspace.FragmentSpaceTest.testGetRCVsForAPClass
void testGetRCVsForAPClass()
Definition: FragmentSpaceTest.java:559

denoptim.fragspace.FragmentSpaceTest.APCC2
static APClass APCC2
Definition: FragmentSpaceTest.java:105

denoptim.fragspace.FragmentSpaceTest.RULAPC4
static final String RULAPC4
Definition: FragmentSpaceTest.java:89

denoptim.fragspace.FragmentSpaceTest.RULAPC1
static final String RULAPC1
Definition: FragmentSpaceTest.java:86

denoptim.fragspace.FragmentSpaceTest.testFusedRingAddedToScaffoldLibrary
void testFusedRingAddedToScaffoldLibrary()
Checks that a graph with a fused ring containing a scaffold vertex is added to the scaffold library.
Definition: FragmentSpaceTest.java:771

denoptim.fragspace.FragmentSpaceTest.testUseWholeMolGeometryForExtractedTemplates
void testUseWholeMolGeometryForExtractedTemplates()
Works with this graph:
Definition: FragmentSpaceTest.java:977

denoptim.fragspace.FragmentSpaceTest.testFusedRingAddedToFragmentLibrary
void testFusedRingAddedToFragmentLibrary()
Check that the following graph's fused ring gets added to the fragment library.
Definition: FragmentSpaceTest.java:738

denoptim.fragspace.FragmentSpaceTest.testGetFragsWithAPClass
void testGetFragsWithAPClass()
Definition: FragmentSpaceTest.java:302

denoptim.fragspace.FragmentSpaceTest.testFusedRingOnlyAddedOnce
void testFusedRingOnlyAddedOnce()
Definition: FragmentSpaceTest.java:801

denoptim.fragspace.FragmentSpaceTest.APC6
static APClass APC6
Definition: FragmentSpaceTest.java:103

denoptim.fragspace.FragmentSpaceTest.rng
final Random rng
Definition: FragmentSpaceTest.java:81

denoptim.fragspace.FragmentSpaceTest.RULAPC3
static final String RULAPC3
Definition: FragmentSpaceTest.java:88

denoptim.fragspace.FragmentSpaceTest.RULAPCC1
static final String RULAPCC1
Definition: FragmentSpaceTest.java:92

denoptim.fragspace.FragmentSpaceTest.getRCV
Vertex getRCV()
Definition: FragmentSpaceTest.java:911

denoptim.fragspace.FragmentSpaceTest.getTestCase
TestCase getTestCase()
Definition: FragmentSpaceTest.java:840

denoptim.fragspace.FragmentSpaceTest.BBTFRAG
static final BBType BBTFRAG
Definition: FragmentSpaceTest.java:95

denoptim.fragspace.FragmentSpaceTest.getCarbonVertex
Fragment getCarbonVertex()
Definition: FragmentSpaceTest.java:892

denoptim.fragspace.FragmentSpaceTest.RULAPCC2
static final String RULAPCC2
Definition: FragmentSpaceTest.java:93

denoptim.fragspace.FragmentSpaceTest.RULAPC6
static final String RULAPC6
Definition: FragmentSpaceTest.java:91

denoptim.fragspace.FragmentSpaceTest.testSymmetry
void testSymmetry()
Definition: FragmentSpaceTest.java:277

denoptim.fragspace.FragmentSpaceTest.APC4
static APClass APC4
Definition: FragmentSpaceTest.java:101

denoptim.fragspace.FragmentSpaceTest.testGetFragsWithAPClassStartingWith
void testGetFragsWithAPClassStartingWith()
Definition: FragmentSpaceTest.java:440

denoptim.fragspace.FragmentSpaceTest.testGetFragmentsCompatibleWithTheseAPs
void testGetFragmentsCompatibleWithTheseAPs()
Definition: FragmentSpaceTest.java:539

denoptim.fragspace.FragmentSpaceTest.getRandomVector
Point3d getRandomVector()
Definition: FragmentSpaceTest.java:929

denoptim.fragspace.FragmentSpaceTest.APC1
static APClass APC1
Definition: FragmentSpaceTest.java:98

denoptim.fragspace.FragmentSpaceTest.SEP
static final String SEP
Definition: FragmentSpaceTest.java:76

denoptim.fragspace.FragmentSpaceTest.testGetRCVsWithAPClass
void testGetRCVsWithAPClass()
Definition: FragmentSpaceTest.java:653

denoptim.fragspace.FragmentSpaceTest.RULAPC5
static final String RULAPC5
Definition: FragmentSpaceTest.java:90

denoptim.fragspace.FragmentSpaceTest.APSUBRULE
static final int APSUBRULE
Definition: FragmentSpaceTest.java:83

denoptim.fragspace.FragmentSpaceTest.testGetVerticesWithAPFingerprint
void testGetVerticesWithAPFingerprint()
Definition: FragmentSpaceTest.java:364

denoptim.fragspace.FragmentSpaceTest.tempDir
static File tempDir
Definition: FragmentSpaceTest.java:79

denoptim.fragspace.FragmentSpaceTest.APC5
static APClass APC5
Definition: FragmentSpaceTest.java:102

denoptim.fragspace.FragmentSpaceTest.APCC1
static APClass APCC1
Definition: FragmentSpaceTest.java:104

denoptim.fragspace.FragmentSpaceTest.buildFragmentSpace
FragmentSpaceParameters buildFragmentSpace()
Definition: FragmentSpaceTest.java:109

denoptim.fragspace.FragmentSpaceTest.APC2
static APClass APC2
Definition: FragmentSpaceTest.java:99

denoptim.fragspace.FragmentSpaceTest.testGetFragAPsCompatibleWithClass
void testGetFragAPsCompatibleWithClass()
Definition: FragmentSpaceTest.java:464

denoptim.fragspace.FragmentSpaceTest.getExpectedTemplate
Template getExpectedTemplate(DGraph g, Vertex c3)
Definition: FragmentSpaceTest.java:876

denoptim.fragspace.FragmentSpaceTest.APCS
static APClass APCS
Definition: FragmentSpaceTest.java:97

denoptim.fragspace.FragmentSpaceTest.APC3
static APClass APC3
Definition: FragmentSpaceTest.java:100

denoptim.fragspace.FragmentSpaceTest.RULAPC2
static final String RULAPC2
Definition: FragmentSpaceTest.java:87

denoptim.fragspace.IdFragmentAndAP
Data structure containing information that identifies a single AP of a vertex/fragment.
Definition: IdFragmentAndAP.java:33

denoptim.fragspace.IdFragmentAndAP.getVertexMolType
BBType getVertexMolType()
Definition: IdFragmentAndAP.java:99

denoptim.fragspace.IdFragmentAndAP.getVertexMolId
int getVertexMolId()
Definition: IdFragmentAndAP.java:92

denoptim.fragspace.IdFragmentAndAP.getApId
int getApId()
Definition: IdFragmentAndAP.java:106

denoptim.graph.APClass
Definition: APClass.java:42

denoptim.graph.APClass.isCPMapCompatibleWith
boolean isCPMapCompatibleWith(APClass other, FragmentSpace fragSpace)
Check compatibility as defined in the compatibility matrix considering this AP as source and the othe...
Definition: APClass.java:483

denoptim.graph.APClass.RCACLASSPLUS
static final APClass RCACLASSPLUS
Conventional class of attachment points on ring-closing vertexes.
Definition: APClass.java:85

denoptim.graph.APClass.RCACLASSMINUS
static final APClass RCACLASSMINUS
Conventional class of attachment points on ring-closing vertexes.
Definition: APClass.java:92

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:164

denoptim.graph.AttachmentPoint
An attachment point (AP) is a possibility to attach a Vertex onto the vertex holding the AP (i....
Definition: AttachmentPoint.java:53

denoptim.graph.AttachmentPoint.getAPClass
APClass getAPClass()
Returns the Attachment Point class.
Definition: AttachmentPoint.java:447

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

denoptim.graph.DGraph.addVertex
void addVertex(Vertex vertex)
Appends a vertex to this graph without creating any edge.
Definition: DGraph.java:1325

denoptim.graph.DGraph.removeVertex
void removeVertex(Vertex vertex)
Remove a vertex from this graph.
Definition: DGraph.java:1347

denoptim.graph.DGraph.getVertexAtPosition
Vertex getVertexAtPosition(int pos)
Returns the vertex that is in the given position of the list of vertices belonging to this graph.
Definition: DGraph.java:2743

denoptim.graph.DGraph.appendVertexOnAP
void appendVertexOnAP(AttachmentPoint srcAP, AttachmentPoint trgAP)
Append a vertex to this graph: adds the new vertex to the list of vertices belonging to the graph,...
Definition: DGraph.java:6005

denoptim.graph.DGraph.getVertexList
List< Vertex > getVertexList()
Definition: DGraph.java:947

denoptim.graph.DGraph.clone
DGraph clone()
Returns almost "deep-copy" of this graph.
Definition: DGraph.java:3415

denoptim.graph.DGraph.renumberGraphVertices
void renumberGraphVertices()
Reassign vertex IDs to all vertices of this graph.
Definition: DGraph.java:5512

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

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

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

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.addAP
void addAP(int atomPositionNumber)
Adds an attachment point with a dummy APClass.
Definition: Fragment.java:343

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.addBond
void addBond(IBond bond)
Definition: Fragment.java:871

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

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.Ring
This class represents the closure of a ring in a spanning tree.
Definition: Ring.java:40

denoptim.graph.SymmetricAPs
A collection of AttachmentPoints that are related by a relation that we call "symmetry",...
Definition: SymmetricAPs.java:21

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

denoptim.graph.Template.setInnerGraph
void setInnerGraph(DGraph innerGraph)
Definition: Template.java:298

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

denoptim.graph.Template.getInnerGraph
DGraph getInnerGraph()
Definition: Template.java:291

denoptim.graph.Vertex
A vertex is a data structure that has an identity and holds a list of AttachmentPoints.
Definition: Vertex.java:62

denoptim.graph.Vertex.setAsRCV
void setAsRCV(boolean isRCV)
Definition: Vertex.java:275

denoptim.graph.Vertex.getAttachmentPoints
abstract List< AttachmentPoint > getAttachmentPoints()

denoptim.graph.Vertex.setBuildingBlockId
void setBuildingBlockId(int buildingBlockId)
Definition: Vertex.java:312

denoptim.graph.Vertex.getSymmetricAPSets
abstract List< SymmetricAPs > getSymmetricAPSets()

denoptim.graph.Vertex.setBuildingBlockType
void setBuildingBlockType(Vertex.BBType buildingBlockType)
Definition: Vertex.java:326

denoptim.graph.Vertex.getIAtomContainer
abstract IAtomContainer getIAtomContainer()

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

denoptim.graph.Vertex.newVertexFromLibrary
static Vertex newVertexFromLibrary(int bbId, Vertex.BBType bbt, FragmentSpace fragSpace)
Builds a new molecular fragment kind of vertex.
Definition: Vertex.java:215

denoptim.graph.rings.RingClosingAttractor
The RingClosingAttractor represent the available valence/connection that allows to close a ring.
Definition: RingClosingAttractor.java:49

denoptim.graph.rings.RingClosingAttractor.RCALABELPERAPCLASS
static final HashMap< APClass, String > RCALABELPERAPCLASS
Conventional labels for attractor pseudoatom.
Definition: RingClosingAttractor.java:172

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

denoptim.io.DenoptimIO.writeCompatibilityMatrix
static void writeCompatibilityMatrix(String fileName, HashMap< APClass, ArrayList< APClass > > cpMap, HashMap< APClass, APClass > capMap, HashSet< APClass > ends)
The class compatibility matrix.
Definition: DenoptimIO.java:1143

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

denoptim.molecularmodeling.ThreeDimTreeBuilder
Tool to build build three-dimensional (3D) tree-like molecular structures from DGraph.
Definition: ThreeDimTreeBuilder.java:76

denoptim.molecularmodeling.ThreeDimTreeBuilder.convertGraphTo3DAtomContainer
IAtomContainer convertGraphTo3DAtomContainer(DGraph graph)
Created a three-dimensional molecular representation from a given DGraph.
Definition: ThreeDimTreeBuilder.java:158

denoptim.programs.RunTimeParameters.getLogger
Logger getLogger()
Get the name of the program specific logger.
Definition: RunTimeParameters.java:349

denoptim.programs.RunTimeParameters.getRandomizer
Randomizer getRandomizer()
Returns the current program-specific randomizer.
Definition: RunTimeParameters.java:598

denoptim.utils.GraphUtils
Utilities for graphs.
Definition: GraphUtils.java:40

denoptim.utils.GraphUtils.getUniqueVertexIndex
static synchronized long getUniqueVertexIndex()
Unique counter for the number of graph vertices generated.
Definition: GraphUtils.java:97

denoptim.utils.MoleculeUtils
Utilities for molecule conversion.
Definition: MoleculeUtils.java:94

denoptim.utils.MoleculeUtils.getSymbolOrLabel
static String getSymbolOrLabel(IAtom atm)
Gets either the elemental symbol (for standard atoms) of the label (for pseudo-atoms).
Definition: MoleculeUtils.java:979

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

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

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

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

denoptim.graph.Vertex.BBType.FRAGMENT
FRAGMENT
Definition: Vertex.java:88

denoptim.graph.Vertex.BBType.CAP
CAP
Definition: Vertex.java:88

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