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

void	setDiscrepancyBases (const std::vector< V * > &discrepancyBases)
	Add all discrepancy bases to `this`. More...

M &	getObservationErrorCovariance (unsigned int simulationNumber)

const M &	getObservationErrorCovariance (unsigned int simulationNumber) const

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

void	print (std::ostream &os) const

void	setUpEmulator ()

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

ScopedPtr< V >::Type	simulationOutputMeans

std::vector< V >	m_discrepancyBases

std::vector< M >	m_observationErrorMatrices

const M *	m_experimentErrors

unsigned int	m_numSimulationAdds

unsigned int	m_numExperimentAdds

ScopedPtr< VectorSpace< V, M > >::Type	oneDSpace

ScopedPtr< V >::Type	emulatorMeanMin

ScopedPtr< V >::Type	emulatorMeanMax

ScopedPtr< BoxSubset< V, M > >::Type	emulatorMeanDomain

ScopedPtr< VectorSpace< V, M > >::Type	emulatorPrecisionSpace

ScopedPtr< V >::Type	emulatorPrecisionMin

ScopedPtr< V >::Type	emulatorPrecisionMax

ScopedPtr< BoxSubset< V, M > >::Type	emulatorPrecisionDomain

ScopedPtr< VectorSpace< V, M > >::Type	emulatorCorrelationSpace

ScopedPtr< V >::Type	emulatorCorrelationMin

ScopedPtr< V >::Type	emulatorCorrelationMax

ScopedPtr< BoxSubset< V, M > >::Type	emulatorCorrelationDomain

ScopedPtr< VectorSpace< V, M > >::Type	observationalPrecisionSpace

ScopedPtr< V >::Type	observationalPrecisionMin

ScopedPtr< V >::Type	observationalPrecisionMax

ScopedPtr< BoxSubset< V, M > >::Type	observationalPrecisionDomain

ScopedPtr< V >::Type	discrepancyPrecisionMin

ScopedPtr< V >::Type	discrepancyPrecisionMax

ScopedPtr< BoxSubset< V, M > >::Type	discrepancyPrecisionDomain

ScopedPtr< VectorSpace< V, M > >::Type	discrepancyCorrelationSpace

ScopedPtr< V >::Type	discrepancyCorrelationMin

ScopedPtr< V >::Type	discrepancyCorrelationMax

ScopedPtr< BoxSubset< V, M > >::Type	discrepancyCorrelationDomain

ScopedPtr< V >::Type	emulatorDataPrecisionMin

ScopedPtr< V >::Type	emulatorDataPrecisionMax

ScopedPtr< BoxSubset< V, M > >::Type	emulatorDataPrecisionDomain

ScopedPtr< VectorSpace< V, M > >::Type	totalSpace

ScopedPtr< V >::Type	totalMins

ScopedPtr< V >::Type	totalMaxs

ScopedPtr< BoxSubset< V, M > >::Type	totalDomain

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

ScopedPtr< UniformVectorRV< V, M > >::Type	m_emulatorMean

ScopedPtr< GammaVectorRV< V, M > >::Type	m_emulatorPrecision

ScopedPtr< GammaVectorRV< V, M > >::Type	m_observationalPrecision

ScopedPtr< BetaVectorRV< V, M > >::Type	m_emulatorCorrelationStrength

ScopedPtr< GammaVectorRV< V, M > >::Type	m_discrepancyPrecision

ScopedPtr< BetaVectorRV< V, M > >::Type	m_discrepancyCorrelationStrength

ScopedPtr< GammaVectorRV< V, M > >::Type	m_emulatorDataPrecision

ScopedPtr < ConcatenatedVectorRV< V, M > >::Type	m_totalPrior

ScopedPtr< V >::Type	m_emulatorPrecisionShapeVec

ScopedPtr< V >::Type	m_emulatorPrecisionScaleVec

ScopedPtr< V >::Type	m_observationalPrecisionShapeVec

ScopedPtr< V >::Type	m_observationalPrecisionScaleVec

ScopedPtr< V >::Type	m_emulatorCorrelationStrengthAlphaVec

ScopedPtr< V >::Type	m_emulatorCorrelationStrengthBetaVec

ScopedPtr< V >::Type	m_discrepancyPrecisionShapeVec

ScopedPtr< V >::Type	m_discrepancyPrecisionScaleVec

ScopedPtr< V >::Type	m_discrepancyCorrelationStrengthAlphaVec

ScopedPtr< V >::Type	m_discrepancyCorrelationStrengthBetaVec

ScopedPtr< V >::Type	m_emulatorDataPrecisionShapeVec

ScopedPtr< V >::Type	m_emulatorDataPrecisionScaleVec

ScopedPtr< GPMSAEmulator< V, M > >::Type	gpmsaEmulator

bool	m_constructedGP

ScopedPtr< M >::Type	m_observationErrorMatrix

ScopedPtr< M >::Type	m_TruncatedSVD_simulationOutputs

std::vector< M >	m_discrepancyMatrices

ScopedPtr< M >::Type	m_BMatrix

ScopedPtr< M >::Type	K

ScopedPtr< V >::Type	residual

ScopedPtr< M >::Type	BT_Wy_B_inv

ScopedPtr< M >::Type	KT_K_inv

Private Attributes
bool	allocated_m_opts

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 123 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 425 of file GPMSA.C.

References QUESO::GPMSAFactory< V, M >::allocated_m_opts, QUESO::VectorSpace< V, M >::dimGlobal(), QUESO::GPMSAFactory< V, M >::m_discrepancyBases, QUESO::GPMSAFactory< V, M >::m_env, QUESO::GPMSAFactory< V, M >::m_experimentOutputSpace, QUESO::GPMSAFactory< V, M >::m_observationErrorMatrices, QUESO::GPMSAFactory< V, M >::m_opts, QUESO::VectorSpace< V, M >::map(), QUESO::GPMSAFactory< V, M >::numExperiments(), QUESO::BaseEnvironment::optionsInputFileName(), queso_assert_equal_to, and queso_error_msg.

   :
     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
     m_constructedGP(false)
 {
   // We should have the same number of outputs from both simulations
   // and experiments
   queso_assert_equal_to(simulationOutputSpace.dimGlobal(),
                         experimentOutputSpace.dimGlobal());
 
   {
     const unsigned int numOutputs =
       this->m_experimentOutputSpace.dimLocal();
     const Map & output_map = experimentOutputSpace.map();
 
     // Set up the default discrepancy basis:
     V all_ones_basis(env, output_map);
     for (unsigned int i=0; i != numOutputs; ++i)
       all_ones_basis[i] = 1;
     m_discrepancyBases.push_back(all_ones_basis);
 
     // Set up the default observation error covariance matrix:
 
     M identity_matrix(env, output_map, 1.0);
 
     for (unsigned int i = 0; i != numExperiments; ++i)
       m_observationErrorMatrices.push_back(identity_matrix);
   }
 
   // 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) {
     allocated_m_opts = false;
     this->m_opts = opts;
   }
   else {
     // Create a default one
     allocated_m_opts = true;
     this->m_opts = new GPMSAOptions(this->m_env, "");
   }
 
   // FIXME: WTF? - RHS
   // this->m_constructedGP = false;
 }

template<class V , class M >

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

Destructor.

Definition at line 498 of file GPMSA.C.

 {
   if (this->allocated_m_opts)
     delete this->m_opts;
 }

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 894 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->setUpEmulator();
   }
 }

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 664 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->setUpEmulator();
   }
 }

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 684 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 650 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 643 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 624 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 636 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 541 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 605 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 617 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 657 of file GPMSA.C.

 {
   return *(this->gpmsaEmulator);
 }

template<class V , class M >

M & QUESO::GPMSAFactory< V, M >::getObservationErrorCovariance ( unsigned int simulationNumber )

Definition at line 936 of file GPMSA.C.

References queso_assert_equal_to, and queso_assert_less.

 {
   queso_assert_less(simulationNumber, m_numSimulations);
   queso_assert_equal_to(m_observationErrorMatrices.size(), m_numSimulations);
 
   return m_observationErrorMatrices[simulationNumber];
 }

template<class V , class M >

const M & QUESO::GPMSAFactory< V, M >::getObservationErrorCovariance ( unsigned int simulationNumber ) const

Definition at line 948 of file GPMSA.C.

References queso_assert_equal_to, and queso_assert_less.

 {
   queso_assert_less(simulationNumber, m_numSimulations);
   queso_assert_equal_to(m_observationErrorMatrices.size(), m_numSimulations);
 
   return m_observationErrorMatrices[simulationNumber];
 }

template<class V , class M >

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

Return number of experiments.

Definition at line 513 of file GPMSA.C.

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

 {
   return this->m_numExperiments;
 }

template<class V , class M >

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

Return number of simulations.

Definition at line 506 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 527 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 967 of file GPMSA.C.

 {
   // Do nothing
 }

template<class V , class M >

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

Definition at line 960 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 520 of file GPMSA.C.

 {
   return this->m_scenarioSpace;
 }

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::setDiscrepancyBases ( const std::vector< V * > & discrepancyBases )

Add all discrepancy bases to this.

This method takes a vector of all the bases to use in the discrepancy model and stores a copy.

The user is responsible for normalizing each basis vector to be consistent with the discrepancy precision coefficients which will multiply them.

If no discrepancy basis is provided, a single "1 for each output" vector will be used.

For now we will assume that outputs are the same for each experiment (tau_ij and phi_ij are independent of i, in the notation of Higdon et al), and so each discrepancy basis can be expressed as a vector indexed by output index.

Definition at line 918 of file GPMSA.C.

References queso_assert_equal_to.

 {
   m_discrepancyBases.clear();
 
   for (unsigned int i = 0; i < discrepancyBases.size(); i++) {
     m_discrepancyBases.push_back(*(discrepancyBases[i]));
   }
 
   // We should not yet have constructed the underlying GP model
   queso_assert_equal_to(this->m_constructedGP, false);
 }

template<class V , class M >

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

Definition at line 699 of file GPMSA.C.

References QUESO::Map::Comm(), and k.

 {
   const unsigned int numOutputs =
     this->m_experimentOutputSpace.dimLocal();
   const unsigned int MAX_SVD_TERMS =
     std::min(m_numSimulations,(unsigned int)(5));
   const unsigned int num_svd_terms =
     std::min(MAX_SVD_TERMS, numOutputs);
 
   const Map & output_map = m_simulationOutputs[0]->map();
 
   const MpiComm & comm = output_map.Comm();
 
   Map serial_map(m_numSimulations, 0, comm);
 
   const BaseEnvironment &env = m_simulationOutputs[0]->env();
 
   simulationOutputMeans.reset
     (new V (env, output_map));
 
   for (unsigned int i=0; i != m_numSimulations; ++i)
     for (unsigned int j=0; j != numOutputs; ++j)
       (*simulationOutputMeans)[j] += (*m_simulationOutputs[i])[j];
 
   for (unsigned int j=0; j != numOutputs; ++j)
     (*simulationOutputMeans)[j] /= m_numSimulations;
 
   M simulation_matrix(env, serial_map, numOutputs);
 
   for (unsigned int i=0; i != m_numSimulations; ++i)
     for (unsigned int j=0; j != numOutputs; ++j)
       simulation_matrix(i,j) =
         (*m_simulationOutputs[i])[j] - (*simulationOutputMeans)[j];
 
   // GSL only finds left singular vectors if n_rows>=n_columns, so we need to
   // calculate them indirectly from the eigenvalues of M^T*M
 
   M S_trans(simulation_matrix.transpose());
 
   M SM_squared(S_trans*simulation_matrix);
 
   M SM_singularVectors(env, SM_squared.map(), numOutputs);
   V SM_singularValues(env, SM_squared.map());
 
   SM_squared.eigen(SM_singularValues, &SM_singularVectors);
 
   // Copy only those vectors we want into K_eta
   m_TruncatedSVD_simulationOutputs.reset
     (new M(env, output_map, num_svd_terms));
 
   for (unsigned int i=0; i != numOutputs; ++i)
     for (unsigned int k = 0; k != num_svd_terms; ++k)
       (*m_TruncatedSVD_simulationOutputs)(i,k) = SM_singularVectors(i,k);
 
   Map copied_map(numOutputs * m_numSimulations, 0, comm);
 
   K.reset
     (new M(env, copied_map, m_numSimulations * num_svd_terms));
   for (unsigned int k=0; k != num_svd_terms; ++k)
     for (unsigned int i1=0; i1 != m_numSimulations; ++i1)
       for (unsigned int i2=0; i2 != numOutputs; ++i2)
         {
           const unsigned int i = i1 * numOutputs + i2;
           const unsigned int j = k * m_numSimulations + i1;
           (*K)(i,j) = SM_singularVectors(i2,k);
         }
 
   KT_K_inv.reset
     (new M((K->transpose() * *K).inverse()));
 
   Map serial_output_map(numOutputs, 0, comm);
 
   for (unsigned int i = 0; i != m_numExperiments; ++i)
     {
       M D_i(env, serial_output_map,
             (unsigned int)(m_discrepancyBases.size()));
 
       for (unsigned int j=0; j != numOutputs; ++j)
         for (unsigned int k=0; k != m_discrepancyBases.size(); ++k)
           D_i(j,k) = m_discrepancyBases[k][j];
 
       m_discrepancyMatrices.push_back(D_i);
     }
 
   // Create the giant matrices!
 
   // We build B from two parts, the diag(D_i)*P_D^T block and
   // the diag(K_i)*P_K^T block, but we build simultaneously so we only
   // need one loop over experiments.
   // Since P_D and P_K are permutation matrices we'll just apply the
   // permutations as we insert.
 
   // W_y is simple block diagonal.
 
   // Neither of these ought to be dense matrices but we're sacrificing
   // efficiency for clarity for now.
 
   const unsigned int num_discrepancy_bases = m_discrepancyBases.size();
   const unsigned int Brows = m_numExperiments * numOutputs;
   const unsigned int Bcols =
     m_numExperiments * (num_discrepancy_bases + num_svd_terms);
 
   const Map B_row_map(Brows, 0, comm);
 
   m_BMatrix.reset
     (new M(env, B_row_map, Bcols));
 
   const unsigned int Wyrows = m_numExperiments * numOutputs;
 
   const Map Wy_row_map(Wyrows, 0, comm);
 
   m_observationErrorMatrix.reset
     (new M(env, Wy_row_map, Wyrows));
 
   M& B = *m_BMatrix;
   M& Wy = *m_observationErrorMatrix;
 
   for (unsigned int ex = 0; ex != m_numExperiments; ++ex)
     {
       const M & D_i = m_discrepancyMatrices[ex];
 
       // For the multivariate case, the bases K_eta computed from
       // simulator outputs are the same as the bases K_i which apply
       // to quantities of interest, because simulator outputs are QoIs
       // alone.
       //
       // FIXME - we need to interpolate K_i in the functional case.
 
       for (unsigned int outi = 0; outi != numOutputs; ++outi)
         {
           unsigned int i = ex*numOutputs+outi;
           for (unsigned int outj = 0; outj != num_discrepancy_bases; ++outj)
             {
               unsigned int j = ex + m_numExperiments * outj;
 
               B(i,j) = D_i(outi,outj);
             }
 
           for (unsigned int outj = 0; outj != num_svd_terms; ++outj)
             {
               unsigned int j = ex +
                 m_numExperiments * (num_discrepancy_bases + outj);
 
               B(i,j) = (*m_TruncatedSVD_simulationOutputs)(outi,outj);
             }
 
           for (unsigned int outj = 0; outj != numOutputs; ++outj)
             {
               // No fancy perturbation here
               unsigned int j = ex*numOutputs+outj;
 
               Wy(i,j) = m_observationErrorMatrices[ex](outi,outj);
             }
         }
     }
 
   M BT_Wy_B (B.transpose() * Wy * B);
 
   // Adding a "small ridge" to make sure this is invertible, as on
   // p.577 - using 1e-4 from discussion notes.
   for (unsigned int i=0; i != Brows; ++i)
     BT_Wy_B(i,i) += 1.e-4;
 
   BT_Wy_B_inv.reset(new M(BT_Wy_B.inverse()));
 
   this->setUpHyperpriors();
 
   this->m_constructedGP = true;
   this->gpmsaEmulator.reset
     (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_discrepancyBases,
       this->m_observationErrorMatrices,
       *(this->m_experimentErrors),
       *(this->m_totalPrior),
       *this->residual,
       *this->BT_Wy_B_inv,
       *this->KT_K_inv));
 }

template<class V , class M >

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

Definition at line 975 of file GPMSA.C.

References QUESO::MpiComm::Comm(), k, queso_assert_equal_to, and QUESO::scalarProduct().

 {
   const unsigned int numOutputs =
     this->m_experimentOutputSpace.dimLocal();
   const unsigned int MAX_SVD_TERMS =
     std::min(m_numSimulations,(unsigned int)(5));
   const unsigned int num_svd_terms =
     std::min(MAX_SVD_TERMS, numOutputs);
   const unsigned int num_discrepancy_bases = m_discrepancyBases.size();
 
   const MpiComm & comm = m_simulationOutputs[0]->map().Comm();
 
   unsigned int rank_B;
   if (m_BMatrix->numRowsGlobal() > m_BMatrix->numCols())
     rank_B = m_BMatrix->rank(0, 1.e-4);
   else
     rank_B = m_BMatrix->transpose().rank(0, 1.e-4);
 
   double emulatorPrecisionShape = this->m_opts->m_emulatorPrecisionShape;
   double emulatorPrecisionScale = this->m_opts->m_emulatorPrecisionScale;
 
   double observationalPrecisionShape = this->m_opts->m_observationalPrecisionShape;
   double observationalPrecisionScale = this->m_opts->m_observationalPrecisionScale;
 
   if (numOutputs > 1)
     {
       Map y_map(m_numExperiments * numOutputs, 0, comm);
       Map eta_map(m_numSimulations * numOutputs, 0, comm);
 
       const unsigned int yhat_size =
         m_numExperiments * (num_discrepancy_bases + num_svd_terms);
 
       const unsigned int etahat_size =
         m_numSimulations * num_svd_terms;
 
       Map zhat_map(yhat_size + etahat_size, 0, comm);
 
       V y(this->m_env, y_map);
       V eta(this->m_env, eta_map);
 
       for (unsigned int i = 0; i < this->m_numExperiments; i++) {
         for (unsigned int k = 0; k != numOutputs; ++k)
           y[i*numOutputs+k] =
             (*((this->m_experimentOutputs)[i]))[k] -
             (*simulationOutputMeans)[k];
       }
 
       for (unsigned int i = 0; i < this->m_numSimulations; i++) {
         for (unsigned int k = 0; k != numOutputs; ++k)
           eta[i*numOutputs+k] =
             (*((this->m_simulationOutputs)[i]))[k] -
             (*simulationOutputMeans)[k];
       }
 
       M& B = *m_BMatrix;
       M& Wy = *m_observationErrorMatrix;
 
       V yhat(*BT_Wy_B_inv * (B.transpose() * (Wy * y)));
 
       queso_assert_equal_to(yhat.sizeGlobal(), yhat_size);
 
       V etahat(*KT_K_inv * (K->transpose() * eta));
 
       residual.reset(new V(this->m_env, zhat_map));
       for (unsigned int i = 0; i < yhat_size; ++i)
         (*residual)[i] = yhat[i];
 
       for (unsigned int i = 0; i < etahat_size; ++i)
         (*residual)[yhat_size+i] = etahat[i];
 
       emulatorPrecisionShape +=
         (this->m_numSimulations * (numOutputs - num_svd_terms)) / 2.0;
 
       V eta_temp(eta);
       eta_temp -= *K * etahat;
 
       emulatorPrecisionScale +=
         scalarProduct(eta, eta_temp) / 2.0;
 
       observationalPrecisionShape +=
         (this->m_numExperiments * numOutputs - rank_B) / 2.0;
 
       V y_temp(Wy * y);
       y_temp -= Wy * B * yhat;
 
       observationalPrecisionScale +=
         scalarProduct(y, y_temp) / 2.0;
     }
   else
     {
       const unsigned int totalRuns = this->m_numExperiments + this->m_numSimulations;
       Map z_map(totalRuns, 0, comm);
       residual.reset(new V (this->m_env, z_map));
 
       // Form residual = D - mean // = D - mu*1 in (3)
       // We currently use the mean of the simulation data, not a free
       // hyperparameter mean
       for (unsigned int i = 0; i < this->m_numExperiments; i++) {
         (*residual)[i] = (*((this->m_experimentOutputs)[i]))[0] -
                          (*simulationOutputMeans)[0];
       }
       for (unsigned int i = 0; i < this->m_numSimulations; i++) {
         (*residual)[i+this->m_numExperiments] =
           (*((this->m_simulationOutputs)[i]))[0] -
           (*simulationOutputMeans)[0];
       }
     }
 
 
   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.reset
     (new VectorSpace<V, M>(this->m_env, "", 1, NULL));
 
   // Emulator mean
   this->emulatorMeanMin.reset(new V(this->oneDSpace->zeroVector()));
   this->emulatorMeanMax.reset(new V(this->oneDSpace->zeroVector()));
   this->emulatorMeanMin->cwSet(-INFINITY);
   this->emulatorMeanMax->cwSet(INFINITY);
 
   this->emulatorMeanDomain.reset
     (new BoxSubset<V, M>
       ("",
        *(this->oneDSpace),
        *(this->emulatorMeanMin),
        *(this->emulatorMeanMax)));
 
   this->m_emulatorMean.reset
     (new UniformVectorRV<V, M>
      ("",
       *(this->emulatorMeanDomain)));
 
   // Emulator precision
   this->emulatorPrecisionSpace.reset
     (new VectorSpace<V, M>
      (this->m_env,
       "",
       num_svd_terms + (numOutputs > 1),
       NULL));
 
   this->emulatorPrecisionMin.reset
     (new V(this->emulatorPrecisionSpace->zeroVector()));
   this->emulatorPrecisionMax.reset
     (new V(this->emulatorPrecisionSpace->zeroVector()));
   this->m_emulatorPrecisionShapeVec.reset
     (new V(this->emulatorPrecisionSpace->zeroVector()));
   this->m_emulatorPrecisionScaleVec.reset
     (new V(this->emulatorPrecisionSpace->zeroVector()));
   this->emulatorPrecisionMin->cwSet(0.3);
   this->emulatorPrecisionMax->cwSet(INFINITY);
   this->m_emulatorPrecisionShapeVec->cwSet(emulatorPrecisionShape);
   this->m_emulatorPrecisionScaleVec->cwSet(emulatorPrecisionScale);
 
   this->emulatorPrecisionDomain.reset
     (new BoxSubset<V, M>
      ("",
       *(this->emulatorPrecisionSpace),
       *(this->emulatorPrecisionMin),
       *(this->emulatorPrecisionMax)));
 
   this->m_emulatorPrecision.reset
     (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.reset
     (new VectorSpace<V, M>
      (this->m_env,
       "",
       dimScenario + dimParameter,
       NULL));
 
   this->emulatorCorrelationMin.reset
     (new V(this->emulatorCorrelationSpace->zeroVector()));
   this->emulatorCorrelationMax.reset
     (new V(this->emulatorCorrelationSpace->zeroVector()));
   this->m_emulatorCorrelationStrengthAlphaVec.reset
     (new V(this->emulatorCorrelationSpace->zeroVector()));
   this->m_emulatorCorrelationStrengthBetaVec.reset
     (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.reset
     (new BoxSubset<V, M>
      ("",
       *(this->emulatorCorrelationSpace),
       *(this->emulatorCorrelationMin),
       *(this->emulatorCorrelationMax)));
 
   this->m_emulatorCorrelationStrength.reset
     (new BetaVectorRV<V, M>
      ("",
       *(this->emulatorCorrelationDomain),
       *(this->m_emulatorCorrelationStrengthAlphaVec),
       *(this->m_emulatorCorrelationStrengthBetaVec)));
 
   // Observation precision
   this->observationalPrecisionSpace.reset
     (new VectorSpace<V, M>
      (this->m_env,
       "",
       1,
       NULL));
 
   this->observationalPrecisionMin.reset
     (new V(this->observationalPrecisionSpace->zeroVector()));
   this->observationalPrecisionMax.reset
     (new V(this->observationalPrecisionSpace->zeroVector()));
   this->m_observationalPrecisionShapeVec.reset
     (new V(this->observationalPrecisionSpace->zeroVector()));
   this->m_observationalPrecisionScaleVec.reset
     (new V(this->observationalPrecisionSpace->zeroVector()));
   this->observationalPrecisionMin->cwSet(0.3);
   this->observationalPrecisionMax->cwSet(INFINITY);
   this->m_observationalPrecisionShapeVec->cwSet
     (this->m_opts->m_observationalPrecisionShape);
   this->m_observationalPrecisionScaleVec->cwSet
     (this->m_opts->m_observationalPrecisionScale);
 
   this->observationalPrecisionDomain.reset
     (new BoxSubset<V, M>
      ("",
       *(this->observationalPrecisionSpace),
       *(this->observationalPrecisionMin),
       *(this->observationalPrecisionMax)));
 
   this->m_observationalPrecision.reset
     (new GammaVectorRV<V, M>
      ("",
       *(this->observationalPrecisionDomain),
       *(this->m_observationalPrecisionShapeVec),
       *(this->m_observationalPrecisionScaleVec)));
 
   // Discrepancy precision
   this->discrepancyPrecisionMin.reset
     (new V(this->oneDSpace->zeroVector()));
   this->discrepancyPrecisionMax.reset
     (new V(this->oneDSpace->zeroVector()));
   this->m_discrepancyPrecisionShapeVec.reset
     (new V(this->oneDSpace->zeroVector()));
   this->m_discrepancyPrecisionScaleVec.reset
     (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.reset
     (new BoxSubset<V, M>
      ("",
       *(this->oneDSpace),
       *(this->discrepancyPrecisionMin),
       *(this->discrepancyPrecisionMax)));
 
   this->m_discrepancyPrecision.reset
     (new GammaVectorRV<V, M>
      ("",
       *(this->discrepancyPrecisionDomain),
       *(this->m_discrepancyPrecisionShapeVec),
       *(this->m_discrepancyPrecisionScaleVec)));
 
   // Discrepancy correlation strength
   this->discrepancyCorrelationSpace.reset
     (new VectorSpace<V, M>
      (this->m_env,
       "",
       dimScenario,
       NULL));
 
   this->discrepancyCorrelationMin.reset
     (new V(this->discrepancyCorrelationSpace->zeroVector()));
   this->discrepancyCorrelationMax.reset
     (new V(this->discrepancyCorrelationSpace->zeroVector()));
   this->m_discrepancyCorrelationStrengthAlphaVec.reset
     (new V(this->discrepancyCorrelationSpace->zeroVector()));
   this->m_discrepancyCorrelationStrengthBetaVec.reset
     (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.reset
     (new BoxSubset<V, M>
      ("",
       *(this->discrepancyCorrelationSpace),
       *(this->discrepancyCorrelationMin),
       *(this->discrepancyCorrelationMax)));
 
   this->m_discrepancyCorrelationStrength.reset
     (new BetaVectorRV<V, M>
      ("",
       *(this->discrepancyCorrelationDomain),
       *(this->m_discrepancyCorrelationStrengthAlphaVec),
       *(this->m_discrepancyCorrelationStrengthBetaVec)));
 
   // Emulator data precision
   this->emulatorDataPrecisionMin.reset
     (new V(this->oneDSpace->zeroVector()));
   this->emulatorDataPrecisionMax.reset
     (new V(this->oneDSpace->zeroVector()));
   this->m_emulatorDataPrecisionShapeVec.reset
     (new V(this->oneDSpace->zeroVector()));
   this->m_emulatorDataPrecisionScaleVec.reset
     (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.reset
     (new BoxSubset<V, M>
      ("",
       *(this->oneDSpace),
       *(this->emulatorDataPrecisionMin),
       *(this->emulatorDataPrecisionMax)));
 
   this->m_emulatorDataPrecision.reset
     (new GammaVectorRV<V, M>
      ("",
       *(this->emulatorDataPrecisionDomain),
       *(this->m_emulatorDataPrecisionShapeVec),
       *(this->m_emulatorDataPrecisionScaleVec)));
 
   // Now form full prior
   unsigned int dimSum = 3 +
                         (numOutputs > 1) * 2 +
                         num_svd_terms +
                         dimParameter +
                         dimParameter +
                         dimScenario +
                         dimScenario;  // yum
 
   this->totalSpace.reset
     (new VectorSpace<V, M>
      (this->m_env,
       "",
       dimSum,
       NULL));
   this->totalMins.reset(new V(this->totalSpace->zeroVector()));
   this->totalMaxs.reset(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
 
   // Min emulator precision
   (*(this->totalMins))[dimParameter+1] = 0.3;
   // Max emulator precision
   (*(this->totalMaxs))[dimParameter+1] = INFINITY;
 
   if (numOutputs > 1)
     for (unsigned int basis = 0; basis != num_svd_terms; ++basis)
       {
         // Min weights precision
         (*(this->totalMins))[dimParameter+2+basis] = 0.3;
         // Max weights precision
         (*(this->totalMaxs))[dimParameter+2+basis] = INFINITY;
       }
 
   // FIXME: F = 1 for now
   // Min discrepancy precision
   (*(this->totalMins))[dimParameter+1+(numOutputs>1)+num_svd_terms+dimScenario+dimParameter] = 0;
   // Max discrepancy precision
   (*(this->totalMaxs))[dimParameter+1+(numOutputs>1)+num_svd_terms+dimScenario+dimParameter] = INFINITY;
 
   (*(this->totalMins))[dimSum-1-(numOutputs>1)] = 60.0;  // Min emulator data precision
   (*(this->totalMaxs))[dimSum-1-(numOutputs>1)] = 1e5;   // Max emulator data precision
 
   if (numOutputs>1) {
     (*(this->totalMins))[dimSum-1] = 0.3;      // Min observation error precision
     (*(this->totalMaxs))[dimSum-1] = INFINITY; // Max observation error precision
   }
 
   this->totalDomain.reset
     (new BoxSubset<V, M>
      ("",
       *(this->totalSpace),
       *(this->totalMins),
       *(this->totalMaxs)));
 
   this->priors[0] = &(this->m_parameterPrior);
   this->priors[1] = this->m_emulatorMean.get();
   this->priors[2] = this->m_emulatorPrecision.get();
   this->priors[3] = this->m_emulatorCorrelationStrength.get();
   this->priors[4] = this->m_discrepancyPrecision.get();
   this->priors[5] = this->m_discrepancyCorrelationStrength.get();
   this->priors[6] = this->m_emulatorDataPrecision.get();
   if (numOutputs > 1)
     this->priors.push_back(this->m_observationalPrecision.get());
 
   // Finally
   this->m_totalPrior.reset
     (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 586 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 598 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 534 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 567 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 579 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 548 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 560 of file GPMSA.C.

 {
   return this->m_simulationScenarios;
 }