FragmenterParameters.java

Go to the documentation of this file.

/*
 *   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/>.
 */
 
package denoptim.programs.fragmenter;
 
import java.io.File;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.files.FileFormat;
import denoptim.files.FileUtils;
import denoptim.fragmenter.FragmentClusterer;
import denoptim.fragmenter.ScaffoldingPolicy;
import denoptim.graph.DGraph;
import denoptim.graph.Template.ContractLevel;
import denoptim.graph.Vertex;
import denoptim.graph.Vertex.BBType;
import denoptim.io.DenoptimIO;
import denoptim.logging.StaticLogger;
import denoptim.programs.RunTimeParameters;
import denoptim.utils.FormulaUtils;
 
 
public class FragmenterParameters extends RunTimeParameters
{
    private String structuresFile;
    
    private String formulaeFile;
    
    private LinkedHashMap<String, String> formulae;
    
    private String cutRulesFile;
    
    List<CuttingRule> cuttingRules;
    
    private int numParallelTasks = 1;
    
    private boolean checkFormula = false;
    
    private boolean acceptUnsetToSingeBOApprox = false;
    
    private boolean addExplicitH = false;
    
    private boolean preFilter = false;
    
    private Set<String> preFilterSMARTS = new HashSet<String>();
    
    private boolean doFragmentation = false;
    
    private boolean doFiltering = false;
 
    private boolean doFragExtractionFromGraphs = false;
    
    private boolean doRejectWeirdIsotopes = true;
    
    private Set<String> rejectedElements = new HashSet<String>();
    
    private Map<String,Double> formulaCriteriaLessThan = 
            new HashMap<String,Double>();
    
    private Set<Map<String,Double>> formulaCriteriaMoreThan = 
            new HashSet<Map<String,Double>>();
    
    private Set<String> rejectedAPClasses = new HashSet<String>();
    
    private Set<String[]> rejectedAPClassCombinations = new HashSet<String[]>();
    
    private int maxFragHeavyAtomCount = -1;
    
    private int minFragHeavyAtomCount = -1;
    
    private Map<String, String> fragRejectionSMARTS = new HashMap<String, String>();
    
    private Map<String, String> fragRetentionSMARTS = new HashMap<String, String>();
 
    private boolean doAddDuOnLinearity = true;
 
    private double linearAngleLimit = 170.0;
 
    private String ignorableFragmentsFile = "";
    
    private ArrayList<Vertex> ignorableFragments = new ArrayList<Vertex>();
    
    private String targetFragmentsFile = "";
    
    private ArrayList<Vertex> targetFragments = new ArrayList<Vertex>();
    
    // NB: javadoc reproduced also in the getter method. See below
    private boolean doManageIsomorphicFamilies = false;
    
    private int isomorphicSampleSize = 1;
    
    public static final int MAXISOMORPHICSAMPLESIZE = 50;
    
    private int mwSlotSize = 10;
    
    private Map<String,File> mwSlotToAllFragsFile = new HashMap<String,File>();
    
    private Map<String,File> mwSlotToUnqFragsFile = new HashMap<String,File>();
    
    private Map<String,Integer> isomorphsCount = new HashMap<String,Integer>();
    
    //TODO: We could use something like the SizeControlledSet used in the EA to 
    // collect unique identifiers.
    
    private AtomicInteger unqIsomorphicFamilyId = new AtomicInteger(0);
    
    public final Object MANAGEMWSLOTSSLOCK = new Object();
    
    private boolean doExtactRepresentativeConformer = false;
    
    private int sizeUnimodalPop = 20;
    
    private double maxNoiseUnimodalPop = 0.2;
    
    private double factorForSDOnStatsOfUnimodalPop = 1.0;
    
    private boolean useCentroidsAsRepresentativeConformer = true;
    
    private boolean saveClustersOfConformerToFile = false;
    
    private boolean isStandaloneFragmentClustering = false;
    
    private boolean workingIn3D = true;
 
    private ScaffoldingPolicy scaffoldingPolicy = 
            ScaffoldingPolicy.LARGEST_FRAGMENT;
 
    protected boolean embedRingsInTemplate = false;
    
    protected ContractLevel embeddedRingsContract = ContractLevel.FREE;
 
    private String fragmentationTmplFile = "";
 
    private List<DGraph> fragmentationTmpls = new ArrayList<DGraph>();
 
    private int maxBufferShellSize = 2;
    
//------------------------------------------------------------------------------
    
    public FragmenterParameters()
    {
        super(ParametersType.FRG_PARAMS);
    }
 
//------------------------------------------------------------------------------
 
    public int getNumTasks()
    {
        return numParallelTasks;
    }
 
//------------------------------------------------------------------------------
 
    public void setNumTasks(int numParallelTasks)
    {
        this.numParallelTasks = numParallelTasks;
    }
    
//------------------------------------------------------------------------------
 
    public String getStructuresFile()
    {
        return structuresFile;
    }
 
//------------------------------------------------------------------------------
    
    public void setStructuresFile(String structuresFile)
    {
        this.structuresFile = structuresFile;
    }
 
//------------------------------------------------------------------------------
    
    public void setFormulaeFile(String formulaeFile)
    {
        this.formulaeFile = formulaeFile;
    }
    
//------------------------------------------------------------------------------
 
    public String getFormulaeFile()
    {
        return formulaeFile;
    }
 
//------------------------------------------------------------------------------
 
    public List<CuttingRule> getCuttingRules()
    {
        return cuttingRules;
    }
    
//------------------------------------------------------------------------------
 
    public void setCuttingRules(List<CuttingRule> cuttingRules)
    {
        this.cuttingRules = cuttingRules;
    }
    
//------------------------------------------------------------------------------
 
    public void setCuttingRulesFilePathname(String pathname)
    {
        this.cutRulesFile = pathname;
    }
    
//------------------------------------------------------------------------------
 
    public String getCuttingRulesFilePathname()
    {
        return cutRulesFile;
    }
 
//------------------------------------------------------------------------------
 
    public LinkedHashMap<String, String> getFormulae()
    {
        return formulae;
    }
 
//------------------------------------------------------------------------------
    
    public boolean doCheckFormula()
    {
        return checkFormula;
    }
 
//------------------------------------------------------------------------------
 
    public void setCheckFormula(boolean checkFormula)
    {
        this.checkFormula = checkFormula;
    }
    
    
//------------------------------------------------------------------------------
    
    public boolean doPreFilter()
    {
        return preFilter;
    }
    
//------------------------------------------------------------------------------
    
    public Set<String> getPreFiltrationSMARTS()
    {
        return preFilterSMARTS;
    }
    
//------------------------------------------------------------------------------
    
    public boolean doFragmentation()
    {
        return doFragmentation;
    }
 
//------------------------------------------------------------------------------
 
    public boolean doFragExtractionFromGraphs()
    {
        return doFragExtractionFromGraphs;
    }
    
//------------------------------------------------------------------------------
 
    public boolean doRejectWeirdIsotopes()
    {
        return doRejectWeirdIsotopes;
    }
    
//------------------------------------------------------------------------------
    
    public boolean doAddDuOnLinearity()
    {
        return doAddDuOnLinearity;
    }
    
//------------------------------------------------------------------------------
 
    public Set<String> getRejectedElements()
    {
        return rejectedElements;
    }
    
//------------------------------------------------------------------------------
 
    public Map<String, Double> getRejectedFormulaLessThan()
    {
        return formulaCriteriaLessThan;
    }
  
//------------------------------------------------------------------------------
    
    public Set<Map<String, Double>> getRejectedFormulaMoreThan()
    {
        return formulaCriteriaMoreThan;
    }
 
//------------------------------------------------------------------------------
    
    public Set<String> getRejectedAPClasses()
    {
        return rejectedAPClasses;
    }
 
//------------------------------------------------------------------------------
    
    public Set<String[]> getRejectedAPClassCombinations()
    {
        return rejectedAPClassCombinations;
    }
 
//------------------------------------------------------------------------------
    
    public int getMaxFragHeavyAtomCount()
    {
        return maxFragHeavyAtomCount;
    }
 
//------------------------------------------------------------------------------
    
    public int getMinFragHeavyAtomCount()
    {
        return minFragHeavyAtomCount;
    }
 
//------------------------------------------------------------------------------
    
    public Map<String, String> getFragRejectionSMARTS()
    {
        return fragRejectionSMARTS;
    }
 
//------------------------------------------------------------------------------
    
    public Map<String, String> getFragRetentionSMARTS()
    {
        return fragRetentionSMARTS;
    }
 
//------------------------------------------------------------------------------
 
    public void setRejectWeirdIsotopes(boolean doRejectWeirdIsotopes)
    {
        this.doRejectWeirdIsotopes = doRejectWeirdIsotopes;
    }
 
//------------------------------------------------------------------------------
    
    public void setRejectedElements(Set<String> rejectedElements)
    {
        this.rejectedElements = rejectedElements;
    }
 
//------------------------------------------------------------------------------
    
    public void setRejectedFormulaLessThan(
            Map<String, Double> formulaMax)
    {
        this.formulaCriteriaLessThan = formulaMax;
    }
 
//------------------------------------------------------------------------------
    
    public void setRejectedFormulaMoreThan(
            Set<Map<String, Double>> formulaCriteriaMoreThan)
    {
        this.formulaCriteriaMoreThan = formulaCriteriaMoreThan;
    }
 
//------------------------------------------------------------------------------
    
    public void setRejectedAPClasses(Set<String> rejectedAPClasses)
    {
        this.rejectedAPClasses = rejectedAPClasses;
    }
 
//------------------------------------------------------------------------------
    
    public void setRejectedAPClassCombinations(
            Set<String[]> rejectedAPClassCombinations)
    {
        this.rejectedAPClassCombinations = rejectedAPClassCombinations;
    }
 
//------------------------------------------------------------------------------
    
    public void setMaxFragHeavyAtomCount(int maxFragHeavyAtomCount)
    {
        this.maxFragHeavyAtomCount = maxFragHeavyAtomCount;
    }
 
//------------------------------------------------------------------------------
    
    public void setMinFragHeavyAtomCount(int minFragHeavyAtomCount)
    {
        this.minFragHeavyAtomCount = minFragHeavyAtomCount;
    }
 
//------------------------------------------------------------------------------
    
    public void setFragRejectionSMARTS(Map<String, String> fragRejectionSMARTS)
    {
        this.fragRejectionSMARTS = fragRejectionSMARTS;
    }
 
//------------------------------------------------------------------------------
    
    public void setFragRetentionSMARTS(Map<String, String> fragRetentionSMARTS)
    {
        this.fragRetentionSMARTS = fragRetentionSMARTS;
    }
 
//------------------------------------------------------------------------------
    
    public ArrayList<Vertex> getIgnorableFragments()
    {
        return ignorableFragments;
    }
    
//------------------------------------------------------------------------------
    
    public ArrayList<Vertex> getTargetFragments()
    {
        return targetFragments;
    }
    
//------------------------------------------------------------------------------
 
    public boolean doManageIsomorphicFamilies()
    {
        return doManageIsomorphicFamilies;
    }
    
//------------------------------------------------------------------------------
 
    public int getIsomorphicSampleSize()
    {
        return isomorphicSampleSize;
    }
 
//------------------------------------------------------------------------------
 
    public void setIsomorphicSampleSize(int isomorphicSampleSize)
    {
        this.isomorphicSampleSize = isomorphicSampleSize;
    }
 
//------------------------------------------------------------------------------
 
    public int getMWSlotSize()
    {
        return mwSlotSize;
    }
 
//------------------------------------------------------------------------------
 
    public void setMWSlotSize(int mwSlotSize)
    {
        this.mwSlotSize = mwSlotSize;
    }
 
//------------------------------------------------------------------------------
 
    public Map<String, File> getMWSlotToAllFragsFile()
    {
        return mwSlotToAllFragsFile;
    }
 
//------------------------------------------------------------------------------
 
    public void setMWSlotToAllFragsFile(Map<String, File> mwSlotToAllFragsFile)
    {
        this.mwSlotToAllFragsFile = mwSlotToAllFragsFile;
    }
 
//------------------------------------------------------------------------------
 
    public Map<String, File> getMWSlotToUnqFragsFile()
    {
        return mwSlotToUnqFragsFile;
    }
    
//------------------------------------------------------------------------------
 
    public File getMWSlotFileNameUnqFrags(String mwSlotId)
    {
        return new File(getWorkDirectory() + DenoptimIO.FS 
                + DENOPTIMConstants.MWSLOTFRAGSFILENAMEROOT + mwSlotId 
                + DENOPTIMConstants.MWSLOTFRAGSUNQFILENANEEND + "."
                + DENOPTIMConstants.TMPFRAGFILEFORMAT.getExtension());
    }
    
//------------------------------------------------------------------------------
 
    public File getMWSlotFileNameAllFrags(String mwSlotId)
    {
        return new File(getWorkDirectory() + DenoptimIO.FS 
                + DENOPTIMConstants.MWSLOTFRAGSFILENAMEROOT + mwSlotId 
                + DENOPTIMConstants.MWSLOTFRAGSALLFILENANEEND + "."
                + DENOPTIMConstants.TMPFRAGFILEFORMAT.getExtension());
    }
 
//------------------------------------------------------------------------------
 
    public Map<String,Integer> getIsomorphsCount()
    {
        return isomorphsCount;
    }
 
//------------------------------------------------------------------------------
 
    public String newIsomorphicFamilyID()
    {
        return "IsomorphicFamily_" + unqIsomorphicFamilyId.getAndIncrement();
    }
    
//------------------------------------------------------------------------------
 
    public boolean doFiltering()
    {
        return doFiltering;
    }
    
//------------------------------------------------------------------------------
    
    public boolean addExplicitH()
    {
        return addExplicitH;
    }
    
//------------------------------------------------------------------------------
    
    public void setAddExplicitH(boolean addExplicitH)
    {
        this.addExplicitH = addExplicitH;
    }
    
//------------------------------------------------------------------------------
 
    public boolean acceptUnsetToSingeBO()
    {
        return acceptUnsetToSingeBOApprox;
    }
    
//-----------------------------------------------------------------------------
 
    public void setEmbedRingsInTemplate(boolean embedRingsInTemplate)
    {
        this.embedRingsInTemplate = embedRingsInTemplate;
    }
    
//-----------------------------------------------------------------------------
 
    public boolean embedRingsInTemplate()
    {
        return embedRingsInTemplate;
    }
    
//------------------------------------------------------------------------------
 
    public void setEmbeddedRingsContract(ContractLevel embeddedRingsContract)
    {
        this.embeddedRingsContract = embeddedRingsContract;
    }
    
//------------------------------------------------------------------------------
 
    public ContractLevel getEmbeddedRingsContract()
    {
        return embeddedRingsContract;
    }
 
//------------------------------------------------------------------------------    
 
    public void setScaffoldingPolicy(ScaffoldingPolicy sp)
    {
        this.scaffoldingPolicy = sp;
    }
    
//------------------------------------------------------------------------------    
 
    public ScaffoldingPolicy getScaffoldingPolicy()
    {
        return scaffoldingPolicy;
    }
 
//------------------------------------------------------------------------------
 
    public List<DGraph> getFragmentationTmpls()
    {
        return fragmentationTmpls;
    }
 
//------------------------------------------------------------------------------
 
    public int getMaxBufferShellSize()
    {
        return maxBufferShellSize;
    }
 
//------------------------------------------------------------------------------
    
    public void interpretKeyword(String key, String value)
            throws DENOPTIMException
    {
        String msg = "";
        switch (key.toUpperCase())
        {
            case "WORKDIR=":
                workDir = value;
                break;
                
            case "STRUCTURESFILE=":
                structuresFile = value;
                break;
 
            case "FORMULATXTFILE=":
                checkFormula = true;
                formulaeFile = value;
                break;
                
            case "PREFILTERSMARTS=":
                preFilter = true;
                preFilterSMARTS.add(value);
                break;
 
            case "CUTTINGRULESFILE=":
                doFragmentation = true;
                cutRulesFile = value;
                break;
 
            case "EXTRACTFROMGRAPHS=":
                structuresFile = value;
                doFragExtractionFromGraphs = true;
                break;
                
            case "ADDEXPLICITHYDROGEN":
                addExplicitH = true;
                break;
                
            case "UNSETTOSINGLEBO":
                acceptUnsetToSingeBOApprox = true;
                break;
 
            case "IGNORABLEFRAGMENTS=":
                ignorableFragmentsFile = value;
                doFiltering = true;
                break;
                
            case "TARGETFRAGMENTS=":
                targetFragmentsFile = value;
                doFiltering = true;
                break;
                
            case "ISOMORPHICSAMPLESIZE=":
                try {
                    isomorphicSampleSize = Integer.parseInt(value);
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                if (isomorphicSampleSize>0)
                    doManageIsomorphicFamilies = true;
                break;
                
            case "REMOVEDUPLICATES":
                doManageIsomorphicFamilies = true;
                break;
                
            case "MWSLOTSIZE=":
                try {
                    mwSlotSize = Integer.parseInt(value);
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                break;
                
            case "REJECTMINORISOTOPES":
                doRejectWeirdIsotopes = true;
                doFiltering = true;
                break;
                
            case "REJECTELEMENT=":
                rejectedElements.add(value);
                doFiltering = true;
                break;
                
            case "REJFORMULALESSTHAN=":
                if (formulaCriteriaLessThan.size()>0)
                {
                    msg = "Attempt to specify more than one criterion for "
                            + "rejecting fragments based on a lower-limit "
                            + "molecular formula. ";
                    throw new DENOPTIMException(msg);
                }
                Map<String,Double> elSymbolsCount = null;
                try {
                    elSymbolsCount = FormulaUtils.parseFormula(value);
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                formulaCriteriaLessThan = elSymbolsCount;
                doFiltering = true;
                break;
                
            case "REJFORMULAMORETHAN=":
                Map<String,Double> elSymbolsCount2= null;
                try {
                    elSymbolsCount2 = FormulaUtils.parseFormula(value);
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                formulaCriteriaMoreThan.add(elSymbolsCount2);
                doFiltering = true;
                break;
                
            case "REJECTAPCLASS=":
                rejectedAPClasses.add(value);
                doFiltering = true;
                break;
                
            case "REJECTAPCLASSCOMBINATION=":
                String[] lst = value.split("\\s+");
                rejectedAPClassCombinations.add(lst);
                doFiltering = true;
                break;
                
            case "MAXFRAGSIZE=":
                try {
                    maxFragHeavyAtomCount = Integer.parseInt(value);
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                doFiltering = true;
                break;
                
            case "MINFRAGSIZE=":
                try {
                    minFragHeavyAtomCount = Integer.parseInt(value);
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                doFiltering = true;
                break;
                
            case "REJECTSMARTS=":
                fragRejectionSMARTS.put(value, value);
                doFiltering = true;
                break;
                
            case "RETAINSMARTS=":
                fragRetentionSMARTS.put(value, value);
                doFiltering = true;
                break;
 
            case "CLUSTERIZEANDCOLLECT=":
                doManageIsomorphicFamilies = true;
                doExtactRepresentativeConformer = true;
                switch (value.trim().toUpperCase())
                {
                    case "CENTROIDS":
                        useCentroidsAsRepresentativeConformer = true;
                        break;
                        
                    case "MOSTCENTRAL":
                        useCentroidsAsRepresentativeConformer = false;
                        break;
                        
                    default:
                        throw new DENOPTIMException("Unable to parse value of " 
                                + key + ": '" + value + "'");
                }
                break;
                
            case "SAVECLUSTERS":
                doExtactRepresentativeConformer = true;
                saveClustersOfConformerToFile = true;
                break;
                
            case "SIZEUNIMODALPOPULATION=":
                sizeUnimodalPop = Integer.parseInt(value);
                break;
                
            case "MAXNOISEUNIMODALPOPULATION=":
                maxNoiseUnimodalPop = Double.parseDouble(value);
                break;
 
            case "SDWEIGHTUNIMODALPOPULATION=":
                factorForSDOnStatsOfUnimodalPop = Double.parseDouble(value);
                break;
                
            case "SCAFFOLDINGPOLICY=":
                String[] words = value.split("\\s+");
                try {
                    scaffoldingPolicy = ScaffoldingPolicy.valueOf(
                            words[0].toUpperCase());
                    if (ScaffoldingPolicy.ELEMENT.equals(scaffoldingPolicy))
                    {
                        if (words.length<2)
                        {
                            throw new DENOPTIMException("Expected elemental "
                                    + "symbol after '" 
                                    + ScaffoldingPolicy.ELEMENT+ "', but none "
                                    + "found");
                        }
                        scaffoldingPolicy.label = words[1];
                    }
                } catch (Throwable t)
                {
                    msg = "Unable to parse value of " + key + ": '" + value + "'";
                    throw new DENOPTIMException(msg, t);
                }
                break;
 
            case "EMBEDRINGSINTEMPLATES=":
            {
                embedRingsInTemplate = readYesNoTrueFalse(value);
                break;
            }
            
            case "RINGEMBEDDINGCONTRACT=":
            {
                if (value.length() > 0)
                {
                    embeddedRingsContract = ContractLevel.valueOf(value);
                }
                break;
            }
 
            case "FRAGMENTATIONTEMPLATE=":
            {
                doFragmentation = true;
                fragmentationTmplFile = value;
                break;
            }
 
            case "BONDSAROUNDTOPOCRITICATOM=":
            {
                maxBufferShellSize = Integer.parseInt(value);
            }
 
/*
            case "=":
                = value;
                doFiltering = true;
                break;
  */              
                
            case "PARALLELTASKS=":
                try
                {
                    numParallelTasks = Integer.parseInt(value);
                }
                catch (Throwable t)
                {
                    msg = "Unable to understand value " + key + "'" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                break;
                
            case "VERBOSITY=":
                try
                {
                    verbosity = Integer.parseInt(value);
                }
                catch (Throwable t)
                {
                    msg = "Unable to understand value " + key + "'" + value + "'";
                    throw new DENOPTIMException(msg);
                }
                break;
                
            default:
                 msg = "Keyword " + key + " is not a known Fragmenter-" 
                         + "related keyword. Check input files.";
                throw new DENOPTIMException(msg);
        }
    }
 
//------------------------------------------------------------------------------
 
    public void checkParameters() throws DENOPTIMException
    {
        if (!workDir.equals(System.getProperty("user.dir")))
        {
            ensureFileExists(workDir);
        }
        ensureIsPositive("numParallelTasks", numParallelTasks, "PARALLELTASKS");
        ensureIsPositive("isomorphicSampleSize", isomorphicSampleSize, 
                "ISOMORPHICSAMPLESIZE");
        ensureIsPositive("mwSlotSize", mwSlotSize, "MWSLOTSIZE");
        ensureFileExistsIfSet(fragmentationTmplFile);
        ensureFileExistsIfSet(structuresFile);
        ensureFileExistsIfSet(cutRulesFile);
        ensureFileExistsIfSet(formulaeFile);
        ensureFileExistsIfSet(ignorableFragmentsFile);
        ensureFileExistsIfSet(targetFragmentsFile);
        
        checkOtherParameters();
    }
 
//------------------------------------------------------------------------------
 
    public void processParameters() throws DENOPTIMException
    {
        if (isMaster)
            createWorkingDirectory();
        
        cuttingRules = new ArrayList<CuttingRule>();
        if (cutRulesFile!=null && !cutRulesFile.isBlank())
        {
            DenoptimIO.readCuttingRules(new File(cutRulesFile), cuttingRules);
        }
        if (formulaeFile!=null && !formulaeFile.isBlank())
        {
            formulae = DenoptimIO.readCSDFormulae(new File(formulaeFile));
        }
        processOtherParameters();
        
        if (ignorableFragmentsFile!=null && !ignorableFragmentsFile.isBlank())
        {
            try
            {
                ignorableFragments = DenoptimIO.readVertexes(
                        new File(ignorableFragmentsFile), BBType.UNDEFINED);
            } catch (Throwable e)
            {
                throw new DENOPTIMException("Problems reading file '" 
                        + ignorableFragmentsFile + "'", e);
            }
        }
        
        if (targetFragmentsFile!=null && !targetFragmentsFile.isBlank())
        {
            try
            {
                targetFragments = DenoptimIO.readVertexes(
                        new File(targetFragmentsFile), BBType.UNDEFINED);
            } catch (Throwable e)
            {
                throw new DENOPTIMException("Problems reading file '" 
                        + targetFragmentsFile + "'", e);
            }
        }
 
        if (fragmentationTmplFile!=null && !fragmentationTmplFile.isBlank())
        {
            try
            {
                fragmentationTmpls = DenoptimIO.readDENOPTIMGraphsFromFile(
                        new File(fragmentationTmplFile));
            } catch (Throwable e)
            {
                throw new DENOPTIMException("Problems reading file '"
                        + fragmentationTmplFile + "'", e);
            }
        }
 
        if (!doFragmentation && !doFragExtractionFromGraphs && doExtactRepresentativeConformer)
        {
            isStandaloneFragmentClustering = true;
        }
       
        if (isMaster)
        {
            StaticLogger.appLogger.log(Level.INFO, "Program log file: " 
                    + logFile + DENOPTIMConstants.EOL 
                    + "Output files associated with the current run are "
                    + "located in " + workDir);
        }
    }
    
//------------------------------------------------------------------------------
    
    private void createWorkingDirectory()
    {
        String curDir = workDir;
        String fileSep = System.getProperty("file.separator");
        boolean success = false;
        while (!success)
        {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddkkmmss");
            String str = "FRG" + sdf.format(new Date());
            workDir = curDir + fileSep + str;
            success = FileUtils.createDirectory(workDir);
        }
        FileUtils.addToRecentFiles(workDir, FileFormat.FRG_RUN);
        logFile = workDir + ".log";
    }
 
//------------------------------------------------------------------------------
 
    public String getPrintedList()
    {
        StringBuilder sb = new StringBuilder(1024);
        sb.append(" " + paramTypeName() + " ").append(NL);
        for (Field f : this.getClass().getDeclaredFields()) 
        {
            try
            {
                sb.append(f.getName()).append(" = ").append(
                            f.get(this)).append(NL);
            }
            catch (Throwable t)
            {
                sb.append("ERROR! Unable to print " + paramTypeName() 
                        + " parameters. Cause: " + t);
                break;
            }
        }
        for (RunTimeParameters otherCollector : otherParameters.values())
        {
            sb.append(otherCollector.getPrintedList());
        }
        return sb.toString();
    }
 
//------------------------------------------------------------------------------
 
    public double getLinearAngleLimit()
    {
        return linearAngleLimit;
    }
 
//------------------------------------------------------------------------------
 
    public void setLinearAngleLimit(double linearAngleLimit)
    {
        this.linearAngleLimit = linearAngleLimit;
    }
    
//------------------------------------------------------------------------------
 
    public boolean doExtactRepresentativeConformer()
    {
        return doExtactRepresentativeConformer;
    }
 
//------------------------------------------------------------------------------
 
    public int getSizeUnimodalPop()
    {
        return sizeUnimodalPop;
    }
 
//------------------------------------------------------------------------------
 
    public void setSizeUnimodalPop(int sizeUnimodalPop)
    {
        this.sizeUnimodalPop = sizeUnimodalPop;
    }
 
//------------------------------------------------------------------------------
 
    public double getMaxNoiseUnimodalPop()
    {
        return maxNoiseUnimodalPop;
    }
 
//------------------------------------------------------------------------------
 
    public void setMaxNoiseUnimodalPop(double maxNoiseUnimodalPop)
    {
        this.maxNoiseUnimodalPop = maxNoiseUnimodalPop;
    }
 
//------------------------------------------------------------------------------
 
    public double getFactorForSDOnStatsOfUnimodalPop()
    {
        return factorForSDOnStatsOfUnimodalPop;
    }
 
    
//------------------------------------------------------------------------------
 
    public void setFactorForSDOnStatsOfUnimodalPop(
            double factorForSDOnStatsOfUnimodalPop)
    {
        this.factorForSDOnStatsOfUnimodalPop = factorForSDOnStatsOfUnimodalPop;
    }
 
//------------------------------------------------------------------------------
 
    public boolean isUseCentroidsAsRepresentativeConformer()
    {
        return useCentroidsAsRepresentativeConformer;
    }
    
//------------------------------------------------------------------------------
 
    public void setUseCentroidsAsRepresentativeConformer(
            boolean useCentroidsAsRepresentativeConformer)
    {
        this.useCentroidsAsRepresentativeConformer = 
                useCentroidsAsRepresentativeConformer;
    }
    
//------------------------------------------------------------------------------
 
    public boolean isSaveClustersOfConformerToFile()
    {
        return saveClustersOfConformerToFile;
    }
 
//------------------------------------------------------------------------------
 
    public void setSaveClustersOfConformerToFile(
            boolean saveClustersOfConformerToFile)
    {
        this.saveClustersOfConformerToFile = saveClustersOfConformerToFile;
    }
 
//------------------------------------------------------------------------------
 
    public boolean isStandaloneFragmentClustering()
    {
        return isStandaloneFragmentClustering;
    }
    
//------------------------------------------------------------------------------
    
    public boolean isWorkingIn3D()
    {
        return workingIn3D;
    }
    
//------------------------------------------------------------------------------    
 
    public void setWorkingIn3D(boolean workingIn3D)
    {
        this.workingIn3D = workingIn3D;
    }
 
//------------------------------------------------------------------------------
 
    public void setFragmentationTmpls(List<DGraph> fragmentationTmpls) {
        this.fragmentationTmpls = fragmentationTmpls;
    }
    
//------------------------------------------------------------------------------    
 
}