A templated class that implements a Monte Carlo generator of samples. More...

#include <MonteCarloSG.h>

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

Public Member Functions
Constructor/Destructor methods
	MonteCarloSG (const char prefix, const McOptionsValues alternativeOptionsValues, const BaseVectorRV< P_V, P_M > &paramRv, const BaseVectorFunction< P_V, P_M, Q_V, Q_M > &qoiFunction)
	Constructor. More...

	~MonteCarloSG ()
	Destructor. More...

Statistical methods
void	generateSequence (BaseVectorSequence< P_V, P_M > &workingPSeq, BaseVectorSequence< Q_V, Q_M > &workingQSeq)
	Generates the QoI (output) sequence, it calls internGenerateSequence(). More...

Private Member Functions
void	internGenerateSequence (const BaseVectorRV< P_V, P_M > &paramRv, BaseVectorSequence< P_V, P_M > &workingPSeq, BaseVectorSequence< Q_V, Q_M > &workingQSeq)
	Generates the QoI (output) sequence; it calls actualGenerateSequence(). More...

void	actualGenerateSequence (const BaseVectorRV< P_V, P_M > &paramRv, BaseVectorSequence< P_V, P_M > &workingPSeq, BaseVectorSequence< Q_V, Q_M > &workingQSeq, unsigned int seqSize)
	This method actually generates the QoI sequence. More...

void	actualReadSequence (const BaseVectorRV< P_V, P_M > &paramRv, const std::string &dataInputFileName, const std::string &dataInputFileType, BaseVectorSequence< P_V, P_M > &workingPSeq, BaseVectorSequence< Q_V, Q_M > &workingQSeq, unsigned int seqSize)
	Reads the sequence. 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

const VectorSpace< P_V, P_M > &	m_paramSpace

const VectorSpace< Q_V, Q_M > &	m_qoiSpace

const VectorFunctionSynchronizer < P_V, P_M, Q_V, Q_M > *	m_qoiFunctionSynchronizer

unsigned int	m_numPsNotSubWritten

unsigned int	m_numQsNotSubWritten

const McOptionsValues *	m_optionsObj

bool	m_userDidNotProvideOptions

I/O methods
void	print (std::ostream &os) const
	Prints the sequence. More...

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

Detailed Description

template<class P_V = GslVector, class P_M = GslMatrix, class Q_V = GslVector, class Q_M = GslMatrix>
class QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >

A templated class that implements a Monte Carlo generator of samples.

This class implements a Monte Carlo generator of samples. 'SG' stands for 'Sequence Generator'. Options reading is handled by class 'MonteCarloOptions'. If options request data to be written in the output file (MATLAB .m format only, for now), the user can check which MATLAB variables are defined and set by running 'grep zeros <OUTPUT file="" name>="">' after the solution procedures ends. The names of the variables are self explanatory.

Definition at line 52 of file MonteCarloSG.h.

Constructor & Destructor Documentation

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

QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::MonteCarloSG	(	const char *	prefix,
		const McOptionsValues *	alternativeOptionsValues,
		const BaseVectorRV< P_V, P_M > &	paramRv,
		const BaseVectorFunction< P_V, P_M, Q_V, Q_M > &	qoiFunction
	)

Constructor.

Requirements: 1) the image set of the vector random variable 'paramRv' and 2) the domain set of the QoI function 'qoiFunction' 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>_mc_'. For instance, if 'prefix' is 'pROblem_775_fp_', then the constructor will read all options that begin with 'pROblem_775_fp_mc_'. Options reading is handled by class 'MonteCarloOptions'.

Parameters

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

Definition at line 33 of file MonteCarloSG.C.

References queso_require_equal_to_msg.

   :
   m_env                     (paramRv.env()),
   m_paramRv                 (paramRv),
   m_qoiFunction             (qoiFunction),
   m_paramSpace              (m_paramRv.imageSet().vectorSpace()),
   m_qoiSpace                (m_qoiFunction.imageSet().vectorSpace()),
   m_qoiFunctionSynchronizer (new VectorFunctionSynchronizer<P_V,P_M,Q_V,Q_M>(m_qoiFunction,m_paramRv.imageSet().vectorSpace().zeroVector(),m_qoiFunction.imageSet().vectorSpace().zeroVector())),
   m_numPsNotSubWritten      (0),
   m_numQsNotSubWritten      (0),
   m_optionsObj              (alternativeOptionsValues),
   m_userDidNotProvideOptions(false)
 {
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "Entering MonteCarloSG<P_V,P_M,Q_V,Q_M>::constructor()"
                             << ": prefix = " << prefix
                             << ", alternativeOptionsValues = " << alternativeOptionsValues
                             << ", m_env.optionsInputFileName() = " << m_env.optionsInputFileName()
                             << std::endl;
   }
 
   // If NULL, we create one
   if (m_optionsObj == NULL) {
     McOptionsValues * tempOptions = new McOptionsValues(&m_env, prefix);
 
     // We did this dance because scanOptionsValues is not a const method, but
     // m_optionsObj is a pointer to const
     m_optionsObj = tempOptions;
 
     // We do this so we don't delete the user's object in the dtor
     m_userDidNotProvideOptions = true;
   }
 
   if (m_optionsObj->m_help != "") {
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << (*m_optionsObj) << std::endl;
     }
   }
 
   queso_require_equal_to_msg(paramRv.imageSet().vectorSpace().dimLocal(), qoiFunction.domainSet().vectorSpace().dimLocal(), "'paramRv' and 'qoiFunction' are related to vector spaces of different dimensions");
 
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "Leaving MonteCarloSG<P_V,P_M,Q_V,Q_M>::constructor()"
                             << std::endl;
   }
 }

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

QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::~MonteCarloSG ( )

Destructor.

Definition at line 85 of file MonteCarloSG.C.

 {
   if (m_optionsObj && m_userDidNotProvideOptions) {
     delete m_optionsObj;
   }
 
   if (m_qoiFunctionSynchronizer) delete m_qoiFunctionSynchronizer;
 }

Member Function Documentation

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

void QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence	(	const BaseVectorRV< P_V, P_M > &	paramRv,
		BaseVectorSequence< P_V, P_M > &	workingPSeq,
		BaseVectorSequence< Q_V, Q_M > &	workingQSeq,
		unsigned int	seqSize
	)

private

This method actually generates the QoI sequence.

Requirements: 1) the vector space containing the domain set of the QoI function 'm_qoiFunction' should have dimension equal to the size of a vector in 'workingPSeq' and 2) the vector space containing the image set of the qoi function 'm_qoiFunction' should have dimension equal to the size of a vector in 'workingQSeq'. If the requirements are satisfied, this operation sets the size and the contents of 'workingPSeq' and 'workingQSeq' using the algorithm options set in the constructor.

Definition at line 334 of file MonteCarloSG.C.

References QUESO::BaseVectorSequence< V, M >::getPositionValues(), QUESO::MiscGetEllapsedSeconds(), QUESO::BaseVectorSequence< V, M >::name(), QUESO::BaseVectorRealizer< V, M >::realization(), QUESO::BaseVectorRV< V, M >::realizer(), QUESO::BaseVectorSequence< V, M >::resizeSequence(), QUESO::BaseVectorSequence< V, M >::setPositionValues(), QUESO::BaseVectorSequence< V, M >::subSequenceSize(), QUESO::BaseVectorSequence< V, M >::subWriteContents(), and QUESO::UQ_OK_RC.

 {
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "Starting the generation of qoi sequence " << workingQSeq.name()
                             << ", with "                                  << requestedSeqSize
                             << " samples..."
                             << std::endl;
   }
 
   int iRC = UQ_OK_RC;
   struct timeval timevalSeq;
   struct timeval timevalQoIFunction;
 
   double seqRunTime         = 0;
   double qoiFunctionRunTime = 0;
 
   iRC = gettimeofday(&timevalSeq, NULL);
   if (iRC) {}; // just to remover compiler warning
 
   workingPSeq.resizeSequence(requestedSeqSize);
   m_numPsNotSubWritten = 0;
   workingQSeq.resizeSequence(requestedSeqSize);
   m_numQsNotSubWritten = 0;
 
   P_V tmpP(m_paramSpace.zeroVector());
   Q_V tmpQ(m_qoiSpace.zeroVector());
 
   unsigned int actualSeqSize = 0;
   for (unsigned int i = 0; i < requestedSeqSize; ++i) {
     paramRv.realizer().realization(tmpP);
 
     if (m_optionsObj->m_qseqMeasureRunTimes) iRC = gettimeofday(&timevalQoIFunction, NULL);
     m_qoiFunctionSynchronizer->callFunction(&tmpP,NULL,&tmpQ,NULL,NULL,NULL); // Might demand parallel environment
     if (m_optionsObj->m_qseqMeasureRunTimes) qoiFunctionRunTime += MiscGetEllapsedSeconds(&timevalQoIFunction);
 
     bool allQsAreFinite = true;
     for (unsigned int j = 0; j < tmpQ.sizeLocal(); ++j) {
       if ((tmpQ[j] == INFINITY) || (tmpQ[j] == -INFINITY)) {
   std::cerr << "WARNING In MonteCarloSG<P_V,P_M,Q_V,Q_M>::actualGenerateSequence()"
                   << ", worldRank "      << m_env.worldRank()
                   << ", fullRank "       << m_env.fullRank()
                   << ", subEnvironment " << m_env.subId()
                   << ", subRank "        << m_env.subRank()
                   << ", inter0Rank "     << m_env.inter0Rank()
                   << ": i = "            << i
                   << ", tmpQ[" << j << "] = " << tmpQ[j]
                   << ", tmpP = "         << tmpP
                   << ", tmpQ = "         << tmpQ
                   << std::endl;
         allQsAreFinite = false;
 
         if (i > 0) {
           workingPSeq.getPositionValues(i-1,tmpP); // FIXME: temporary code
           workingQSeq.getPositionValues(i-1,tmpQ); // FIXME: temporary code
         }
 
         break;
       }
     }
     if (allQsAreFinite) {}; // just to remover compiler warning
 
     //if (allQsAreFinite) { // FIXME: this will cause different processors to have sequences of different sizes
       workingPSeq.setPositionValues(i,tmpP);
       m_numPsNotSubWritten++;
       if ((m_optionsObj->m_pseqDataOutputPeriod           >  0  ) &&
           (((i+1) % m_optionsObj->m_pseqDataOutputPeriod) == 0  ) &&
           (m_optionsObj->m_pseqDataOutputFileName         != ".")) {
         workingPSeq.subWriteContents(i + 1 - m_optionsObj->m_pseqDataOutputPeriod,
                                      m_optionsObj->m_pseqDataOutputPeriod,
                                      m_optionsObj->m_pseqDataOutputFileName,
                                      m_optionsObj->m_pseqDataOutputFileType,
                                      m_optionsObj->m_pseqDataOutputAllowedSet);
         if (m_env.subDisplayFile()) {
           *m_env.subDisplayFile() << "In MonteCarloG<P_V,P_M>::actualGenerateSequence()"
                                   << ": just wrote pseq positions (per period request)"
                                   << std::endl;
         }
         m_numPsNotSubWritten = 0;
       }
 
       workingQSeq.setPositionValues(i,tmpQ);
       m_numQsNotSubWritten++;
       if ((m_optionsObj->m_qseqDataOutputPeriod           >  0  ) &&
           (((i+1) % m_optionsObj->m_qseqDataOutputPeriod) == 0  ) &&
           (m_optionsObj->m_qseqDataOutputFileName         != ".")) {
         workingQSeq.subWriteContents(i + 1 - m_optionsObj->m_qseqDataOutputPeriod,
                                      m_optionsObj->m_qseqDataOutputPeriod,
                                      m_optionsObj->m_qseqDataOutputFileName,
                                      m_optionsObj->m_qseqDataOutputFileType,
                                      m_optionsObj->m_qseqDataOutputAllowedSet);
         if (m_env.subDisplayFile()) {
           *m_env.subDisplayFile() << "In MonteCarloG<P_V,P_M>::actualGenerateSequence()"
                                   << ": just wrote qseq positions (per period request)"
                                   << std::endl;
         }
         m_numQsNotSubWritten = 0;
       }
 
       actualSeqSize++;
 
     //}
 
     if ((m_optionsObj->m_qseqDisplayPeriod            > 0) &&
         (((i+1) % m_optionsObj->m_qseqDisplayPeriod) == 0)) {
       if (m_env.subDisplayFile()) {
         *m_env.subDisplayFile() << "Finished generating " << i+1
                                 << " qoi samples"
                                 << std::endl;
       }
     }
   }
 
   //if (actualSeqSize != requestedSeqSize) {
   //  workingPSeq.resizeSequence(actualSeqSize);
   //  workingQSeq.resizeSequence(actualSeqSize);
   //}
 
   seqRunTime = MiscGetEllapsedSeconds(&timevalSeq);
 
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "Finished the generation of qoi sequence " << workingQSeq.name()
                             << ", with sub "                              << workingQSeq.subSequenceSize()
                             << " samples"
                             << "\nSome information about this sequence:"
                             << "\n  Sequence run time = " << seqRunTime
                             << " seconds"
                             << "\n\n Breaking of the seq run time:\n"
                             << "\n  QoI function run time   = " << qoiFunctionRunTime
                             << " seconds ("                     << 100.*qoiFunctionRunTime/seqRunTime
                             << "%)"
                             << std::endl;
   }
 
   return;
 }

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

void QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualReadSequence	(	const BaseVectorRV< P_V, P_M > &	paramRv,
		const std::string &	dataInputFileName,
		const std::string &	dataInputFileType,
		BaseVectorSequence< P_V, P_M > &	workingPSeq,
		BaseVectorSequence< Q_V, Q_M > &	workingQSeq,
		unsigned int	seqSize
	)

private

Reads the sequence.

Definition at line 476 of file MonteCarloSG.C.

References QUESO::BaseVectorRealizer< V, M >::realization(), QUESO::BaseVectorRV< V, M >::realizer(), QUESO::BaseVectorSequence< V, M >::resizeSequence(), QUESO::BaseVectorSequence< V, M >::setPositionValues(), and QUESO::BaseVectorSequence< V, M >::unifiedReadContents().

 {
   workingPSeq.resizeSequence(requestedSeqSize);
   P_V tmpP(m_paramSpace.zeroVector());
   for (unsigned int i = 0; i < requestedSeqSize; ++i) {
     paramRv.realizer().realization(tmpP);
     workingPSeq.setPositionValues(i,tmpP);
   }
 
   workingQSeq.unifiedReadContents(dataInputFileName,dataInputFileType,requestedSeqSize);
 
   return;
 }

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

void QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::generateSequence	(	BaseVectorSequence< P_V, P_M > &	workingPSeq,
		BaseVectorSequence< Q_V, Q_M > &	workingQSeq
	)

Generates the QoI (output) sequence, it calls internGenerateSequence().

This method checks for a parallel environment (and uses it if available) and calls the private member function internGenerateSequence() to generate a sequence of values of the Quantity of interest (QoI).

Definition at line 96 of file MonteCarloSG.C.

References queso_require_equal_to_msg, and QUESO::BaseVectorSequence< V, M >::vectorSizeLocal().

 {
   queso_require_equal_to_msg(m_qoiFunction.domainSet().vectorSpace().dimLocal(), workingPSeq.vectorSizeLocal(), "'m_qoiFunction.domainSet' and 'workingPSeq' are related to vector spaces of different dimensions");
 
   queso_require_equal_to_msg(m_qoiFunction.imageSet().vectorSpace().dimLocal(), workingQSeq.vectorSizeLocal(), "'m_qoiFunction.imageSet' and 'workingQSeq' are related to vector spaces of different dimensions");
 
   MiscCheckTheParallelEnvironment<P_V,Q_V>(m_paramRv.imageSet().vectorSpace().zeroVector(),
                                              m_qoiFunction.imageSet().vectorSpace().zeroVector());
   internGenerateSequence(m_paramRv,workingPSeq,workingQSeq);
 
   return;
 }

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

void QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence	(	const BaseVectorRV< P_V, P_M > &	paramRv,
		BaseVectorSequence< P_V, P_M > &	workingPSeq,
		BaseVectorSequence< Q_V, Q_M > &	workingQSeq
	)

private

Generates the QoI (output) sequence; it calls actualGenerateSequence().

This method calls the private member actualGenerateSequence() to actually generate a sequence of values of the Quantity of interest (QoI). It writes both the QoI and the parameter sequences to output files. If a parallel environment is available, the user has the choice of (via the input options file) which sub-environment will write data to files. The unified sequence of data (QoI and/or Parameter sequences) of all the sub-environments (or of the single environment, in case of a serial run) is also written to files.

Definition at line 120 of file MonteCarloSG.C.

References QUESO::BaseVectorSequence< V, M >::name(), QUESO::FilePtrSetStruct::ofsVar, queso_require_equal_to_msg, QUESO::BaseVectorRV< V, M >::realizer(), QUESO::BaseVectorSequence< V, M >::setName(), QUESO::BaseVectorRealizer< V, M >::subPeriod(), QUESO::BaseVectorSequence< V, M >::subSequenceSize(), QUESO::BaseVectorSequence< V, M >::subWriteContents(), QUESO::BaseVectorSequence< V, M >::unifiedWriteContents(), UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT, and UQ_MOC_SG_FILENAME_FOR_NO_FILE.

 {
   workingPSeq.setName(m_optionsObj->m_prefix+"ParamSeq");
   workingQSeq.setName(m_optionsObj->m_prefix+"QoiSeq");
 
   //****************************************************
   // Generate sequence of QoI values
   //****************************************************
   unsigned int subActualSizeBeforeGeneration = std::min(m_optionsObj->m_qseqSize,paramRv.realizer().subPeriod());
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 0)) {
     *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                             << ": m_optionsObj->m_qseqSize = "                             << m_optionsObj->m_qseqSize
                             << ", paramRv.realizer().subPeriod() = "                            << paramRv.realizer().subPeriod()
                             << ", about to call actualGenerateSequence() with subActualSize = " << subActualSizeBeforeGeneration
                             << std::endl;
   }
   if (m_optionsObj->m_qseqDataInputFileName == UQ_MOC_SG_FILENAME_FOR_NO_FILE) {
     actualGenerateSequence(paramRv,
                            workingPSeq,
                            workingQSeq,
                            subActualSizeBeforeGeneration);
   }
   else {
     actualReadSequence(paramRv,
                        m_optionsObj->m_qseqDataInputFileName,
                        m_optionsObj->m_qseqDataInputFileType,
                        workingPSeq,
                        workingQSeq,
                        subActualSizeBeforeGeneration);
   }
   unsigned int subActualSizeAfterGeneration = workingPSeq.subSequenceSize();
   queso_require_equal_to_msg(subActualSizeAfterGeneration, workingQSeq.subSequenceSize(), "P and Q sequences should have the same size!");
 
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 0)) {
     *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                             << ": returned from call to actualGenerateSequence() with subActualSize = " << subActualSizeAfterGeneration
                             << std::endl;
   }
 
   //****************************************************
   // Open generic output file
   //****************************************************
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                             << ", prefix = "                                                        << m_optionsObj->m_prefix
                             << ": checking necessity of opening generic output file (qseq name is " << workingQSeq.name()
                             << ") ..."
                             << std::endl;
   }
   FilePtrSetStruct genericFilePtrSet;
   m_env.openOutputFile(m_optionsObj->m_dataOutputFileName,
                        UQ_FILE_EXTENSION_FOR_MATLAB_FORMAT, // Yes, always ".m"
                        m_optionsObj->m_dataOutputAllowedSet,
                        false,
                        genericFilePtrSet);
 
   //****************************************************
   // Eventually:
   // --> write parameter sequence
   // --> compute statistics on it
   //****************************************************
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                             << ", prefix = "                                            << m_optionsObj->m_prefix
                             << ": checking necessity of opening output files for pseq " << workingPSeq.name()
                             << "..."
                             << std::endl;
   }
 
   // Take "sub" care of pseq
   if ((m_numPsNotSubWritten                        >  0                             ) &&
       (m_optionsObj->m_pseqDataOutputFileName != UQ_MOC_SG_FILENAME_FOR_NO_FILE)) {
     workingPSeq.subWriteContents(subActualSizeBeforeGeneration - m_numPsNotSubWritten,
                                  m_numPsNotSubWritten,
                                  m_optionsObj->m_pseqDataOutputFileName,
                                  m_optionsObj->m_pseqDataOutputFileType,
                                  m_optionsObj->m_pseqDataOutputAllowedSet);
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In MonteCarloG<P_V,P_M>::internGenerateSequence()"
                               << ": just wrote remaining pseq positions (per period request)"
                               << std::endl;
     }
     m_numPsNotSubWritten = 0;
     //if (m_env.subDisplayFile()) {
     //  *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
     //                          << ", prefix = "                 << m_optionsObj->m_prefix
     //                          << ": closed data output file '" << m_optionsObj->m_pseqDataOutputFileName
     //                          << "' for pseq "                 << workingPSeq.name()
     //                          << std::endl;
     //}
   }
 
   // Take "unified" care of pseq
   if (m_optionsObj->m_pseqDataOutputFileName != UQ_MOC_SG_FILENAME_FOR_NO_FILE) {
     workingPSeq.unifiedWriteContents(m_optionsObj->m_pseqDataOutputFileName,m_optionsObj->m_pseqDataOutputFileType);
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ", prefix = "                         << m_optionsObj->m_prefix
                               << ": closed unified data output file '" << m_optionsObj->m_pseqDataOutputFileName
                               << "' for pseq "                         << workingPSeq.name()
                               << std::endl;
     }
   }
 
   // Take case of other aspects of pseq
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_optionsObj->m_pseqComputeStats) {
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 0)) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ": about to call 'workingPSeq.computeStatistics()'"
                               << std::endl;
     }
     workingPSeq.computeStatistics(*m_optionsObj->m_pseqStatisticalOptionsObj,
                                   genericFilePtrSet.ofsVar);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 0)) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ": returned from call to 'workingPSeq.computeStatistics()'"
                               << std::endl;
     }
   }
 #endif
   //****************************************************
   // Eventually:
   // --> write QoI sequence
   // --> compute statistics on it
   //****************************************************
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                             << ", prefix = "                                            << m_optionsObj->m_prefix
                             << ": checking necessity of opening output files for qseq " << workingQSeq.name()
                             << "..."
                             << std::endl;
   }
 
   // Take "sub" care of qseq
   if ((m_numQsNotSubWritten                        >  0                             ) &&
       (m_optionsObj->m_qseqDataOutputFileName != UQ_MOC_SG_FILENAME_FOR_NO_FILE)) {
     workingQSeq.subWriteContents(subActualSizeBeforeGeneration - m_numQsNotSubWritten,
                                  m_numQsNotSubWritten,
                                  m_optionsObj->m_qseqDataOutputFileName,
                                  m_optionsObj->m_qseqDataOutputFileType,
                                  m_optionsObj->m_qseqDataOutputAllowedSet);
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In MonteCarloG<P_V,P_M>::internGenerateSequence()"
                               << ": just wrote remaining qseq positions (per period request)"
                               << std::endl;
     }
     m_numQsNotSubWritten = 0;
     //if (m_env.subDisplayFile()) {
     //  *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
     //                          << ", prefix = "                 << m_optionsObj->m_prefix
     //                          << ": closed data output file '" << m_optionsObj->m_qseqDataOutputFileName
     //                          << "' for qseq "                 << workingQSeq.name()
     //                          << std::endl;
     //}
   }
 
   // Take "unified" care of qseq
   if (m_optionsObj->m_qseqDataOutputFileName != UQ_MOC_SG_FILENAME_FOR_NO_FILE) {
     workingQSeq.unifiedWriteContents(m_optionsObj->m_qseqDataOutputFileName,m_optionsObj->m_qseqDataOutputFileType);
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ", prefix = "                         << m_optionsObj->m_prefix
                               << ": closed unified data output file '" << m_optionsObj->m_qseqDataOutputFileName
                               << "' for qseq "                         << workingQSeq.name()
                               << std::endl;
     }
   }
 
   // Take case of other aspects of qseq
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_optionsObj->m_qseqComputeStats) {
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 0)) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ": about to call 'workingQSeq.computeStatistics()'"
                               << std::endl;
     }
     workingQSeq.computeStatistics(*m_optionsObj->m_qseqStatisticalOptionsObj,
                                   genericFilePtrSet.ofsVar);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 0)) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ": returned from call to 'workingQSeq.computeStatistics()'"
                               << std::endl;
     }
   }
 #endif
   //****************************************************
   // Close generic output file
   //****************************************************
   if (genericFilePtrSet.ofsVar) {
     //std::cout << "TODAY 000" << std::endl;
     delete genericFilePtrSet.ofsVar;
     //genericFilePtrSet.ofsVar->close();
     //std::cout << "TODAY 001" << std::endl;
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In MonteCarloSG<P_V,P_M,Q_V,Q_M>::internGenerateSequence()"
                               << ", prefix = "                         << m_optionsObj->m_prefix
                               << ": closed generic data output file '" << m_optionsObj->m_dataOutputFileName
                               << "' for QoI sequence "                 << workingQSeq.name()
                               << std::endl;
     }
   }
   if (m_env.subDisplayFile()) {
     *m_env.subDisplayFile() << std::endl;
   }
 
   return;
 }

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

void QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::print ( std::ostream & os ) const

Prints the sequence.

Definition at line 113 of file MonteCarloSG.C.

 {
   return;
 }