queso-0.53.0
SimulationModelOptions.C
Go to the documentation of this file.
1 //-----------------------------------------------------------------------bl-
2 //--------------------------------------------------------------------------
3 //
4 // QUESO - a library to support the Quantification of Uncertainty
5 // for Estimation, Simulation and Optimization
6 //
7 // Copyright (C) 2008-2015 The PECOS Development Team
8 //
9 // This library is free software; you can redistribute it and/or
10 // modify it under the terms of the Version 2.1 GNU Lesser General
11 // Public License as published by the Free Software Foundation.
12 //
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // Lesser General Public License for more details.
17 //
18 // You should have received a copy of the GNU Lesser General Public
19 // License along with this library; if not, write to the Free Software
20 // Foundation, Inc. 51 Franklin Street, Fifth Floor,
21 // Boston, MA 02110-1301 USA
22 //
23 //-----------------------------------------------------------------------el-
24 
25 #include <boost/program_options.hpp>
26 
27 #include <queso/SimulationModelOptions.h>
28 #include <queso/Miscellaneous.h>
29 
30 namespace QUESO {
31 
32 SmOptionsValues::SmOptionsValues()
33  :
34  m_prefix("sm_"),
35  m_dataOutputFileName(UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV),
36  m_dataOutputAllowAll(UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV),
37  //m_dataOutputAllowedSet(),
38  m_p_eta(UQ_SIMULATION_MODEL_P_ETA_ODV),
39  m_zeroRelativeSingularValue(UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV),
40  m_cdfThresholdForPEta(UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV),
41  m_a_w(UQ_SIMULATION_MODEL_A_W_ODV),
42  m_b_w(UQ_SIMULATION_MODEL_B_W_ODV),
43  m_a_rho_w(UQ_SIMULATION_MODEL_A_RHO_W_ODV),
44  m_b_rho_w(UQ_SIMULATION_MODEL_B_RHO_W_ODV),
45  m_a_eta(UQ_SIMULATION_MODEL_A_ETA_ODV),
46  m_b_eta(UQ_SIMULATION_MODEL_B_ETA_ODV),
47  m_a_s(UQ_SIMULATION_MODEL_A_S_ODV),
48  m_b_s(UQ_SIMULATION_MODEL_B_S_ODV),
49  m_parser(NULL),
50  m_option_help(m_prefix + "help"),
51  m_option_dataOutputFileName(m_prefix + "dataOutputFileName"),
52  m_option_dataOutputAllowAll(m_prefix + "dataOutputAllowAll"),
53  m_option_dataOutputAllowedSet(m_prefix + "dataOutputAllowedSet"),
54  m_option_p_eta(m_prefix + "p_eta"),
55  m_option_zeroRelativeSingularValue(m_prefix + "zeroRelativeSingularValue"),
56  m_option_cdfThresholdForPEta(m_prefix + "cdfThresholdForPEta"),
57  m_option_a_w(m_prefix + "a_w"),
58  m_option_b_w(m_prefix + "b_w"),
59  m_option_a_rho_w(m_prefix + "a_rho_w"),
60  m_option_b_rho_w(m_prefix + "b_rho_w"),
61  m_option_a_eta(m_prefix + "a_eta"),
62  m_option_b_eta(m_prefix + "b_eta"),
63  m_option_a_s(m_prefix + "a_s"),
64  m_option_b_s(m_prefix + "b_s")
65 {
66 }
67 
68 SmOptionsValues::SmOptionsValues(const BaseEnvironment * env, const char *
69  prefix)
70  :
71  m_prefix((std::string)(prefix) + "sm_"),
72  m_dataOutputFileName(UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV),
73  m_dataOutputAllowAll(UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV),
74  //m_dataOutputAllowedSet(),
75  m_p_eta(UQ_SIMULATION_MODEL_P_ETA_ODV),
76  m_zeroRelativeSingularValue(UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV),
77  m_cdfThresholdForPEta(UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV),
78  m_a_w(UQ_SIMULATION_MODEL_A_W_ODV),
79  m_b_w(UQ_SIMULATION_MODEL_B_W_ODV),
80  m_a_rho_w(UQ_SIMULATION_MODEL_A_RHO_W_ODV),
81  m_b_rho_w(UQ_SIMULATION_MODEL_B_RHO_W_ODV),
82  m_a_eta(UQ_SIMULATION_MODEL_A_ETA_ODV),
83  m_b_eta(UQ_SIMULATION_MODEL_B_ETA_ODV),
84  m_a_s(UQ_SIMULATION_MODEL_A_S_ODV),
85  m_b_s(UQ_SIMULATION_MODEL_B_S_ODV),
86  m_parser(new BoostInputOptionsParser(env->optionsInputFileName())),
87  m_option_help(m_prefix + "help"),
88  m_option_dataOutputFileName(m_prefix + "dataOutputFileName"),
89  m_option_dataOutputAllowAll(m_prefix + "dataOutputAllowAll"),
90  m_option_dataOutputAllowedSet(m_prefix + "dataOutputAllowedSet"),
91  m_option_p_eta(m_prefix + "p_eta"),
92  m_option_zeroRelativeSingularValue(m_prefix + "zeroRelativeSingularValue"),
93  m_option_cdfThresholdForPEta(m_prefix + "cdfThresholdForPEta"),
94  m_option_a_w(m_prefix + "a_w"),
95  m_option_b_w(m_prefix + "b_w"),
96  m_option_a_rho_w(m_prefix + "a_rho_w"),
97  m_option_b_rho_w(m_prefix + "b_rho_w"),
98  m_option_a_eta(m_prefix + "a_eta"),
99  m_option_b_eta(m_prefix + "b_eta"),
100  m_option_a_s(m_prefix + "a_s"),
101  m_option_b_s(m_prefix + "b_s")
102 {
103  m_parser->registerOption(m_option_help, "produce help message for simulation model options");
104  m_parser->registerOption<std::string >(m_option_dataOutputFileName, UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV , "name of data output file" );
105  m_parser->registerOption<bool >(m_option_dataOutputAllowAll, UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV , "allow all or not" );
106  m_parser->registerOption<std::string >(m_option_dataOutputAllowedSet, UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOWED_SET_ODV , "subEnvs that will write to data output file" );
107  m_parser->registerOption<unsigned int>(m_option_p_eta, UQ_SIMULATION_MODEL_P_ETA_ODV , "p_eta" );
108  m_parser->registerOption<double >(m_option_zeroRelativeSingularValue, UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV, "zeroRelativeSingularValue" );
109  m_parser->registerOption<double >(m_option_cdfThresholdForPEta, UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV , "cdfThresholdForPEta" );
110  m_parser->registerOption<double >(m_option_a_w, UQ_SIMULATION_MODEL_A_W_ODV , "a_w" );
111  m_parser->registerOption<double >(m_option_b_w, UQ_SIMULATION_MODEL_B_W_ODV , "b_w" );
112  m_parser->registerOption<double >(m_option_a_rho_w, UQ_SIMULATION_MODEL_A_RHO_W_ODV , "a_rho_w" );
113  m_parser->registerOption<double >(m_option_b_rho_w, UQ_SIMULATION_MODEL_B_RHO_W_ODV , "b_rho_w" );
114  m_parser->registerOption<double >(m_option_a_eta, UQ_SIMULATION_MODEL_A_ETA_ODV , "a_eta" );
115  m_parser->registerOption<double >(m_option_b_eta, UQ_SIMULATION_MODEL_B_ETA_ODV , "b_eta" );
116  m_parser->registerOption<double >(m_option_a_s, UQ_SIMULATION_MODEL_A_S_ODV , "a_s" );
117  m_parser->registerOption<double >(m_option_b_s, UQ_SIMULATION_MODEL_B_S_ODV , "b_s" );
118 
119  m_parser->scanInputFile();
120 
121  m_parser->getOption<std::string >(m_option_dataOutputFileName, m_dataOutputFileName);
122  m_parser->getOption<bool >(m_option_dataOutputAllowAll, m_dataOutputAllowAll);
123  m_parser->getOption<std::set<unsigned int> >(m_option_dataOutputAllowedSet, m_dataOutputAllowedSet);
124  m_parser->getOption<unsigned int>(m_option_p_eta, m_p_eta);
125  m_parser->getOption<double >(m_option_zeroRelativeSingularValue, m_zeroRelativeSingularValue);
126  m_parser->getOption<double >(m_option_cdfThresholdForPEta, m_cdfThresholdForPEta);
127  m_parser->getOption<double >(m_option_a_w, m_a_w);
128  m_parser->getOption<double >(m_option_b_w, m_b_w);
129  m_parser->getOption<double >(m_option_a_rho_w, m_a_rho_w);
130  m_parser->getOption<double >(m_option_b_rho_w, m_b_rho_w);
131  m_parser->getOption<double >(m_option_a_eta, m_a_eta);
132  m_parser->getOption<double >(m_option_b_eta, m_b_eta);
133  m_parser->getOption<double >(m_option_a_s, m_a_s);
134  m_parser->getOption<double >(m_option_b_s, m_b_s);
135 }
136 
137 SmOptionsValues::~SmOptionsValues()
138 {
139 }
140 
141 SmOptionsValues::SmOptionsValues(const SmOptionsValues& src)
142 {
143  this->copy(src);
144 }
145 
146 SmOptionsValues&
147 SmOptionsValues::operator=(const SmOptionsValues& rhs)
148 {
149  this->copy(rhs);
150  return *this;
151 }
152 
153 // void
154 // SmOptionsValues::defineOptions()
155 // {
156 // (*m_optionsDescription).add_options()
157 // (m_option_help.c_str(), "produce help message for simulation model options")
158 // (m_option_dataOutputFileName.c_str(), boost::program_options::value<std::string >()->default_value(UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV ), "name of data output file" )
159 // (m_option_dataOutputAllowAll.c_str(), boost::program_options::value<bool >()->default_value(UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV ), "allow all or not" )
160 // (m_option_dataOutputAllowedSet.c_str(), boost::program_options::value<std::string >()->default_value(UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOWED_SET_ODV ), "subEnvs that will write to data output file" )
161 // (m_option_p_eta.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_SIMULATION_MODEL_P_ETA_ODV ), "p_eta" )
162 // (m_option_zeroRelativeSingularValue.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV), "zeroRelativeSingularValue" )
163 // (m_option_cdfThresholdForPEta.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV ), "cdfThresholdForPEta" )
164 // (m_option_a_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_W_ODV ), "a_w" )
165 // (m_option_b_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_W_ODV ), "b_w" )
166 // (m_option_a_rho_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_RHO_W_ODV ), "a_rho_w" )
167 // (m_option_b_rho_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_RHO_W_ODV ), "b_rho_w" )
168 // (m_option_a_eta.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_ETA_ODV ), "a_eta" )
169 // (m_option_b_eta.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_ETA_ODV ), "b_eta" )
170 // (m_option_a_s.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_S_ODV ), "a_s" )
171 // (m_option_b_s.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_S_ODV ), "b_s" )
172 // ;
173 // }
174 //
175 // void
176 // SmOptionsValues::getOptionValues()
177 // {
178 // if ((*m_optionsMap).count(m_option_help)) {
179 // if (m_env->subDisplayFile()) {
180 // *m_env->subDisplayFile() << (*m_optionsDescription)
181 // << std::endl;
182 // }
183 // }
184 //
185 // if ((*m_optionsMap).count(m_option_dataOutputFileName)) {
186 // m_dataOutputFileName = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_dataOutputFileName]).as<std::string>();
187 // }
188 //
189 // if ((*m_optionsMap).count(m_option_dataOutputAllowAll)) {
190 // m_dataOutputAllowAll = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_dataOutputAllowAll]).as<bool>();
191 // }
192 //
193 // if (m_dataOutputAllowAll) {
194 // m_dataOutputAllowedSet.insert(m_env->subId());
195 // }
196 // else if ((*m_optionsMap).count(m_option_dataOutputAllowedSet)) {
197 // m_dataOutputAllowedSet.clear();
198 // std::vector<double> tmpAllow(0,0.);
199 // std::string inputString = (*m_optionsMap)[m_option_dataOutputAllowedSet].as<std::string>();
200 // MiscReadDoublesFromString(inputString,tmpAllow);
201 //
202 // if (tmpAllow.size() > 0) {
203 // for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
204 // m_dataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
205 // }
206 // }
207 // }
208 //
209 // if ((*m_optionsMap).count(m_option_p_eta)) {
210 // m_p_eta = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_p_eta]).as<unsigned int>();
211 // }
212 //
213 // if ((*m_optionsMap).count(m_option_zeroRelativeSingularValue)) {
214 // m_zeroRelativeSingularValue = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_zeroRelativeSingularValue]).as<double>();
215 // }
216 //
217 // if ((*m_optionsMap).count(m_option_cdfThresholdForPEta)) {
218 // m_cdfThresholdForPEta = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_cdfThresholdForPEta]).as<double>();
219 // }
220 //
221 // if ((*m_optionsMap).count(m_option_a_w)) {
222 // m_a_w = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_a_w]).as<double>();
223 // }
224 //
225 // if ((*m_optionsMap).count(m_option_b_w)) {
226 // m_b_w = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_b_w]).as<double>();
227 // }
228 //
229 // if ((*m_optionsMap).count(m_option_a_rho_w)) {
230 // m_a_rho_w = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_a_rho_w]).as<double>();
231 // }
232 //
233 // if ((*m_optionsMap).count(m_option_b_rho_w)) {
234 // m_b_rho_w = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_b_rho_w]).as<double>();
235 // }
236 //
237 // if ((*m_optionsMap).count(m_option_a_eta)) {
238 // m_a_eta = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_a_eta]).as<double>();
239 // }
240 //
241 // if ((*m_optionsMap).count(m_option_b_eta)) {
242 // m_b_eta = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_b_eta]).as<double>();
243 // }
244 //
245 // if ((*m_optionsMap).count(m_option_a_s)) {
246 // m_a_s = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_a_s]).as<double>();
247 // }
248 //
249 // if ((*m_optionsMap).count(m_option_b_s)) {
250 // m_b_s = ((const boost::program_options::variable_value&) (*m_optionsMap)[m_option_b_s]).as<double>();
251 // }
252 // }
253 
254 void
255 SmOptionsValues::copy(const SmOptionsValues& src)
256 {
257  m_dataOutputFileName = src.m_dataOutputFileName;
258  m_dataOutputAllowAll = src.m_dataOutputAllowAll;
259  m_dataOutputAllowedSet = src.m_dataOutputAllowedSet;
260  m_p_eta = src.m_p_eta;
261  m_zeroRelativeSingularValue = src.m_zeroRelativeSingularValue;
262  m_cdfThresholdForPEta = src.m_cdfThresholdForPEta;
263  m_a_w = src.m_a_w;
264  m_b_w = src.m_b_w;
265  m_a_rho_w = src.m_a_rho_w;
266  m_b_rho_w = src.m_b_rho_w;
267  m_a_eta = src.m_a_eta;
268  m_b_eta = src.m_b_eta;
269  m_a_s = src.m_a_s;
270  m_b_s = src.m_b_s;
271 
272  return;
273 }
274 
275 SimulationModelOptions::SimulationModelOptions(
276  const BaseEnvironment& env,
277  const char* prefix)
278  :
279  m_ov (),
280  m_prefix ((std::string)(prefix) + "sm_"),
281  m_env (env),
282  m_optionsDesc (new boost::program_options::options_description("Simulation model options")),
283  m_option_help (m_prefix + "help" ),
284  m_option_dataOutputFileName (m_prefix + "dataOutputFileName" ),
285  m_option_dataOutputAllowAll (m_prefix + "dataOutputAllowAll" ),
286  m_option_dataOutputAllowedSet (m_prefix + "dataOutputAllowedSet" ),
287  m_option_p_eta (m_prefix + "p_eta" ),
288  m_option_zeroRelativeSingularValue(m_prefix + "zeroRelativeSingularValue"),
289  m_option_cdfThresholdForPEta (m_prefix + "cdfThresholdForPEta" ),
290  m_option_a_w (m_prefix + "a_w" ),
291  m_option_b_w (m_prefix + "b_w" ),
292  m_option_a_rho_w (m_prefix + "a_rho_w" ),
293  m_option_b_rho_w (m_prefix + "b_rho_w" ),
294  m_option_a_eta (m_prefix + "a_eta" ),
295  m_option_b_eta (m_prefix + "b_eta" ),
296  m_option_a_s (m_prefix + "a_s" ),
297  m_option_b_s (m_prefix + "b_s" )
298 {
299  queso_require_not_equal_to_msg(m_env.optionsInputFileName(), "", "this constructor is incompatible with the abscense of an options input file");
300 }
301 
302 SimulationModelOptions::SimulationModelOptions(
303  const BaseEnvironment& env,
304  const char* prefix,
305  const SmOptionsValues& alternativeOptionsValues)
306  :
307  m_ov (alternativeOptionsValues),
308  m_prefix ((std::string)(prefix) + "sm_"),
309  m_env (env),
310  m_optionsDesc (NULL),
311  m_option_help (m_prefix + "help" ),
312  m_option_dataOutputFileName (m_prefix + "dataOutputFileName" ),
313  m_option_dataOutputAllowAll (m_prefix + "dataOutputAllowAll" ),
314  m_option_dataOutputAllowedSet (m_prefix + "dataOutputAllowedSet" ),
315  m_option_p_eta (m_prefix + "p_eta" ),
316  m_option_zeroRelativeSingularValue(m_prefix + "zeroRelativeSingularValue"),
317  m_option_cdfThresholdForPEta (m_prefix + "cdfThresholdForPEta" ),
318  m_option_a_w (m_prefix + "a_w" ),
319  m_option_b_w (m_prefix + "b_w" ),
320  m_option_a_rho_w (m_prefix + "a_rho_w" ),
321  m_option_b_rho_w (m_prefix + "b_rho_w" ),
322  m_option_a_eta (m_prefix + "a_eta" ),
323  m_option_b_eta (m_prefix + "b_eta" ),
324  m_option_a_s (m_prefix + "a_s" ),
325  m_option_b_s (m_prefix + "b_s" )
326 {
327  queso_deprecated();
328 
329  queso_require_equal_to_msg(m_env.optionsInputFileName(), "", "this constructor is incompatible with the existence of an options input file");
330 
331  if (m_env.subDisplayFile() != NULL) {
332  *m_env.subDisplayFile() << "In SimulationModelOptions::constructor(2)"
333  << ": after setting values of options with prefix '" << m_prefix
334  << "', state of object is:"
335  << "\n" << *this
336  << std::endl;
337  }
338 }
339 
340 SimulationModelOptions::~SimulationModelOptions()
341 {
342  queso_deprecated();
343 
344  if (m_optionsDesc) delete m_optionsDesc;
345 }
346 
347 void
348 SimulationModelOptions::scanOptionsValues()
349 {
350  queso_deprecated();
351 
352  queso_require_msg(m_optionsDesc, "m_optionsDesc variable is NULL");
353 
354  defineMyOptions (*m_optionsDesc);
355  m_env.scanInputFileForMyOptions(*m_optionsDesc);
356  //std::cout << "scan 000\n"
357  // << std::endl;
358  getMyOptionValues (*m_optionsDesc);
359  //std::cout << "scan 001\n"
360  // << std::endl;
361 
362  if (m_env.subDisplayFile() != NULL) {
363  *m_env.subDisplayFile() << "In SimulationModelOptions::scanOptionsValues()"
364  << ": after reading values of options with prefix '" << m_prefix
365  << "', state of object is:"
366  << "\n" << *this
367  << std::endl;
368  }
369 
370  return;
371 }
372 
373 void
374 SimulationModelOptions::defineMyOptions(boost::program_options::options_description& optionsDesc) const
375 {
376  queso_deprecated();
377 
378  optionsDesc.add_options()
379  (m_option_help.c_str(), "produce help message for simulation model options")
380  (m_option_dataOutputFileName.c_str(), boost::program_options::value<std::string >()->default_value(UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV ), "name of data output file" )
381  (m_option_dataOutputAllowAll.c_str(), boost::program_options::value<bool >()->default_value(UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV ), "allow all or not" )
382  (m_option_dataOutputAllowedSet.c_str(), boost::program_options::value<std::string >()->default_value(UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOWED_SET_ODV ), "subEnvs that will write to data output file" )
383  (m_option_p_eta.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_SIMULATION_MODEL_P_ETA_ODV ), "p_eta" )
384  (m_option_zeroRelativeSingularValue.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV), "zeroRelativeSingularValue" )
385  (m_option_cdfThresholdForPEta.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV ), "cdfThresholdForPEta" )
386  (m_option_a_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_W_ODV ), "a_w" )
387  (m_option_b_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_W_ODV ), "b_w" )
388  (m_option_a_rho_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_RHO_W_ODV ), "a_rho_w" )
389  (m_option_b_rho_w.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_RHO_W_ODV ), "b_rho_w" )
390  (m_option_a_eta.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_ETA_ODV ), "a_eta" )
391  (m_option_b_eta.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_ETA_ODV ), "b_eta" )
392  (m_option_a_s.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_A_S_ODV ), "a_s" )
393  (m_option_b_s.c_str(), boost::program_options::value<double >()->default_value(UQ_SIMULATION_MODEL_B_S_ODV ), "b_s" )
394  ;
395 
396  return;
397 }
398 
399 void
400 SimulationModelOptions::getMyOptionValues(boost::program_options::options_description& optionsDesc)
401 {
402  if (m_env.allOptionsMap().count(m_option_help)) {
403  if (m_env.subDisplayFile()) {
404  *m_env.subDisplayFile() << optionsDesc
405  << std::endl;
406  }
407  }
408 
409  if (m_env.allOptionsMap().count(m_option_dataOutputFileName)) {
410  m_ov.m_dataOutputFileName = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_dataOutputFileName]).as<std::string>();
411  }
412 
413  if (m_env.allOptionsMap().count(m_option_dataOutputAllowAll)) {
414  m_ov.m_dataOutputAllowAll = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_dataOutputAllowAll]).as<bool>();
415  }
416 
417  if (m_ov.m_dataOutputAllowAll) {
418  m_ov.m_dataOutputAllowedSet.insert(m_env.subId());
419  }
420  else if (m_env.allOptionsMap().count(m_option_dataOutputAllowedSet)) {
421  m_ov.m_dataOutputAllowedSet.clear();
422  std::vector<double> tmpAllow(0,0.);
423  std::string inputString = m_env.allOptionsMap()[m_option_dataOutputAllowedSet].as<std::string>();
424  MiscReadDoublesFromString(inputString,tmpAllow);
425 
426  if (tmpAllow.size() > 0) {
427  for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
428  m_ov.m_dataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
429  }
430  }
431  }
432 
433  if (m_env.allOptionsMap().count(m_option_p_eta)) {
434  m_ov.m_p_eta = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_p_eta]).as<unsigned int>();
435  }
436 
437  if (m_env.allOptionsMap().count(m_option_zeroRelativeSingularValue)) {
438  m_ov.m_zeroRelativeSingularValue = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_zeroRelativeSingularValue]).as<double>();
439  }
440 
441  if (m_env.allOptionsMap().count(m_option_cdfThresholdForPEta)) {
442  m_ov.m_cdfThresholdForPEta = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_cdfThresholdForPEta]).as<double>();
443  }
444 
445  if (m_env.allOptionsMap().count(m_option_a_w)) {
446  m_ov.m_a_w = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_a_w]).as<double>();
447  }
448 
449  if (m_env.allOptionsMap().count(m_option_b_w)) {
450  m_ov.m_b_w = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_b_w]).as<double>();
451  }
452 
453  if (m_env.allOptionsMap().count(m_option_a_rho_w)) {
454  m_ov.m_a_rho_w = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_a_rho_w]).as<double>();
455  }
456 
457  if (m_env.allOptionsMap().count(m_option_b_rho_w)) {
458  m_ov.m_b_rho_w = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_b_rho_w]).as<double>();
459  }
460 
461  if (m_env.allOptionsMap().count(m_option_a_eta)) {
462  m_ov.m_a_eta = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_a_eta]).as<double>();
463  }
464 
465  if (m_env.allOptionsMap().count(m_option_b_eta)) {
466  m_ov.m_b_eta = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_b_eta]).as<double>();
467  }
468 
469  if (m_env.allOptionsMap().count(m_option_a_s)) {
470  m_ov.m_a_s = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_a_s]).as<double>();
471  }
472 
473  if (m_env.allOptionsMap().count(m_option_b_s)) {
474  m_ov.m_b_s = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_b_s]).as<double>();
475  }
476 
477  return;
478 }
479 
480 void
481 SimulationModelOptions::print(std::ostream& os) const
482 {
483  queso_deprecated();
484 
485  os << "\n" << m_option_dataOutputFileName << " = " << m_ov.m_dataOutputFileName
486  << "\n" << m_option_dataOutputAllowAll << " = " << m_ov.m_dataOutputAllowAll
487  << "\n" << m_option_dataOutputAllowedSet << " = ";
488  for (std::set<unsigned int>::iterator setIt = m_ov.m_dataOutputAllowedSet.begin(); setIt != m_ov.m_dataOutputAllowedSet.end(); ++setIt) {
489  os << *setIt << " ";
490  }
491  os << "\n" << m_option_p_eta << " = " << m_ov.m_p_eta
492  << "\n" << m_option_zeroRelativeSingularValue << " = " << m_ov.m_zeroRelativeSingularValue
493  << "\n" << m_option_cdfThresholdForPEta << " = " << m_ov.m_cdfThresholdForPEta
494  << "\n" << m_option_a_w << " = " << m_ov.m_a_w
495  << "\n" << m_option_b_w << " = " << m_ov.m_b_w
496  << "\n" << m_option_a_rho_w << " = " << m_ov.m_a_rho_w
497  << "\n" << m_option_b_rho_w << " = " << m_ov.m_b_rho_w
498  << "\n" << m_option_a_eta << " = " << m_ov.m_a_eta
499  << "\n" << m_option_b_eta << " = " << m_ov.m_b_eta
500  << "\n" << m_option_a_s << " = " << m_ov.m_a_s
501  << "\n" << m_option_b_s << " = " << m_ov.m_b_s
502  << std::endl;
503 
504  return;
505 }
506 
507 std::ostream& operator<<(std::ostream& os, const SimulationModelOptions& obj)
508 {
509  queso_deprecated();
510 
511  obj.print(os);
512 
513  return os;
514 }
515 
516 } // End namespace QUESO
UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV
#define UQ_SIMULATION_MODEL_DATA_OUTPUT_FILE_NAME_ODV
Definition: SimulationModelOptions.h:34
UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOWED_SET_ODV
#define UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOWED_SET_ODV
Definition: SimulationModelOptions.h:36
UQ_SIMULATION_MODEL_P_ETA_ODV
#define UQ_SIMULATION_MODEL_P_ETA_ODV
Definition: SimulationModelOptions.h:37
QUESO::BaseEnvironment::scanInputFileForMyOptions
void scanInputFileForMyOptions(const boost::program_options::options_description &optionsDesc) const
This method scans the input file provided by the user to QUESO.
Definition: Environment.C:345
UQ_SIMULATION_MODEL_B_ETA_ODV
#define UQ_SIMULATION_MODEL_B_ETA_ODV
Definition: SimulationModelOptions.h:45
UQ_SIMULATION_MODEL_B_S_ODV
#define UQ_SIMULATION_MODEL_B_S_ODV
Definition: SimulationModelOptions.h:47
QUESO::SmOptionsValues::m_dataOutputAllowedSet
std::set< unsigned int > m_dataOutputAllowedSet
Definition: SimulationModelOptions.h:70
queso_require_not_equal_to_msg
#define queso_require_not_equal_to_msg(expr1, expr2, msg)
Definition: asserts.h:86
QUESO::operator<<
std::ostream & operator<<(std::ostream &os, const BaseEnvironment &obj)
QUESO::SmOptionsValues::m_option_zeroRelativeSingularValue
std::string m_option_zeroRelativeSingularValue
Definition: SimulationModelOptions.h:91
UQ_SIMULATION_MODEL_A_RHO_W_ODV
#define UQ_SIMULATION_MODEL_A_RHO_W_ODV
Definition: SimulationModelOptions.h:42
QUESO::BaseEnvironment::allOptionsMap
boost::program_options::variables_map & allOptionsMap() const
Definition: Environment.C:336
QUESO::SmOptionsValues::m_parser
BoostInputOptionsParser * m_parser
Definition: SimulationModelOptions.h:84
UQ_SIMULATION_MODEL_A_ETA_ODV
#define UQ_SIMULATION_MODEL_A_ETA_ODV
Definition: SimulationModelOptions.h:44
UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV
#define UQ_SIMULATION_MODEL_ZERO_RELATIVE_SINGULAR_VALUE_ODV
Definition: SimulationModelOptions.h:38
UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV
#define UQ_SIMULATION_MODEL_CDF_THRESHOLD_FOR_P_ETA_ODV
Definition: SimulationModelOptions.h:39
queso_require_equal_to_msg
#define queso_require_equal_to_msg(expr1, expr2, msg)
Definition: asserts.h:85
QUESO::SmOptionsValues::copy
void copy(const SmOptionsValues &src)
Definition: SimulationModelOptions.C:255
QUESO::BaseEnvironment::optionsInputFileName
std::string optionsInputFileName() const
Access to the attribute m_optionsInputFileName, which stores the name of the input file passed by the...
Definition: Environment.C:307
QUESO::BoostInputOptionsParser::scanInputFile
void scanInputFile()
This is the method that parses the input file.
Definition: BoostInputOptionsParser.C:56
QUESO::SimulationModelOptions::SimulationModelOptions
SimulationModelOptions(const BaseEnvironment &env, const char *prefix)
Definition: SimulationModelOptions.C:275
queso_require_msg
#define queso_require_msg(asserted, msg)
Definition: asserts.h:69
UQ_SIMULATION_MODEL_A_S_ODV
#define UQ_SIMULATION_MODEL_A_S_ODV
Definition: SimulationModelOptions.h:46
QUESO::BaseEnvironment::subDisplayFile
std::ofstream * subDisplayFile() const
Access function for m_subDisplayFile (displays file on stream).
Definition: Environment.C:274
QUESO::SimulationModelOptions::m_optionsDesc
boost::program_options::options_description * m_optionsDesc
Definition: SimulationModelOptions.h:126
QUESO::SimulationModelOptions::print
void print(std::ostream &os) const
Definition: SimulationModelOptions.C:481
QUESO::BaseEnvironment
This (virtual) class sets up the environment underlying the use of the QUESO library by an executable...
Definition: Environment.h:193
UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV
#define UQ_SIMULATION_MODEL_DATA_OUTPUT_ALLOW_ALL_ODV
Definition: SimulationModelOptions.h:35
QUESO::SimulationModelOptions::getMyOptionValues
void getMyOptionValues(boost::program_options::options_description &optionsDesc)
Definition: SimulationModelOptions.C:400
QUESO::BaseEnvironment::subId
unsigned int subId() const
Access function to the number of each sub-environment Id: m_subId.
Definition: Environment.C:295
QUESO::BoostInputOptionsParser::registerOption
void registerOption(std::string name, T defaultValue, std::string description)
Call this to register an option with the parser.
Definition: BoostInputOptionsParser.C:79
QUESO::MiscReadDoublesFromString
void MiscReadDoublesFromString(const std::string &inputString, std::vector< double > &outputDoubles)
Definition: Miscellaneous.C:40
UQ_SIMULATION_MODEL_B_W_ODV
#define UQ_SIMULATION_MODEL_B_W_ODV
Definition: SimulationModelOptions.h:41
queso_deprecated
#define queso_deprecated()
Definition: Defines.h:120
UQ_SIMULATION_MODEL_A_W_ODV
#define UQ_SIMULATION_MODEL_A_W_ODV
Definition: SimulationModelOptions.h:40
UQ_SIMULATION_MODEL_B_RHO_W_ODV
#define UQ_SIMULATION_MODEL_B_RHO_W_ODV
Definition: SimulationModelOptions.h:43
QUESO::SmOptionsValues::operator=
SmOptionsValues & operator=(const SmOptionsValues &rhs)
Definition: SimulationModelOptions.C:147
QUESO::BoostInputOptionsParser::getOption
void getOption(std::string &name, T &value)
Get option name from the parser and set value to the parsed value.
Definition: BoostInputOptionsParser.C:98
QUESO::SimulationModelOptions::defineMyOptions
void defineMyOptions(boost::program_options::options_description &optionsDesc) const
Definition: SimulationModelOptions.C:374
Generated on Thu Jun 11 2015 13:52:32 for queso-0.53.0 by  doxygen 1.8.5