#include <GPMSA.h>

Collaboration diagram for QUESO::GPMSAFactory< V, M >:

Public Member Functions
	GPMSAFactory (const BaseEnvironment &env, GPMSAOptions *opts, const BaseVectorRV< V, M > &parameterPrior, const VectorSpace< V, M > &scenarioSpace, const VectorSpace< V, M > &parameterSpace, const VectorSpace< V, M > &simulationOutputSpace, const VectorSpace< V, M > &experimentOutputSpace, unsigned int numSimulations, unsigned int numExperiments)
	Constructor. More...

	~GPMSAFactory ()
	Destructor. More...

void	addSimulation (V &simulationScenario, V &simulationParameter, V &simulationOutput)
	Add a simulation to `this`. More...

void	addSimulations (const std::vector< V * > &simulationScenarios, const std::vector< V * > &simulationParameters, const std::vector< V * > &simulationOutputs)
	Adds multiple simulations to `this`. More...

void	addExperiments (const std::vector< V * > &experimentScenarios, const std::vector< V * > &experimentOutputs, const M *experimentErrors)
	Add all experiments to `this`. More...

const ConcatenatedVectorRV< V, M > &	prior () const

void	print (std::ostream &os) const

void	setUpHyperpriors ()

Getters
unsigned int	numSimulations () const
	Return number of simulations. More...

unsigned int	numExperiments () const
	Return number of experiments. More...

const VectorSpace< V, M > &	scenarioSpace () const
	Return the vector space in which scenarios live. More...

const VectorSpace< V, M > &	parameterSpace () const
	Return the vector space in which parameters live. More...

const VectorSpace< V, M > &	simulationOutputSpace () const
	Return the vector space in which simulations live. More...

const VectorSpace< V, M > &	experimentOutputSpace () const
	Return the vector space in which experiments live. More...

const V &	simulationScenario (unsigned int simulationId) const
	Return the point in `scenarioSpace` for simulation `simulationId`. More...

const std::vector< V * > &	simulationScenarios () const
	Return all points in `scenarioSpace` for all simulations. More...

const V &	simulationParameter (unsigned int simulationId) const
	Return the point in `parameterSpace` for simulation `simulationId`. More...

const std::vector< V * > &	simulationParameters () const
	Return all points in `parameterSpace` for all simulations. More...

const V &	simulationOutput (unsigned int simulationId) const
	Return the simulation output for simulation `simulationId`. More...

const std::vector< V * > &	simulationOutputs () const
	Return all points in `simulationOutputSpace` for all simulations. More...

const V &	experimentScenario (unsigned int experimentId) const
	Return the point in `scenarioSpace` for experiment `experimentId`. More...

const std::vector< V * > &	experimentScenarios () const
	Return all points in `scenarioSpace` for all experiments. More...

const V &	experimentOutput (unsigned int experimentId) const
	Return the experiment output for experiment `experimentId`. More...

const std::vector< V * > &	experimentOutputs () const
	Return all points in `experimentOutputSpace` for all experiments. More...

const M &	experimentErrors () const
	Return all observation error covarince matrices for all experiments. More...

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

const GPMSAEmulator< V, M > &	getGPMSAEmulator () const
	Return the GPMSAEmulator likelihood object. More...

Public Attributes
const BaseEnvironment &	m_env

const BaseVectorRV< V, M > &	m_parameterPrior

const VectorSpace< V, M > &	m_scenarioSpace

const VectorSpace< V, M > &	m_parameterSpace

const VectorSpace< V, M > &	m_simulationOutputSpace

const VectorSpace< V, M > &	m_experimentOutputSpace

unsigned int	m_numSimulations

unsigned int	m_numExperiments

std::vector< V * >	m_simulationScenarios

std::vector< V * >	m_simulationParameters

std::vector< V * >	m_simulationOutputs

std::vector< V * >	m_experimentScenarios

std::vector< V * >	m_experimentOutputs

const M *	m_experimentErrors

unsigned int	m_numSimulationAdds

unsigned int	m_numExperimentAdds

VectorSpace< V, M > *	oneDSpace

V *	emulatorMeanMin

V *	emulatorMeanMax

BoxSubset< V, M > *	emulatorMeanDomain

V *	emulatorPrecisionMin

V *	emulatorPrecisionMax

BoxSubset< V, M > *	emulatorPrecisionDomain

VectorSpace< V, M > *	emulatorCorrelationSpace

V *	emulatorCorrelationMin

V *	emulatorCorrelationMax

BoxSubset< V, M > *	emulatorCorrelationDomain

V *	discrepancyPrecisionMin

V *	discrepancyPrecisionMax

BoxSubset< V, M > *	discrepancyPrecisionDomain

VectorSpace< V, M > *	discrepancyCorrelationSpace

V *	discrepancyCorrelationMin

V *	discrepancyCorrelationMax

BoxSubset< V, M > *	discrepancyCorrelationDomain

V *	emulatorDataPrecisionMin

V *	emulatorDataPrecisionMax

BoxSubset< V, M > *	emulatorDataPrecisionDomain

VectorSpace< V, M > *	totalSpace

V *	totalMins

V *	totalMaxs

BoxSubset< V, M > *	totalDomain

std::vector< const BaseVectorRV< V, M > * >	priors

UniformVectorRV< V, M > *	m_emulatorMean

GammaVectorRV< V, M > *	m_emulatorPrecision

BetaVectorRV< V, M > *	m_emulatorCorrelationStrength

GammaVectorRV< V, M > *	m_discrepancyPrecision

BetaVectorRV< V, M > *	m_discrepancyCorrelationStrength

GammaVectorRV< V, M > *	m_emulatorDataPrecision

ConcatenatedVectorRV< V, M > *	m_totalPrior

V *	m_emulatorPrecisionShapeVec

V *	m_emulatorPrecisionScaleVec

V *	m_emulatorCorrelationStrengthAlphaVec

V *	m_emulatorCorrelationStrengthBetaVec

V *	m_discrepancyPrecisionShapeVec

V *	m_discrepancyPrecisionScaleVec

V *	m_discrepancyCorrelationStrengthAlphaVec

V *	m_discrepancyCorrelationStrengthBetaVec

V *	m_emulatorDataPrecisionShapeVec

V *	m_emulatorDataPrecisionScaleVec

GPMSAEmulator< V, M > *	gpmsaEmulator

bool	m_constructedGP

Private Attributes
GPMSAOptions *	m_opts

Friends
std::ostream &	operator<< (std::ostream &os, const GPMSAFactory< V, M > &obj)

Detailed Description

template<class V = GslVector, class M = GslMatrix>
class QUESO::GPMSAFactory< V, M >

Definition at line 99 of file GPMSA.h.

Constructor & Destructor Documentation

template<class V , class M >

QUESO::GPMSAFactory< V, M >::GPMSAFactory	(	const BaseEnvironment &	env,
		GPMSAOptions *	opts,
		const BaseVectorRV< V, M > &	parameterPrior,
		const VectorSpace< V, M > &	scenarioSpace,
		const VectorSpace< V, M > &	parameterSpace,
		const VectorSpace< V, M > &	simulationOutputSpace,
		const VectorSpace< V, M > &	experimentOutputSpace,
		unsigned int	numSimulations,
		unsigned int	numExperiments
	)

Constructor.

Definition at line 243 of file GPMSA.C.

References QUESO::GPMSAFactory< V, M >::m_constructedGP, QUESO::GPMSAFactory< V, M >::m_env, QUESO::GPMSAFactory< V, M >::m_opts, QUESO::BaseEnvironment::optionsInputFileName(), queso_error_msg, and QUESO::GPMSAFactory< V, M >::setUpHyperpriors().

   :
     m_env(env),
     m_parameterPrior(parameterPrior),
     m_scenarioSpace(scenarioSpace),
     m_parameterSpace(parameterSpace),
     m_simulationOutputSpace(simulationOutputSpace),
     m_experimentOutputSpace(experimentOutputSpace),
     m_numSimulations(numSimulations),
     m_numExperiments(numExperiments),
     m_simulationScenarios(numSimulations, (V *)NULL),
     m_simulationParameters(numSimulations, (V *)NULL),
     m_simulationOutputs(numSimulations, (V *)NULL),
     m_experimentScenarios(numExperiments, (V *)NULL),
     m_experimentOutputs(numExperiments, (V *)NULL),
     m_numSimulationAdds(0),
     m_numExperimentAdds(0),
     priors(7, (const BaseVectorRV<V, M> *)NULL)  // Needed for gcc 4.3.2
 {
   // DM: Not sure if the logic in these 3 if-blocks is correct
   if ((opts == NULL) && (this->m_env.optionsInputFileName() == "")) {
     queso_error_msg("Must options object or an input file");
   }
 
   if (opts != NULL) {
     this->m_opts = opts;
   }
   else {
     // Create a default one
     this->m_opts = new GPMSAOptions(this->m_env, "");
   }
 
   this->setUpHyperpriors();
   this->m_constructedGP = false;
 }

template<class V , class M >

QUESO::GPMSAFactory< V, M >::~GPMSAFactory ( )

Destructor.

Definition at line 289 of file GPMSA.C.

 {
   // Do nothing
 }

Member Function Documentation

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::addExperiments	(	const std::vector< V * > &	experimentScenarios,
		const std::vector< V * > &	experimentOutputs,
		const M *	experimentErrors
	)

Add all experiments to this.

This method takes a vector of all the experimental data and associated observation errors/correlations and stores them. This cannot be done piecemeal like the simulation data.

Each experiment ([i]) is assumed to correspond to the point expermientScenarios[i] in scenario space. The observation error covariance matrix is assumed to be stored in experimentErrors.

Definition at line 502 of file GPMSA.C.

References queso_require_less_equal_msg.

 {
   queso_require_less_equal_msg(experimentScenarios.size(), this->m_numExperiments, "too many experiments...");
 
   for (unsigned int i = 0; i < this->m_experimentScenarios.size(); i++) {
     this->m_experimentScenarios[i] = experimentScenarios[i];
     this->m_experimentOutputs[i] = experimentOutputs[i];
   }
   this->m_experimentErrors = experimentErrors;
   this->m_numExperimentAdds += experimentScenarios.size();
 
   if ((this->m_numSimulationAdds == this->m_numSimulations) &&
       (this->m_numExperimentAdds == this->m_numExperiments) &&
       (this->m_constructedGP == false)) {
     this->m_constructedGP = true;
     this->gpmsaEmulator = new GPMSAEmulator<V, M>(
         this->prior().imageSet(),
         this->m_scenarioSpace,
         this->m_parameterSpace,
         this->m_simulationOutputSpace,
         this->m_experimentOutputSpace,
         this->m_numSimulations,
         this->m_numExperiments,
         this->m_simulationScenarios,
         this->m_simulationParameters,
         this->m_simulationOutputs,
         this->m_experimentScenarios,
         this->m_experimentOutputs,
         *(this->m_experimentErrors),
         *(this->m_totalPrior));
   }
 }

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::addSimulation	(	V &	simulationScenario,
		V &	simulationParameter,
		V &	simulationOutput
	)

Add a simulation to this.

The simulation added to this is assumed to correspond to the point simulationScenario in scenario space and simulationParameter in parameter space. The simulation output is assumed to be stored in simulationOutput.

Definition at line 454 of file GPMSA.C.

References queso_require_less_msg.

 {
   queso_require_less_msg(this->m_numSimulationAdds, this->m_numSimulations, "too many simulation adds...");
 
   this->m_simulationScenarios[this->m_numSimulationAdds] = &simulationScenario;
   this->m_simulationParameters[this->m_numSimulationAdds] = &simulationParameter;
   this->m_simulationOutputs[this->m_numSimulationAdds] = &simulationOutput;
   this->m_numSimulationAdds++;
 
   if ((this->m_numSimulationAdds == this->m_numSimulations) &&
       (this->m_numExperimentAdds == this->m_numExperiments) &&
       (this->m_constructedGP == false)) {
     this->m_constructedGP = true;
     this->gpmsaEmulator = new GPMSAEmulator<V, M>(
         this->prior().imageSet(),
         this->m_scenarioSpace,
         this->m_parameterSpace,
         this->m_simulationOutputSpace,
         this->m_experimentOutputSpace,
         this->m_numSimulations,
         this->m_numExperiments,
         this->m_simulationScenarios,
         this->m_simulationParameters,
         this->m_simulationOutputs,
         this->m_experimentScenarios,
         this->m_experimentOutputs,
         *(this->m_experimentErrors),
         *(this->m_totalPrior));
   }
 }

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::addSimulations	(	const std::vector< V * > &	simulationScenarios,
		const std::vector< V * > &	simulationParameters,
		const std::vector< V * > &	simulationOutputs
	)

Adds multiple simulations to this.

This method takes a vector of simulations and calls addSimulation on each element

Definition at line 489 of file GPMSA.C.

 {
   for (unsigned int i = 0; i < this->m_numSimulations; i++) {
     this->addSimulation(*(simulationScenarios[i]), *(simulationParameters[i]),
         *(simulationOutputs[i]));
   }
 }

template<class V , class M >

const BaseEnvironment & QUESO::GPMSAFactory< V, M >::env ( ) const

Return the QUESO environment.

Definition at line 440 of file GPMSA.C.

 {
   return this->m_env;
 }

template<class V , class M >

const M & QUESO::GPMSAFactory< V, M >::experimentErrors ( ) const

Return all observation error covarince matrices for all experiments.

Definition at line 433 of file GPMSA.C.

 {
   return *(this->m_experimentErrors);
 }

template<class V , class M >

const V & QUESO::GPMSAFactory< V, M >::experimentOutput ( unsigned int experimentId ) const

Return the experiment output for experiment experimentId.

The returned vector is a point in experimentOutputSpace

Definition at line 414 of file GPMSA.C.

References queso_require_less_msg, and queso_require_msg.

 {
   queso_require_less_msg(experimentId, (this->m_experimentOutputs).size(), "experimentId is too large");
 
   queso_require_msg(this->m_experimentOutputs[experimentId], "vector is NULL");
 
   return *(this->m_experimentOutputs[experimentId]);
 }

template<class V , class M >

const std::vector< V * > & QUESO::GPMSAFactory< V, M >::experimentOutputs ( ) const

Return all points in experimentOutputSpace for all experiments.

This returns all points in experiment output space at which experiments were executed

Definition at line 426 of file GPMSA.C.

 {
   return this->m_experimentOutputs;
 }

template<class V , class M >

const VectorSpace< V, M > & QUESO::GPMSAFactory< V, M >::experimentOutputSpace ( ) const

Return the vector space in which experiments live.

Definition at line 331 of file GPMSA.C.

 {
   return this->m_experimentOutputSpace;
 }

template<class V , class M >

const V & QUESO::GPMSAFactory< V, M >::experimentScenario ( unsigned int experimentId ) const

Return the point in scenarioSpace for experiment experimentId.

This returns the point in scenario space at which experiment experimentId was executed

Definition at line 395 of file GPMSA.C.

References queso_require_less_msg, and queso_require_msg.

 {
   queso_require_less_msg(experimentId, (this->m_experimentScenarios).size(), "experimentId is too large");
 
   queso_require_msg(this->m_experimentScenarios[experimentId], "vector is NULL");
 
   return *(this->m_experimentScenarios[experimentId]);
 }

template<class V , class M >

const std::vector< V * > & QUESO::GPMSAFactory< V, M >::experimentScenarios ( ) const

Return all points in scenarioSpace for all experiments.

This returns all points in scenario space at which experiments were executed

Definition at line 407 of file GPMSA.C.

 {
   return this->m_experimentScenarios;
 }

template<class V , class M >

const GPMSAEmulator< V, M > & QUESO::GPMSAFactory< V, M >::getGPMSAEmulator ( ) const

Return the GPMSAEmulator likelihood object.

Definition at line 447 of file GPMSA.C.

 {
   return *(this->gpmsaEmulator);
 }

template<class V , class M >

unsigned int QUESO::GPMSAFactory< V, M >::numExperiments ( ) const

Return number of experiments.

Definition at line 303 of file GPMSA.C.

 {
   return this->m_numExperiments;
 }

template<class V , class M >

unsigned int QUESO::GPMSAFactory< V, M >::numSimulations ( ) const

Return number of simulations.

Definition at line 296 of file GPMSA.C.

 {
   return this->m_numSimulations;
 }

template<class V , class M >

const VectorSpace< V, M > & QUESO::GPMSAFactory< V, M >::parameterSpace ( ) const

Return the vector space in which parameters live.

Definition at line 317 of file GPMSA.C.

 {
   return this->m_parameterSpace;
 }

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::print ( std::ostream & os ) const

Definition at line 547 of file GPMSA.C.

 {
   // Do nothing
 }

template<class V , class M >

const ConcatenatedVectorRV< V, M > & QUESO::GPMSAFactory< V, M >::prior ( ) const

Definition at line 540 of file GPMSA.C.

 {
   return *(this->m_totalPrior);
 }

template<class V , class M >

const VectorSpace< V, M > & QUESO::GPMSAFactory< V, M >::scenarioSpace ( ) const

Return the vector space in which scenarios live.

Definition at line 310 of file GPMSA.C.

 {
   return this->m_scenarioSpace;
 }

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::setUpHyperpriors ( )

Definition at line 555 of file GPMSA.C.

Referenced by QUESO::GPMSAFactory< V, M >::GPMSAFactory().

 {
   double emulatorPrecisionShape = this->m_opts->m_emulatorPrecisionShape;
   double emulatorPrecisionScale = this->m_opts->m_emulatorPrecisionScale;
   double emulatorCorrelationStrengthAlpha = this->m_opts->m_emulatorCorrelationStrengthAlpha;
   double emulatorCorrelationStrengthBeta = this->m_opts->m_emulatorCorrelationStrengthBeta;
   double discrepancyPrecisionShape = this->m_opts->m_discrepancyPrecisionShape;
   double discrepancyPrecisionScale = this->m_opts->m_discrepancyPrecisionScale;
   double discrepancyCorrelationStrengthAlpha = this->m_opts->m_discrepancyCorrelationStrengthAlpha;
   double discrepancyCorrelationStrengthBeta = this->m_opts->m_discrepancyCorrelationStrengthBeta;
   double emulatorDataPrecisionShape = this->m_opts->m_emulatorDataPrecisionShape;
   double emulatorDataPrecisionScale = this->m_opts->m_emulatorDataPrecisionScale;
 
   this->oneDSpace = new VectorSpace<V, M>(this->m_env, "", 1, NULL);
 
   // Emulator mean
   this->emulatorMeanMin = new V(this->oneDSpace->zeroVector());
   this->emulatorMeanMax = new V(this->oneDSpace->zeroVector());
   this->emulatorMeanMin->cwSet(-INFINITY);
   this->emulatorMeanMax->cwSet(INFINITY);
 
   this->emulatorMeanDomain = new BoxSubset<V, M>(
       "",
       *(this->oneDSpace),
       *(this->emulatorMeanMin),
       *(this->emulatorMeanMax));
 
   this->m_emulatorMean = new UniformVectorRV<V, M>(
       "",
       *(this->emulatorMeanDomain));
 
   // Emulator precision
   this->emulatorPrecisionMin = new V(this->oneDSpace->zeroVector());
   this->emulatorPrecisionMax = new V(this->oneDSpace->zeroVector());
   this->m_emulatorPrecisionShapeVec = new V(this->oneDSpace->zeroVector());
   this->m_emulatorPrecisionScaleVec = new V(this->oneDSpace->zeroVector());
   this->emulatorPrecisionMin->cwSet(0.3);
   this->emulatorPrecisionMax->cwSet(INFINITY);
   this->m_emulatorPrecisionShapeVec->cwSet(emulatorPrecisionShape);
   this->m_emulatorPrecisionScaleVec->cwSet(emulatorPrecisionScale);
 
   this->emulatorPrecisionDomain = new BoxSubset<V, M>(
       "",
       *(this->oneDSpace),
       *(this->emulatorPrecisionMin),
       *(this->emulatorPrecisionMax));
 
   this->m_emulatorPrecision = new GammaVectorRV<V, M>("",
       *(this->emulatorPrecisionDomain),
       *(this->m_emulatorPrecisionShapeVec),
       *(this->m_emulatorPrecisionScaleVec));
 
   // Emulator correlation strength
   unsigned int dimScenario = (this->scenarioSpace()).dimLocal();
   unsigned int dimParameter = (this->parameterSpace()).dimLocal();
   this->emulatorCorrelationSpace = new VectorSpace<V, M>(
       this->m_env,
       "",
       dimScenario + dimParameter,
       NULL);
 
   this->emulatorCorrelationMin = new V(
       this->emulatorCorrelationSpace->zeroVector());
   this->emulatorCorrelationMax = new V(
       this->emulatorCorrelationSpace->zeroVector());
   this->m_emulatorCorrelationStrengthAlphaVec = new V(
       this->emulatorCorrelationSpace->zeroVector());
   this->m_emulatorCorrelationStrengthBetaVec = new V(
       this->emulatorCorrelationSpace->zeroVector());
   this->emulatorCorrelationMin->cwSet(0);
   this->emulatorCorrelationMax->cwSet(1);
   this->m_emulatorCorrelationStrengthAlphaVec->cwSet(emulatorCorrelationStrengthAlpha);
   this->m_emulatorCorrelationStrengthBetaVec->cwSet(emulatorCorrelationStrengthBeta);
 
   this->emulatorCorrelationDomain = new BoxSubset<V, M>(
       "",
       *(this->emulatorCorrelationSpace),
       *(this->emulatorCorrelationMin),
       *(this->emulatorCorrelationMax));
 
   this->m_emulatorCorrelationStrength = new BetaVectorRV<V, M>("",
       *(this->emulatorCorrelationDomain),
       *(this->m_emulatorCorrelationStrengthAlphaVec),
       *(this->m_emulatorCorrelationStrengthBetaVec));
 
   // Discrepancy precision
   this->discrepancyPrecisionMin = new V(this->oneDSpace->zeroVector());
   this->discrepancyPrecisionMax = new V(this->oneDSpace->zeroVector());
   this->m_discrepancyPrecisionShapeVec = new V(this->oneDSpace->zeroVector());
   this->m_discrepancyPrecisionScaleVec = new V(this->oneDSpace->zeroVector());
   this->discrepancyPrecisionMin->cwSet(0);
   this->discrepancyPrecisionMax->cwSet(INFINITY);
   this->m_discrepancyPrecisionShapeVec->cwSet(discrepancyPrecisionShape);
   this->m_discrepancyPrecisionScaleVec->cwSet(discrepancyPrecisionScale);
 
   this->discrepancyPrecisionDomain = new BoxSubset<V, M>(
       "",
       *(this->oneDSpace),
       *(this->discrepancyPrecisionMin),
       *(this->emulatorPrecisionMax));
 
   this->m_discrepancyPrecision = new GammaVectorRV<V, M>("",
       *(this->discrepancyPrecisionDomain),
       *(this->m_discrepancyPrecisionShapeVec),
       *(this->m_discrepancyPrecisionScaleVec));
 
   // Discrepancy correlation strength
   this->discrepancyCorrelationSpace = new VectorSpace<V, M>(
       this->m_env,
       "",
       dimScenario,
       NULL);
 
   this->discrepancyCorrelationMin = new V(
       this->discrepancyCorrelationSpace->zeroVector());
   this->discrepancyCorrelationMax = new V(
       this->discrepancyCorrelationSpace->zeroVector());
   this->m_discrepancyCorrelationStrengthAlphaVec = new V(
       this->discrepancyCorrelationSpace->zeroVector());
   this->m_discrepancyCorrelationStrengthBetaVec = new V(
       this->discrepancyCorrelationSpace->zeroVector());
   this->discrepancyCorrelationMin->cwSet(0);
   this->discrepancyCorrelationMax->cwSet(1);
   this->m_discrepancyCorrelationStrengthAlphaVec->cwSet(discrepancyCorrelationStrengthAlpha);
   this->m_discrepancyCorrelationStrengthBetaVec->cwSet(discrepancyCorrelationStrengthBeta);
 
   this->discrepancyCorrelationDomain = new BoxSubset<V, M>(
       "",
       *(this->discrepancyCorrelationSpace),
       *(this->discrepancyCorrelationMin),
       *(this->discrepancyCorrelationMax));
 
   this->m_discrepancyCorrelationStrength = new BetaVectorRV<V, M>("",
       *(this->discrepancyCorrelationDomain),
       *(this->m_discrepancyCorrelationStrengthAlphaVec),
       *(this->m_discrepancyCorrelationStrengthBetaVec));
 
   // Emulator data precision
   this->emulatorDataPrecisionMin = new V(this->oneDSpace->zeroVector());
   this->emulatorDataPrecisionMax = new V(this->oneDSpace->zeroVector());
   this->m_emulatorDataPrecisionShapeVec = new V(this->oneDSpace->zeroVector());
   this->m_emulatorDataPrecisionScaleVec = new V(this->oneDSpace->zeroVector());
   this->emulatorDataPrecisionMin->cwSet(60.0);
   this->emulatorDataPrecisionMax->cwSet(1e5);
   this->m_emulatorDataPrecisionShapeVec->cwSet(emulatorDataPrecisionShape);
   this->m_emulatorDataPrecisionScaleVec->cwSet(emulatorDataPrecisionScale);
 
   this->emulatorDataPrecisionDomain = new BoxSubset<V, M>(
       "",
       *(this->oneDSpace),
       *(this->emulatorDataPrecisionMin),
       *(this->emulatorDataPrecisionMax));
 
   this->m_emulatorDataPrecision = new GammaVectorRV<V, M>("",
       *(this->emulatorDataPrecisionDomain),
       *(this->m_emulatorDataPrecisionShapeVec),
       *(this->m_emulatorDataPrecisionScaleVec));
 
   // Now form full prior
   unsigned int dimSum = 4 +
                         dimParameter +
                         dimParameter +
                         dimScenario +
                         dimScenario;  // yum
 
   this->totalSpace = new VectorSpace<V, M>(
       this->m_env,
       "",
       dimSum,
       NULL);
   this->totalMins = new V(this->totalSpace->zeroVector());
   this->totalMaxs = new V(this->totalSpace->zeroVector());
 
   // Hackety hack McHackington.  There's no better way to do this unfortunately
   this->totalMins->cwSet(0);
   this->totalMaxs->cwSet(1);
 
   (*(this->totalMins))[dimParameter] = -INFINITY;  // Min mean
   (*(this->totalMaxs))[dimParameter] = INFINITY;  // Max mean
   (*(this->totalMins))[dimParameter+1] = 0.3;  // Min emulator precision
   (*(this->totalMaxs))[dimParameter+1] = INFINITY;  // Max emulator precision
   (*(this->totalMins))[dimSum-1] = 60.0;  // Min emulator data precision
   (*(this->totalMaxs))[dimSum-1] = 1e5;  // Max emulator data precision
 
   // Min discrepancy precision
   (*(this->totalMins))[dimScenario+dimParameter+dimParameter+2] = 0;
   // Max discrepancy precision
   (*(this->totalMaxs))[dimScenario+dimParameter+dimParameter+2] = INFINITY;
 
   this->totalDomain = new BoxSubset<V, M>(
       "",
       *(this->totalSpace),
       *(this->totalMins),
       *(this->totalMaxs));
 
   this->priors[0] = &(this->m_parameterPrior);
   this->priors[1] = this->m_emulatorMean;
   this->priors[2] = this->m_emulatorPrecision;
   this->priors[3] = this->m_emulatorCorrelationStrength;
   this->priors[4] = this->m_discrepancyPrecision;
   this->priors[5] = this->m_discrepancyCorrelationStrength;
   this->priors[6] = this->m_emulatorDataPrecision;
 
   // Finally
   this->m_totalPrior = new ConcatenatedVectorRV<V, M>(
       "",
       this->priors,
       *(this->totalDomain));
 }

template<class V , class M >

const V & QUESO::GPMSAFactory< V, M >::simulationOutput ( unsigned int simulationId ) const

Return the simulation output for simulation simulationId.

The returned vector is a point in simulationOutputSpace

Definition at line 376 of file GPMSA.C.

References queso_require_less_msg, and queso_require_msg.

 {
   queso_require_less_msg(simulationId, m_simulationOutputs.size(), "simulationId is too large");
 
   queso_require_msg(m_simulationOutputs[simulationId], "vector is NULL");
 
   return *(this->m_simulationOutputs[simulationId]);
 }

template<class V , class M >

const std::vector< V * > & QUESO::GPMSAFactory< V, M >::simulationOutputs ( ) const

Return all points in simulationOutputSpace for all simulations.

This returns all points in simulation output space at which simulations were executed

Definition at line 388 of file GPMSA.C.

 {
   return this->m_simulationOutputs;
 }

template<class V , class M >

const VectorSpace< V, M > & QUESO::GPMSAFactory< V, M >::simulationOutputSpace ( ) const

Return the vector space in which simulations live.

Definition at line 324 of file GPMSA.C.

 {
   return this->m_simulationOutputSpace;
 }

template<class V , class M >

const V & QUESO::GPMSAFactory< V, M >::simulationParameter ( unsigned int simulationId ) const

Return the point in parameterSpace for simulation simulationId.

This returns the point in parameter space at which simulation simulationId was executed

Definition at line 357 of file GPMSA.C.

References queso_require_less_msg, and queso_require_msg.

 {
   queso_require_less_msg(simulationId, m_simulationParameters.size(), "simulationId is too large");
 
   queso_require_msg(m_simulationParameters[simulationId], "vector is NULL");
 
   return *(this->m_simulationParameters[simulationId]);
 }

template<class V , class M >

const std::vector< V * > & QUESO::GPMSAFactory< V, M >::simulationParameters ( ) const

Return all points in parameterSpace for all simulations.

This returns all points in parameter space at which simulations were executed

Definition at line 369 of file GPMSA.C.

 {
   return this->m_simulationParameters;
 }

template<class V , class M >

const V & QUESO::GPMSAFactory< V, M >::simulationScenario ( unsigned int simulationId ) const

Return the point in scenarioSpace for simulation simulationId.

This returns the point in scenario space at which simulation simulationId was executed

Definition at line 338 of file GPMSA.C.

References queso_require_less_msg, and queso_require_msg.

 {
   queso_require_less_msg(simulationId, m_simulationScenarios.size(), "simulationId is too large");
 
   queso_require_msg(m_simulationScenarios[simulationId], "vector is NULL");
 
   return *(this->m_simulationScenarios[simulationId]);
 }

template<class V , class M >

const std::vector< V * > & QUESO::GPMSAFactory< V, M >::simulationScenarios ( ) const

Return all points in scenarioSpace for all simulations.

This returns all points in scenario space at which simulations were executed

Definition at line 350 of file GPMSA.C.

 {
   return this->m_simulationScenarios;
 }