QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M > Class Template Reference

This templated class represents a Statistical Forward Problem. More...

#include <StatisticalForwardProblem.h>

Collaboration diagram for QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >:

Public Member Functions
Constructor/Destructor methods
	StatisticalForwardProblem (const char *prefix, const SfpOptionsValues *alternativeOptionsValues, const BaseVectorRV< P_V, P_M > &paramRv, const BaseVectorFunction< P_V, P_M, Q_V, Q_M > &qoiFunction, GenericVectorRV< Q_V, Q_M > &qoiRv)
	Constructor. More...
	~StatisticalForwardProblem ()
	Destructor. More...
Statistical methods
bool	computeSolutionFlag () const
	Whether or not compute the solution. More...
void	solveWithMonteCarlo (const McOptionsValues *alternativeOptionsValues)
	Solves the problem through Monte Carlo algorithm. More...
const GenericVectorRV< Q_V, Q_M > &	qoiRv () const
	Returns the QoI RV; access to private attribute m_qoiRv. More...
const BaseVectorSequence< Q_V, Q_M > &	getParamChain () const
	Returns the parameter chain; access to private attribute m_paramChain. More...

Private Member Functions
void	commonConstructor ()
	TODO: Common constructor. More...

Private Attributes
const BaseEnvironment &	m_env
const BaseVectorRV< P_V, P_M > &	m_paramRv
const BaseVectorFunction< P_V, P_M, Q_V, Q_M > &	m_qoiFunction
GenericVectorRV< Q_V, Q_M > &	m_qoiRv
BaseVectorSequence< Q_V, Q_M > *	m_paramChain
BaseVectorSequence< Q_V, Q_M > *	m_qoiChain
MonteCarloSG< P_V, P_M, Q_V, Q_M > *	m_mcSeqGenerator
BaseVectorRealizer< Q_V, Q_M > *	m_solutionRealizer
BaseJointPdf< Q_V, Q_M > *	m_solutionPdf
SfpOptionsValues	m_alternativeOptionsValues
StatisticalForwardProblemOptions *	m_optionsObj

I/O methods
void	print (std::ostream &os) const
	TODO: Prints the sequence. More...
std::ostream &	operator<< (std::ostream &os, const StatisticalForwardProblem< P_V, P_M, Q_V, Q_M > &obj)

Detailed Description

template<class P_V, class P_M, class Q_V, class Q_M>
class QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >

This templated class represents a Statistical Forward Problem.

This templated class represents a statistical forward problem. It is templated on the types 'P_V' and 'Q_V' of vectors and types 'P_M' and 'Q_M' of matrices, where 'P_' stands for 'parameter' and 'Q_' stands for 'quantities of interest'. Conceptually, a statistical forward problem has two input entities and one output entity.
The input entities of a statistical forward problem are:

1. the input (parameter) RV, an instance of class 'BaseVectorRV<P_V,P_M>', and
2. the QoI function, an instance of class 'BaseVectorFunction<P_V,P_M,Q_V,Q_M>'.

Let denote the mathematical QoI function and denote a vector of parameters. The QoI function object stores the routine that computes and whatever data necessary by such routine. See file 'libs/basic/inc/VectorFunction.h' for more details.
The output entity of a statistical forward problem is:

1. the QoI RV, another instance of class 'BaseVectorRV<P_V,P_M>'.

The QoI RV stores the solution according to the Bayesian approach. The solution of a SPF is computed by calling 'solveWithMonteCarlo()'. More operations, with different methods, will be available in the future.
The solution process might demand extra objects to be passed through the chosen solution operation interface. This distinction is important: this class separates 'what the problem is' from 'how the problem is solved'. Upon return from a solution operation, the QoI RV is available through the operation 'qoiRv()'. Such QoI RV is able to provide:

1. a vector realizer through the operation 'qoiRv().realizer()', which returns an instance of the class 'BaseVectorRealizer<Q_V,Q_M>'.

Definition at line 77 of file StatisticalForwardProblem.h.

Constructor & Destructor Documentation

template<class P_V , class P_M , class Q_V , class Q_M >

QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::StatisticalForwardProblem	(	const char *	prefix,
		const SfpOptionsValues *	alternativeOptionsValues,
		const BaseVectorRV< P_V, P_M > &	paramRv,
		const BaseVectorFunction< P_V, P_M, Q_V, Q_M > &	qoiFunction,
		GenericVectorRV< Q_V, Q_M > &	qoiRv
	)

Constructor.

Requirements: 1) the image set of the vector random variable 'paramRv' and the domain set of the QoI function 'qoiFunction' should belong to vector spaces of equal dimensions and 2) the image set of the QoI function 'qoiFunction' and the image set of the vector random variable 'qoiRv' should belong to vector spaces of equal dimensions. If the requirements are satisfied, the constructor then reads input options that begin with the string '<prefix>fp_'. Options reading is handled by class 'StatisticalForwardProblemOptions'. If no options input file is provided, the construction assigns alternativeOptionsValues to the options of the SFP.

Parameters

prefix	The prefix
alternativeOptionsValues	Options (if no input file)
paramRv	The input RV
qoiFunction	The QoI function
qoiRv	The QoI RV

Definition at line 34 of file StatisticalForwardProblem.C.

References UQ_FATAL_TEST_MACRO.

  :
  m_env                     (paramRv.env()),
  m_paramRv                 (paramRv),
  m_qoiFunction             (qoiFunction),
  m_qoiRv                   (qoiRv),
  m_paramChain              (NULL),
  m_qoiChain                (NULL),
  m_mcSeqGenerator          (NULL),
  m_solutionRealizer        (NULL),
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
  m_subMdfGrids             (NULL),
  m_subMdfValues            (NULL),
#endif
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
  m_subSolutionMdf          (NULL),
  m_subCdfGrids             (NULL),
  m_subCdfValues            (NULL),
  m_subSolutionCdf          (NULL),
  m_unifiedCdfGrids         (NULL),
  m_unifiedCdfValues        (NULL),
  m_unifiedSolutionCdf      (NULL),
#endif
  m_solutionPdf             (NULL),
  m_alternativeOptionsValues(),
  m_optionsObj              (NULL)
{
  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "Entering StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::constructor()"
                            << ": prefix = " << prefix
                            << ", alternativeOptionsValues = " << alternativeOptionsValues
                            << ", m_env.optionsInputFileName() = " << m_env.optionsInputFileName()
                            << std::endl;
  }

  if (alternativeOptionsValues) m_alternativeOptionsValues = *alternativeOptionsValues;
  if (m_env.optionsInputFileName() == "") {
    m_optionsObj = new StatisticalForwardProblemOptions(m_env,prefix,m_alternativeOptionsValues);
  }
  else {
    m_optionsObj = new StatisticalForwardProblemOptions(m_env,prefix);
    m_optionsObj->scanOptionsValues();
  }

  UQ_FATAL_TEST_MACRO(paramRv.imageSet().vectorSpace().dimLocal() != qoiFunction.domainSet().vectorSpace().dimLocal(),
                      m_env.worldRank(),
                      "StatisticalForwardProblem<P_V,P_M>::constructor()",
                      "'paramRv' and 'qoiFunction' are related to vector spaces of different dimensions");

  UQ_FATAL_TEST_MACRO(qoiFunction.imageSet().vectorSpace().dimLocal() != qoiRv.imageSet().vectorSpace().dimLocal(),
                      m_env.worldRank(),
                      "StatisticalForwardProblem<P_V,P_M>::constructor()",
                      "'qoiFunction' and 'qoiRv' are related to vector spaces of different dimensions");

  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "Leaving StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::constructor()"
                            << ": prefix = " << m_optionsObj->m_prefix
                            << std::endl;
  }
}

template<class P_V , class P_M , class Q_V , class Q_M >

QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::~StatisticalForwardProblem

(

)

Destructor.

Definition at line 102 of file StatisticalForwardProblem.C.

{
  if (m_solutionPdf       ) delete m_solutionPdf;

#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
  if (m_unifiedSolutionCdf) delete m_unifiedSolutionCdf;
  if (m_unifiedCdfValues  ) delete m_unifiedCdfValues;
  if (m_unifiedCdfGrids   ) delete m_unifiedCdfGrids;

  if (m_subSolutionCdf    ) delete m_subSolutionCdf;
  if (m_subCdfValues      ) delete m_subCdfValues;
  if (m_subCdfGrids       ) delete m_subCdfGrids;

  if (m_subSolutionMdf    ) delete m_subSolutionMdf;
#endif
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
  if (m_subMdfValues      ) delete m_subMdfValues;
  if (m_subMdfGrids       ) delete m_subMdfGrids;
#endif
  if (m_solutionRealizer  ) delete m_solutionRealizer;

  if (m_mcSeqGenerator    ) delete m_mcSeqGenerator;

  if (m_qoiChain) {
    m_qoiChain->clear();
    delete m_qoiChain;
  }

  if (m_paramChain) {
    m_paramChain->clear();
    delete m_paramChain;
  }

  if (m_optionsObj        ) delete m_optionsObj;
}

Member Function Documentation

template<class P_V, class P_M, class Q_V, class Q_M>

void QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::commonConstructor ( )

private

TODO: Common constructor.

Todo:

: implement me!

template<class P_V , class P_M , class Q_V , class Q_M >

bool QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::computeSolutionFlag

(

)

const

Whether or not compute the solution.

Definition at line 141 of file StatisticalForwardProblem.C.

{
  return m_optionsObj->m_ov.m_computeSolution;
}

template<class P_V , class P_M , class Q_V , class Q_M >

const BaseVectorSequence< Q_V, Q_M > & QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::getParamChain

(

)

const

Returns the parameter chain; access to private attribute m_paramChain.

Definition at line 402 of file StatisticalForwardProblem.C.

References UQ_FATAL_TEST_MACRO.

{

  // Make sure this runs after the forward propagation
  // only then we obtain the actual realizations of the parameters
  UQ_FATAL_TEST_MACRO(m_paramChain == NULL,
                      m_env.worldRank(),
                      (std::string)("StatisticalForwardProblem<V,M,V,M>::getParamChain()"),
                      "m_paramChain is NULL");

  return *m_paramChain;
 
}

template<class P_V , class P_M , class Q_V , class Q_M >

void QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::print

(

std::ostream &

os

)

const

TODO: Prints the sequence.

Todo:

: implement me!

Definition at line 418 of file StatisticalForwardProblem.C.

{
  return;
}

template<class P_V , class P_M , class Q_V , class Q_M >

const GenericVectorRV< Q_V, Q_M > & QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::qoiRv

(

)

const

Returns the QoI RV; access to private attribute m_qoiRv.

Definition at line 373 of file StatisticalForwardProblem.C.

{
  return m_qoiRv;
}

template<class P_V , class P_M , class Q_V , class Q_M >

void QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::solveWithMonteCarlo

(

const McOptionsValues *

alternativeOptionsValues

)

Solves the problem through Monte Carlo algorithm.

  Requirements: none at this moment. If the requirements are satisfied, this operation checks
 the member flag 'm_computeSolution' (one of the options read from the input file during 
 construction). If the flag is 'false', the operation returns immediately, computing nothing.
 If the flag is 'true', the operation sets the member variable 'm_qoiRv' accordingly. 
 The operation:

1. instantiates 'SequenceOfVectors<P_V,P_M>' (the input sequence of vectors),
2. instantiates 'SequenceOfVectors<Q_V,Q_M>' (the output sequence of vectors),
3. instantiates 'MonteCarloSG<P_V,P_M,Q_V,Q_M>' (the Monte Carlo algorithm),
4. populates the output sequence with the Monte Carlo algorithm,
5. sets the realizer of 'm_qoiRv' with the contents of the output sequence, and

Definition at line 148 of file StatisticalForwardProblem.C.

References QUESO::ComputeCovCorrMatricesBetweenVectorSequences(), QUESO::BaseVectorCdf< V, M >::m_prefix, QUESO::FilePtrSetStruct::ofsVar, QUESO::SequenceOfVectors< V, M >::subUniformlySampledCdf(), QUESO::SequenceOfVectors< V, M >::unifiedUniformlySampledCdf(), UQ_FATAL_TEST_MACRO, and UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT.

{
  m_env.fullComm().Barrier();
  m_env.fullComm().syncPrintDebugMsg("Entering StatisticalForwardProblem<P_V,P_M>::solveWithMonteCarlo()",1,3000000);

  if (m_optionsObj->m_ov.m_computeSolution == false) {
    if ((m_env.subDisplayFile())) {
      *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                              << ": avoiding solution, as requested by user"
                              << std::endl;
    }
    return;
  }
  if ((m_env.subDisplayFile())) {
    *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                            << ": computing solution, as requested by user"
                            << std::endl;
  }

  if (m_solutionPdf       ) delete m_solutionPdf;

#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
  if (m_unifiedSolutionCdf) delete m_unifiedSolutionCdf;
  if (m_unifiedCdfValues  ) delete m_unifiedCdfValues;
  if (m_unifiedCdfGrids   ) delete m_unifiedCdfGrids;

  if (m_subSolutionCdf    ) delete m_subSolutionCdf;
  if (m_subCdfValues      ) delete m_subCdfValues;
  if (m_subCdfGrids       ) delete m_subCdfGrids;

  if (m_subSolutionMdf    ) delete m_subSolutionMdf;
#endif
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
  if (m_subMdfValues      ) delete m_subMdfValues;
  if (m_subMdfGrids       ) delete m_subMdfGrids;
#endif
  if (m_solutionRealizer  ) delete m_solutionRealizer;

  if (m_mcSeqGenerator    ) delete m_mcSeqGenerator;

  if (m_qoiChain) {
    m_qoiChain->clear();
    delete m_qoiChain;
  }

  if (m_paramChain) {
    m_paramChain->clear();
    delete m_paramChain;
  }

  Q_V numEvaluationPointsVec(m_qoiRv.imageSet().vectorSpace().zeroVector());
  numEvaluationPointsVec.cwSet(250.);

  // Compute output realizer: Monte Carlo approach
  m_paramChain = new SequenceOfVectors<P_V,P_M>(m_paramRv.imageSet().vectorSpace(),0,m_optionsObj->m_prefix+"paramChain");
  m_qoiChain   = new SequenceOfVectors<Q_V,Q_M>(m_qoiRv.imageSet().vectorSpace(),  0,m_optionsObj->m_prefix+"qoiChain"  );
  m_mcSeqGenerator = new MonteCarloSG<P_V,P_M,Q_V,Q_M>(m_optionsObj->m_prefix.c_str(),
                                                              alternativeOptionsValues,
                                                              m_paramRv,
                                                              m_qoiFunction);
  //m_qoiRv);
  m_mcSeqGenerator->generateSequence(*m_paramChain,
                                     *m_qoiChain);
  m_solutionRealizer = new SequentialVectorRealizer<Q_V,Q_M>((m_optionsObj->m_prefix+"Qoi").c_str(),
                                                                    *m_qoiChain);
  m_qoiRv.setRealizer(*m_solutionRealizer);

  // Compute output mdf: uniform sampling approach
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
  m_subMdfGrids  = new ArrayOfOneDGrids <Q_V,Q_M>((m_optionsObj->m_prefix+"QoiMdf_").c_str(),m_qoiRv.imageSet().vectorSpace());
  m_subMdfValues = new ArrayOfOneDTables<Q_V,Q_M>((m_optionsObj->m_prefix+"QoiMdf_").c_str(),m_qoiRv.imageSet().vectorSpace());
  m_qoiChain->subUniformlySampledMdf(numEvaluationPointsVec, // input
                                     *m_subMdfGrids,         // output
                                     *m_subMdfValues);       // output

  m_subSolutionMdf = new SampledVectorMdf<Q_V,Q_M>((m_optionsObj->m_prefix+"Qoi").c_str(),
                                                          *m_subMdfGrids,
                                                          *m_subMdfValues);
  m_qoiRv.setMdf(*m_subSolutionMdf);
#endif

  // Compute output cdf: uniform sampling approach
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
  std::string subCoreName_qoiCdf(m_optionsObj->m_prefix+    "QoiCdf_");
  std::string uniCoreName_qoiCdf(m_optionsObj->m_prefix+"unifQoiCdf_");
  if (m_env.numSubEnvironments() == 1) subCoreName_qoiCdf = uniCoreName_qoiCdf;

  std::string subCoreName_solutionCdf(m_optionsObj->m_prefix+    "Qoi");
  std::string uniCoreName_solutionCdf(m_optionsObj->m_prefix+"unifQoi");
  if (m_env.numSubEnvironments() == 1) subCoreName_solutionCdf = uniCoreName_solutionCdf;

  m_subCdfGrids  = new ArrayOfOneDGrids <Q_V,Q_M>(subCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
  m_subCdfValues = new ArrayOfOneDTables<Q_V,Q_M>(subCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
  m_qoiChain->subUniformlySampledCdf(numEvaluationPointsVec, // input
                                     *m_subCdfGrids,         // output
                                     *m_subCdfValues);       // output

  m_subSolutionCdf = new SampledVectorCdf<Q_V,Q_M>(subCoreName_solutionCdf.c_str(),
                                                          *m_subCdfGrids,
                                                          *m_subCdfValues);
  m_qoiRv.setSubCdf(*m_subSolutionCdf);

  // Compute unified cdf if necessary
  if (m_env.numSubEnvironments() == 1) {
    m_qoiRv.setUnifiedCdf(*m_subSolutionCdf);
  }
  else {
    m_unifiedCdfGrids  = new ArrayOfOneDGrids <Q_V,Q_M>(uniCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
    m_unifiedCdfValues = new ArrayOfOneDTables<Q_V,Q_M>(uniCoreName_qoiCdf.c_str(),m_qoiRv.imageSet().vectorSpace());
    m_qoiChain->unifiedUniformlySampledCdf(numEvaluationPointsVec, // input
                                           *m_unifiedCdfGrids,     // output
                                           *m_unifiedCdfValues);   // output

    m_unifiedSolutionCdf = new SampledVectorCdf<Q_V,Q_M>(uniCoreName_solutionCdf.c_str(),
                                                                *m_unifiedCdfGrids,
                                                                *m_unifiedCdfValues);
    m_qoiRv.setUnifiedCdf(*m_unifiedSolutionCdf);
  }
#endif
  // Compute (just unified one) covariance matrix, if requested
  // Compute (just unified one) correlation matrix, if requested
  P_M* pqCovarianceMatrix  = NULL;
  P_M* pqCorrelationMatrix = NULL;
  if (m_optionsObj->m_ov.m_computeCovariances || m_optionsObj->m_ov.m_computeCorrelations) {
    if (m_env.subDisplayFile()) {
      *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                              << ", prefix = " << m_optionsObj->m_prefix
                              << ": instantiating cov and corr matrices"
                              << std::endl;
    }
    pqCovarianceMatrix = new P_M(m_env,
                                 m_paramRv.imageSet().vectorSpace().map(),       // number of rows
                                 m_qoiRv.imageSet().vectorSpace().dimGlobal());  // number of cols
    pqCorrelationMatrix = new P_M(m_env,
                                  m_paramRv.imageSet().vectorSpace().map(),      // number of rows
                                  m_qoiRv.imageSet().vectorSpace().dimGlobal()); // number of cols
    ComputeCovCorrMatricesBetweenVectorSequences(*m_paramChain,
                                                   *m_qoiChain,
                                                   std::min(m_paramRv.realizer().subPeriod(),m_qoiRv.realizer().subPeriod()), // FIX ME: might be INFINITY
                                                   *pqCovarianceMatrix,
                                                   *pqCorrelationMatrix);
  }

  // Write data out
  if (m_env.subDisplayFile()) {
    if (pqCovarianceMatrix ) {
      *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                              << ", prefix = "                           << m_optionsObj->m_prefix
                              << ": contents of covariance matrix are\n" << *pqCovarianceMatrix
                              << std::endl;
    }
    if (pqCorrelationMatrix) {
      *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                              << ", prefix = "                            << m_optionsObj->m_prefix
                              << ": contents of correlation matrix are\n" << *pqCorrelationMatrix
                              << std::endl;
    }
  }

  // Open data output file
  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                            << ", prefix = "                                        << m_optionsObj->m_prefix
                            << ": checking necessity of opening data output file '" << m_optionsObj->m_ov.m_dataOutputFileName
                            << "'"
                            << std::endl;
  }
  FilePtrSetStruct filePtrSet;
  if (m_env.openOutputFile(m_optionsObj->m_ov.m_dataOutputFileName,
                           UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT, // Yes, always ".m"
                           m_optionsObj->m_ov.m_dataOutputAllowedSet,
                           false,
                           filePtrSet)) {
#ifdef UQ_ALSO_COMPUTE_MDFS_WITHOUT_KDE
    m_qoiRv.mdf().print(*filePtrSet.ofsVar);
#endif
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
    *filePtrSet.ofsVar << m_qoiRv.subCdf();
#endif

    //if (pqCovarianceMatrix ) *filePtrSet.ofsVar << *pqCovarianceMatrix;  // FIX ME: output matrix in matlab format
    //if (pqCorrelationMatrix) *filePtrSet.ofsVar << *pqCorrelationMatrix; // FIX ME: output matrix in matlab format

    // Write unified cdf if necessary
#ifdef QUESO_COMPUTES_EXTRA_POST_PROCESSING_STATISTICS
    if (m_env.numSubEnvironments() > 1) {
      if (m_qoiRv.imageSet().vectorSpace().numOfProcsForStorage() == 1) {
        if (m_env.inter0Rank() == 0) {
          *filePtrSet.ofsVar << m_qoiRv.unifiedCdf(); //*m_unifiedSolutionCdf;
        }
      }
      else {
        UQ_FATAL_TEST_MACRO(true,
                            m_env.worldRank(),
                            "StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()",
                            "unified cdf writing, parallel vectors not supported yet");
      }
    }
#endif
    // Close data output file
    m_env.closeFile(filePtrSet,UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT);
    if (m_env.subDisplayFile()) {
      *m_env.subDisplayFile() << "In StatisticalForwardProblem<P_V,P_M,Q_V,Q_M>::solveWithMonteCarlo()"
                              << ", prefix = "                 << m_optionsObj->m_prefix
                              << ": closed data output file '" << m_optionsObj->m_ov.m_dataOutputFileName
                              << "'"
                              << std::endl;
    }
  }
  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << std::endl;
  }

  if (pqCovarianceMatrix ) delete pqCovarianceMatrix;
  if (pqCorrelationMatrix) delete pqCorrelationMatrix;

  m_env.fullComm().syncPrintDebugMsg("Leaving StatisticalForwardProblem<P_V,P_M>::solveWithMonteCarlo()",1,3000000);
  m_env.fullComm().Barrier();

  return;
}

Friends And Related Function Documentation

template<class P_V, class P_M, class Q_V, class Q_M>

std::ostream& operator<< ( std::ostream &  os, const StatisticalForwardProblem< P_V, P_M, Q_V, Q_M > &  obj  )

friend

Definition at line 141 of file StatisticalForwardProblem.h.

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

Member Data Documentation

template<class P_V, class P_M, class Q_V, class Q_M>

SfpOptionsValues QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_alternativeOptionsValues

private

Definition at line 167 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

const BaseEnvironment& QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_env

private

Definition at line 153 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

MonteCarloSG<P_V,P_M,Q_V,Q_M>* QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_mcSeqGenerator

private

Definition at line 161 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

StatisticalForwardProblemOptions* QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_optionsObj

private

Definition at line 168 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

BaseVectorSequence<Q_V,Q_M>* QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_paramChain

private

Definition at line 159 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

const BaseVectorRV<P_V,P_M>& QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_paramRv

private

Definition at line 155 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

BaseVectorSequence<Q_V,Q_M>* QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_qoiChain

private

Definition at line 160 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

const BaseVectorFunction<P_V,P_M,Q_V,Q_M>& QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_qoiFunction

private

Definition at line 156 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

GenericVectorRV<Q_V,Q_M>& QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_qoiRv

private

Definition at line 157 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

BaseJointPdf<Q_V,Q_M>* QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_solutionPdf

private

Definition at line 165 of file StatisticalForwardProblem.h.

template<class P_V, class P_M, class Q_V, class Q_M>

BaseVectorRealizer<Q_V,Q_M>* QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::m_solutionRealizer

private

Definition at line 163 of file StatisticalForwardProblem.h.

---

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

• src/stats/inc/StatisticalForwardProblem.h
• src/stats/src/StatisticalForwardProblem.C