runner/compbio/runner/OptionCombinator.java

   1 /* Copyright (c) 2011 Peter Troshin\r
   2  *  \r
   3  *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 2.0     \r
   4  * \r
   5  *  This library is free software; you can redistribute it and/or modify it under the terms of the\r
   6  *  Apache License version 2 as published by the Apache Software Foundation\r
   7  * \r
   8  *  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without\r
   9  *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Apache \r
  10  *  License for more details.\r
  11  * \r
  12  *  A copy of the license is in apache_license.txt. It is also available here:\r
  13  * @see: http://www.apache.org/licenses/LICENSE-2.0.txt\r
  14  * \r
  15  * Any republication or derived work distributed in source code form\r
  16  * must include this copyright and license notice.\r
  17  */\r
  18 \r
  19 package compbio.runner;\r
  20 \r
  21 import java.util.ArrayList;\r
  22 import java.util.HashMap;\r
  23 import java.util.List;\r
  24 import java.util.Map;\r
  25 import java.util.Random;\r
  26 \r
  27 import org.apache.log4j.Logger;\r
  28 \r
  29 import compbio.engine.client.Executable;\r
  30 import compbio.metadata.Option;\r
  31 import compbio.metadata.Parameter;\r
  32 import compbio.metadata.RunnerConfig;\r
  33 import compbio.metadata.ValueConstrain;\r
  34 import compbio.util.Util;\r
  35 import compbio.util.annotation.Immutable;\r
  36 \r
  37 /**\r
  38  * This class solve the following problems. Given the RunnerConfig\r
  39  * \r
  40  * 1) generate a valid option string with all options and parameters in it\r
  41  * \r
  42  * 2) Permute all possible combinations of options order and parameters values\r
  43  * \r
  44  * \r
  45  * @author pvtroshin\r
  46  * \r
  47  */\r
  48 @Immutable\r
  49 public final class OptionCombinator {\r
  50 \r
  51         private static Logger log = Logger.getLogger(OptionCombinator.class);\r
  52         private static final String MINVALUE = "-100";\r
  53         private static final String MAXVALUE = "100";\r
  54 \r
  55         private static final Random rand = new Random();\r
  56         private final RunnerConfig<? extends Executable<?>> rconfig;\r
  57 \r
  58         public OptionCombinator(RunnerConfig<? extends Executable<?>> rconfig) {\r
  59                 if (rconfig == null) {\r
  60                         throw new IllegalArgumentException("RunnerConfig must be provided!");\r
  61                 }\r
  62                 this.rconfig = rconfig;\r
  63         }\r
  64 \r
  65         public List<String> optionsToCommandString(List<Option<?>> options) {\r
  66                 List<String> strOptions = new ArrayList<String>();\r
  67                 for (Option<?> option : options) {\r
  68                         strOptions.add(optionToCommandString(option));\r
  69                 }\r
  70                 return strOptions;\r
  71         }\r
  72 \r
  73         public List<String> getOptionsAtRandom() {\r
  74                 return optionsToCommandString(getAllOptions());\r
  75         }\r
  76 \r
  77         public List<Option<?>> getAllOptions() {\r
  78                 return new ArrayList<Option<?>>(rconfig.getOptions());\r
  79         }\r
  80 \r
  81         static String optionToCommandString(Option<?> option) {\r
  82                 int size = option.getOptionNames().size();\r
  83                 int idx = rand.nextInt(size);\r
  84                 return option.getOptionNames().get(idx);\r
  85         }\r
  86 \r
  87         public List<Parameter<?>> getAllParameters() {\r
  88                 List<Parameter<?>> args = new ArrayList<Parameter<?>>();\r
  89                 for (Parameter<?> prm : rconfig.getParameters()) {\r
  90                         // Make sure there is a default value linked to the parameter to use later\r
  91                         // prm.setDefaultValue(getValue(prm));\r
  92                         args.add(prm);\r
  93                 }\r
  94                 return args;\r
  95         }\r
  96 \r
  97         public List<String> argumentsToCommandString(List<? extends Option<?>> arguments) {\r
  98                 return argumentsToCommandString(arguments, rconfig);\r
  99         }\r
 100 \r
 101         public static List<String> argumentsToCommandString(List<? extends Option<?>> arguments,RunnerConfig<? extends Executable<?>> rconfig) {\r
 102                 if (arguments == null || rconfig == null) {\r
 103                         throw new NullPointerException("Arguments and RunnerConfig objects must be provided!");\r
 104                 }\r
 105 \r
 106                 List<String> command = new ArrayList<String>();\r
 107                 for (Option<?> option : arguments) {\r
 108                         if (option instanceof Parameter<?>) {\r
 109                                 Parameter<?> prm = (Parameter<?>) option;\r
 110                                 command.add(prm.getOptionName() + rconfig.getPrmSeparator() + getValue(prm));\r
 111                                 log.trace("Setting parameter " + prm);\r
 112                         } else {\r
 113                                 log.trace("Setting option " + option);\r
 114                                 command.add(optionToCommandString(option));\r
 115                         }\r
 116                 }\r
 117                 return command;\r
 118         }\r
 119 \r
 120         public List<String> parametersToCommandString(List<Parameter<?>> orderedList, Map<Parameter<?>, String> prmValue) {\r
 121                 List<String> args = new ArrayList<String>();\r
 122                 for (Parameter<?> param : orderedList) {\r
 123                         args.add(param.getOptionName() + rconfig.getPrmSeparator() + prmValue.get(param));\r
 124                 }\r
 125                 return args;\r
 126         }\r
 127 \r
 128         public Map<Parameter<?>, String> getAllConstrainedParametersWithBorderValues( boolean minValue) {\r
 129                 Map<Parameter<?>, String> paramValue = new HashMap<Parameter<?>, String>();\r
 130                 for (Parameter<?> prm : rconfig.getParameters()) {\r
 131                         ValueConstrain vc = prm.getValidValue();\r
 132                         if (vc == null) {\r
 133                                 continue;\r
 134                         }\r
 135                         String value =  getUpperBorderValue(prm);\r
 136                         if (minValue) {\r
 137                                 value = getLowBorderValue(prm);\r
 138                         }\r
 139                         paramValue.put(prm, value);\r
 140                 }\r
 141                 return paramValue;\r
 142         }\r
 143 \r
 144         public Map<Parameter<?>, String> getAllConstrainedParametersWithRandomValues() {\r
 145         Map<Parameter<?>, String> paramValue = new HashMap<Parameter<?>, String>();\r
 146                 for (Parameter<?> prm : rconfig.getParameters()) {\r
 147                         ValueConstrain vc = prm.getValidValue();\r
 148                         if (vc == null) {\r
 149                                 continue;\r
 150                         }\r
 151                         paramValue.put(prm, getRandomValue(prm));\r
 152                 }\r
 153                 return paramValue;\r
 154         }\r
 155 \r
 156         String getLowBorderValue(Parameter<?> param) {\r
 157                 assert param != null;\r
 158                 ValueConstrain vc = param.getValidValue();\r
 159                 Number minVal = vc.getMin();\r
 160                 return minVal == null ? MINVALUE : minVal.toString();\r
 161         }\r
 162 \r
 163         String getUpperBorderValue(Parameter<?> param) {\r
 164                 assert param != null;\r
 165                 ValueConstrain vc = param.getValidValue();\r
 166                 Number maxVal = vc.getMax();\r
 167                 return maxVal == null ? MAXVALUE : maxVal.toString();\r
 168         }\r
 169 \r
 170         String getRandomValue(Parameter<?> param) {\r
 171                 assert param != null;\r
 172                 String low = getLowBorderValue(param);\r
 173                 String high = getUpperBorderValue(param);\r
 174                 ValueConstrain vc = param.getValidValue();\r
 175 \r
 176                 if (vc.getType() == ValueConstrain.Type.Float) {\r
 177                         return new Double(Util.getRandomNumber(Double.parseDouble(low), Double.parseDouble(high))).toString();\r
 178                 }\r
 179                 return new Integer(Util.getRandomNumber(Integer.parseInt(low), Integer.parseInt(high))).toString();\r
 180         }\r
 181 \r
 182         static String getValue(Parameter<?> param) {\r
 183         assert param != null;\r
 184         if (param.getDefaultValue() != null) {\r
 185                 log.trace("Returning default value: " + param.getDefaultValue());\r
 186                 return param.getDefaultValue();\r
 187         } else {\r
 188                 // Some parameters do not have default values e.g. seq type - nuc or protein\r
 189                 List<String> passValues = param.getPossibleValues();\r
 190                 int idx = rand.nextInt(passValues.size());\r
 191                 log.trace("Returning random value: " + passValues.get(idx));\r
 192                 return passValues.get(idx);\r
 193                 }\r
 194         }\r
 195 \r
 196 }\r