queso-0.57.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
GPMSAOptions.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-2017 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/Defines.h>
26 
27 #ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
28 #include <boost/program_options.hpp>
29 #else
30 #include <queso/getpot.h>
31 #endif // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
32 
33 #include <queso/GPMSAOptions.h>
34 
35 #include <queso/GslVector.h>
36 
37 
38 // ODV = option default value
39 #define UQ_GPMSA_HELP ""
40 #define UQ_GPMSA_MAX_SIMULATOR_BASIS_VECTORS_ODV 0
41 #define UQ_GPMSA_SIMULATOR_BASIS_VARIANCE_TO_CAPTURE 1.0
42 #define UQ_GPMSA_EMULATOR_PRECISION_SHAPE_ODV 5.0
43 #define UQ_GPMSA_EMULATOR_PRECISION_SCALE_ODV 0.2
44 #define UQ_GPMSA_OBSERVATIONAL_PRECISION_SHAPE_ODV 5.0
45 #define UQ_GPMSA_OBSERVATIONAL_PRECISION_SCALE_ODV 0.2
46 #define UQ_GPMSA_EMULATOR_CORRELATION_STRENGTH_ALPHA_ODV 1.0
47 #define UQ_GPMSA_EMULATOR_CORRELATION_STRENGTH_BETA_ODV 0.1
48 #define UQ_GPMSA_DISCREPANCY_PRECISION_SHAPE_ODV 1.0
49 #define UQ_GPMSA_DISCREPANCY_PRECISION_SCALE_ODV 1e4
50 #define UQ_GPMSA_DISCREPANCY_CORRELATION_STRENGTH_ALPHA_ODV 1.0
51 #define UQ_GPMSA_DISCREPANCY_CORRELATION_STRENGTH_BETA_ODV 0.1
52 #define UQ_GPMSA_EMULATOR_DATA_PRECISION_SHAPE_ODV 3.0
53 #define UQ_GPMSA_EMULATOR_DATA_PRECISION_SCALE_ODV 333.333
54 
55 namespace { // Anonymous namespace for helper functions
56 
57 template <typename V>
58 void min_max_update(V & min, V & max, const V & new_data)
59 {
60  unsigned int dim = min.sizeGlobal();
61  queso_assert_equal_to(dim, max.sizeGlobal());
62  queso_assert_equal_to(dim, new_data.sizeGlobal());
63 
64  for (unsigned int p=0; p != dim; ++p)
65  {
66  min[p] = std::min(min[p], new_data[p]);
67  max[p] = std::max(max[p], new_data[p]);
68  }
69 }
70 
71 
72 template <typename V>
73 void mean_var_update(unsigned int & n, V & mean, V & var, const V & new_data)
74 {
75  ++n;
76 
77  const V delta (new_data - mean);
78 
79  V delta_n (delta);
80  delta_n /= n;
81 
82  mean += delta_n;
83 
84  V delta2 (new_data - mean);
85  delta2 *= delta;
86 
87  var += delta2;
88 }
89 
90 } // end anonymous namespace
91 
92 
93 
94 namespace QUESO {
95 
97  const BaseEnvironment & env,
98  const char * prefix)
99 {
100  this->set_defaults();
101  this->parse(env, prefix);
102 }
103 
104 
106  :
107  m_env(NULL)
108 #ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
109  ,m_parser(new BoostInputOptionsParser())
110 #endif // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
111 {
112  this->set_defaults();
113  this->set_prefix("");
114 }
115 
116 
117 void
118 GPMSAOptions::set_prefix(const char * prefix)
119 {
120  m_prefix = std::string(prefix) + "gpmsa_";
121 
122  m_option_help = m_prefix + "help";
123  m_option_maxEmulatorBasisVectors = m_prefix + "max_emulator_basis_vectors";
124  m_option_emulatorBasisVarianceToCapture = m_prefix + "emulator_basis_variance_to_capture";
125  m_option_emulatorPrecisionShape = m_prefix + "emulator_precision_shape";
126  m_option_emulatorPrecisionScale = m_prefix + "emulator_precision_scale";
127  m_option_calibrateObservationalPrecision = m_prefix + "calibrate_observational_precision";
128  m_option_observationalPrecisionShape = m_prefix + "observational_precision_shape";
129  m_option_observationalPrecisionScale = m_prefix + "observational_precision_scale";
130  m_option_emulatorCorrelationStrengthAlpha = m_prefix + "emulator_correlation_strength_alpha";
131  m_option_emulatorCorrelationStrengthBeta = m_prefix + "emulator_correlation_strength_beta";
132  m_option_discrepancyPrecisionShape = m_prefix + "discrepancy_precision_shape";
133  m_option_discrepancyPrecisionScale = m_prefix + "discrepancy_precision_scale";
134  m_option_discrepancyCorrelationStrengthAlpha = m_prefix + "discrepancy_correlation_strength_alpha";
135  m_option_discrepancyCorrelationStrengthBeta = m_prefix + "discrepancy_correlation_strength_beta";
136  m_option_emulatorDataPrecisionShape = m_prefix + "emulator_data_precision_shape";
137  m_option_emulatorDataPrecisionScale = m_prefix + "emulator_data_precision_scale";
138  m_option_autoscaleMinMaxAll = m_prefix + "autoscale_min_max_all";
139  m_option_autoscaleMeanVarAll = m_prefix + "autoscale_mean_var_all";
140 }
141 
142 
143 
144 void
146 {
147  m_help = UQ_GPMSA_HELP;
148  m_maxEmulatorBasisVectors = UQ_GPMSA_MAX_SIMULATOR_BASIS_VECTORS_ODV;
149  m_emulatorBasisVarianceToCapture = UQ_GPMSA_SIMULATOR_BASIS_VARIANCE_TO_CAPTURE;
150  m_emulatorPrecisionShape = UQ_GPMSA_EMULATOR_PRECISION_SHAPE_ODV;
151  m_emulatorPrecisionScale = UQ_GPMSA_EMULATOR_PRECISION_SCALE_ODV;
153  m_observationalPrecisionShape = UQ_GPMSA_OBSERVATIONAL_PRECISION_SHAPE_ODV;
154  m_observationalPrecisionScale = UQ_GPMSA_OBSERVATIONAL_PRECISION_SCALE_ODV;
155  m_emulatorCorrelationStrengthAlpha = UQ_GPMSA_EMULATOR_CORRELATION_STRENGTH_ALPHA_ODV;
156  m_emulatorCorrelationStrengthBeta = UQ_GPMSA_EMULATOR_CORRELATION_STRENGTH_BETA_ODV;
157  m_discrepancyPrecisionShape = UQ_GPMSA_DISCREPANCY_PRECISION_SHAPE_ODV;
158  m_discrepancyPrecisionScale = UQ_GPMSA_DISCREPANCY_PRECISION_SCALE_ODV;
159  m_discrepancyCorrelationStrengthAlpha = UQ_GPMSA_DISCREPANCY_CORRELATION_STRENGTH_ALPHA_ODV;
160  m_discrepancyCorrelationStrengthBeta = UQ_GPMSA_DISCREPANCY_CORRELATION_STRENGTH_BETA_ODV;
161  m_emulatorDataPrecisionShape = UQ_GPMSA_EMULATOR_DATA_PRECISION_SHAPE_ODV;
162  m_emulatorDataPrecisionScale = UQ_GPMSA_EMULATOR_DATA_PRECISION_SCALE_ODV;
163 
164  m_autoscaleMinMaxAll = false;
165  m_autoscaleMeanVarAll = false;
166 
167  checkOptions();
168 }
169 
170 
171 void
173  const char * prefix)
174 {
175  m_env = &env;
176 
177  if (m_env->optionsInputFileName() == "") {
178  queso_error_msg("Missing input file is required");
179  }
180 
181  this->set_prefix(prefix);
182 
183 #ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
185 
186  m_parser->registerOption<std::string>
187  (m_option_help,
188  m_help,
189  "produce help message Gaussian process emulator");
190 
191  m_parser->registerOption
194  "shape hyperprior (Gamma) parameter for emulator precision");
195  m_parser->registerOption
198  "scale hyperprior (Gamma) parameter for emulator precision");
199 
200  m_parser->registerOption
203  "whether to use a calibrated hyperparameter for observational precision");
204 
205  m_parser->registerOption
208  "shape hyperprior (Gamma) parameter for observational precision");
209  m_parser->registerOption
212  "scale hyperprior (Gamma) parameter for observational precision");
213 
214  m_parser->registerOption
217  "alpha hyperprior (Beta) parameter for emulator correlation strength");
218  m_parser->registerOption
221  "beta hyperprior (Beta) parameter for emulator correlation strength");
222 
223  m_parser->registerOption
226  "shape hyperprior (Gamma) parameter for discrepancy precision");
227  m_parser->registerOption
230  "scale hyperprior (Gamma) parameter for discrepancy precision");
231 
232  m_parser->registerOption
235  "alpha hyperprior (Beta) parameter for discrepancy correlation strength");
236  m_parser->registerOption
239  "beta hyperprior (Beta) parameter for discrepancy correlation strength");
240 
241  m_parser->registerOption
244  "shape hyperprior (Gamma) parameter for emulator data precision");
245  m_parser->registerOption
248  "scale hyperprior (Gamma) parameter for emulator data precision");
249 
250  m_parser->registerOption
253  "option to autoscale all parameters and outputs based on data range");
254  m_parser->registerOption
257  "option to autoscale all parameters and outputs based on data statistics");
258 
259  m_parser->scanInputFile();
260 
261  m_parser->getOption<std::string>(m_option_help, m_help);
277 #else
278  m_help = env.input()(m_option_help, UQ_GPMSA_HELP);
285 
295 
302 
309 
316 
323 
330 #endif // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
331 
332  checkOptions();
333 }
334 
336 {
337 }
338 
339 
340 void
342 {
343  this->m_autoscaleMinMaxAll = true;
344 }
345 
346 
347 void
349 {
350  m_autoscaleMinMaxUncertain.insert(i);
351 }
352 
353 
354 void
356 {
357  m_autoscaleMinMaxScenario.insert(i);
358 }
359 
360 
361 void
363 {
364  this->m_autoscaleMeanVarAll = true;
365 }
366 
367 
368 void
370 {
371  m_autoscaleMeanVarUncertain.insert(i);
372 }
373 
374 
375 void
377 {
378  m_autoscaleMeanVarScenario.insert(i);
379 }
380 
381 
382 void
384  double range_min,
385  double range_max)
386 {
387  if (i >= m_uncertainScaleMin.size())
388  {
389  m_uncertainScaleMin.resize(i+1, 0);
390  m_uncertainScaleRange.resize(i+1, 1);
391  }
392  m_uncertainScaleMin[i] = range_min;
393  m_uncertainScaleRange[i] = range_max - range_min;
394 }
395 
396 
397 void
399  double range_min,
400  double range_max)
401 {
402  if (i >= m_scenarioScaleMin.size())
403  {
404  m_scenarioScaleMin.resize(i+1, 0);
405  m_scenarioScaleRange.resize(i+1, 1);
406  }
407  m_scenarioScaleMin[i] = range_min;
408  m_scenarioScaleRange[i] = range_max - range_min;
409 }
410 
411 
412 template <typename V>
413 void
415  (const std::vector<typename SharedPtr<V>::Type> & m_simulationScenarios,
416  const std::vector<typename SharedPtr<V>::Type> & m_simulationParameters,
417  const std::vector<typename SharedPtr<V>::Type> & m_simulationOutputs,
418  const std::vector<typename SharedPtr<V>::Type> & m_experimentScenarios,
419  const std::vector<typename SharedPtr<V>::Type> & m_experimentOutputs)
420 {
421  if ((m_autoscaleMinMaxAll && m_autoscaleMeanVarAll) ||
422  ((m_autoscaleMinMaxAll || m_autoscaleMeanVarAll) &&
423  (!m_autoscaleMinMaxUncertain.empty() ||
424  !m_autoscaleMeanVarUncertain.empty() ||
425  !m_autoscaleMinMaxScenario.empty() ||
426  !m_autoscaleMeanVarScenario.empty())))
427  queso_error_msg("Cannot autoscale based on incompatible criteria");
428 
429  unsigned int dimScenario = m_simulationScenarios.size() ?
430  m_simulationScenarios[0]->sizeGlobal() : 0;
431 
432  unsigned int dimParameter = m_simulationParameters.size() ?
433  m_simulationParameters[0]->sizeGlobal() : 0;
434 
435  if (m_autoscaleMinMaxAll || !m_autoscaleMinMaxScenario.empty())
436  {
437  V maxScenario(*m_simulationScenarios[0]);
438 
439  V minScenario(*m_simulationScenarios[0]);
440 
441  for (unsigned int i=1; i < m_simulationScenarios.size(); ++i)
442  min_max_update(minScenario, maxScenario,
443  (*m_simulationScenarios[i]));
444 
445  for (unsigned int i=0; i < m_experimentScenarios.size(); ++i)
446  min_max_update(minScenario, maxScenario,
447  (*m_experimentScenarios[i]));
448 
449  for (unsigned int p=0; p != dimScenario; ++p)
450  if (m_autoscaleMinMaxAll ||
451  m_autoscaleMinMaxScenario.count(p))
452  {
453  if ((m_scenarioScaleMin.size() > p) &&
454  ((m_scenarioScaleMin[p] != 0) ||
455  (m_scenarioScaleRange[p] != 1)))
456  queso_error_msg("Cannot autoscale and manually scale the same scenario parameter");
457 
458  this->set_scenario_parameter_scaling(p, minScenario[p],
459  maxScenario[p]);
460  }
461  }
462 
463  if (m_autoscaleMinMaxAll || !m_autoscaleMinMaxUncertain.empty())
464  {
465  V maxUncertain(*m_simulationParameters[0]);
466 
467  V minUncertain(*m_simulationParameters[0]);
468 
469  for (unsigned int i=1; i < m_simulationParameters.size(); ++i)
470  min_max_update(minUncertain, maxUncertain,
471  (*m_simulationParameters[i]));
472 
473  for (unsigned int p=0; p != dimParameter; ++p)
474  if (m_autoscaleMinMaxAll ||
475  m_autoscaleMinMaxUncertain.count(p))
476  {
477  if ((m_uncertainScaleMin.size() > p) &&
478  ((m_uncertainScaleMin[p] != 0) ||
479  (m_uncertainScaleRange[p] != 1)))
480  queso_error_msg("Cannot autoscale and manually scale the same uncertain parameter");
481 
482  this->set_uncertain_parameter_scaling(p, minUncertain[p],
483  maxUncertain[p]);
484  }
485  }
486 
487 
488  if (m_autoscaleMeanVarAll || !m_autoscaleMeanVarScenario.empty())
489  {
490  unsigned int n=0;
491 
492  V meanScenario(*m_simulationScenarios[0]);
493 
494  V varScenario(m_simulationScenarios[0]->env(),
495  m_simulationScenarios[0]->map());
496 
497  for (unsigned int i=0; i < m_simulationScenarios.size(); ++i)
498  mean_var_update(n, meanScenario, varScenario,
499  *m_simulationScenarios[i]);
500 
501  for (unsigned int i=0; i < m_experimentScenarios.size(); ++i)
502  mean_var_update(n, meanScenario, varScenario,
503  *m_experimentScenarios[i]);
504 
505  varScenario /= n;
506 
507  for (unsigned int p=0; p != dimScenario; ++p)
508  if (m_autoscaleMeanVarAll ||
509  m_autoscaleMeanVarScenario.count(p))
510  {
511  if ((m_scenarioScaleMin.size() > p) &&
512  ((m_scenarioScaleMin[p] != 0) ||
513  (m_scenarioScaleRange[p] != 1)))
514  queso_error_msg("Cannot autoscale and manually scale the same scenario parameter");
515 
516  this->set_scenario_parameter_scaling(p, meanScenario[p],
517  meanScenario[p] +
518  std::sqrt(varScenario[p]));
519  }
520  }
521 
522 
523  if (m_autoscaleMeanVarAll || !m_autoscaleMeanVarUncertain.empty())
524  {
525  unsigned int n=0;
526 
527  V meanUncertain(*m_simulationParameters[0]);
528 
529  V varUncertain(m_simulationParameters[0]->env(),
530  m_simulationParameters[0]->map());
531 
532  for (unsigned int i=0; i < m_simulationParameters.size(); ++i)
533  mean_var_update(n, meanUncertain, varUncertain,
534  *m_simulationParameters[i]);
535 
536  varUncertain /= n;
537 
538  for (unsigned int p=0; p != dimScenario; ++p)
539  if (m_autoscaleMeanVarAll ||
540  m_autoscaleMeanVarUncertain.count(p))
541  {
542  if ((m_uncertainScaleMin.size() > p) &&
543  ((m_uncertainScaleMin[p] != 0) ||
544  (m_uncertainScaleRange[p] != 1)))
545  queso_error_msg("Cannot autoscale and manually scale the same uncertain parameter");
546 
547  this->set_uncertain_parameter_scaling(p, meanUncertain[p],
548  meanUncertain[p] +
549  std::sqrt(varUncertain[p]));
550  }
551  }
552 }
553 
554 
555 double
557  double physical_param)
558 const
559 {
560  if (i < m_scenarioScaleMin.size())
561  return (physical_param - m_scenarioScaleMin[i]) /
563  return physical_param;
564 }
565 
566 
567 double
569  double physical_param)
570 const
571 {
572  if (i < m_uncertainScaleMin.size())
573  return (physical_param - m_uncertainScaleMin[i]) /
575  return physical_param;
576 }
577 
578 
579 void
581 {
582  if (m_help != "") {
583  if (m_env && m_env->subDisplayFile()) {
584  *m_env->subDisplayFile() << (*this) << std::endl;
585  }
586  }
587 }
588 
589 void
590 GPMSAOptions::print(std::ostream& os) const
591 {
592  os << "\n" << m_option_emulatorPrecisionShape << " = " << this->m_emulatorPrecisionShape
593  << "\n" << m_option_emulatorPrecisionScale << " = " << this->m_emulatorPrecisionScale
605  << "\n" << m_option_autoscaleMinMaxAll << " = " << this->m_autoscaleMinMaxAll
606  << "\n" << m_option_autoscaleMeanVarAll << " = " << this->m_autoscaleMeanVarAll
607  << std::endl;
608 }
609 
610 std::ostream &
611 operator<<(std::ostream& os, const GPMSAOptions & obj)
612 {
613 #ifndef QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
614  os << (*(obj.m_parser)) << std::endl;
615 #endif // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
616  obj.print(os);
617  return os;
618 }
619 
620 
621 
622 // Template instantiations
623 template
624 void
625 GPMSAOptions::set_final_scaling<GslVector>
626  (const std::vector<SharedPtr<GslVector>::Type> &,
627  const std::vector<SharedPtr<GslVector>::Type> &,
628  const std::vector<SharedPtr<GslVector>::Type> &,
629  const std::vector<SharedPtr<GslVector>::Type> &,
630  const std::vector<SharedPtr<GslVector>::Type> &);
631 
632 
633 } // End namespace QUESO
std::shared_ptr< T > Type
Definition: SharedPtr.h:69
std::string m_option_observationalPrecisionShape
Definition: GPMSAOptions.h:281
std::string m_option_discrepancyPrecisionShape
Definition: GPMSAOptions.h:285
void print(std::ostream &os) const
Prints this to os.
Definition: GPMSAOptions.C:590
void set_autoscale_meanvar_scenario_parameter(unsigned int i)
Do automatic normalization, using mean and variance of the.
Definition: GPMSAOptions.C:376
std::string m_option_emulatorDataPrecisionShape
Definition: GPMSAOptions.h:289
double m_emulatorDataPrecisionScale
The scale parameter for the Gamma hyperprior for the emulator data precision.
Definition: GPMSAOptions.h:232
double m_emulatorCorrelationStrengthBeta
The beta paramter for the Beta hyperprior for the emulator correlation strength.
Definition: GPMSAOptions.h:211
double normalized_uncertain_parameter(unsigned int i, double physical_param) const
Calculate a normalized value from a physical value for the.
Definition: GPMSAOptions.C:568
This (virtual) class sets up the environment underlying the use of the QUESO library by an executable...
Definition: Environment.h:198
std::vector< double > m_uncertainScaleMin
Definition: GPMSAOptions.h:259
double m_emulatorPrecisionScale
The scale parameter for the Gamma hyperprior for the emulator precision.
Definition: GPMSAOptions.h:192
std::string m_option_emulatorBasisVarianceToCapture
Definition: GPMSAOptions.h:277
std::vector< double > m_scenarioScaleMin
Definition: GPMSAOptions.h:268
std::string m_option_discrepancyPrecisionScale
Definition: GPMSAOptions.h:286
void set_autoscale_meanvar_uncertain_parameter(unsigned int i)
Do automatic normalization, using mean and variance of the.
Definition: GPMSAOptions.C:369
std::string m_option_observationalPrecisionScale
Definition: GPMSAOptions.h:282
std::string m_option_autoscaleMeanVarAll
Definition: GPMSAOptions.h:293
std::ostream & operator<<(std::ostream &os, const SequenceStatisticalOptions &obj)
const GetPot & input() const
The GetPot input file parser.
Definition: Environment.C:1149
std::string m_option_discrepancyCorrelationStrengthBeta
Definition: GPMSAOptions.h:288
void set_uncertain_parameter_scaling(unsigned int i, double range_min, double range_max)
Set a value, for uncertain parameter i in simulation inputs, of.
Definition: GPMSAOptions.C:383
std::string optionsInputFileName() const
Access to the attribute m_optionsInputFileName, which stores the name of the input file passed by the...
Definition: Environment.C:354
void set_prefix(const char *prefix)
Set parameter option names to begin with prefix.
Definition: GPMSAOptions.C:118
virtual ~GPMSAOptions()
Destructor.
Definition: GPMSAOptions.C:335
int m_maxEmulatorBasisVectors
The maximum number of basis vectors to use for approximating.
Definition: GPMSAOptions.h:80
double m_discrepancyCorrelationStrengthBeta
The beta paramter for the Beta hyperprior for the discrepancy correlation strength.
Definition: GPMSAOptions.h:223
std::string m_option_discrepancyCorrelationStrengthAlpha
Definition: GPMSAOptions.h:287
std::string m_option_emulatorDataPrecisionScale
Definition: GPMSAOptions.h:290
std::string m_prefix
The prefix to look for in the input file.
Definition: GPMSAOptions.h:70
std::string m_option_calibrateObservationalPrecision
Definition: GPMSAOptions.h:280
QUESO::ScopedPtr< BoostInputOptionsParser >::Type m_parser
Definition: GPMSAOptions.h:240
const BaseEnvironment * m_env
Definition: GPMSAOptions.h:237
std::string m_help
If this string is non-empty, print the options object to the output file.
Definition: GPMSAOptions.h:73
double m_emulatorCorrelationStrengthAlpha
The alpha paramter for the Beta hyperprior for the emulator correlation strength. ...
Definition: GPMSAOptions.h:208
void set_scenario_parameter_scaling(unsigned int i, double range_min, double range_max)
Set a value, for scenario parameter i in simulation and.
Definition: GPMSAOptions.C:398
std::string m_option_emulatorPrecisionShape
Definition: GPMSAOptions.h:278
std::vector< double > m_scenarioScaleRange
Definition: GPMSAOptions.h:273
double m_discrepancyPrecisionScale
The scale parameter for the Gamma hyperprior for the discrepancy precision.
Definition: GPMSAOptions.h:217
double m_emulatorPrecisionShape
The shape parameter for the Gamma hyperprior for the emulator precision.
Definition: GPMSAOptions.h:189
void parse(const BaseEnvironment &env, const char *prefix)
Given prefix, read the input file for parameters named &quot;prefix&quot;+*.
Definition: GPMSAOptions.C:172
double normalized_scenario_parameter(unsigned int i, double physical_param) const
Calculate a normalized value from a physical value for the.
Definition: GPMSAOptions.C:556
std::string m_option_emulatorCorrelationStrengthAlpha
Definition: GPMSAOptions.h:283
double m_discrepancyPrecisionShape
The shape parameter for the Gamma hyperprior for the discrepancy precision.
Definition: GPMSAOptions.h:214
std::string m_option_help
Definition: GPMSAOptions.h:275
double m_emulatorDataPrecisionShape
The shape parameter for the Gamma hyperprior for the emulator data precision.
Definition: GPMSAOptions.h:229
int dim
Definition: ann_test.cpp:472
bool m_calibrateObservationalPrecision
Whether to use an observational error precision hyperparameter.
Definition: GPMSAOptions.h:198
GPMSAOptions()
Construct with default parameters.
Definition: GPMSAOptions.C:105
void set_autoscale_minmax_uncertain_parameter(unsigned int i)
Do automatic normalization, using minimum and maximum values in.
Definition: GPMSAOptions.C:348
std::set< unsigned int > m_autoscaleMinMaxScenario
Definition: GPMSAOptions.h:254
std::set< unsigned int > m_autoscaleMinMaxUncertain
Definition: GPMSAOptions.h:249
void set_final_scaling(const std::vector< typename SharedPtr< V >::Type > &m_simulationScenarios, const std::vector< typename SharedPtr< V >::Type > &m_simulationParameters, const std::vector< typename SharedPtr< V >::Type > &m_simulationOutputs, const std::vector< typename SharedPtr< V >::Type > &m_experimentScenarios, const std::vector< typename SharedPtr< V >::Type > &m_experimentOutputs)
Determine the physical parameter ranges (range_min, range_max)
Definition: GPMSAOptions.C:415
std::set< unsigned int > m_autoscaleMeanVarUncertain
Definition: GPMSAOptions.h:250
double m_discrepancyCorrelationStrengthAlpha
The alpha paramter for the Beta hyperprior for the discrepancy correlation strength.
Definition: GPMSAOptions.h:220
const BaseEnvironment & env() const
Returns the QUESO environment.
double m_emulatorBasisVarianceToCapture
The minimum fraction of the variance in simulation output to.
Definition: GPMSAOptions.h:88
std::string m_option_maxEmulatorBasisVectors
Definition: GPMSAOptions.h:276
void set_defaults()
Set default values for parameter options.
Definition: GPMSAOptions.C:145
double m_observationalPrecisionScale
The scale parameter for the Gamma hyperprior for the observational precision.
Definition: GPMSAOptions.h:204
void set_autoscale_minmax_scenario_parameter(unsigned int i)
Do automatic normalization, using minimum and maximum values in.
Definition: GPMSAOptions.C:355
std::string m_option_emulatorPrecisionScale
Definition: GPMSAOptions.h:279
std::string m_option_autoscaleMinMaxAll
Definition: GPMSAOptions.h:292
void set_autoscale_minmax()
Do automatic normalization, using minimum and maximum values in.
Definition: GPMSAOptions.C:341
double m_observationalPrecisionShape
The shape parameter for the Gamma hyperprior for the observational precision.
Definition: GPMSAOptions.h:201
This class defines the options that specify the behaviour of the Gaussian process emulator...
Definition: GPMSAOptions.h:45
std::string m_option_emulatorCorrelationStrengthBeta
Definition: GPMSAOptions.h:284
void set_autoscale_meanvar()
Do automatic normalization, using mean and variance of the.
Definition: GPMSAOptions.C:362
std::set< unsigned int > m_autoscaleMeanVarScenario
Definition: GPMSAOptions.h:255
std::vector< double > m_uncertainScaleRange
Definition: GPMSAOptions.h:264
std::ofstream * subDisplayFile() const
Access function for m_subDisplayFile (displays file on stream).
Definition: Environment.C:320

Generated on Tue Jun 5 2018 19:48:55 for queso-0.57.1 by  doxygen 1.8.5