queso-0.52.0
MonteCarloSGOptions.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 <queso/MonteCarloSGOptions.h>
26 #include <queso/Miscellaneous.h>
27 
28 // -------------------------------------------------
29 // McOptionsValues --------------------------
30 // -------------------------------------------------
31 
32 namespace QUESO {
33 
34 // Default constructor -----------------------------
35 McOptionsValues::McOptionsValues(
36 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
37  const SsOptionsValues* alternativePSsOptionsValues,
38  const SsOptionsValues* alternativeQSsOptionsValues
39 #endif
40  )
41  :
42  m_dataOutputFileName (UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV ),
43 //m_dataOutputAllowedSet (),
44  m_pseqDataOutputPeriod (UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV ),
45  m_pseqDataOutputFileName (UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV),
46  m_pseqDataOutputFileType (UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV),
47 //m_pseqDataOutputAllowedSet (),
48 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
49  m_pseqComputeStats (UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV ),
50 #endif
51  m_qseqDataInputFileName (UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV ),
52  m_qseqDataInputFileType (UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV ),
53  m_qseqSize (UQ_MOC_SG_QSEQ_SIZE_ODV ),
54  m_qseqDisplayPeriod (UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV ),
55  m_qseqMeasureRunTimes (UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV ),
56  m_qseqDataOutputPeriod (UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV ),
57  m_qseqDataOutputFileName (UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV),
58  m_qseqDataOutputFileType (UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV)
59 //m_qseqDataOutputAllowedSet (),
60 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
61  ,
62  m_qseqComputeStats (UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV ),
63  m_alternativePSsOptionsValues(),
64  m_alternativeQSsOptionsValues()
65 #endif
66 {
67 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
68  if (alternativePSsOptionsValues) m_alternativePSsOptionsValues = *alternativePSsOptionsValues;
69  if (alternativeQSsOptionsValues) m_alternativeQSsOptionsValues = *alternativeQSsOptionsValues;
70 #endif
71 }
72 // Copy constructor --------------------------------
73 McOptionsValues::McOptionsValues(const McOptionsValues& src)
74 {
75  this->copy(src);
76 }
77 // Destructor ---------------------------------------
78 McOptionsValues::~McOptionsValues()
79 {
80 }
81 // Set methods --------------------------------------
82 McOptionsValues&
83 McOptionsValues::operator=(const McOptionsValues& rhs)
84 {
85  this->copy(rhs);
86  return *this;
87 }
88 // Private methods-----------------------------------
89 void
90 McOptionsValues::copy(const McOptionsValues& src)
91 {
92  m_dataOutputFileName = src.m_dataOutputFileName;
93  m_dataOutputAllowedSet = src.m_dataOutputAllowedSet;
94  m_pseqDataOutputPeriod = src.m_pseqDataOutputPeriod;
95  m_pseqDataOutputFileName = src.m_pseqDataOutputFileName;
96  m_pseqDataOutputFileType = src.m_pseqDataOutputFileType;
97  m_pseqDataOutputAllowedSet = src.m_pseqDataOutputAllowedSet;
98 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
99  m_pseqComputeStats = src.m_pseqComputeStats;
100 #endif
101  m_qseqDataInputFileName = src.m_qseqDataInputFileName;
102  m_qseqDataInputFileType = src.m_qseqDataInputFileType;
103  m_qseqSize = src.m_qseqSize;
104  m_qseqDisplayPeriod = src.m_qseqDisplayPeriod;
105  m_qseqMeasureRunTimes = src.m_qseqMeasureRunTimes;
106  m_qseqDataOutputPeriod = src.m_qseqDataOutputPeriod;
107  m_qseqDataOutputFileName = src.m_qseqDataOutputFileName;
108  m_qseqDataOutputFileType = src.m_qseqDataOutputFileType;
109  m_qseqDataOutputAllowedSet = src.m_qseqDataOutputAllowedSet;
110 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
111  m_qseqComputeStats = src.m_qseqComputeStats;
112 #endif
113 
114 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
115  m_alternativePSsOptionsValues = src.m_alternativePSsOptionsValues;
116  m_alternativeQSsOptionsValues = src.m_alternativeQSsOptionsValues;
117 #endif
118 
119  return;
120 }
121 
122 // --------------------------------------------------
123 //MonteCarloSGOptions ------------------------
124 // --------------------------------------------------
125 
126 // Default constructor -----------------------------
127 MonteCarloSGOptions::MonteCarloSGOptions(
128  const BaseEnvironment& env,
129  const char* prefix)
130  :
131 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
132  m_ov (NULL,NULL),
133  m_pseqStatisticalOptionsObj (NULL),
134  m_qseqStatisticalOptionsObj (NULL),
135 #else
136  m_ov (),
137 #endif
138  m_prefix ((std::string)(prefix) + "mc_"),
139  m_env (env),
140  m_optionsDesc (new po::options_description("Monte Carlo options")),
141  m_option_help (m_prefix + "help" ),
142  m_option_dataOutputFileName (m_prefix + "dataOutputFileName" ),
143  m_option_dataOutputAllowedSet (m_prefix + "dataOutputAllowedSet" ),
144  m_option_pseq_dataOutputPeriod (m_prefix + "pseq_dataOutputPeriod" ),
145  m_option_pseq_dataOutputFileName (m_prefix + "pseq_dataOutputFileName" ),
146  m_option_pseq_dataOutputFileType (m_prefix + "pseq_dataOutputFileType" ),
147  m_option_pseq_dataOutputAllowedSet(m_prefix + "pseq_dataOutputAllowedSet" ),
148 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
149  m_option_pseq_computeStats (m_prefix + "pseq_computeStats" ),
150 #endif
151  m_option_qseq_dataInputFileName (m_prefix + "qseq_dataInputFileName" ),
152  m_option_qseq_dataInputFileType (m_prefix + "qseq_dataInputFileType" ),
153  m_option_qseq_size (m_prefix + "qseq_size" ),
154  m_option_qseq_displayPeriod (m_prefix + "qseq_displayPeriod" ),
155  m_option_qseq_measureRunTimes (m_prefix + "qseq_measureRunTimes" ),
156  m_option_qseq_dataOutputPeriod (m_prefix + "qseq_dataOutputPeriod" ),
157  m_option_qseq_dataOutputFileName (m_prefix + "qseq_dataOutputFileName" ),
158  m_option_qseq_dataOutputFileType (m_prefix + "qseq_dataOutputFileType" ),
159  m_option_qseq_dataOutputAllowedSet(m_prefix + "qseq_dataOutputAllowedSet" )
160 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
161  ,
162  m_option_qseq_computeStats (m_prefix + "qseq_computeStats" )
163 #endif
164 {
165  UQ_FATAL_TEST_MACRO(m_env.optionsInputFileName() == "",
166  m_env.worldRank(),
167  "MonteCarloSGOptions::constructor(1)",
168  "this constructor is incompatible with the absence of an options input file");
169 }
170 // Constructor 2 -----------------------------------
171 MonteCarloSGOptions::MonteCarloSGOptions(
172  const BaseEnvironment& env,
173  const char* prefix,
174  const McOptionsValues& alternativeOptionsValues)
175  :
176  m_ov (alternativeOptionsValues),
177 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
178  m_pseqStatisticalOptionsObj (NULL),
179  m_qseqStatisticalOptionsObj (NULL),
180 #endif
181  m_prefix ((std::string)(prefix) + "mc_"),
182  m_env (env),
183  m_optionsDesc (NULL),
184  m_option_help (m_prefix + "help" ),
185  m_option_dataOutputFileName (m_prefix + "dataOutputFileName" ),
186  m_option_dataOutputAllowedSet (m_prefix + "dataOutputAllowedSet" ),
187  m_option_pseq_dataOutputPeriod (m_prefix + "pseq_dataOutputPeriod" ),
188  m_option_pseq_dataOutputFileName (m_prefix + "pseq_dataOutputFileName" ),
189  m_option_pseq_dataOutputFileType (m_prefix + "pseq_dataOutputFileType" ),
190  m_option_pseq_dataOutputAllowedSet(m_prefix + "pseq_dataOutputAllowedSet"),
191 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
192  m_option_pseq_computeStats (m_prefix + "pseq_computeStats" ),
193 #endif
194  m_option_qseq_dataInputFileName (m_prefix + "qseq_dataInputFileName" ),
195  m_option_qseq_dataInputFileType (m_prefix + "qseq_dataInputFileType" ),
196  m_option_qseq_size (m_prefix + "qseq_size" ),
197  m_option_qseq_displayPeriod (m_prefix + "qseq_displayPeriod" ),
198  m_option_qseq_measureRunTimes (m_prefix + "qseq_measureRunTimes" ),
199  m_option_qseq_dataOutputPeriod (m_prefix + "qseq_dataOutputPeriod" ),
200  m_option_qseq_dataOutputFileName (m_prefix + "qseq_dataOutputFileName" ),
201  m_option_qseq_dataOutputFileType (m_prefix + "qseq_dataOutputFileType" ),
202  m_option_qseq_dataOutputAllowedSet(m_prefix + "qseq_dataOutputAllowedSet")
203 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
204  ,
205  m_option_qseq_computeStats (m_prefix + "qseq_computeStats" )
206 #endif
207 {
208  UQ_FATAL_TEST_MACRO(m_env.optionsInputFileName() != "",
209  m_env.worldRank(),
210  "MonteCarloSGOptions::constructor(2)",
211  "this constructor is incompatible with the existence of an options input file");
212 
213  if (m_env.subDisplayFile() != NULL) {
214  *m_env.subDisplayFile() << "In MonteCarloSGOptions::constructor(2)"
215  << ": after setting values of options with prefix '" << m_prefix
216  << "', state of object is:"
217  << "\n" << *this
218  << std::endl;
219  }
220 
221  // dakota
222 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
223  if (m_ov.m_pseqComputeStats) m_pseqStatisticalOptionsObj =
224  new SequenceStatisticalOptions(m_env,m_prefix + "pseq_",m_ov.m_alternativePSsOptionsValues);
225  if (m_ov.m_qseqComputeStats) m_qseqStatisticalOptionsObj =
226  new SequenceStatisticalOptions(m_env,m_prefix + "qseq_",m_ov.m_alternativeQSsOptionsValues);
227 #endif
228 }
229 // Destructor --------------------------------------
230 MonteCarloSGOptions::~MonteCarloSGOptions()
231 {
232 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
233  if (m_pseqStatisticalOptionsObj) delete m_pseqStatisticalOptionsObj; // dakota
234  if (m_qseqStatisticalOptionsObj) delete m_qseqStatisticalOptionsObj; // dakota
235 #endif
236  if (m_optionsDesc ) delete m_optionsDesc;
237 }
238 // I/O methods -------------------------------------
239 void
240 MonteCarloSGOptions::scanOptionsValues()
241 {
242  UQ_FATAL_TEST_MACRO(m_optionsDesc == NULL,
243  m_env.worldRank(),
244  "MonteCarloSGOptions::scanOptionsValues()",
245  "m_optionsDesc variable is NULL");
246 
247  defineMyOptions (*m_optionsDesc);
248  m_env.scanInputFileForMyOptions(*m_optionsDesc);
249  getMyOptionValues (*m_optionsDesc);
250 
251  if (m_env.subDisplayFile() != NULL) {
252  *m_env.subDisplayFile() << "In MonteCarloSGOptions::scanOptionsValues()"
253  << ": after reading values of options with prefix '" << m_prefix
254  << "', state of object is:"
255  << "\n" << *this
256  << std::endl;
257  }
258 
259  // dakota
260 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
261  if (m_ov.m_pseqComputeStats) m_pseqStatisticalOptionsObj =
262  new SequenceStatisticalOptions(m_env,m_prefix + "pseq_");
263  if (m_ov.m_qseqComputeStats) m_qseqStatisticalOptionsObj =
264  new SequenceStatisticalOptions(m_env,m_prefix + "qseq_");
265 #endif
266  return;
267 }
268 // Private methods ---------------------------------
269 void
270 MonteCarloSGOptions::defineMyOptions(po::options_description& optionsDesc) const
271 {
272  optionsDesc.add_options()
273  (m_option_help.c_str(), "produce help message for Monte Carlo distribution calculator")
274  (m_option_dataOutputFileName.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV ), "name of generic data output file" )
275  (m_option_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV ), "subEnvs that will write to generic data output file" )
276  (m_option_pseq_dataOutputPeriod.c_str(), po::value<unsigned int>()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV ), "period of message display during param sequence generation" )
277  (m_option_pseq_dataOutputFileName.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV ), "name of data output file for parameters" )
278  (m_option_pseq_dataOutputFileType.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV ), "type of data output file for parameters" )
279  (m_option_pseq_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV), "subEnvs that will write to data output file for parameters" )
280 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
281  (m_option_pseq_computeStats.c_str(), po::value<bool >()->default_value(UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV ), "compute statistics on sequence of parameter" )
282 #endif
283  (m_option_qseq_dataInputFileName.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV ), "name of data input file for qois" )
284  (m_option_qseq_dataInputFileType.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV ), "type of data input file for qois" )
285  (m_option_qseq_size.c_str(), po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_SIZE_ODV ), "size of qoi sequence" )
286  (m_option_qseq_displayPeriod.c_str(), po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV ), "period of message display during qoi sequence generation" )
287  (m_option_qseq_measureRunTimes.c_str(), po::value<bool >()->default_value(UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV ), "measure run times" )
288  (m_option_qseq_dataOutputPeriod.c_str(), po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV ), "period of message display during qoi sequence generation" )
289  (m_option_qseq_dataOutputFileName.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV ), "name of data output file for qois" )
290  (m_option_qseq_dataOutputFileType.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV ), "type of data output file for qois" )
291  (m_option_qseq_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV), "subEnvs that will write to data output file for qois" )
292 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
293  (m_option_qseq_computeStats.c_str(), po::value<bool >()->default_value(UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV ), "compute statistics on sequence of qoi" )
294 #endif
295  ;
296 
297  return;
298 }
299 
300 void
301 MonteCarloSGOptions::getMyOptionValues(po::options_description& optionsDesc)
302 {
303  if (m_env.allOptionsMap().count(m_option_help)) {
304  if (m_env.subDisplayFile()) {
305  *m_env.subDisplayFile() << optionsDesc
306  << std::endl;
307  }
308  }
309 
310  if (m_env.allOptionsMap().count(m_option_dataOutputFileName)) {
311  m_ov.m_dataOutputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_dataOutputFileName]).as<std::string>();
312  }
313 
314  if (m_env.allOptionsMap().count(m_option_dataOutputAllowedSet)) {
315  m_ov.m_dataOutputAllowedSet.clear();
316  std::vector<double> tmpAllow(0,0.);
317  std::string inputString = m_env.allOptionsMap()[m_option_dataOutputAllowedSet].as<std::string>();
318  MiscReadDoublesFromString(inputString,tmpAllow);
319 
320  if (tmpAllow.size() > 0) {
321  for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
322  m_ov.m_dataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
323  }
324  }
325  }
326 
327  if (m_env.allOptionsMap().count(m_option_pseq_dataOutputPeriod)) {
328  m_ov.m_pseqDataOutputPeriod = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_dataOutputPeriod]).as<unsigned int>();
329  }
330 
331  if (m_env.allOptionsMap().count(m_option_pseq_dataOutputFileName)) {
332  m_ov.m_pseqDataOutputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_dataOutputFileName]).as<std::string>();
333  }
334 
335  if (m_env.allOptionsMap().count(m_option_pseq_dataOutputFileType)) {
336  m_ov.m_pseqDataOutputFileType = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_dataOutputFileType]).as<std::string>();
337  }
338 
339  if (m_env.allOptionsMap().count(m_option_pseq_dataOutputAllowedSet)) {
340  m_ov.m_pseqDataOutputAllowedSet.clear();
341  std::vector<double> tmpAllow(0,0.);
342  std::string inputString = m_env.allOptionsMap()[m_option_pseq_dataOutputAllowedSet].as<std::string>();
343  MiscReadDoublesFromString(inputString,tmpAllow);
344 
345  if (tmpAllow.size() > 0) {
346  for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
347  m_ov.m_pseqDataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
348  }
349  }
350  }
351 
352 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
353  if (m_env.allOptionsMap().count(m_option_pseq_computeStats)) {
354  m_ov.m_pseqComputeStats = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_computeStats]).as<bool>();
355  }
356 #endif
357  if (m_env.allOptionsMap().count(m_option_qseq_dataInputFileName)) {
358  m_ov.m_qseqDataInputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataInputFileName]).as<std::string>();
359  }
360 
361  if (m_env.allOptionsMap().count(m_option_qseq_dataInputFileType)) {
362  m_ov.m_qseqDataInputFileType = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataInputFileType]).as<std::string>();
363  }
364 
365  if (m_env.allOptionsMap().count(m_option_qseq_size)) {
366  m_ov.m_qseqSize = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_size]).as<unsigned int>();
367  }
368 
369  if (m_env.allOptionsMap().count(m_option_qseq_displayPeriod)) {
370  m_ov.m_qseqDisplayPeriod = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_displayPeriod]).as<unsigned int>();
371  }
372 
373  if (m_env.allOptionsMap().count(m_option_qseq_measureRunTimes)) {
374  m_ov.m_qseqMeasureRunTimes = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_measureRunTimes]).as<bool>();
375  }
376 
377  if (m_env.allOptionsMap().count(m_option_qseq_dataOutputPeriod)) {
378  m_ov.m_qseqDataOutputPeriod = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataOutputPeriod]).as<unsigned int>();
379  }
380 
381  if (m_env.allOptionsMap().count(m_option_qseq_dataOutputFileName)) {
382  m_ov.m_qseqDataOutputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataOutputFileName]).as<std::string>();
383  }
384 
385  if (m_env.allOptionsMap().count(m_option_qseq_dataOutputFileType)) {
386  m_ov.m_qseqDataOutputFileType = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataOutputFileType]).as<std::string>();
387  }
388 
389  if (m_env.allOptionsMap().count(m_option_qseq_dataOutputAllowedSet)) {
390  m_ov.m_qseqDataOutputAllowedSet.clear();
391  std::vector<double> tmpAllow(0,0.);
392  std::string inputString = m_env.allOptionsMap()[m_option_qseq_dataOutputAllowedSet].as<std::string>();
393  MiscReadDoublesFromString(inputString,tmpAllow);
394 
395  if (tmpAllow.size() > 0) {
396  for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
397  m_ov.m_qseqDataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
398  }
399  }
400  }
401 
402 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
403  if (m_env.allOptionsMap().count(m_option_qseq_computeStats)) {
404  m_ov.m_qseqComputeStats = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_computeStats]).as<bool>();
405  }
406 #endif
407  return;
408 }
409 
410 void
411 MonteCarloSGOptions::print(std::ostream& os) const
412 {
413  os << m_option_dataOutputFileName << " = " << m_ov.m_dataOutputFileName
414  << "\n" << m_option_dataOutputAllowedSet << " = ";
415  for (std::set<unsigned int>::iterator setIt = m_ov.m_dataOutputAllowedSet.begin(); setIt != m_ov.m_dataOutputAllowedSet.end(); ++setIt) {
416  os << *setIt << " ";
417  }
418  os << "\n" << m_option_pseq_dataOutputPeriod << " = " << m_ov.m_pseqDataOutputPeriod
419  << "\n" << m_option_pseq_dataOutputFileName << " = " << m_ov.m_pseqDataOutputFileName
420  << "\n" << m_option_pseq_dataOutputFileType << " = " << m_ov.m_pseqDataOutputFileType
421  << "\n" << m_option_pseq_dataOutputAllowedSet << " = ";
422  for (std::set<unsigned int>::iterator setIt = m_ov.m_pseqDataOutputAllowedSet.begin(); setIt != m_ov.m_pseqDataOutputAllowedSet.end(); ++setIt) {
423  os << *setIt << " ";
424  }
425  os
426 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
427  << "\n" << m_option_pseq_computeStats << " = " << m_ov.m_pseqComputeStats
428 #endif
429  << "\n" << m_option_qseq_dataInputFileName << " = " << m_ov.m_qseqDataInputFileName
430  << "\n" << m_option_qseq_dataInputFileType << " = " << m_ov.m_qseqDataInputFileType
431  << "\n" << m_option_qseq_size << " = " << m_ov.m_qseqSize
432  << "\n" << m_option_qseq_displayPeriod << " = " << m_ov.m_qseqDisplayPeriod
433  << "\n" << m_option_qseq_measureRunTimes << " = " << m_ov.m_qseqMeasureRunTimes
434  << "\n" << m_option_qseq_dataOutputPeriod << " = " << m_ov.m_qseqDataOutputPeriod
435  << "\n" << m_option_qseq_dataOutputFileName << " = " << m_ov.m_qseqDataOutputFileName
436  << "\n" << m_option_qseq_dataOutputFileType << " = " << m_ov.m_qseqDataOutputFileType
437  << "\n" << m_option_qseq_dataOutputAllowedSet << " = ";
438  for (std::set<unsigned int>::iterator setIt = m_ov.m_qseqDataOutputAllowedSet.begin(); setIt != m_ov.m_qseqDataOutputAllowedSet.end(); ++setIt) {
439  os << *setIt << " ";
440  }
441 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
442  os << "\n" << m_option_qseq_computeStats << " = " << m_ov.m_qseqComputeStats;
443 #endif
444 
445  return;
446 }
447 
448 std::ostream& operator<<(std::ostream& os, const MonteCarloSGOptions& obj)
449 {
450  obj.print(os);
451 
452  return os;
453 }
454 
455 } // End namespace QUESO
QUESO::MonteCarloSGOptions::m_option_qseq_dataOutputAllowedSet
std::string m_option_qseq_dataOutputAllowedSet
Definition: MonteCarloSGOptions.h:205
QUESO::MonteCarloSGOptions::m_option_pseq_dataOutputAllowedSet
std::string m_option_pseq_dataOutputAllowedSet
Definition: MonteCarloSGOptions.h:192
QUESO::McOptionsValues::copy
void copy(const McOptionsValues &src)
Copies the option values from src to this.
Definition: MonteCarloSGOptions.C:90
UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV
#define UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV
Definition: MonteCarloSGOptions.h:46
UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV
#define UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV
Definition: MonteCarloSGOptions.h:51
QUESO::MiscReadDoublesFromString
void MiscReadDoublesFromString(const std::string &inputString, std::vector< double > &outputDoubles)
Definition: Miscellaneous.C:39
UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV
#define UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV
Definition: MonteCarloSGOptions.h:41
QUESO::McOptionsValues::m_pseqDataOutputPeriod
unsigned int m_pseqDataOutputPeriod
Definition: MonteCarloSGOptions.h:97
QUESO::BaseEnvironment::worldRank
int worldRank() const
Returns the process world rank.
Definition: Environment.C:235
QUESO::MonteCarloSGOptions::scanOptionsValues
void scanOptionsValues()
It scans the option values from the options input file.
Definition: MonteCarloSGOptions.C:240
QUESO::BaseEnvironment::subDisplayFile
std::ofstream * subDisplayFile() const
Access function for m_subDisplayFile (displays file on stream).
Definition: Environment.C:305
UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV
#define UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV
Definition: MonteCarloSGOptions.h:37
QUESO::operator<<
std::ostream & operator<<(std::ostream &os, const BaseEnvironment &obj)
QUESO::McOptionsValues
This class provides options for the Monte Carlo sequence generator if no input file is available...
Definition: MonteCarloSGOptions.h:66
UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV
#define UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV
Definition: MonteCarloSGOptions.h:50
QUESO::BaseEnvironment::allOptionsMap
po::variables_map & allOptionsMap() const
Definition: Environment.C:368
QUESO::McOptionsValues::McOptionsValues
McOptionsValues()
Default constructor.
Definition: MonteCarloSGOptions.C:35
QUESO::BaseEnvironment
This (virtual) class sets up the environment underlying the use of the QUESO library by an executable...
Definition: Environment.h:187
UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV
#define UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV
Definition: MonteCarloSGOptions.h:34
UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV
#define UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV
Definition: MonteCarloSGOptions.h:38
QUESO::McOptionsValues::m_dataOutputAllowedSet
std::set< unsigned int > m_dataOutputAllowedSet
Definition: MonteCarloSGOptions.h:95
QUESO::MonteCarloSGOptions::m_env
const BaseEnvironment & m_env
Definition: MonteCarloSGOptions.h:182
UQ_FATAL_TEST_MACRO
#define UQ_FATAL_TEST_MACRO(test, givenRank, where, what)
Definition: Defines.h:223
UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV
#define UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV
Definition: MonteCarloSGOptions.h:47
QUESO::McOptionsValues::m_pseqDataOutputFileName
std::string m_pseqDataOutputFileName
Definition: MonteCarloSGOptions.h:98
QUESO::MonteCarloSGOptions::print
void print(std::ostream &os) const
It prints the option values.
Definition: MonteCarloSGOptions.C:411
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:341
UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV
#define UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV
Definition: MonteCarloSGOptions.h:35
QUESO::McOptionsValues::m_pseqDataOutputFileType
std::string m_pseqDataOutputFileType
Definition: MonteCarloSGOptions.h:99
QUESO::MonteCarloSGOptions::defineMyOptions
void defineMyOptions(po::options_description &optionsDesc) const
Defines the options for the Monte Carlo sequence generator as the default options.
Definition: MonteCarloSGOptions.C:270
UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV
#define UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV
Definition: MonteCarloSGOptions.h:48
QUESO::MonteCarloSGOptions::m_optionsDesc
po::options_description * m_optionsDesc
Definition: MonteCarloSGOptions.h:183
UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV
#define UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV
Definition: MonteCarloSGOptions.h:49
UQ_MOC_SG_QSEQ_SIZE_ODV
#define UQ_MOC_SG_QSEQ_SIZE_ODV
Definition: MonteCarloSGOptions.h:45
QUESO::McOptionsValues::operator=
McOptionsValues & operator=(const McOptionsValues &rhs)
Assignment operator; it copies rhs to this.
Definition: MonteCarloSGOptions.C:83
QUESO::MonteCarloSGOptions::getMyOptionValues
void getMyOptionValues(po::options_description &optionsDesc)
Gets the sequence options.
Definition: MonteCarloSGOptions.C:301
UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV
#define UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV
Definition: MonteCarloSGOptions.h:52
QUESO::MonteCarloSGOptions::MonteCarloSGOptions
MonteCarloSGOptions(const BaseEnvironment &env, const char *prefix)
Constructor: reads options from the input file.
Definition: MonteCarloSGOptions.C:127
QUESO::McOptionsValues::m_qseqDataOutputAllowedSet
std::set< unsigned int > m_qseqDataOutputAllowedSet
Definition: MonteCarloSGOptions.h:113
UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV
#define UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV
Definition: MonteCarloSGOptions.h:39
QUESO::MonteCarloSGOptions
This class reads the options for the Monte Carlo sequence generator from an input file...
Definition: MonteCarloSGOptions.h:141
UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV
#define UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV
Definition: MonteCarloSGOptions.h:44
UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV
#define UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV
Definition: MonteCarloSGOptions.h:40
QUESO::McOptionsValues::m_pseqDataOutputAllowedSet
std::set< unsigned int > m_pseqDataOutputAllowedSet
Definition: MonteCarloSGOptions.h:100
UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV
#define UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV
Definition: MonteCarloSGOptions.h:43
QUESO::BaseEnvironment::scanInputFileForMyOptions
void scanInputFileForMyOptions(const po::options_description &optionsDesc) const
This method scans the input file provided by the user to QUESO.
Definition: Environment.C:378
Generated on Thu Apr 23 2015 19:30:55 for queso-0.52.0 by  doxygen 1.8.5