This class defines the options that specify the behaviour of the Gaussian process emulator. More...

#include <GPMSAOptions.h>

Collaboration diagram for QUESO::GPMSAOptions:

Public Member Functions
	GPMSAOptions (const BaseEnvironment &env, const char *prefix)
	Given prefix, read the input file for parameters named "prefix"+*. More...

	GPMSAOptions ()
	Construct with default parameters. More...

void	set_prefix (const char *prefix)
	Set parameter option names to begin with prefix. More...

void	set_defaults ()
	Set default values for parameter options. More...

void	parse (const BaseEnvironment &env, const char *prefix)
	Given prefix, read the input file for parameters named "prefix"+*. More...

virtual	~GPMSAOptions ()
	Destructor. More...

void	print (std::ostream &os) const
	Prints `this` to `os`. More...

void	set_autoscale_minmax_uncertain_parameter (unsigned int i)
	Do automatic normalization, using minimum and maximum values in. More...

void	set_autoscale_minmax_scenario_parameter (unsigned int i)
	Do automatic normalization, using minimum and maximum values in. More...

void	set_autoscale_minmax ()
	Do automatic normalization, using minimum and maximum values in. More...

void	set_autoscale_meanvar_uncertain_parameter (unsigned int i)
	Do automatic normalization, using mean and variance of the. More...

void	set_autoscale_meanvar_scenario_parameter (unsigned int i)
	Do automatic normalization, using mean and variance of the. More...

void	set_autoscale_meanvar ()
	Do automatic normalization, using mean and variance of the. More...

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. More...

void	set_scenario_parameter_scaling (unsigned int i, double range_min, double range_max)
	Set a value, for scenario parameter i in simulation and. More...

void	set_output_scaling (unsigned int i, double range_min, double range_max)
	Set a value, for output value i in simulation and. More...

template<typename V >
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) More...

double	normalized_scenario_parameter (unsigned int i, double physical_param) const
	Calculate a normalized value from a physical value for the. More...

double	normalized_uncertain_parameter (unsigned int i, double physical_param) const
	Calculate a normalized value from a physical value for the. More...

const BaseEnvironment &	env () const
	Returns the QUESO environment. More...

Public Attributes
std::string	m_prefix
	The prefix to look for in the input file. More...

std::string	m_help
	If this string is non-empty, print the options object to the output file. More...

int	m_maxEmulatorBasisVectors
	The maximum number of basis vectors to use for approximating. More...

double	m_emulatorBasisVarianceToCapture
	The minimum fraction of the variance in simulation output to. More...

double	m_emulatorPrecisionShape
	The shape parameter for the Gamma hyperprior for the emulator precision. More...

double	m_emulatorPrecisionScale
	The scale parameter for the Gamma hyperprior for the emulator precision. More...

bool	m_calibrateObservationalPrecision
	Whether to use an observational error precision hyperparameter. More...

double	m_observationalPrecisionShape
	The shape parameter for the Gamma hyperprior for the observational precision. More...

double	m_observationalPrecisionScale
	The scale parameter for the Gamma hyperprior for the observational precision. More...

double	m_emulatorCorrelationStrengthAlpha
	The alpha paramter for the Beta hyperprior for the emulator correlation strength. More...

double	m_emulatorCorrelationStrengthBeta
	The beta paramter for the Beta hyperprior for the emulator correlation strength. More...

double	m_discrepancyPrecisionShape
	The shape parameter for the Gamma hyperprior for the discrepancy precision. More...

double	m_discrepancyPrecisionScale
	The scale parameter for the Gamma hyperprior for the discrepancy precision. More...

double	m_discrepancyCorrelationStrengthAlpha
	The alpha paramter for the Beta hyperprior for the discrepancy correlation strength. More...

double	m_discrepancyCorrelationStrengthBeta
	The beta paramter for the Beta hyperprior for the discrepancy correlation strength. More...

double	m_emulatorDataPrecisionShape
	The shape parameter for the Gamma hyperprior for the emulator data precision. More...

double	m_emulatorDataPrecisionScale
	The scale parameter for the Gamma hyperprior for the emulator data precision. More...

Private Member Functions
void	checkOptions ()

Private Attributes
const BaseEnvironment *	m_env

QUESO::ScopedPtr < BoostInputOptionsParser > ::Type	m_parser

bool	m_autoscaleMinMaxAll

bool	m_autoscaleMeanVarAll

std::set< unsigned int >	m_autoscaleMinMaxUncertain

std::set< unsigned int >	m_autoscaleMeanVarUncertain

std::set< unsigned int >	m_autoscaleMinMaxScenario

std::set< unsigned int >	m_autoscaleMeanVarScenario

std::vector< double >	m_uncertainScaleMin

std::vector< double >	m_uncertainScaleRange

std::vector< double >	m_scenarioScaleMin

std::vector< double >	m_scenarioScaleRange

std::string	m_option_help

std::string	m_option_maxEmulatorBasisVectors

std::string	m_option_emulatorBasisVarianceToCapture

std::string	m_option_emulatorPrecisionShape

std::string	m_option_emulatorPrecisionScale

std::string	m_option_calibrateObservationalPrecision

std::string	m_option_observationalPrecisionShape

std::string	m_option_observationalPrecisionScale

std::string	m_option_emulatorCorrelationStrengthAlpha

std::string	m_option_emulatorCorrelationStrengthBeta

std::string	m_option_discrepancyPrecisionShape

std::string	m_option_discrepancyPrecisionScale

std::string	m_option_discrepancyCorrelationStrengthAlpha

std::string	m_option_discrepancyCorrelationStrengthBeta

std::string	m_option_emulatorDataPrecisionShape

std::string	m_option_emulatorDataPrecisionScale

std::string	m_option_autoscaleMinMaxAll

std::string	m_option_autoscaleMeanVarAll

Friends
std::ostream &	operator<< (std::ostream &os, const GPMSAOptions &obj)

Detailed Description

This class defines the options that specify the behaviour of the Gaussian process emulator.

Definition at line 45 of file GPMSAOptions.h.

Constructor & Destructor Documentation

QUESO::GPMSAOptions::GPMSAOptions	(	const BaseEnvironment &	env,
		const char *	prefix
	)

Given prefix, read the input file for parameters named "prefix"+*.

Definition at line 96 of file GPMSAOptions.C.

References parse(), and set_defaults().

 {
   this->set_defaults();
   this->parse(env, prefix);
 }

QUESO::GPMSAOptions::GPMSAOptions ( )

Construct with default parameters.

Definition at line 105 of file GPMSAOptions.C.

References set_defaults(), and set_prefix().

   :
   m_env(NULL)
 #ifndef DISABLE_BOOST_PROGRAM_OPTIONS
   ,m_parser(new BoostInputOptionsParser())
 #endif  // DISABLE_BOOST_PROGRAM_OPTIONS
 {
   this->set_defaults();
   this->set_prefix("");
 }

QUESO::GPMSAOptions::~GPMSAOptions ( )

virtual

Destructor.

Definition at line 335 of file GPMSAOptions.C.

336 {

337 }

Member Function Documentation

void QUESO::GPMSAOptions::checkOptions ( )

private

Definition at line 580 of file GPMSAOptions.C.

References m_env, m_help, and QUESO::BaseEnvironment::subDisplayFile().

Referenced by parse(), and set_defaults().

 {
   if (m_help != "") {
     if (m_env && m_env->subDisplayFile()) {
       *m_env->subDisplayFile() << (*this) << std::endl;
     }
   }
 }

const BaseEnvironment& QUESO::GPMSAOptions::env ( ) const

Returns the QUESO environment.

Referenced by parse().

double QUESO::GPMSAOptions::normalized_scenario_parameter	(	unsigned int	i,
		double	physical_param
	)		const

Calculate a normalized value from a physical value for the.

Definition at line 556 of file GPMSAOptions.C.

References m_scenarioScaleMin, and m_scenarioScaleRange.

 {
   if (i < m_scenarioScaleMin.size())
     return (physical_param - m_scenarioScaleMin[i]) /
             m_scenarioScaleRange[i];
   return physical_param;
 }

double QUESO::GPMSAOptions::normalized_uncertain_parameter	(	unsigned int	i,
		double	physical_param
	)		const

Calculate a normalized value from a physical value for the.

Definition at line 568 of file GPMSAOptions.C.

References m_uncertainScaleMin, and m_uncertainScaleRange.

 {
   if (i < m_uncertainScaleMin.size())
     return (physical_param - m_uncertainScaleMin[i]) /
             m_uncertainScaleRange[i];
   return physical_param;
 }

void QUESO::GPMSAOptions::parse	(	const BaseEnvironment &	env,
		const char *	prefix
	)

Given prefix, read the input file for parameters named "prefix"+*.

Definition at line 172 of file GPMSAOptions.C.

References checkOptions(), env(), QUESO::BaseEnvironment::input(), m_autoscaleMeanVarAll, m_autoscaleMinMaxAll, m_calibrateObservationalPrecision, m_discrepancyCorrelationStrengthAlpha, m_discrepancyCorrelationStrengthBeta, m_discrepancyPrecisionScale, m_discrepancyPrecisionShape, m_emulatorCorrelationStrengthAlpha, m_emulatorCorrelationStrengthBeta, m_emulatorDataPrecisionScale, m_emulatorDataPrecisionShape, m_emulatorPrecisionScale, m_emulatorPrecisionShape, m_env, m_help, m_observationalPrecisionScale, m_observationalPrecisionShape, m_option_autoscaleMeanVarAll, m_option_autoscaleMinMaxAll, m_option_calibrateObservationalPrecision, m_option_discrepancyCorrelationStrengthAlpha, m_option_discrepancyCorrelationStrengthBeta, m_option_discrepancyPrecisionScale, m_option_discrepancyPrecisionShape, m_option_emulatorCorrelationStrengthAlpha, m_option_emulatorCorrelationStrengthBeta, m_option_emulatorDataPrecisionScale, m_option_emulatorDataPrecisionShape, m_option_emulatorPrecisionScale, m_option_emulatorPrecisionShape, m_option_help, m_option_observationalPrecisionScale, m_option_observationalPrecisionShape, m_parser, QUESO::BaseEnvironment::optionsInputFileName(), and set_prefix().

Referenced by GPMSAOptions().

 {
   m_env = &env;
 
   if (m_env->optionsInputFileName() == "") {
     queso_error_msg("Missing input file is required");
   }
 
   this->set_prefix(prefix);
 
 #ifndef DISABLE_BOOST_PROGRAM_OPTIONS
   m_parser.reset(new BoostInputOptionsParser(env.optionsInputFileName()));
 
   m_parser->registerOption<std::string>
     (m_option_help,
      m_help,
      "produce help message Gaussian process emulator");
 
   m_parser->registerOption
     (m_option_emulatorPrecisionShape,
      m_emulatorPrecisionShape,
      "shape hyperprior (Gamma) parameter for emulator precision");
   m_parser->registerOption
     (m_option_emulatorPrecisionScale,
     m_emulatorPrecisionScale,
     "scale hyperprior (Gamma) parameter for emulator precision");
 
   m_parser->registerOption
     (m_option_calibrateObservationalPrecision,
     m_calibrateObservationalPrecision,
     "whether to use a calibrated hyperparameter for observational precision");
 
   m_parser->registerOption
     (m_option_observationalPrecisionShape,
     m_observationalPrecisionShape,
     "shape hyperprior (Gamma) parameter for observational precision");
   m_parser->registerOption
     (m_option_observationalPrecisionScale,
     m_observationalPrecisionScale,
     "scale hyperprior (Gamma) parameter for observational precision");
 
   m_parser->registerOption
     (m_option_emulatorCorrelationStrengthAlpha,
     m_emulatorCorrelationStrengthAlpha,
     "alpha hyperprior (Beta) parameter for emulator correlation strength");
   m_parser->registerOption
     (m_option_emulatorCorrelationStrengthBeta,
     m_emulatorCorrelationStrengthBeta,
     "beta hyperprior (Beta) parameter for emulator correlation strength");
 
   m_parser->registerOption
     (m_option_discrepancyPrecisionShape,
     m_discrepancyPrecisionShape,
     "shape hyperprior (Gamma) parameter for discrepancy precision");
   m_parser->registerOption
     (m_option_discrepancyPrecisionScale,
     m_discrepancyPrecisionScale,
     "scale hyperprior (Gamma) parameter for discrepancy precision");
 
   m_parser->registerOption
     (m_option_discrepancyCorrelationStrengthAlpha,
     m_discrepancyCorrelationStrengthAlpha,
     "alpha hyperprior (Beta) parameter for discrepancy correlation strength");
   m_parser->registerOption
     (m_option_discrepancyCorrelationStrengthBeta,
     m_discrepancyCorrelationStrengthBeta,
     "beta hyperprior (Beta) parameter for discrepancy correlation strength");
 
   m_parser->registerOption
     (m_option_emulatorDataPrecisionShape,
     m_emulatorDataPrecisionShape,
     "shape hyperprior (Gamma) parameter for emulator data precision");
   m_parser->registerOption
     (m_option_emulatorDataPrecisionScale,
     m_emulatorDataPrecisionScale,
     "scale hyperprior (Gamma) parameter for emulator data precision");
 
   m_parser->registerOption
     (m_option_autoscaleMinMaxAll,
     m_autoscaleMinMaxAll,
     "option to autoscale all parameters and outputs based on data range");
   m_parser->registerOption
     (m_option_autoscaleMeanVarAll,
     m_autoscaleMeanVarAll,
     "option to autoscale all parameters and outputs based on data statistics");
 
   m_parser->scanInputFile();
 
   m_parser->getOption<std::string>(m_option_help,                           m_help);
   m_parser->getOption<double>(m_option_emulatorPrecisionShape,              m_emulatorPrecisionShape);
   m_parser->getOption<double>(m_option_emulatorPrecisionScale,              m_emulatorPrecisionScale);
   m_parser->getOption<bool>  (m_option_calibrateObservationalPrecision,     m_calibrateObservationalPrecision);
   m_parser->getOption<double>(m_option_observationalPrecisionShape,         m_observationalPrecisionShape);
   m_parser->getOption<double>(m_option_observationalPrecisionScale,         m_observationalPrecisionScale);
   m_parser->getOption<double>(m_option_emulatorCorrelationStrengthAlpha,    m_emulatorCorrelationStrengthAlpha);
   m_parser->getOption<double>(m_option_emulatorCorrelationStrengthBeta,     m_emulatorCorrelationStrengthBeta);
   m_parser->getOption<double>(m_option_discrepancyPrecisionShape,           m_discrepancyPrecisionShape);
   m_parser->getOption<double>(m_option_discrepancyPrecisionScale,           m_discrepancyPrecisionScale);
   m_parser->getOption<double>(m_option_discrepancyCorrelationStrengthAlpha, m_discrepancyCorrelationStrengthAlpha);
   m_parser->getOption<double>(m_option_discrepancyCorrelationStrengthBeta,  m_discrepancyCorrelationStrengthBeta);
   m_parser->getOption<double>(m_option_emulatorDataPrecisionShape,          m_emulatorDataPrecisionShape);
   m_parser->getOption<double>(m_option_emulatorDataPrecisionScale,          m_emulatorDataPrecisionScale);
   m_parser->getOption<bool>  (m_option_autoscaleMinMaxAll,                  m_autoscaleMinMaxAll);
   m_parser->getOption<bool>  (m_option_autoscaleMeanVarAll,                 m_autoscaleMeanVarAll);
 #else
   m_help = env.input()(m_option_help, UQ_GPMSA_HELP);
   m_emulatorPrecisionShape =
     env.input()(m_option_emulatorPrecisionShape,
                 m_emulatorPrecisionShape);
   m_emulatorPrecisionScale =
     env.input()(m_option_emulatorPrecisionScale,
                 m_emulatorPrecisionScale);
 
   m_calibrateObservationalPrecision =
     env.input()(m_option_calibrateObservationalPrecision,
                 m_calibrateObservationalPrecision);
   m_observationalPrecisionShape =
     env.input()(m_option_observationalPrecisionShape,
                 m_observationalPrecisionShape);
   m_observationalPrecisionScale =
     env.input()(m_option_observationalPrecisionScale,
                 m_observationalPrecisionScale);
 
   m_emulatorCorrelationStrengthAlpha =
     env.input()(m_option_emulatorCorrelationStrengthAlpha,
                 m_emulatorCorrelationStrengthAlpha);
   m_emulatorCorrelationStrengthBeta =
     env.input()(m_option_emulatorCorrelationStrengthBeta,
                 m_emulatorCorrelationStrengthBeta);
 
   m_discrepancyPrecisionShape =
     env.input()(m_option_discrepancyPrecisionShape,
                 m_discrepancyPrecisionShape);
   m_discrepancyPrecisionScale =
     env.input()(m_option_discrepancyPrecisionScale,
                 m_discrepancyPrecisionScale);
 
   m_discrepancyCorrelationStrengthAlpha =
     env.input()(m_option_discrepancyCorrelationStrengthAlpha,
                 m_discrepancyCorrelationStrengthAlpha);
   m_discrepancyCorrelationStrengthBeta =
     env.input()(m_option_discrepancyCorrelationStrengthBeta,
                 m_discrepancyCorrelationStrengthBeta);
 
   m_emulatorDataPrecisionShape =
     env.input()(m_option_emulatorDataPrecisionShape,
                 m_emulatorDataPrecisionShape);
   m_emulatorDataPrecisionScale =
     env.input()(m_option_emulatorDataPrecisionScale,
                 m_emulatorDataPrecisionScale);
 
   m_emulatorDataPrecisionShape =
     env.input()(m_option_autoscaleMinMaxAll,
                 m_autoscaleMinMaxAll);
   m_emulatorDataPrecisionScale =
     env.input()(m_option_autoscaleMeanVarAll,
                 m_autoscaleMeanVarAll);
 #endif  // DISABLE_BOOST_PROGRAM_OPTIONS
 
   checkOptions();
 }

void QUESO::GPMSAOptions::print ( std::ostream & os ) const

Prints this to os.

Definition at line 590 of file GPMSAOptions.C.

References m_autoscaleMeanVarAll, m_autoscaleMinMaxAll, m_calibrateObservationalPrecision, m_discrepancyCorrelationStrengthAlpha, m_discrepancyCorrelationStrengthBeta, m_discrepancyPrecisionScale, m_discrepancyPrecisionShape, m_emulatorCorrelationStrengthAlpha, m_emulatorCorrelationStrengthBeta, m_emulatorDataPrecisionScale, m_emulatorDataPrecisionShape, m_emulatorPrecisionScale, m_emulatorPrecisionShape, m_observationalPrecisionScale, m_observationalPrecisionShape, m_option_autoscaleMeanVarAll, m_option_autoscaleMinMaxAll, m_option_calibrateObservationalPrecision, m_option_discrepancyCorrelationStrengthAlpha, m_option_discrepancyCorrelationStrengthBeta, m_option_discrepancyPrecisionScale, m_option_discrepancyPrecisionShape, m_option_emulatorCorrelationStrengthAlpha, m_option_emulatorCorrelationStrengthBeta, m_option_emulatorDataPrecisionScale, m_option_emulatorDataPrecisionShape, m_option_emulatorPrecisionScale, m_option_emulatorPrecisionShape, m_option_observationalPrecisionScale, and m_option_observationalPrecisionShape.

Referenced by QUESO::operator<<().

 {
   os << "\n" << m_option_emulatorPrecisionShape << " = " << this->m_emulatorPrecisionShape
      << "\n" << m_option_emulatorPrecisionScale << " = " << this->m_emulatorPrecisionScale
      << "\n" << m_option_calibrateObservationalPrecision << " = " << this->m_calibrateObservationalPrecision
      << "\n" << m_option_observationalPrecisionShape << " = " << this->m_observationalPrecisionShape
      << "\n" << m_option_observationalPrecisionScale << " = " << this->m_observationalPrecisionScale
      << "\n" << m_option_emulatorCorrelationStrengthAlpha << " = " << this->m_emulatorCorrelationStrengthAlpha
      << "\n" << m_option_emulatorCorrelationStrengthBeta << " = " << this->m_emulatorCorrelationStrengthBeta
      << "\n" << m_option_discrepancyPrecisionShape << " = " << this->m_discrepancyPrecisionShape
      << "\n" << m_option_discrepancyPrecisionScale << " = " << this->m_discrepancyPrecisionScale
      << "\n" << m_option_discrepancyCorrelationStrengthAlpha << " = " << this->m_discrepancyCorrelationStrengthAlpha
      << "\n" << m_option_discrepancyCorrelationStrengthBeta << " = " << this->m_discrepancyCorrelationStrengthBeta
      << "\n" << m_option_emulatorDataPrecisionShape << " = " << this->m_emulatorDataPrecisionShape
      << "\n" << m_option_emulatorDataPrecisionScale << " = " << this->m_emulatorDataPrecisionScale
      << "\n" << m_option_autoscaleMinMaxAll << " = " << this->m_autoscaleMinMaxAll
      << "\n" << m_option_autoscaleMeanVarAll << " = " << this->m_autoscaleMeanVarAll
      << std::endl;
 }

void QUESO::GPMSAOptions::set_autoscale_meanvar ( )

Do automatic normalization, using mean and variance of the.

Definition at line 362 of file GPMSAOptions.C.

References m_autoscaleMeanVarAll.

 {
   this->m_autoscaleMeanVarAll = true;
 }

void QUESO::GPMSAOptions::set_autoscale_meanvar_scenario_parameter ( unsigned int i )

Do automatic normalization, using mean and variance of the.

Definition at line 376 of file GPMSAOptions.C.

References m_autoscaleMeanVarScenario.

 {
   m_autoscaleMeanVarScenario.insert(i);
 }

void QUESO::GPMSAOptions::set_autoscale_meanvar_uncertain_parameter ( unsigned int i )

Do automatic normalization, using mean and variance of the.

Definition at line 369 of file GPMSAOptions.C.

References m_autoscaleMeanVarUncertain.

 {
   m_autoscaleMeanVarUncertain.insert(i);
 }

void QUESO::GPMSAOptions::set_autoscale_minmax ( )

Do automatic normalization, using minimum and maximum values in.

Definition at line 341 of file GPMSAOptions.C.

References m_autoscaleMinMaxAll.

 {
   this->m_autoscaleMinMaxAll = true;
 }

void QUESO::GPMSAOptions::set_autoscale_minmax_scenario_parameter ( unsigned int i )

Do automatic normalization, using minimum and maximum values in.

Definition at line 355 of file GPMSAOptions.C.

References m_autoscaleMinMaxScenario.

 {
   m_autoscaleMinMaxScenario.insert(i);
 }

void QUESO::GPMSAOptions::set_autoscale_minmax_uncertain_parameter ( unsigned int i )

Do automatic normalization, using minimum and maximum values in.

Definition at line 348 of file GPMSAOptions.C.

References m_autoscaleMinMaxUncertain.

 {
   m_autoscaleMinMaxUncertain.insert(i);
 }

void QUESO::GPMSAOptions::set_defaults ( )

Set default values for parameter options.

Definition at line 145 of file GPMSAOptions.C.

References checkOptions(), m_autoscaleMeanVarAll, m_autoscaleMinMaxAll, m_calibrateObservationalPrecision, m_discrepancyCorrelationStrengthAlpha, m_discrepancyCorrelationStrengthBeta, m_discrepancyPrecisionScale, m_discrepancyPrecisionShape, m_emulatorBasisVarianceToCapture, m_emulatorCorrelationStrengthAlpha, m_emulatorCorrelationStrengthBeta, m_emulatorDataPrecisionScale, m_emulatorDataPrecisionShape, m_emulatorPrecisionScale, m_emulatorPrecisionShape, m_help, m_maxEmulatorBasisVectors, m_observationalPrecisionScale, and m_observationalPrecisionShape.

Referenced by GPMSAOptions().

 {
   m_help = UQ_GPMSA_HELP;
   m_maxEmulatorBasisVectors = UQ_GPMSA_MAX_SIMULATOR_BASIS_VECTORS_ODV;
   m_emulatorBasisVarianceToCapture = UQ_GPMSA_SIMULATOR_BASIS_VARIANCE_TO_CAPTURE;
   m_emulatorPrecisionShape = UQ_GPMSA_EMULATOR_PRECISION_SHAPE_ODV;
   m_emulatorPrecisionScale = UQ_GPMSA_EMULATOR_PRECISION_SCALE_ODV;
   m_calibrateObservationalPrecision = false;
   m_observationalPrecisionShape = UQ_GPMSA_OBSERVATIONAL_PRECISION_SHAPE_ODV;
   m_observationalPrecisionScale = UQ_GPMSA_OBSERVATIONAL_PRECISION_SCALE_ODV;
   m_emulatorCorrelationStrengthAlpha = UQ_GPMSA_EMULATOR_CORRELATION_STRENGTH_ALPHA_ODV;
   m_emulatorCorrelationStrengthBeta = UQ_GPMSA_EMULATOR_CORRELATION_STRENGTH_BETA_ODV;
   m_discrepancyPrecisionShape = UQ_GPMSA_DISCREPANCY_PRECISION_SHAPE_ODV;
   m_discrepancyPrecisionScale = UQ_GPMSA_DISCREPANCY_PRECISION_SCALE_ODV;
   m_discrepancyCorrelationStrengthAlpha = UQ_GPMSA_DISCREPANCY_CORRELATION_STRENGTH_ALPHA_ODV;
   m_discrepancyCorrelationStrengthBeta = UQ_GPMSA_DISCREPANCY_CORRELATION_STRENGTH_BETA_ODV;
   m_emulatorDataPrecisionShape = UQ_GPMSA_EMULATOR_DATA_PRECISION_SHAPE_ODV;
   m_emulatorDataPrecisionScale = UQ_GPMSA_EMULATOR_DATA_PRECISION_SCALE_ODV;
 
   m_autoscaleMinMaxAll = false;
   m_autoscaleMeanVarAll = false;
 
   checkOptions();
 }

template<typename V >

template void QUESO::GPMSAOptions::set_final_scaling< GslVector >	(	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 at line 415 of file GPMSAOptions.C.

 {
   if ((m_autoscaleMinMaxAll && m_autoscaleMeanVarAll) ||
       ((m_autoscaleMinMaxAll || m_autoscaleMeanVarAll) &&
        (!m_autoscaleMinMaxUncertain.empty() ||
         !m_autoscaleMeanVarUncertain.empty() ||
         !m_autoscaleMinMaxScenario.empty() ||
         !m_autoscaleMeanVarScenario.empty())))
     queso_error_msg("Cannot autoscale based on incompatible criteria");
 
   unsigned int dimScenario = m_simulationScenarios.size() ?
           m_simulationScenarios[0]->sizeGlobal() : 0;
 
   unsigned int dimParameter = m_simulationParameters.size() ?
           m_simulationParameters[0]->sizeGlobal() : 0;
 
   if (m_autoscaleMinMaxAll || !m_autoscaleMinMaxScenario.empty())
     {
       V maxScenario(*m_simulationScenarios[0]);
 
       V minScenario(*m_simulationScenarios[0]);
 
       for (unsigned int i=1; i < m_simulationScenarios.size(); ++i)
         min_max_update(minScenario, maxScenario,
                        (*m_simulationScenarios[i]));
 
       for (unsigned int i=0; i < m_experimentScenarios.size(); ++i)
         min_max_update(minScenario, maxScenario,
                        (*m_experimentScenarios[i]));
 
       for (unsigned int p=0; p != dimScenario; ++p)
         if (m_autoscaleMinMaxAll ||
             m_autoscaleMinMaxScenario.count(p))
           {
             if ((m_scenarioScaleMin.size() > p) &&
                 ((m_scenarioScaleMin[p] != 0) ||
                  (m_scenarioScaleRange[p] != 1)))
               queso_error_msg("Cannot autoscale and manually scale the same scenario parameter");
 
             this->set_scenario_parameter_scaling(p, minScenario[p],
                                                     maxScenario[p]);
           }
     }
 
   if (m_autoscaleMinMaxAll || !m_autoscaleMinMaxUncertain.empty())
     {
       V maxUncertain(*m_simulationParameters[0]);
 
       V minUncertain(*m_simulationParameters[0]);
 
       for (unsigned int i=1; i < m_simulationParameters.size(); ++i)
         min_max_update(minUncertain, maxUncertain,
                        (*m_simulationParameters[i]));
 
       for (unsigned int p=0; p != dimParameter; ++p)
         if (m_autoscaleMinMaxAll ||
             m_autoscaleMinMaxUncertain.count(p))
           {
             if ((m_uncertainScaleMin.size() > p) &&
                 ((m_uncertainScaleMin[p] != 0) ||
                  (m_uncertainScaleRange[p] != 1)))
               queso_error_msg("Cannot autoscale and manually scale the same uncertain parameter");
 
             this->set_uncertain_parameter_scaling(p, minUncertain[p],
                                                      maxUncertain[p]);
           }
     }
 
 
   if (m_autoscaleMeanVarAll || !m_autoscaleMeanVarScenario.empty())
     {
       unsigned int n=0;
 
       V meanScenario(*m_simulationScenarios[0]);
 
       V varScenario(m_simulationScenarios[0]->env(),
                     m_simulationScenarios[0]->map());
 
       for (unsigned int i=0; i < m_simulationScenarios.size(); ++i)
         mean_var_update(n, meanScenario, varScenario,
                         *m_simulationScenarios[i]);
 
       for (unsigned int i=0; i < m_experimentScenarios.size(); ++i)
         mean_var_update(n, meanScenario, varScenario,
                         *m_experimentScenarios[i]);
 
       varScenario /= n;
 
       for (unsigned int p=0; p != dimScenario; ++p)
         if (m_autoscaleMeanVarAll ||
             m_autoscaleMeanVarScenario.count(p))
           {
             if ((m_scenarioScaleMin.size() > p) &&
                 ((m_scenarioScaleMin[p] != 0) ||
                  (m_scenarioScaleRange[p] != 1)))
               queso_error_msg("Cannot autoscale and manually scale the same scenario parameter");
 
             this->set_scenario_parameter_scaling(p, meanScenario[p],
                                                  meanScenario[p] +
                                                  std::sqrt(varScenario[p]));
           }
     }
 
 
   if (m_autoscaleMeanVarAll || !m_autoscaleMeanVarUncertain.empty())
     {
       unsigned int n=0;
 
       V meanUncertain(*m_simulationParameters[0]);
 
       V varUncertain(m_simulationParameters[0]->env(),
                      m_simulationParameters[0]->map());
 
       for (unsigned int i=0; i < m_simulationParameters.size(); ++i)
         mean_var_update(n, meanUncertain, varUncertain,
                         *m_simulationParameters[i]);
 
       varUncertain /= n;
 
       for (unsigned int p=0; p != dimScenario; ++p)
         if (m_autoscaleMeanVarAll ||
             m_autoscaleMeanVarUncertain.count(p))
           {
             if ((m_uncertainScaleMin.size() > p) &&
                 ((m_uncertainScaleMin[p] != 0) ||
                  (m_uncertainScaleRange[p] != 1)))
               queso_error_msg("Cannot autoscale and manually scale the same uncertain parameter");
 
             this->set_uncertain_parameter_scaling(p, meanUncertain[p],
                                                   meanUncertain[p] +
                                                   std::sqrt(varUncertain[p]));
           }
     }
 }

void QUESO::GPMSAOptions::set_output_scaling	(	unsigned int	i,
		double	range_min,
		double	range_max
	)

Set a value, for output value i in simulation and.

void QUESO::GPMSAOptions::set_prefix ( const char * prefix )

Set parameter option names to begin with prefix.

Definition at line 118 of file GPMSAOptions.C.

References m_option_autoscaleMeanVarAll, m_option_autoscaleMinMaxAll, m_option_calibrateObservationalPrecision, m_option_discrepancyCorrelationStrengthAlpha, m_option_discrepancyCorrelationStrengthBeta, m_option_discrepancyPrecisionScale, m_option_discrepancyPrecisionShape, m_option_emulatorBasisVarianceToCapture, m_option_emulatorCorrelationStrengthAlpha, m_option_emulatorCorrelationStrengthBeta, m_option_emulatorDataPrecisionScale, m_option_emulatorDataPrecisionShape, m_option_emulatorPrecisionScale, m_option_emulatorPrecisionShape, m_option_help, m_option_maxEmulatorBasisVectors, m_option_observationalPrecisionScale, m_option_observationalPrecisionShape, and m_prefix.

Referenced by GPMSAOptions(), and parse().

 {
   m_prefix = std::string(prefix) + "gpmsa_";
 
   m_option_help = m_prefix + "help";
   m_option_maxEmulatorBasisVectors = m_prefix + "max_emulator_basis_vectors";
   m_option_emulatorBasisVarianceToCapture = m_prefix + "emulator_basis_variance_to_capture";
   m_option_emulatorPrecisionShape = m_prefix + "emulator_precision_shape";
   m_option_emulatorPrecisionScale = m_prefix + "emulator_precision_scale";
   m_option_calibrateObservationalPrecision = m_prefix + "calibrate_observational_precision";
   m_option_observationalPrecisionShape = m_prefix + "observational_precision_shape";
   m_option_observationalPrecisionScale = m_prefix + "observational_precision_scale";
   m_option_emulatorCorrelationStrengthAlpha = m_prefix + "emulator_correlation_strength_alpha";
   m_option_emulatorCorrelationStrengthBeta = m_prefix + "emulator_correlation_strength_beta";
   m_option_discrepancyPrecisionShape = m_prefix + "discrepancy_precision_shape";
   m_option_discrepancyPrecisionScale = m_prefix + "discrepancy_precision_scale";
   m_option_discrepancyCorrelationStrengthAlpha = m_prefix + "discrepancy_correlation_strength_alpha";
   m_option_discrepancyCorrelationStrengthBeta = m_prefix + "discrepancy_correlation_strength_beta";
   m_option_emulatorDataPrecisionShape = m_prefix + "emulator_data_precision_shape";
   m_option_emulatorDataPrecisionScale = m_prefix + "emulator_data_precision_scale";
   m_option_autoscaleMinMaxAll = m_prefix + "autoscale_min_max_all";
   m_option_autoscaleMeanVarAll = m_prefix + "autoscale_mean_var_all";
 }

void QUESO::GPMSAOptions::set_scenario_parameter_scaling	(	unsigned int	i,
		double	range_min,
		double	range_max
	)

Set a value, for scenario parameter i in simulation and.

Definition at line 398 of file GPMSAOptions.C.

References m_scenarioScaleMin, and m_scenarioScaleRange.

 {
   if (i >= m_scenarioScaleMin.size())
   {
     m_scenarioScaleMin.resize(i+1, 0);
     m_scenarioScaleRange.resize(i+1, 1);
   }
   m_scenarioScaleMin[i] = range_min;
   m_scenarioScaleRange[i] = range_max - range_min;
 }

void QUESO::GPMSAOptions::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 at line 383 of file GPMSAOptions.C.

References m_uncertainScaleMin, and m_uncertainScaleRange.

 {
   if (i >= m_uncertainScaleMin.size())
   {
     m_uncertainScaleMin.resize(i+1, 0);
     m_uncertainScaleRange.resize(i+1, 1);
   }
   m_uncertainScaleMin[i] = range_min;
   m_uncertainScaleRange[i] = range_max - range_min;
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const GPMSAOptions &	obj
	)

friend

Definition at line 611 of file GPMSAOptions.C.

 {
 #ifndef DISABLE_BOOST_PROGRAM_OPTIONS
   os << (*(obj.m_parser)) << std::endl;
 #endif  // DISABLE_BOOST_PROGRAM_OPTIONS
   obj.print(os);
   return os;
 }

Member Data Documentation

bool QUESO::GPMSAOptions::m_autoscaleMeanVarAll

private

Definition at line 245 of file GPMSAOptions.h.

Referenced by parse(), print(), set_autoscale_meanvar(), and set_defaults().

std::set<unsigned int> QUESO::GPMSAOptions::m_autoscaleMeanVarScenario

private

Definition at line 255 of file GPMSAOptions.h.

Referenced by set_autoscale_meanvar_scenario_parameter().

std::set<unsigned int> QUESO::GPMSAOptions::m_autoscaleMeanVarUncertain

private

Definition at line 250 of file GPMSAOptions.h.

Referenced by set_autoscale_meanvar_uncertain_parameter().

bool QUESO::GPMSAOptions::m_autoscaleMinMaxAll

private

Definition at line 244 of file GPMSAOptions.h.

Referenced by parse(), print(), set_autoscale_minmax(), and set_defaults().

std::set<unsigned int> QUESO::GPMSAOptions::m_autoscaleMinMaxScenario

private

Definition at line 254 of file GPMSAOptions.h.

Referenced by set_autoscale_minmax_scenario_parameter().

std::set<unsigned int> QUESO::GPMSAOptions::m_autoscaleMinMaxUncertain

private

Definition at line 249 of file GPMSAOptions.h.

Referenced by set_autoscale_minmax_uncertain_parameter().

bool QUESO::GPMSAOptions::m_calibrateObservationalPrecision

Whether to use an observational error precision hyperparameter.

Definition at line 198 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_discrepancyCorrelationStrengthAlpha

The alpha paramter for the Beta hyperprior for the discrepancy correlation strength.

Definition at line 220 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_discrepancyCorrelationStrengthBeta

The beta paramter for the Beta hyperprior for the discrepancy correlation strength.

Definition at line 223 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_discrepancyPrecisionScale

The scale parameter for the Gamma hyperprior for the discrepancy precision.

Definition at line 217 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_discrepancyPrecisionShape

The shape parameter for the Gamma hyperprior for the discrepancy precision.

Definition at line 214 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_emulatorBasisVarianceToCapture

The minimum fraction of the variance in simulation output to.

Definition at line 88 of file GPMSAOptions.h.

Referenced by set_defaults().

double QUESO::GPMSAOptions::m_emulatorCorrelationStrengthAlpha

The alpha paramter for the Beta hyperprior for the emulator correlation strength.

Definition at line 208 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_emulatorCorrelationStrengthBeta

The beta paramter for the Beta hyperprior for the emulator correlation strength.

Definition at line 211 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_emulatorDataPrecisionScale

The scale parameter for the Gamma hyperprior for the emulator data precision.

Definition at line 232 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_emulatorDataPrecisionShape

The shape parameter for the Gamma hyperprior for the emulator data precision.

Definition at line 229 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_emulatorPrecisionScale

The scale parameter for the Gamma hyperprior for the emulator precision.

Definition at line 192 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_emulatorPrecisionShape

The shape parameter for the Gamma hyperprior for the emulator precision.

Definition at line 189 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

const BaseEnvironment* QUESO::GPMSAOptions::m_env

private

Definition at line 237 of file GPMSAOptions.h.

Referenced by checkOptions(), and parse().

std::string QUESO::GPMSAOptions::m_help

If this string is non-empty, print the options object to the output file.

Definition at line 73 of file GPMSAOptions.h.

Referenced by checkOptions(), parse(), and set_defaults().

int QUESO::GPMSAOptions::m_maxEmulatorBasisVectors

The maximum number of basis vectors to use for approximating.

Definition at line 80 of file GPMSAOptions.h.

Referenced by QUESO::GPMSAEmulator< V, M >::GPMSAEmulator(), and set_defaults().

double QUESO::GPMSAOptions::m_observationalPrecisionScale

The scale parameter for the Gamma hyperprior for the observational precision.

Definition at line 204 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

double QUESO::GPMSAOptions::m_observationalPrecisionShape

The shape parameter for the Gamma hyperprior for the observational precision.

Definition at line 201 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_defaults().

std::string QUESO::GPMSAOptions::m_option_autoscaleMeanVarAll

private

Definition at line 293 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_autoscaleMinMaxAll

private

Definition at line 292 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_calibrateObservationalPrecision

private

Definition at line 280 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_discrepancyCorrelationStrengthAlpha

private

Definition at line 287 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_discrepancyCorrelationStrengthBeta

private

Definition at line 288 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_discrepancyPrecisionScale

private

Definition at line 286 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_discrepancyPrecisionShape

private

Definition at line 285 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorBasisVarianceToCapture

private

Definition at line 277 of file GPMSAOptions.h.

Referenced by set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorCorrelationStrengthAlpha

private

Definition at line 283 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorCorrelationStrengthBeta

private

Definition at line 284 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorDataPrecisionScale

private

Definition at line 290 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorDataPrecisionShape

private

Definition at line 289 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorPrecisionScale

private

Definition at line 279 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_emulatorPrecisionShape

private

Definition at line 278 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_help

private

Definition at line 275 of file GPMSAOptions.h.

Referenced by parse(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_maxEmulatorBasisVectors

private

Definition at line 276 of file GPMSAOptions.h.

Referenced by set_prefix().

std::string QUESO::GPMSAOptions::m_option_observationalPrecisionScale

private

Definition at line 282 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

std::string QUESO::GPMSAOptions::m_option_observationalPrecisionShape

private

Definition at line 281 of file GPMSAOptions.h.

Referenced by parse(), print(), and set_prefix().

QUESO::ScopedPtr<BoostInputOptionsParser>::Type QUESO::GPMSAOptions::m_parser

private

Definition at line 240 of file GPMSAOptions.h.

Referenced by QUESO::operator<<(), and parse().

std::string QUESO::GPMSAOptions::m_prefix

The prefix to look for in the input file.

Definition at line 70 of file GPMSAOptions.h.

Referenced by set_prefix().

std::vector<double> QUESO::GPMSAOptions::m_scenarioScaleMin

private

Definition at line 268 of file GPMSAOptions.h.

Referenced by normalized_scenario_parameter(), and set_scenario_parameter_scaling().

std::vector<double> QUESO::GPMSAOptions::m_scenarioScaleRange

private

Definition at line 273 of file GPMSAOptions.h.

Referenced by normalized_scenario_parameter(), and set_scenario_parameter_scaling().

std::vector<double> QUESO::GPMSAOptions::m_uncertainScaleMin

private

Definition at line 259 of file GPMSAOptions.h.

Referenced by normalized_uncertain_parameter(), and set_uncertain_parameter_scaling().

std::vector<double> QUESO::GPMSAOptions::m_uncertainScaleRange

private

Definition at line 264 of file GPMSAOptions.h.

Referenced by normalized_uncertain_parameter(), and set_uncertain_parameter_scaling().

The documentation for this class was generated from the following files:

src/gp/inc/GPMSAOptions.h
src/gp/src/GPMSAOptions.C

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation