QUESO::GPMSAFactory< V, M > Class Template Reference

#include <GPMSA.h>

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 (typename SharedPtr< V >::Type simulationScenario, typename SharedPtr< V >::Type simulationParameter, typename SharedPtr< V >::Type simulationOutput)
	Add a simulation to this. More...
void	addSimulations (const std::vector< typename SharedPtr< V >::Type > &simulationScenarios, const std::vector< typename SharedPtr< V >::Type > &simulationParameters, const std::vector< typename SharedPtr< V >::Type > &simulationOutputs)
	Adds multiple simulations to this. More...
void	addExperiments (const std::vector< typename SharedPtr< V >::Type > &experimentScenarios, const std::vector< typename SharedPtr< V >::Type > &experimentOutputs, const typename SharedPtr< M >::Type experimentErrors)
	Add all experiments to this. More...
void	addExperiments (const std::vector< typename SharedPtr< V >::Type > &experimentScenarios, const std::vector< typename SharedPtr< V >::Type > &experimentOutputs, const std::vector< typename SharedPtr< M >::Type > &experimentErrors)
	Add all experiments to this. More...
void	setDiscrepancyBases (const std::vector< typename SharedPtr< V >::Type > &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
const GPMSAOptions &	options () const
	Return GPMSAOptions structure. More...
GPMSAOptions &	options ()
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< typename SharedPtr< V >::Type > &	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< typename SharedPtr< V >::Type > &	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< typename SharedPtr< V >::Type > &	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< typename SharedPtr< V >::Type > &	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< typename SharedPtr< V >::Type > &	experimentOutputs () const
	Return all points in experimentOutputSpace for all experiments. More...
const SharedPtr< M >::Type	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< typename SharedPtr< V >::Type >	m_simulationScenarios
std::vector< typename SharedPtr< V >::Type >	m_simulationParameters
std::vector< typename SharedPtr< V >::Type >	m_simulationOutputs
std::vector< typename SharedPtr< V >::Type >	m_experimentScenarios
std::vector< typename SharedPtr< V >::Type >	m_experimentOutputs
ScopedPtr< V >::Type	simulationOutputMeans
std::vector< typename SharedPtr< V >::Type >	m_discrepancyBases
std::vector< typename SharedPtr< M >::Type >	m_observationErrorMatrices
unsigned int	m_numSimulationAdds
unsigned int	m_numExperimentAdds
unsigned int	num_svd_terms
ScopedPtr< VectorSpace< V, M > >::Type	oneDSpace
ScopedPtr< V >::Type	truncationErrorPrecisionMin
ScopedPtr< V >::Type	truncationErrorPrecisionMax
ScopedPtr< BoxSubset< V, M > >::Type	truncationErrorPrecisionDomain
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_truncationErrorPrecision
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
SharedPtr< 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 127 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 454 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(), and QUESO::BaseEnvironment::optionsInputFileName().

  :
    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),
    m_simulationParameters(numSimulations),
    m_simulationOutputs(numSimulations),
    m_experimentScenarios(numExperiments),
    m_experimentOutputs(numExperiments),
    m_numSimulationAdds(0),
    m_numExperimentAdds(0),
    num_svd_terms(0),
    priors(),
    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:
    typename SharedPtr<V>::Type all_ones_basis(new V(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:
    for (unsigned int i = 0; i != numExperiments; ++i)
      {
        typename SharedPtr<M>::Type identity_matrix(new M(env, output_map, 1.0));
        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 528 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< typename SharedPtr< V >::Type > &	experimentScenarios,
		const std::vector< typename SharedPtr< V >::Type > &	experimentOutputs,
		const typename SharedPtr< M >::Type	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.

This method is solely for backward compatibility. Covariances between errors from different experiments will be ignored.

Definition at line 951 of file GPMSA.C.

{
  queso_require_less_equal_msg(experimentScenarios.size(), this->m_numExperiments, "too many experiments...");

  unsigned int offset = 0;
  for (unsigned int i = 0; i < this->m_experimentScenarios.size(); i++) {
    this->m_experimentScenarios[i] = experimentScenarios[i];
    this->m_experimentOutputs[i] = experimentOutputs[i];

    const unsigned int outsize =
      this->m_experimentOutputs[i]->sizeGlobal();
    for (unsigned int outi = 0; outi != outsize; ++outi)
      for (unsigned int outj = 0; outj != outsize; ++outj)
        (*this->m_observationErrorMatrices[i])(outi,outj) =
          (*experimentErrors)(offset+outi, offset+outj);

    offset += outsize;
  }

  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 >::addExperiments	(	const std::vector< typename SharedPtr< V >::Type > &	experimentScenarios,
		const std::vector< typename SharedPtr< V >::Type > &	experimentOutputs,
		const std::vector< typename SharedPtr< M >::Type > &	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. Each experiment has a corresponding error covariance matrix stored in experimentErrors[i]

Definition at line 985 of file GPMSA.C.

{
  queso_require_less_equal_msg(experimentScenarios.size(), this->m_numExperiments, "too many experiments...");
  queso_require_equal_to(experimentScenarios.size(),
                         experimentOutputs.size());
  queso_require_equal_to(experimentScenarios.size(),
                         experimentErrors.size());

  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_observationErrorMatrices[i] = experimentErrors[i];
  }
  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	(	typename SharedPtr< V >::Type	simulationScenario,
		typename SharedPtr< V >::Type	simulationParameter,
		typename SharedPtr< V >::Type	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 703 of file GPMSA.C.

{
  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< typename SharedPtr< V >::Type > &	simulationScenarios,
		const std::vector< typename SharedPtr< V >::Type > &	simulationParameters,
		const std::vector< typename SharedPtr< V >::Type > &	simulationOutputs
	)

Adds multiple simulations to this.

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

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

{
  return this->m_env;
}

template<class V = GslVector, class M = GslMatrix>

const SharedPtr<M>::Type QUESO::GPMSAFactory< V, M >::experimentErrors

(

)

const

Return all observation error covarince matrices for all experiments.

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

References QUESO::size.

{
  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< typename SharedPtr< V >::Type > & 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 682 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 587 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 651 of file GPMSA.C.

References QUESO::size.

{
  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< typename SharedPtr< V >::Type > & 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 663 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 696 of file GPMSA.C.

{
  return *(this->gpmsaEmulator);
}

template<class V , class M >

M & QUESO::GPMSAFactory< V, M >::getObservationErrorCovariance

(

unsigned int

simulationNumber

)

Definition at line 1027 of file GPMSA.C.

{
  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 1039 of file GPMSA.C.

{
  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 559 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 552 of file GPMSA.C.

{
  return this->m_numSimulations;
}

template<class V , class M >

const GPMSAOptions & QUESO::GPMSAFactory< V, M >::options

(

)

const

Return GPMSAOptions structure.

Definition at line 536 of file GPMSA.C.

{
  return *this->m_opts;
}

template<class V , class M >

GPMSAOptions & QUESO::GPMSAFactory< V, M >::options

(

)

Definition at line 544 of file GPMSA.C.

{
  return *this->m_opts;
}

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 573 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 1058 of file GPMSA.C.

{
  // Do nothing
}

template<class V , class M >

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

(

)

const

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

{
  return this->m_scenarioSpace;
}

template<class V , class M >

void QUESO::GPMSAFactory< V, M >::setDiscrepancyBases

(

const std::vector< typename SharedPtr< V >::Type > &

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

{
  m_discrepancyBases = discrepancyBases;

  // 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 739 of file GPMSA.C.

References QUESO::Map::Comm().

{
  this->m_opts->template set_final_scaling<V>
    (m_simulationScenarios,
     m_simulationParameters,
     m_simulationOutputs,
     m_experimentScenarios,
     m_experimentOutputs);

  const unsigned int numOutputs =
    this->m_experimentOutputSpace.dimLocal();

  this->num_svd_terms = this->m_opts->m_maxEmulatorBasisVectors ?
    std::min((unsigned int)(this->m_opts->m_maxEmulatorBasisVectors), numOutputs) :
    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];

      // Each error covariance matrix had better be SPD
      const M & W_i = (*m_observationErrorMatrices[ex]);
#ifndef NDEBUG
      M W_i_copy(W_i);
      int rv = W_i_copy.chol();
      queso_assert_msg(!rv, "Observation error matrix W_" << ex <<
                       " was not SPD!");
#endif

      // 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) = W_i(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_observationErrorMatrix,
      *(this->m_totalPrior),
      *this->residual,
      *this->BT_Wy_B_inv,
      *this->KT_K_inv,
      *this->m_opts));
}

template<class V , class M >

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

(

)

Definition at line 1066 of file GPMSA.C.

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

{
  const unsigned int numOutputs =
    this->m_experimentOutputSpace.dimLocal();

  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));

  // Truncation error precision
  if (this->num_svd_terms < numOutputs)
    {
      this->truncationErrorPrecisionMin.reset(new V(this->oneDSpace->zeroVector()));
      this->truncationErrorPrecisionMax.reset(new V(this->oneDSpace->zeroVector()));
      this->truncationErrorPrecisionMin->cwSet(-INFINITY);
      this->truncationErrorPrecisionMax->cwSet(INFINITY);

      this->truncationErrorPrecisionDomain.reset
        (new BoxSubset<V, M>
          ("",
           *(this->oneDSpace),
           *(this->truncationErrorPrecisionMin),
           *(this->truncationErrorPrecisionMax)));

      this->m_truncationErrorPrecision.reset
        (new UniformVectorRV<V, M>
         ("",
          *(this->truncationErrorPrecisionDomain)));
    }

  // 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 = 2 +
                        (this->num_svd_terms < numOutputs) +
                        (numOutputs > 1) +
                        this->m_opts->m_calibrateObservationalPrecision +
                        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);

  // Min emulator precision
  (*(this->totalMins))[dimParameter] = 0.3;
  // Max emulator precision
  (*(this->totalMaxs))[dimParameter] = INFINITY;

  if (numOutputs > 1)
    for (unsigned int basis = 0; basis != num_svd_terms; ++basis)
      {
        // Min weights precision
        (*(this->totalMins))[dimParameter+1+basis] = 0.3;
        // Max weights precision
        (*(this->totalMaxs))[dimParameter+1+basis] = INFINITY;
      }

  // FIXME: F = 1 for now
  // Min discrepancy precision
  (*(this->totalMins))[dimParameter+(numOutputs>1)+num_svd_terms+dimScenario+dimParameter] = 0;
  // Max discrepancy precision
  (*(this->totalMaxs))[dimParameter+(numOutputs>1)+num_svd_terms+dimScenario+dimParameter] = INFINITY;

  const int emulator_data_precision_index =
    dimSum - 1 - this->m_opts->m_calibrateObservationalPrecision;
  (*(this->totalMins))[emulator_data_precision_index] = 60.0;  // Min emulator data precision
  (*(this->totalMaxs))[emulator_data_precision_index] = 1e5;   // Max emulator data precision

  if (this->m_opts->m_calibrateObservationalPrecision) {
    (*(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.push_back(&(this->m_parameterPrior));

  if (this->num_svd_terms < numOutputs)
    this->priors.push_back(this->m_truncationErrorPrecision.get());

  this->priors.push_back(this->m_emulatorPrecision.get());
  this->priors.push_back(this->m_emulatorCorrelationStrength.get());
  this->priors.push_back(this->m_discrepancyPrecision.get());
  this->priors.push_back(this->m_discrepancyCorrelationStrength.get());
  this->priors.push_back(this->m_emulatorDataPrecision.get());
  if (this->m_opts->m_calibrateObservationalPrecision)
    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 632 of file GPMSA.C.

{
  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< typename SharedPtr< V >::Type > & 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 644 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 580 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 613 of file GPMSA.C.

{
  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< typename SharedPtr< V >::Type > & 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 625 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 594 of file GPMSA.C.

{
  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< typename SharedPtr< V >::Type > & 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 606 of file GPMSA.C.

{
  return this->m_simulationScenarios;
}

Friends And Related Function Documentation

template<class V = GslVector, class M = GslMatrix>

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

friend

Definition at line 327 of file GPMSA.h.

  {
    obj.print(os);
    return os;
  }

Member Data Documentation

template<class V = GslVector, class M = GslMatrix>

bool QUESO::GPMSAFactory< V, M >::allocated_m_opts

private

Definition at line 481 of file GPMSA.h.

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

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<M>::Type QUESO::GPMSAFactory< V, M >::BT_Wy_B_inv

Definition at line 474 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 413 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::discrepancyCorrelationMax

Definition at line 412 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::discrepancyCorrelationMin

Definition at line 411 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 410 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 407 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::discrepancyPrecisionMax

Definition at line 406 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::discrepancyPrecisionMin

Definition at line 405 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 396 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::emulatorCorrelationMax

Definition at line 395 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::emulatorCorrelationMin

Definition at line 394 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 393 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 418 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::emulatorDataPrecisionMax

Definition at line 417 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::emulatorDataPrecisionMin

Definition at line 416 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 390 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::emulatorPrecisionMax

Definition at line 389 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::emulatorPrecisionMin

Definition at line 388 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 387 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 453 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<M>::Type QUESO::GPMSAFactory< V, M >::K

Definition at line 469 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<M>::Type QUESO::GPMSAFactory< V, M >::KT_K_inv

Definition at line 477 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<M>::Type QUESO::GPMSAFactory< V, M >::m_BMatrix

Definition at line 466 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

bool QUESO::GPMSAFactory< V, M >::m_constructedGP

Definition at line 454 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<V>::Type> QUESO::GPMSAFactory< V, M >::m_discrepancyBases

Definition at line 355 of file GPMSA.h.

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

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 435 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_discrepancyCorrelationStrengthAlphaVec

Definition at line 447 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_discrepancyCorrelationStrengthBetaVec

Definition at line 448 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

std::vector<M> QUESO::GPMSAFactory< V, M >::m_discrepancyMatrices

Definition at line 464 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 434 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_discrepancyPrecisionScaleVec

Definition at line 446 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_discrepancyPrecisionShapeVec

Definition at line 445 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 433 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_emulatorCorrelationStrengthAlphaVec

Definition at line 443 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_emulatorCorrelationStrengthBetaVec

Definition at line 444 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 436 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_emulatorDataPrecisionScaleVec

Definition at line 450 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_emulatorDataPrecisionShapeVec

Definition at line 449 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 431 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_emulatorPrecisionScaleVec

Definition at line 440 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_emulatorPrecisionShapeVec

Definition at line 439 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

const BaseEnvironment& QUESO::GPMSAFactory< V, M >::m_env

Definition at line 334 of file GPMSA.h.

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

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<V>::Type> QUESO::GPMSAFactory< V, M >::m_experimentOutputs

Definition at line 350 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

const VectorSpace<V, M>& QUESO::GPMSAFactory< V, M >::m_experimentOutputSpace

Definition at line 341 of file GPMSA.h.

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

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<V>::Type> QUESO::GPMSAFactory< V, M >::m_experimentScenarios

Definition at line 349 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

unsigned int QUESO::GPMSAFactory< V, M >::m_numExperimentAdds

Definition at line 361 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

unsigned int QUESO::GPMSAFactory< V, M >::m_numExperiments

Definition at line 344 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

unsigned int QUESO::GPMSAFactory< V, M >::m_numSimulationAdds

Definition at line 360 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

unsigned int QUESO::GPMSAFactory< V, M >::m_numSimulations

Definition at line 343 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 432 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_observationalPrecisionScaleVec

Definition at line 442 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::m_observationalPrecisionShapeVec

Definition at line 441 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<M>::Type> QUESO::GPMSAFactory< V, M >::m_observationErrorMatrices

Definition at line 357 of file GPMSA.h.

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

template<class V = GslVector, class M = GslMatrix>

SharedPtr<M>::Type QUESO::GPMSAFactory< V, M >::m_observationErrorMatrix

Definition at line 457 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

GPMSAOptions* QUESO::GPMSAFactory< V, M >::m_opts

private

Definition at line 482 of file GPMSA.h.

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

template<class V = GslVector, class M = GslMatrix>

const BaseVectorRV<V, M>& QUESO::GPMSAFactory< V, M >::m_parameterPrior

Definition at line 336 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

const VectorSpace<V, M>& QUESO::GPMSAFactory< V, M >::m_parameterSpace

Definition at line 339 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

const VectorSpace<V, M>& QUESO::GPMSAFactory< V, M >::m_scenarioSpace

Definition at line 338 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<V>::Type> QUESO::GPMSAFactory< V, M >::m_simulationOutputs

Definition at line 348 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

const VectorSpace<V, M>& QUESO::GPMSAFactory< V, M >::m_simulationOutputSpace

Definition at line 340 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<V>::Type> QUESO::GPMSAFactory< V, M >::m_simulationParameters

Definition at line 347 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

std::vector<typename SharedPtr<V>::Type> QUESO::GPMSAFactory< V, M >::m_simulationScenarios

Definition at line 346 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 437 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<M>::Type QUESO::GPMSAFactory< V, M >::m_TruncatedSVD_simulationOutputs

Definition at line 462 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<UniformVectorRV<V, M> >::Type QUESO::GPMSAFactory< V, M >::m_truncationErrorPrecision

Definition at line 430 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

unsigned int QUESO::GPMSAFactory< V, M >::num_svd_terms

Definition at line 376 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 402 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::observationalPrecisionMax

Definition at line 401 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::observationalPrecisionMin

Definition at line 400 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 399 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 379 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 427 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::residual

Definition at line 471 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::simulationOutputMeans

Definition at line 353 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 425 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::totalMaxs

Definition at line 423 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::totalMins

Definition at line 422 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

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

Definition at line 421 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<BoxSubset<V, M> >::Type QUESO::GPMSAFactory< V, M >::truncationErrorPrecisionDomain

Definition at line 384 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::truncationErrorPrecisionMax

Definition at line 383 of file GPMSA.h.

template<class V = GslVector, class M = GslMatrix>

ScopedPtr<V>::Type QUESO::GPMSAFactory< V, M >::truncationErrorPrecisionMin

Definition at line 382 of file GPMSA.h.

---

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

• src/gp/inc/GPMSA.h
• src/gp/src/GPMSA.C