QUESO::GPMSAOptions Class Reference

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

#include <GPMSAOptions.h>

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 QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  ,m_parser(new BoostInputOptionsParser())
#endif  // QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
{
  this->set_defaults();
  this->set_prefix("");
}

QUESO::GPMSAOptions::~GPMSAOptions ( )

virtual

Destructor.

Definition at line 335 of file GPMSAOptions.C.

{
}

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 QUESO_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_autoscaleMinMaxAll =
    env.input()(m_option_autoscaleMinMaxAll,
                m_autoscaleMinMaxAll);
  m_autoscaleMeanVarAll =
    env.input()(m_option_autoscaleMeanVarAll,
                m_autoscaleMeanVarAll);
#endif  // QUESO_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 QUESO_DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // QUESO_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