$darkmode
DENOPTIM
RunTimeParameters.java
Go to the documentation of this file.
1/*
2 * DENOPTIM
3 * Copyright (C) 2019 Marco Foscato <marco.foscato@uib.no>
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Affero General Public License as published
7 * by the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU Affero General Public License for more details.
14 *
15 * You should have received a copy of the GNU Affero General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19package denoptim.programs;
20
21import java.io.BufferedReader;
22import java.io.FileReader;
23import java.io.IOException;
24import java.lang.reflect.Constructor;
25import java.util.HashMap;
26import java.util.Map;
27import java.util.logging.ConsoleHandler;
28import java.util.logging.FileHandler;
29import java.util.logging.Handler;
30import java.util.logging.Level;
31import java.util.logging.Logger;
32import java.util.logging.SimpleFormatter;
33import java.util.logging.StreamHandler;
34
35import denoptim.exception.DENOPTIMException;
36import denoptim.files.FileUtils;
37import denoptim.fitness.FitnessParameters;
38import denoptim.fragspace.FragmentSpaceParameters;
39import denoptim.graph.rings.RingClosureParameters;
40import denoptim.io.DenoptimIO;
41import denoptim.main.Main.RunType;
42import denoptim.programs.combinatorial.CEBLParameters;
43import denoptim.programs.denovo.GAParameters;
44import denoptim.programs.fitnessevaluator.FRParameters;
45import denoptim.programs.fragmenter.FragmenterParameters;
46import denoptim.programs.genetweeker.GeneOpsRunnerParameters;
47import denoptim.programs.grapheditor.GraphEdParameters;
48import denoptim.programs.graphlisthandler.GraphListsHandlerParameters;
49import denoptim.programs.isomorphism.IsomorphismParameters;
50import denoptim.programs.mol2graph.Mol2GraphParameters;
51import denoptim.programs.moldecularmodelbuilder.MMBuilderParameters;
52import denoptim.utils.Randomizer;
53
54
70public abstract class RunTimeParameters
71{
79 protected boolean isMaster = true;
80
84 protected String workDir = System.getProperty("user.dir");
85
89 protected String logFile = "unset";
90
98 private Logger logger = Logger.getLogger("DummyLogger");
99
103 private Randomizer rng = null;
104
110 protected int verbosity = 0;
111
115 protected Map<ParametersType, RunTimeParameters> otherParameters =
116 new HashMap<ParametersType, RunTimeParameters>();
117
121 private ParametersType paramType = null;
122
126 public static enum ParametersType {
131
136
141
146
152
158
163
168
173
178
183
188
193
198 private String keywordRoot;
199
203 private Class<?> implementation;
204
205 static {
206 CEBL_PARAMS.keywordRoot = "FSE-";
207 GA_PARAMS.keywordRoot = "GA-";
208 FS_PARAMS.keywordRoot = "FS-";
209 FRG_PARAMS.keywordRoot = "FRG-";
210 RC_PARAMS.keywordRoot = "RC-";
211 FIT_PARAMS.keywordRoot = "FP-";
212 FR_PARAMS.keywordRoot = "FR-";
213 MMB_PARAM.keywordRoot = "3DB-";
214 GO_PARAMS.keywordRoot = "TESTGENOPS-";
215 GE_PARAMS.keywordRoot = "GRAPHEDIT-";
216 GLH_PARAMS.keywordRoot = "GRAPHLISTS-";
217 ISO_PARAMS.keywordRoot = "ISOMORPHISM-";
218 M2G_PARAMS.keywordRoot = "M2G-";
219
220 CEBL_PARAMS.implementation = CEBLParameters.class;
221 GA_PARAMS.implementation = GAParameters.class;
222 FS_PARAMS.implementation = FragmentSpaceParameters.class;
223 FRG_PARAMS.implementation = FragmenterParameters.class;
224 RC_PARAMS.implementation = RingClosureParameters.class;
225 FIT_PARAMS.implementation = FitnessParameters.class;
226 FR_PARAMS.implementation = FRParameters.class;
227 MMB_PARAM.implementation = MMBuilderParameters.class;
228 GO_PARAMS.implementation = GeneOpsRunnerParameters.class;
229 GE_PARAMS.implementation = GraphEdParameters.class;
230 GLH_PARAMS.implementation = GraphListsHandlerParameters.class;
231 ISO_PARAMS.implementation = IsomorphismParameters.class;
232 M2G_PARAMS.implementation = Mol2GraphParameters.class;
233 }
234
238 public Class<?> getImplementation()
239 {
240 return implementation;
241 }
242
247 public String getKeywordRoot()
248 {
249 return keywordRoot;
250 }
251 }
252
253 /*
254 * TODO: if we want a general Parameter class it will have to define
255 * - unique name of the parameter
256 * - java type used to collect the value
257 * - default value
258 * - description of what the parameter is or what it controls
259 * - code for parsing the value from input files
260 * - code for checking
261 * - core for processing the parameter
262 * - what else?
263 *
264 * Challenge: what about parameters that depend on other parameters?
265 * Need to control order of processing the parameters, in some occasions.
266 */
267
268
272 public final String NL = System.getProperty("line.separator");
273
274//-----------------------------------------------------------------------------
275
281 {
282 this.paramType = paramType;
283
284 /*
285 * This is the default logger "DummyLogger". It should be overwritten
286 * by a call to startProgramSpecificLogger
287 */
288 this.logger.setLevel(Level.SEVERE);
289 }
290
291//-----------------------------------------------------------------------------
292
297 public String paramTypeName()
298 {
299 return paramType.toString();
300 }
301
302//-----------------------------------------------------------------------------
303
308 public String getWorkDirectory()
309 {
310 return workDir;
311 }
312
313//-----------------------------------------------------------------------------
314
319 public void setWorkDirectory(String pathname)
320 {
321 this.workDir = pathname;
322 }
323
324//-----------------------------------------------------------------------------
325
330 public String getLogFilePathname()
331 {
332 return logFile;
333 }
334
335//-----------------------------------------------------------------------------
336
341 public void setLogFilePathname(String pathname)
342 {
343 this.workDir = pathname;
344 }
345
346//-----------------------------------------------------------------------------
347
351 public Logger getLogger()
352 {
353 return logger;
354 }
355
356//-----------------------------------------------------------------------------
357
364 private void setLogger(Logger logger)
365 {
366 this.logger = logger;
367 for (RunTimeParameters innerParams : otherParameters.values())
368 {
369 innerParams.setLogger(logger);
370 }
371 }
372
373//-----------------------------------------------------------------------------
374
388 public Logger startProgramSpecificLogger(String loggerIdentifier)
389 throws SecurityException, IOException
390 {
391 return startProgramSpecificLogger(loggerIdentifier, true);
392 }
393
394//-----------------------------------------------------------------------------
395
410 public Logger startProgramSpecificLogger(String loggerIdentifier,
411 boolean toLogFile)
412 throws SecurityException, IOException
413 {
414 logger = Logger.getLogger(loggerIdentifier);
415
416 int n = logger.getHandlers().length;
417 for (int i=0; i<n; i++)
418 {
419 logger.removeHandler(logger.getHandlers()[0]);
420 }
421
422 if (toLogFile)
423 {
424 FileHandler fileHdlr = new FileHandler(logFile);
425 SimpleFormatter formatterTxt = new SimpleFormatter();
426 fileHdlr.setFormatter(formatterTxt);
427 logger.setUseParentHandlers(false);
428 logger.addHandler(fileHdlr);
429 logger.setLevel(Level.INFO);
430 String header = "Started logging for " + loggerIdentifier;
431 logger.log(Level.INFO,header);
432 } else {
433 logger.addHandler(new StreamHandler(System.out,
434 new SimpleFormatter()));
435 }
436
437 if (verbosity!=0)
438 {
439 Logger parlogger = logger;
440 while (parlogger != null)
441 {
442 parlogger.setLevel(verbosityTologLevel());
443 for (Handler handler : parlogger.getHandlers())
444 {
445 handler.setLevel(verbosityTologLevel());
446 }
447 parlogger = parlogger.getParent();
448 }
449 }
450
451 for (RunTimeParameters innerParams : otherParameters.values())
452 {
453 innerParams.setLogger(logger);
454 }
455
456 return logger;
457 }
458
459//-----------------------------------------------------------------------------
460
466 public Logger startConsoleLogger(String loggerIdentifier)
467 {
468 logger = Logger.getLogger(loggerIdentifier);
469
470 int n = logger.getHandlers().length;
471 for (int i=0; i<n; i++)
472 {
473 logger.removeHandler(logger.getHandlers()[0]);
474 }
475 ConsoleHandler handler = new ConsoleHandler();
476 handler.setFormatter(new SimpleFormatter());
477 handler.setLevel(Level.INFO);
478 logger.addHandler(handler);
479
480 if (verbosity!=0)
481 {
482 logger.setLevel(verbosityTologLevel());
483 for (int iH=0; iH<logger.getHandlers().length; iH++)
484 {
485 logger.getHandlers()[iH].setLevel(verbosityTologLevel());
486 }
487 }
488
489 for (RunTimeParameters innerParams : otherParameters.values())
490 {
491 innerParams.setLogger(logger);
492 }
493
494 return logger;
495 }
496
497//-----------------------------------------------------------------------------
498
506 public static boolean readYesNoTrueFalse(String s)
507 {
508 boolean result = false;
509 String value = s.trim().toUpperCase();
510 if (value.equals("YES")
511 || value.equals("Y")
512 || value.equals("T")
513 || value.equals("TRUE"))
514 {
515 result = true;
516 } else if (value.equals("NO")
517 || value.equals("N")
518 || value.equals("F")
519 || value.equals("FALSE"))
520 {
521 result = false;
522 }
523 return result;
524 }
525
526//-----------------------------------------------------------------------------
527
528 private Level verbosityTologLevel()
529 {
530 int rebased = verbosity+3;
531 switch (rebased)
532 {
533 case 0:
534 return Level.OFF;
535 case 1:
536 return Level.SEVERE;
537 case 2:
538 return Level.WARNING;
539 case 3:
540 return Level.INFO;
541 case 4:
542 return Level.FINE;
543 case 5:
544 return Level.FINER;
545 case 6:
546 return Level.FINEST;
547 default:
548 // NB: Level.ALL does not actually allow all log. Don't use it.
549 if (rebased>6)
550 return Level.FINEST;
551 else
552 return Level.OFF;
553 }
554 }
555
556//-----------------------------------------------------------------------------
557
563 public int getVerbosity()
564 {
565 return verbosity;
566 }
567
568//------------------------------------------------------------------------------
569
578 public void setVerbosity(int l)
579 {
580 this.verbosity = l;
581 if (logger!=null)
582 {
583 logger.setLevel(verbosityTologLevel());
584 for (int iH=0; iH<logger.getHandlers().length; iH++)
585 {
586 logger.getHandlers()[iH].setLevel(verbosityTologLevel());
587 }
588 }
589
590 for (RunTimeParameters innerParams : otherParameters.values())
591 {
592 innerParams.setVerbosity(l);
593 }
594 }
595
596//-----------------------------------------------------------------------------
597
606 {
607 if (rng==null)
608 {
609 for (RunTimeParameters innerParams : otherParameters.values())
610 {
611 if (innerParams.rng!=null)
612 {
613 rng = innerParams.rng;
614 return innerParams.rng;
615 }
616 }
617
618 rng = new Randomizer();
619 for (RunTimeParameters innerParams : otherParameters.values())
620 {
621 innerParams.setRandomizer(rng);
622 }
623 }
624 return rng;
625 }
626
627//-----------------------------------------------------------------------------
628
633 public long getRandomSeed()
634 {
635 return rng.getSeed();
636 }
637
638//-----------------------------------------------------------------------------
639
646 {
647 this.rng = rng;
648 for (RunTimeParameters innerParams : otherParameters.values())
649 {
650 innerParams.setRandomizer(rng);
651 }
652 }
653
654//-----------------------------------------------------------------------------
655
662 {
663 rng = new Randomizer();
664 for (RunTimeParameters innerParams : otherParameters.values())
665 {
666 innerParams.setRandomizer(rng);
667 }
668 return rng;
669 }
670
671//-----------------------------------------------------------------------------
672
678 public Randomizer startRandomizer(long seed)
679 {
680 rng = new Randomizer(seed);
681 for (RunTimeParameters innerParams : otherParameters.values())
682 {
683 innerParams.setRandomizer(rng);
684 }
685 return rng;
686 }
687
688//-----------------------------------------------------------------------------
689
695 public void readParameterFile(String infile) throws DENOPTIMException
696 {
697 String line;
698 BufferedReader br = null;
699 try
700 {
701 br = new BufferedReader(new FileReader(infile));
702 while ((line = br.readLine()) != null)
703 {
704 readParameterLine(line);
705 }
706 }
707 catch (NumberFormatException | IOException nfe)
708 {
709 throw new DENOPTIMException(nfe);
710 }
711 finally
712 {
713 try
714 {
715 if (br != null)
716 {
717 br.close();
718 br = null;
719 }
720 }
721 catch (IOException ioe)
722 {
723 throw new DENOPTIMException(ioe);
724 }
725 }
726 }
727
728//-----------------------------------------------------------------------------
729
735 public void readParameterLine(String line) throws DENOPTIMException
736 {
737 if ((line.trim()).length() == 0)
738 return;
739
740 if (line.startsWith("#")) //commented out lines
741 return;
742
743 if (line.toUpperCase().startsWith(paramType.keywordRoot))
744 {
745 interpretKeyword(line);
746 } else {
747 for (ParametersType parType : ParametersType.values())
748 {
749 if (line.toUpperCase().startsWith(parType.keywordRoot))
750 {
751 if (!otherParameters.containsKey(parType))
752 {
753 RunTimeParameters otherParams =
755 otherParams.isMaster = false;
756 otherParameters.put(parType, otherParams);
757 }
758 otherParameters.get(parType).interpretKeyword(line);
759 }
760 }
761 }
762 }
763
764//-----------------------------------------------------------------------------
765
774 {
775 RunTimeParameters instance = null;
776 try
777 {
778 Constructor<?> c = paramType.getImplementation().getConstructor();
779 instance = (RunTimeParameters) c.newInstance();
780 } catch (Exception e) {
781 e.printStackTrace();
782 // This should never happen because the constructor has to be there.
783 }
784 return instance;
785 }
786
787//------------------------------------------------------------------------------
788
795 {
796 return otherParameters.containsKey(type);
797 }
798
799//------------------------------------------------------------------------------
800
806 {
807 return otherParameters.get(type);
808 }
809
810//------------------------------------------------------------------------------
811
815 public void setParameters(RunTimeParameters otherParams)
816 {
817 otherParams.isMaster = false;
818 otherParameters.put(otherParams.paramType, otherParams);
819 }
820
821//------------------------------------------------------------------------------
822
823// TODO: consider this mechanism for retrieving parameters once all parameters
824// will be of type Parameter.
825//
826// /**
827// * @param type the type of embedded parameters to search for.
828// * @return the requested parameter, or null.
829// */
830// public RunTimeParameters getParameter(ParametersType type,
831// String parName)
832// {
833// if (!containsParameters(type))
834// {
835// otherParams.isMaster = false;
836// otherParameters.put(type, getInstanceFor(type));
837// }
838//
839// return otherParameters.get(type).get(parName);
840// }
841//
843//
844// public Parameter get(String parameterName)
845// {
846// return ...;
847// }
848
849//-----------------------------------------------------------------------------
850
856 public void interpretKeyword(String line) throws DENOPTIMException
857 {
858 String key = line.trim();
859 String value = "";
860 if (line.contains("="))
861 {
862 key = line.substring(paramType.keywordRoot.length(),
863 line.indexOf("=") + 1).trim();
864 value = line.substring(line.indexOf("=") + 1).trim();
865 } else {
866 key = line.substring(paramType.keywordRoot.length());
867 }
868 try
869 {
870 interpretKeyword(key,value);
871 }
872 catch (DENOPTIMException e)
873 {
874 throw new DENOPTIMException(e.getMessage()+" Check line "+line);
875 }
876 }
877
878//-----------------------------------------------------------------------------
879
887 public abstract void interpretKeyword(String key, String value)
888 throws DENOPTIMException;
889
890//-----------------------------------------------------------------------------
891
896 public abstract void checkParameters() throws DENOPTIMException;
897
898//------------------------------------------------------------------------------
899
905 {
906 for (RunTimeParameters otherCollector : otherParameters.values())
907 {
908 otherCollector.checkParameters();
909 }
910 }
911
912//------------------------------------------------------------------------------
913
918 public abstract void processParameters() throws DENOPTIMException;
919
920//------------------------------------------------------------------------------
921
927 {
928 for (RunTimeParameters otherCollector : otherParameters.values())
929 {
930 otherCollector.processParameters();
931 }
932 }
933
934//------------------------------------------------------------------------------
935
942 //NB: this must be abstract because the superclass cannot look into the
943 // private fields of the subclass. When the parameters will be stored as
944 // objects rather then fields, then we should be able to have the
945 // public String getPrintedList only in this class.
946 public abstract String getPrintedList();
947 /*
948 public String getPrintedList()
949 {
950 StringBuilder sb = new StringBuilder(1024);
951 sb.append(" " + paramTypeName() + " ").append(NL);
952 for (Field f : this.getClass().getDeclaredFields())
953 {
954 try
955 {
956 sb.append(f.getName()).append(" = ").append(
957 f.get(this)).append(NL);
958 }
959 catch (Throwable t)
960 {
961 sb.append("ERROR! Unable to print " + paramTypeName()
962 + " parameters. Cause: " + t);
963 break;
964 }
965 }
966 for (RunTimeParameters otherCollector : otherParameters.values())
967 {
968 sb.append(otherCollector.getPrintedList());
969 }
970 return sb.toString();
971 }
972 */
973
974//----------------------------------------------------------------------------
975
980 public void printParameters()
981 {
982 StringBuilder sb = new StringBuilder(1024);
983 sb.append(getPrintedList()).append(NL);
984 sb.append("-------------------------------------------"
985 + "----------------------").append(NL);
986 logger.log(Level.INFO,sb.toString());
987 }
988
989 //------------------------------------------------------------------------------
990
997 protected void ensureFileExistsIfSet(String pathname)
998 {
999 if (pathname == null || pathname.isBlank())
1000 return;
1001
1002 if (!FileUtils.checkExists(pathname))
1003 {
1004 String msg = "ERROR! File '" + pathname + "' not found!";
1005 throw new Error(msg);
1006 }
1007 }
1008
1009//------------------------------------------------------------------------------
1010
1016 protected void ensureFileExists(String pathname)
1017 {
1018 if (!FileUtils.checkExists(pathname))
1019 {
1020 String msg = "ERROR! File '" + pathname + "' not found!";
1021 throw new Error(msg);
1022 }
1023 }
1024
1025//------------------------------------------------------------------------------
1026
1032 protected void ensureNotNull(String paramName, String param, String paramKey)
1033 {
1034 if (param == null)
1035 {
1036 String msg = "ERROR! Parameter '" + paramName + "' is null! "
1037 + "Please, add '" + paramType.keywordRoot + paramKey
1038 + "' to the input parameters.";
1039 throw new Error(msg);
1040 }
1041 }
1042
1043//------------------------------------------------------------------------------
1044
1050 protected void ensureIsPositive(String paramName, int value, String paramKey)
1051 {
1052 if (value <= 0)
1053 {
1054 String msg = "ERROR! Parameter '" + paramName + "' not striktly "
1055 + "positive (" + value + "). "
1056 + "Please, use a positive value for '" + paramType.keywordRoot
1057 + paramKey + "'.";
1058 throw new Error(msg);
1059 }
1060 }
1061
1062//------------------------------------------------------------------------------
1063
1069 protected void ensureIsPositiveOrZero(String paramName, int value,
1070 String paramKey)
1071 {
1072 if (value < 0)
1073 {
1074 String msg = "ERROR! Parameter '" + paramName + "' is negative ("
1075 + value + "). "
1076 + "Please, use a positive value for '" + paramType.keywordRoot
1077 + paramKey + "'.";
1078 throw new Error(msg);
1079 }
1080 }
1081
1082//------------------------------------------------------------------------------
1083
1089 protected void ensureInRange(String paramName, int value, int min, int max,
1090 String paramKey)
1091 {
1092 if (max < value || min > value)
1093 {
1094 String msg = "ERROR! Parameter '" + paramName + "' is not in range"
1095 + min + " < x < " + max + " (value: " + value + "). "
1096 + "Please, correct the value of '" + paramType.keywordRoot
1097 + paramKey + "'.";
1098 throw new Error(msg);
1099 }
1100 }
1101
1102//----------------------------------------------------------------------------
1103
1104}
static boolean checkExists(String fileName)
Definition: FileUtils.java:241
Settings defining the calculation of fitness.
Parameters defining the fragment space.
Parameters and setting related to handling ring closures.
Collection of parameters controlling the behavior of the software.
Map< ParametersType, RunTimeParameters > otherParameters
Collection of other parameters by type.
void setRandomizer(Randomizer rng)
Sets the randomizer.
Logger startProgramSpecificLogger(String loggerIdentifier)
Starts a logger with the given name.
RunTimeParameters(ParametersType paramType)
Constructor.
boolean isMaster
Flag signaling this is the master collection of parameters.
boolean containsParameters(ParametersType type)
void setLogger(Logger logger)
Set the name of the program specific logger.
abstract void checkParameters()
Evaluate consistency of input parameters.
void setParameters(RunTimeParameters otherParams)
String getWorkDirectory()
Gets the pathname to the working directory.
static RunTimeParameters getInstanceFor(ParametersType paramType)
Builds the implementation of this class suitable to allocate parameters of the given type.
Randomizer startRandomizer(long seed)
Starts a program specific randomizer, i.e., a tool for generating random numbers and taking random de...
static boolean readYesNoTrueFalse(String s)
Reads a string searching for any common way to say either yes/true (including shorthand t/y) or no/fa...
abstract String getPrintedList()
Returns the list of parameters in a string with newline characters as delimiters.
void ensureFileExists(String pathname)
Ensures a pathname does lead to an existing file or triggers an error.
void interpretKeyword(String line)
Processes a string looking for keyword and a possibly associated value.
RunTimeParameters getParameters(ParametersType type)
void readParameterFile(String infile)
Read the parameter TXT file line by line and interpret its content.
Logger getLogger()
Get the name of the program specific logger.
Logger startProgramSpecificLogger(String loggerIdentifier, boolean toLogFile)
Starts a logger with the given name.
Logger logger
Program-specific logger.
void ensureIsPositiveOrZero(String paramName, int value, String paramKey)
Ensures that a parameter is a positive number (x>=0) or triggers an error.
String getLogFilePathname()
Gets the pathname to the log file.
void printParameters()
Print all parameters.
void setLogFilePathname(String pathname)
Sets the pathname to the log file.
abstract void processParameters()
Processes all parameters and initialize related objects.
void ensureNotNull(String paramName, String param, String paramKey)
Ensures that a parameter is not null or triggers an error.
String paramTypeName()
Returns a string defining the type the parameters collected here.
void ensureInRange(String paramName, int value, int min, int max, String paramKey)
Ensures that a parameter is within a range or triggers an error.
void ensureIsPositive(String paramName, int value, String paramKey)
Ensures that a parameter is a positive number (x>=0) or triggers an error.
Randomizer rng
Program-specific random numbers and random decisions generator.
void checkOtherParameters()
Checks any of the parameter collections contained in this instance.
abstract void interpretKeyword(String key, String value)
Processes a keyword/value pair and assign the related parameters.
Logger startConsoleLogger(String loggerIdentifier)
Starts a program-specific logger that prints to System.err stream.
final String NL
New line character.
Randomizer startRandomizer()
Starts a program specific randomizer, i.e., a tool for generating random numbers and taking random de...
ParametersType paramType
The type of parameters collected in this instance.
int getVerbosity()
Returns the level of verbosity, i.e., the amount of log that we want to print.
void processOtherParameters()
Processes any of the parameter collections contained in this instance.
int verbosity
Verbosity level for logger.
void setVerbosity(int l)
Set the level of verbosity.
Randomizer getRandomizer()
Returns the current program-specific randomizer.
void setWorkDirectory(String pathname)
Gets the pathname to the working directory.
void ensureFileExistsIfSet(String pathname)
Ensures a pathname is not empty nor null and that it does lead to an existing file or triggers an err...
Parameters controlling execution of the combinatorial algorithm for exploration of a fragment space b...
Parameters for genetic algorithm.
Parameters controlling execution of FitnessRunner.
Parameters controlling execution of the fragmenter.
Parameters controlling execution of TestOperator.
Parameters controlling execution of GraphEditor.
Parameters controlling execution of Isomorphism main class.
Parameters controlling execution of GraphEditor.
Parameters for the conformer generator (3D builder).
Tool to generate random numbers and random decisions.
Definition: Randomizer.java:35
GO_PARAMS
Parameters controlling stand-alone run of genetic operators.
FR_PARAMS
Parameters controlling a stand-alone fitness evaluation run.
M2G_PARAMS
Parameters controlling molecule-to-graph conversion.
String keywordRoot
The root of any keyword that is meant to be used to set any of the parameters belonging to this class...
FS_PARAMS
Parameters pertaining the definition of the fragment space.
CEBL_PARAMS
Parameters pertaining the combinatorial exploration by layer.
ISO_PARAMS
Parameters controlling the stand-alone detection of graph isomorphism.
FRG_PARAMS
Parameters controlling the fragmenter.
MMB_PARAM
Parameters pertaining the construction of three-dimensional molecular models using the Tinker-based m...
GLH_PARAMS
Parameters controlling the stand-alone management of list of graphs.
FIT_PARAMS
Parameters pertaining the calculation of fitness (i.e., the fitness provider).
GA_PARAMS
Parameters pertaining the genetic algorithm.
RC_PARAMS
Parameters pertaining to ring closures in graphs.
GE_PARAMS
Parameters controlling the stand-alone editing of graphs.