RunTimeParameters.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;
 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.logging.StreamHandler;
 
import denoptim.exception.DENOPTIMException;
import denoptim.files.FileUtils;
import denoptim.fitness.FitnessParameters;
import denoptim.fragspace.FragmentSpaceParameters;
import denoptim.graph.rings.RingClosureParameters;
import denoptim.main.Main.RunType;
import denoptim.programs.combinatorial.CEBLParameters;
import denoptim.programs.denovo.GAParameters;
import denoptim.programs.fitnessevaluator.FRParameters;
import denoptim.programs.fragmenter.FragmenterParameters;
import denoptim.programs.genetweeker.GeneOpsRunnerParameters;
import denoptim.programs.grapheditor.GraphEdParameters;
import denoptim.programs.graphlisthandler.GraphListsHandlerParameters;
import denoptim.programs.isomorphism.IsomorphismParameters;
import denoptim.programs.moldecularmodelbuilder.MMBuilderParameters;
import denoptim.utils.Randomizer;
 
 
public abstract class RunTimeParameters
{
    protected boolean isMaster = true;
    
    protected String workDir = System.getProperty("user.dir");
 
    protected String logFile = "unset";
    
    private Logger logger = Logger.getLogger("DummyLogger");
    
    private Randomizer rng = null;
    
    protected int verbosity = 0;
    
    protected Map<ParametersType, RunTimeParameters> otherParameters = 
            new HashMap<ParametersType, RunTimeParameters>();
    
    private ParametersType paramType = null;
    
    public static enum ParametersType { 
        CEBL_PARAMS,
        
        GA_PARAMS,
        
        FS_PARAMS,
        
        RC_PARAMS,
        
        FIT_PARAMS, 
        
        MMB_PARAM, 
        
        FR_PARAMS, 
        
        GO_PARAMS, 
        
        GE_PARAMS,
        
        GLH_PARAMS,
        
        ISO_PARAMS, 
        
        FRG_PARAMS;
        
        private String keywordRoot;
        
        private Class<?> implementation;
        
        static {
            CEBL_PARAMS.keywordRoot = "FSE-";
            GA_PARAMS.keywordRoot = "GA-";
            FS_PARAMS.keywordRoot = "FS-";
            FRG_PARAMS.keywordRoot = "FRG-";
            RC_PARAMS.keywordRoot = "RC-";
            FIT_PARAMS.keywordRoot = "FP-";
            FR_PARAMS.keywordRoot = "FR-";
            MMB_PARAM.keywordRoot = "3DB-";
            GO_PARAMS.keywordRoot = "TESTGENOPS-";
            GE_PARAMS.keywordRoot = "GRAPHEDIT-";
            GLH_PARAMS.keywordRoot = "GRAPHLISTS-";
            ISO_PARAMS.keywordRoot = "ISOMORPHISM-";
            
            CEBL_PARAMS.implementation = CEBLParameters.class;
            GA_PARAMS.implementation = GAParameters.class;
            FS_PARAMS.implementation = FragmentSpaceParameters.class;
            FRG_PARAMS.implementation = FragmenterParameters.class;
            RC_PARAMS.implementation = RingClosureParameters.class;
            FIT_PARAMS.implementation = FitnessParameters.class;
            FR_PARAMS.implementation = FRParameters.class;
            MMB_PARAM.implementation = MMBuilderParameters.class;
            GO_PARAMS.implementation = GeneOpsRunnerParameters.class;
            GE_PARAMS.implementation = GraphEdParameters.class;
            GLH_PARAMS.implementation = GraphListsHandlerParameters.class;
            ISO_PARAMS.implementation = IsomorphismParameters.class;
        }
 
        public Class<?> getImplementation()
        {
            return implementation;
        }
        
        public String getKeywordRoot()
        {
            return keywordRoot;
        }
    }
    
    /*
     * TODO: if we want a general Parameter class it will have to define
     * - unique name of the parameter
     * - java type used to collect the value
     * - default value
     * - description of what the parameter is or what it controls
     * - code for parsing the value from input files
     * - code for checking
     * - core for processing the parameter
     * - what else?
     * 
     *  Challenge: what about parameters that depend on other parameters?
     *  Need to control order of processing the parameters, in some occasions.
     */
    
    
    public final String NL = System.getProperty("line.separator");
    
//-----------------------------------------------------------------------------
    
    public RunTimeParameters(ParametersType paramType)
    {
        this.paramType = paramType;
        
        /*
         * This is the default logger "DummyLogger". It should be overwritten
         * by a call to startProgramSpecificLogger
         */
        this.logger.setLevel(Level.SEVERE); 
    }
    
//-----------------------------------------------------------------------------
    
    public String paramTypeName()
    {
        return paramType.toString();
    }
 
//-----------------------------------------------------------------------------
 
    public String getWorkDirectory()
    {
        return workDir;
    }
    
//-----------------------------------------------------------------------------
 
    public void setWorkDirectory(String pathname)
    {
        this.workDir = pathname;
    }
 
//-----------------------------------------------------------------------------
 
    public String getLogFilePathname()
    {
        return logFile;
    }
    
//-----------------------------------------------------------------------------
 
    public void setLogFilePathname(String pathname)
    {
        this.workDir = pathname;
    }
    
//-----------------------------------------------------------------------------
    
    public Logger getLogger()
    {
        return logger;
    }
    
//-----------------------------------------------------------------------------
    
    private void setLogger(Logger logger)
    {
        this.logger = logger;
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setLogger(logger);
        }
    }
    
//-----------------------------------------------------------------------------
    
    public Logger startProgramSpecificLogger(String loggerIdentifier) 
            throws SecurityException, IOException
    { 
        return startProgramSpecificLogger(loggerIdentifier, true);
    }
    
//-----------------------------------------------------------------------------
    
    public Logger startProgramSpecificLogger(String loggerIdentifier, 
            boolean toLogFile) 
            throws SecurityException, IOException
    {
        logger = Logger.getLogger(loggerIdentifier);
        
        int n = logger.getHandlers().length;
        for (int i=0; i<n; i++)
        {
            logger.removeHandler(logger.getHandlers()[0]);
        }
 
        if (toLogFile)
        {
            FileHandler fileHdlr = new FileHandler(logFile);
            SimpleFormatter formatterTxt = new SimpleFormatter();
            fileHdlr.setFormatter(formatterTxt);
            logger.setUseParentHandlers(false);
            logger.addHandler(fileHdlr);
            logger.setLevel(Level.INFO);
            String header = "Started logging for " + loggerIdentifier;
            logger.log(Level.INFO,header);
        } else {
            logger.addHandler(new StreamHandler(System.out, 
                    new SimpleFormatter()));
        }
        
        if (verbosity!=0)
        {
            logger.setLevel(verbosityTologLevel());
            for (int iH=0; iH<logger.getHandlers().length; iH++)
            {
                logger.getHandlers()[iH].setLevel(verbosityTologLevel());
            }
        }
        
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setLogger(logger);
        }
        
        return logger;
    }
    
//-----------------------------------------------------------------------------
    
    public Logger startConsoleLogger(String loggerIdentifier)
    {
        logger = Logger.getLogger(loggerIdentifier);
        
        int n = logger.getHandlers().length;
        for (int i=0; i<n; i++)
        {
            logger.removeHandler(logger.getHandlers()[0]);
        }
        ConsoleHandler handler = new ConsoleHandler();
        handler.setFormatter(new SimpleFormatter());
        handler.setLevel(Level.INFO);
        logger.addHandler(handler);
        
        if (verbosity!=0)
        {
            logger.setLevel(verbosityTologLevel());
            for (int iH=0; iH<logger.getHandlers().length; iH++)
            {
                logger.getHandlers()[iH].setLevel(verbosityTologLevel());
            }
        }
        
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setLogger(logger);
        }
        
        return logger;
    }
    
//-----------------------------------------------------------------------------
 
    public static boolean readYesNoTrueFalse(String s)
    {
        boolean result = false;
        String value = s.trim().toUpperCase();
        if (value.equals("YES") 
                || value.equals("Y")
                || value.equals("T")
                || value.equals("TRUE"))
        {
            result = true;
        } else if (value.equals("NO") 
                || value.equals("N")
                || value.equals("F")
                || value.equals("FALSE"))
        {
            result = false;   
        }
        return result;
    }
    
//-----------------------------------------------------------------------------
    
    private Level verbosityTologLevel()
    {
        int rebased = verbosity+3;
        switch (rebased)
        {
            case 0:
                return Level.OFF;
            case 1:
                return Level.SEVERE;
            case 2:
                return Level.WARNING;
            case 3:
                return Level.INFO;
            case 4:
                return Level.FINE;
            case 5:
                return Level.FINER;
            case 6:
                return Level.FINEST;
            default:
                // NB: Level.ALL does not actually allow all log. Don't use it.
                if (rebased>6)
                    return Level.FINEST;
                else
                    return Level.OFF;
        }
    }
 
//-----------------------------------------------------------------------------
 
    public int getVerbosity()
    {
        return verbosity;
    }
    
//------------------------------------------------------------------------------
    
    public void setVerbosity(int l)
    {
        this.verbosity = l;
        if (logger!=null)
        {
            logger.setLevel(verbosityTologLevel());
            for (int iH=0; iH<logger.getHandlers().length; iH++)
            {
                logger.getHandlers()[iH].setLevel(verbosityTologLevel());
            }
        }
        
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setVerbosity(l);
        }
    }
 
//-----------------------------------------------------------------------------
    
    public Randomizer getRandomizer()
    {
        if (rng==null)
        {
            for (RunTimeParameters innerParams : otherParameters.values())
            {
                if (innerParams.rng!=null)
                {
                    rng = innerParams.rng;
                    return innerParams.rng;
                }
            }
            
            rng = new Randomizer();
            for (RunTimeParameters innerParams : otherParameters.values())
            {
                innerParams.setRandomizer(rng);
            }
        }
        return rng;
    }
    
//-----------------------------------------------------------------------------
    
    public long getRandomSeed()
    {
        return rng.getSeed();
    }
 
//-----------------------------------------------------------------------------
    
    public void setRandomizer(Randomizer rng)
    {
        this.rng = rng;
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setRandomizer(rng);
        }
    }
 
//-----------------------------------------------------------------------------
    
    public Randomizer startRandomizer()
    {
        rng = new Randomizer();
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setRandomizer(rng);
        }
        return rng;
    }
    
//-----------------------------------------------------------------------------
    
    public Randomizer startRandomizer(long seed)
    {
        rng = new Randomizer(seed);
        for (RunTimeParameters innerParams : otherParameters.values())
        {
            innerParams.setRandomizer(rng);
        }
        return rng;
    }
    
//-----------------------------------------------------------------------------
 
    public void readParameterFile(String infile) throws DENOPTIMException
    {
        String line;
        BufferedReader br = null;
        try
        {
            br = new BufferedReader(new FileReader(infile));
            while ((line = br.readLine()) != null)
            {
                readParameterLine(line);
            }
        }
        catch (NumberFormatException | IOException nfe)
        {
            throw new DENOPTIMException(nfe);
        }
        finally
        {
            try
            {
                if (br != null)
                {
                    br.close();
                    br = null;
                }
            }
            catch (IOException ioe)
            {
                throw new DENOPTIMException(ioe);
            }
        }
    }
    
//-----------------------------------------------------------------------------
    
    public void readParameterLine(String line) throws DENOPTIMException
    {
        if ((line.trim()).length() == 0)
            return;
 
        if (line.startsWith("#")) //commented out lines
            return;
        
        if (line.toUpperCase().startsWith(paramType.keywordRoot))
        {
            interpretKeyword(line);
        } else {
            for (ParametersType parType : ParametersType.values())
            {
                if (line.toUpperCase().startsWith(parType.keywordRoot))
                {
                    if (!otherParameters.containsKey(parType))
                    {
                        RunTimeParameters otherParams = 
                                RunTimeParameters.getInstanceFor(parType);
                        otherParams.isMaster = false;
                        otherParameters.put(parType, otherParams);
                    }
                    otherParameters.get(parType).interpretKeyword(line);
                }
            }
        }
    }
 
//-----------------------------------------------------------------------------
 
    private static RunTimeParameters getInstanceFor(ParametersType paramType)
    {
        RunTimeParameters instance = null;
        try
        {
            Constructor<?> c = paramType.getImplementation().getConstructor();
            instance = (RunTimeParameters) c.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            // This should never happen because the constructor has to be there.
        }
        return instance;
    }
    
//------------------------------------------------------------------------------
    
    public boolean containsParameters(ParametersType type)
    {
        return otherParameters.containsKey(type);
    }
    
//------------------------------------------------------------------------------
    
    public RunTimeParameters getParameters(ParametersType type)
    {
        return otherParameters.get(type);
    }
    
//------------------------------------------------------------------------------
    
    public void setParameters(RunTimeParameters otherParams)
    {
        otherParams.isMaster = false;
        otherParameters.put(otherParams.paramType, otherParams);
    }
    
//------------------------------------------------------------------------------
    
// TODO: consider this mechanism for retrieving parameters once all parameters
//       will be of type Parameter.
//
//    /**
//     * @param type the type of embedded parameters to search for.
//     * @return the requested parameter, or null.
//     */
//    public RunTimeParameters getParameter(ParametersType type, 
//            String parName)
//    {
//        if (!containsParameters(type))
//        {
//            otherParams.isMaster = false;
//            otherParameters.put(type, getInstanceFor(type)); 
//        }
//
//        return otherParameters.get(type).get(parName);
//    }
//    
//    
//    public Parameter get(String parameterName)
//    {
//        return ...;
//    }
 
//-----------------------------------------------------------------------------
 
    public void interpretKeyword(String line) throws DENOPTIMException
    {
        String key = line.trim();
        String value = "";
        if (line.contains("="))
        {
            key = line.substring(paramType.keywordRoot.length(),
                    line.indexOf("=") + 1).trim();
            value = line.substring(line.indexOf("=") + 1).trim();
        } else {
            key = line.substring(paramType.keywordRoot.length());
        }
        try
        {
            interpretKeyword(key,value);
        }
        catch (DENOPTIMException e)
        {
            throw new DENOPTIMException(e.getMessage()+" Check line "+line);
        }
    }
 
//-----------------------------------------------------------------------------
 
    public abstract void interpretKeyword(String key, String value) 
            throws DENOPTIMException;
    
//-----------------------------------------------------------------------------
 
    public abstract void checkParameters() throws DENOPTIMException;
 
//------------------------------------------------------------------------------
 
    protected void checkOtherParameters() throws DENOPTIMException
    {
        for (RunTimeParameters otherCollector : otherParameters.values())
        {
            otherCollector.checkParameters();
        }
    }
    
//------------------------------------------------------------------------------
 
    public abstract void processParameters() throws DENOPTIMException;
        
//------------------------------------------------------------------------------
 
    protected void processOtherParameters() throws DENOPTIMException
    {
        for (RunTimeParameters otherCollector : otherParameters.values())
        {
            otherCollector.processParameters();
        }
    }
    
//------------------------------------------------------------------------------
 
    //NB: this must be abstract because the superclass cannot look into the
    // private fields of the subclass. When the parameters will be stored as
    // objects rather then fields, then we should be able to have the 
    // public String getPrintedList only in this class.
    public abstract String getPrintedList();
    /*
    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 void printParameters()
    {
        StringBuilder sb = new StringBuilder(1024);
        sb.append(getPrintedList()).append(NL);
        sb.append("-------------------------------------------"
                + "----------------------").append(NL);
        logger.log(Level.INFO,sb.toString());
    }
 
  //------------------------------------------------------------------------------
 
    protected void ensureFileExistsIfSet(String pathname)
    {
        if (pathname == null || pathname.isBlank())
            return;
                    
        if (!FileUtils.checkExists(pathname))
        {
            String msg = "ERROR! File '" + pathname + "' not found!";
            throw new Error(msg);
        }
    }
    
//------------------------------------------------------------------------------
 
    protected void ensureFileExists(String pathname)
    {
        if (!FileUtils.checkExists(pathname))
        {
            String msg = "ERROR! File '" + pathname + "' not found!";
            throw new Error(msg);
        }
    }
    
//------------------------------------------------------------------------------
 
    protected void ensureNotNull(String paramName, String param, String paramKey)
    {
        if (param == null)
        {
            String msg = "ERROR! Parameter '" + paramName + "' is null! "
                + "Please, add '" + paramType.keywordRoot + paramKey 
                + "' to the input parameters.";
            throw new Error(msg);
        }
    }
    
//------------------------------------------------------------------------------
 
    protected void ensureIsPositive(String paramName, int value, String paramKey)
    {
        if (value <= 0)
        {
            String msg = "ERROR! Parameter '" + paramName + "' not striktly "
                + "positive (" + value + "). "
                + "Please, use a positive value for '" + paramType.keywordRoot 
                + paramKey + "'.";
            throw new Error(msg);
        }
    }
    
//------------------------------------------------------------------------------
 
    protected void ensureIsPositiveOrZero(String paramName, int value, 
            String paramKey)
    {
        if (value < 0)
        {
            String msg = "ERROR! Parameter '" + paramName + "' is negative ("
                + value + "). "
                + "Please, use a positive value for '" + paramType.keywordRoot 
                + paramKey + "'.";
            throw new Error(msg);
        }
    }
    
//------------------------------------------------------------------------------
 
    protected void ensureInRange(String paramName, int value, int min, int max, 
            String paramKey)
    {
        if (max < value || min > value)
        {
            String msg = "ERROR! Parameter '" + paramName + "' is not in range"
                + min + " < x < " + max + " (value: " + value + "). "
                + "Please, correct the value of '" + paramType.keywordRoot 
                + paramKey + "'.";
            throw new Error(msg);
        }
    }
 
//----------------------------------------------------------------------------
 
}