This class reads the options for the Monte Carlo sequence generator from an input file. More...

#include <MonteCarloSGOptions.h>

Collaboration diagram for QUESO::MonteCarloSGOptions:

Public Member Functions
Constructor/Destructor methods
	MonteCarloSGOptions (const BaseEnvironment &env, const char *prefix)
	Constructor: reads options from the input file. More...

	MonteCarloSGOptions (const BaseEnvironment &env, const char *prefix, const McOptionsValues &alternativeOptionsValues)
	Constructor: with alternative option values. More...

	~MonteCarloSGOptions ()
	Destructor. More...

I/O methods
void	scanOptionsValues ()
	It scans the option values from the options input file. More...

void	print (std::ostream &os) const
	It prints the option values. More...

Public Attributes
McOptionsValues	m_ov

std::string	m_prefix

Private Member Functions
void	defineMyOptions (po::options_description &optionsDesc) const
	Defines the options for the Monte Carlo sequence generator as the default options. More...

void	getMyOptionValues (po::options_description &optionsDesc)
	Gets the sequence options. More...

Private Attributes
const BaseEnvironment &	m_env

po::options_description *	m_optionsDesc

std::string	m_option_help

std::string	m_option_dataOutputFileName

std::string	m_option_dataOutputAllowedSet

std::string	m_option_pseq_dataOutputPeriod

std::string	m_option_pseq_dataOutputFileName

std::string	m_option_pseq_dataOutputFileType

std::string	m_option_pseq_dataOutputAllowedSet

std::string	m_option_qseq_dataInputFileName

std::string	m_option_qseq_dataInputFileType

std::string	m_option_qseq_size

std::string	m_option_qseq_displayPeriod

std::string	m_option_qseq_measureRunTimes

std::string	m_option_qseq_dataOutputPeriod

std::string	m_option_qseq_dataOutputFileName

std::string	m_option_qseq_dataOutputFileType

std::string	m_option_qseq_dataOutputAllowedSet

Detailed Description

This class reads the options for the Monte Carlo sequence generator from an input file.

Monte Carlo sequence generator expects options for its methods. This class reads the options for the Monte Carlo sequence generator from an input file provided by the user. The class expects the prefix '<prefix>_mc_'. For instance, if 'prefix' is 'foo_775_fp_', then the constructor will read all options that begin with 'foo_775_fp_mc_'.

Definition at line 141 of file MonteCarloSGOptions.h.

Constructor & Destructor Documentation

QUESO::MonteCarloSGOptions::MonteCarloSGOptions	(	const BaseEnvironment &	env,
		const char *	prefix
	)

Constructor: reads options from the input file.

Definition at line 127 of file MonteCarloSGOptions.C.

References m_env, QUESO::BaseEnvironment::optionsInputFileName(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   m_ov                              (NULL,NULL),
   m_pseqStatisticalOptionsObj       (NULL),
   m_qseqStatisticalOptionsObj       (NULL),
 #else
   m_ov                              (),
 #endif
   m_prefix                          ((std::string)(prefix) + "mc_"),
   m_env                             (env),
   m_optionsDesc                     (new po::options_description("Monte Carlo options")),
   m_option_help                     (m_prefix + "help"                       ),
   m_option_dataOutputFileName       (m_prefix + "dataOutputFileName"         ),
   m_option_dataOutputAllowedSet     (m_prefix + "dataOutputAllowedSet"       ),
   m_option_pseq_dataOutputPeriod    (m_prefix + "pseq_dataOutputPeriod"      ),
   m_option_pseq_dataOutputFileName  (m_prefix + "pseq_dataOutputFileName"    ),
   m_option_pseq_dataOutputFileType  (m_prefix + "pseq_dataOutputFileType"    ),
   m_option_pseq_dataOutputAllowedSet(m_prefix + "pseq_dataOutputAllowedSet"  ),
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   m_option_pseq_computeStats        (m_prefix + "pseq_computeStats"          ),
 #endif
   m_option_qseq_dataInputFileName   (m_prefix + "qseq_dataInputFileName"     ),
   m_option_qseq_dataInputFileType   (m_prefix + "qseq_dataInputFileType"     ),
   m_option_qseq_size                (m_prefix + "qseq_size"                  ),
   m_option_qseq_displayPeriod       (m_prefix + "qseq_displayPeriod"         ),
   m_option_qseq_measureRunTimes     (m_prefix + "qseq_measureRunTimes"       ),
   m_option_qseq_dataOutputPeriod    (m_prefix + "qseq_dataOutputPeriod"      ),
   m_option_qseq_dataOutputFileName  (m_prefix + "qseq_dataOutputFileName"    ),
   m_option_qseq_dataOutputFileType  (m_prefix + "qseq_dataOutputFileType"    ),
   m_option_qseq_dataOutputAllowedSet(m_prefix + "qseq_dataOutputAllowedSet"  )
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   ,
   m_option_qseq_computeStats        (m_prefix + "qseq_computeStats"          )
 #endif
 {
   UQ_FATAL_TEST_MACRO(m_env.optionsInputFileName() == "",
                       m_env.worldRank(),
                       "MonteCarloSGOptions::constructor(1)",
                       "this constructor is incompatible with the absence of an options input file");
 }

QUESO::MonteCarloSGOptions::MonteCarloSGOptions	(	const BaseEnvironment &	env,
		const char *	prefix,
		const McOptionsValues &	alternativeOptionsValues
	)

Constructor: with alternative option values.

In this constructor, the input options are given by alternativeOptionsValues, thus, they are not read from an input file.

Definition at line 171 of file MonteCarloSGOptions.C.

References m_env, m_ov, m_prefix, QUESO::BaseEnvironment::optionsInputFileName(), QUESO::BaseEnvironment::subDisplayFile(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
   m_ov                              (alternativeOptionsValues),
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   m_pseqStatisticalOptionsObj       (NULL),
   m_qseqStatisticalOptionsObj       (NULL),
 #endif
   m_prefix                          ((std::string)(prefix) + "mc_"),
   m_env                             (env),
   m_optionsDesc                     (NULL),
   m_option_help                     (m_prefix + "help"                     ),
   m_option_dataOutputFileName       (m_prefix + "dataOutputFileName"       ),
   m_option_dataOutputAllowedSet     (m_prefix + "dataOutputAllowedSet"     ),
   m_option_pseq_dataOutputPeriod    (m_prefix + "pseq_dataOutputPeriod"    ),
   m_option_pseq_dataOutputFileName  (m_prefix + "pseq_dataOutputFileName"  ),
   m_option_pseq_dataOutputFileType  (m_prefix + "pseq_dataOutputFileType"  ),
   m_option_pseq_dataOutputAllowedSet(m_prefix + "pseq_dataOutputAllowedSet"),
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   m_option_pseq_computeStats        (m_prefix + "pseq_computeStats"        ),
 #endif
   m_option_qseq_dataInputFileName   (m_prefix + "qseq_dataInputFileName"   ),
   m_option_qseq_dataInputFileType   (m_prefix + "qseq_dataInputFileType"   ),
   m_option_qseq_size                (m_prefix + "qseq_size"                ),
   m_option_qseq_displayPeriod       (m_prefix + "qseq_displayPeriod"       ),
   m_option_qseq_measureRunTimes     (m_prefix + "qseq_measureRunTimes"     ),
   m_option_qseq_dataOutputPeriod    (m_prefix + "qseq_dataOutputPeriod"    ),
   m_option_qseq_dataOutputFileName  (m_prefix + "qseq_dataOutputFileName"  ),
   m_option_qseq_dataOutputFileType  (m_prefix + "qseq_dataOutputFileType"  ),
   m_option_qseq_dataOutputAllowedSet(m_prefix + "qseq_dataOutputAllowedSet")
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   ,
   m_option_qseq_computeStats        (m_prefix + "qseq_computeStats"        )
 #endif
 {
   UQ_FATAL_TEST_MACRO(m_env.optionsInputFileName() != "",
                       m_env.worldRank(),
                       "MonteCarloSGOptions::constructor(2)",
                       "this constructor is incompatible with the existence of an options input file");
 
   if (m_env.subDisplayFile() != NULL) {
     *m_env.subDisplayFile() << "In MonteCarloSGOptions::constructor(2)"
                             << ": after setting values of options with prefix '" << m_prefix
                             << "', state of object is:"
                             << "\n" << *this
                             << std::endl;
   }
 
   // dakota
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_ov.m_pseqComputeStats) m_pseqStatisticalOptionsObj =
     new SequenceStatisticalOptions(m_env,m_prefix + "pseq_",m_ov.m_alternativePSsOptionsValues);
   if (m_ov.m_qseqComputeStats) m_qseqStatisticalOptionsObj =
     new SequenceStatisticalOptions(m_env,m_prefix + "qseq_",m_ov.m_alternativeQSsOptionsValues);
 #endif
 }

QUESO::MonteCarloSGOptions::~MonteCarloSGOptions ( )

Destructor.

Definition at line 230 of file MonteCarloSGOptions.C.

References m_optionsDesc.

 {
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_pseqStatisticalOptionsObj) delete m_pseqStatisticalOptionsObj; // dakota
   if (m_qseqStatisticalOptionsObj) delete m_qseqStatisticalOptionsObj; // dakota
 #endif
   if (m_optionsDesc              ) delete m_optionsDesc;
 } 

Member Function Documentation

void QUESO::MonteCarloSGOptions::defineMyOptions ( po::options_description & optionsDesc ) const

private

Defines the options for the Monte Carlo sequence generator as the default options.

Definition at line 270 of file MonteCarloSGOptions.C.

Referenced by scanOptionsValues().

 {
   optionsDesc.add_options()     
     (m_option_help.c_str(),                                                                                                            "produce help message for Monte Carlo distribution calculator")
     (m_option_dataOutputFileName.c_str(),        po::value<std::string >()->default_value(UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV       ), "name of generic data output file"                            )
     (m_option_dataOutputAllowedSet.c_str(),      po::value<std::string >()->default_value(UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV     ), "subEnvs that will write to generic data output file"         )
     (m_option_pseq_dataOutputPeriod.c_str(),     po::value<unsigned int>()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV     ), "period of message display during param sequence generation"  )
     (m_option_pseq_dataOutputFileName.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV  ), "name of data output file for parameters"                     )
     (m_option_pseq_dataOutputFileType.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV  ), "type of data output file for parameters"                     )
     (m_option_pseq_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV), "subEnvs that will write to data output file for parameters"  )
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     (m_option_pseq_computeStats.c_str(),         po::value<bool        >()->default_value(UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV          ), "compute statistics on sequence of parameter"                 )
 #endif
     (m_option_qseq_dataInputFileName.c_str(),    po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV   ), "name of data input file for qois"                            )
     (m_option_qseq_dataInputFileType.c_str(),    po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV   ), "type of data input file for qois"                            )
     (m_option_qseq_size.c_str(),                 po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_SIZE_ODV                   ), "size of qoi sequence"                                        )
     (m_option_qseq_displayPeriod.c_str(),        po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV         ), "period of message display during qoi sequence generation"    )
     (m_option_qseq_measureRunTimes.c_str(),      po::value<bool        >()->default_value(UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV      ), "measure run times"                                           )
     (m_option_qseq_dataOutputPeriod.c_str(),     po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV     ), "period of message display during qoi sequence generation"    )
     (m_option_qseq_dataOutputFileName.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV  ), "name of data output file for qois"                           )
     (m_option_qseq_dataOutputFileType.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV  ), "type of data output file for qois"                           )
     (m_option_qseq_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV), "subEnvs that will write to data output file for qois"        )
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     (m_option_qseq_computeStats.c_str(),         po::value<bool        >()->default_value(UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV          ), "compute statistics on sequence of qoi"                       )
 #endif
    ;
 
   return;
 }

void QUESO::MonteCarloSGOptions::getMyOptionValues ( po::options_description & optionsDesc )

private

Gets the sequence options.

Definition at line 301 of file MonteCarloSGOptions.C.

Referenced by scanOptionsValues().

 {
   if (m_env.allOptionsMap().count(m_option_help)) {
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << optionsDesc
                               << std::endl;
     }
   }
 
   if (m_env.allOptionsMap().count(m_option_dataOutputFileName)) {
     m_ov.m_dataOutputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_dataOutputFileName]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_dataOutputAllowedSet)) {
     m_ov.m_dataOutputAllowedSet.clear();
     std::vector<double> tmpAllow(0,0.);
     std::string inputString = m_env.allOptionsMap()[m_option_dataOutputAllowedSet].as<std::string>();
     MiscReadDoublesFromString(inputString,tmpAllow);
 
     if (tmpAllow.size() > 0) {
       for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
         m_ov.m_dataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
       }
     }
   }
 
   if (m_env.allOptionsMap().count(m_option_pseq_dataOutputPeriod)) {
     m_ov.m_pseqDataOutputPeriod = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_dataOutputPeriod]).as<unsigned int>();
   }
 
   if (m_env.allOptionsMap().count(m_option_pseq_dataOutputFileName)) {
     m_ov.m_pseqDataOutputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_dataOutputFileName]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_pseq_dataOutputFileType)) {
     m_ov.m_pseqDataOutputFileType = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_dataOutputFileType]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_pseq_dataOutputAllowedSet)) {
     m_ov.m_pseqDataOutputAllowedSet.clear();
     std::vector<double> tmpAllow(0,0.);
     std::string inputString = m_env.allOptionsMap()[m_option_pseq_dataOutputAllowedSet].as<std::string>();
     MiscReadDoublesFromString(inputString,tmpAllow);
 
     if (tmpAllow.size() > 0) {
       for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
         m_ov.m_pseqDataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
       }
     }
   }
 
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_env.allOptionsMap().count(m_option_pseq_computeStats)) {
     m_ov.m_pseqComputeStats = ((const po::variable_value&) m_env.allOptionsMap()[m_option_pseq_computeStats]).as<bool>();
   }
 #endif
   if (m_env.allOptionsMap().count(m_option_qseq_dataInputFileName)) {
     m_ov.m_qseqDataInputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataInputFileName]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_dataInputFileType)) {
     m_ov.m_qseqDataInputFileType = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataInputFileType]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_size)) {
     m_ov.m_qseqSize = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_size]).as<unsigned int>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_displayPeriod)) {
     m_ov.m_qseqDisplayPeriod = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_displayPeriod]).as<unsigned int>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_measureRunTimes)) {
     m_ov.m_qseqMeasureRunTimes = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_measureRunTimes]).as<bool>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_dataOutputPeriod)) {
     m_ov.m_qseqDataOutputPeriod = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataOutputPeriod]).as<unsigned int>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_dataOutputFileName)) {
     m_ov.m_qseqDataOutputFileName = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataOutputFileName]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_dataOutputFileType)) {
     m_ov.m_qseqDataOutputFileType = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_dataOutputFileType]).as<std::string>();
   }
 
   if (m_env.allOptionsMap().count(m_option_qseq_dataOutputAllowedSet)) {
     m_ov.m_qseqDataOutputAllowedSet.clear();
     std::vector<double> tmpAllow(0,0.);
     std::string inputString = m_env.allOptionsMap()[m_option_qseq_dataOutputAllowedSet].as<std::string>();
     MiscReadDoublesFromString(inputString,tmpAllow);
 
     if (tmpAllow.size() > 0) {
       for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
         m_ov.m_qseqDataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
       }
     }
   }
 
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_env.allOptionsMap().count(m_option_qseq_computeStats)) {
     m_ov.m_qseqComputeStats = ((const po::variable_value&) m_env.allOptionsMap()[m_option_qseq_computeStats]).as<bool>();
   }
 #endif
   return;
 }

void QUESO::MonteCarloSGOptions::print ( std::ostream & os ) const

It prints the option values.

Definition at line 411 of file MonteCarloSGOptions.C.

Referenced by QUESO::operator<<().

 {
   os <<         m_option_dataOutputFileName   << " = " << m_ov.m_dataOutputFileName
      << "\n" << m_option_dataOutputAllowedSet << " = ";
   for (std::set<unsigned int>::iterator setIt = m_ov.m_dataOutputAllowedSet.begin(); setIt != m_ov.m_dataOutputAllowedSet.end(); ++setIt) {
     os << *setIt << " ";
   }
   os << "\n" << m_option_pseq_dataOutputPeriod     << " = " << m_ov.m_pseqDataOutputPeriod
      << "\n" << m_option_pseq_dataOutputFileName   << " = " << m_ov.m_pseqDataOutputFileName
      << "\n" << m_option_pseq_dataOutputFileType   << " = " << m_ov.m_pseqDataOutputFileType
      << "\n" << m_option_pseq_dataOutputAllowedSet << " = ";
   for (std::set<unsigned int>::iterator setIt = m_ov.m_pseqDataOutputAllowedSet.begin(); setIt != m_ov.m_pseqDataOutputAllowedSet.end(); ++setIt) {
     os << *setIt << " ";
   }
   os
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
      << "\n" << m_option_pseq_computeStats         << " = " << m_ov.m_pseqComputeStats
 #endif
      << "\n" << m_option_qseq_dataInputFileName    << " = " << m_ov.m_qseqDataInputFileName
      << "\n" << m_option_qseq_dataInputFileType    << " = " << m_ov.m_qseqDataInputFileType
      << "\n" << m_option_qseq_size                 << " = " << m_ov.m_qseqSize
      << "\n" << m_option_qseq_displayPeriod        << " = " << m_ov.m_qseqDisplayPeriod
      << "\n" << m_option_qseq_measureRunTimes      << " = " << m_ov.m_qseqMeasureRunTimes
      << "\n" << m_option_qseq_dataOutputPeriod     << " = " << m_ov.m_qseqDataOutputPeriod
      << "\n" << m_option_qseq_dataOutputFileName   << " = " << m_ov.m_qseqDataOutputFileName
      << "\n" << m_option_qseq_dataOutputFileType   << " = " << m_ov.m_qseqDataOutputFileType
      << "\n" << m_option_qseq_dataOutputAllowedSet << " = ";
   for (std::set<unsigned int>::iterator setIt = m_ov.m_qseqDataOutputAllowedSet.begin(); setIt != m_ov.m_qseqDataOutputAllowedSet.end(); ++setIt) {
     os << *setIt << " ";
   }
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   os << "\n" << m_option_qseq_computeStats << " = " << m_ov.m_qseqComputeStats;
 #endif
 
   return;
 }

void QUESO::MonteCarloSGOptions::scanOptionsValues ( )

It scans the option values from the options input file.

Definition at line 240 of file MonteCarloSGOptions.C.

References defineMyOptions(), getMyOptionValues(), m_env, m_optionsDesc, m_ov, m_prefix, QUESO::BaseEnvironment::scanInputFileForMyOptions(), QUESO::BaseEnvironment::subDisplayFile(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(m_optionsDesc == NULL,
                       m_env.worldRank(),
                       "MonteCarloSGOptions::scanOptionsValues()",
                       "m_optionsDesc variable is NULL");
 
   defineMyOptions                (*m_optionsDesc);
   m_env.scanInputFileForMyOptions(*m_optionsDesc);
   getMyOptionValues              (*m_optionsDesc);
 
   if (m_env.subDisplayFile() != NULL) {
     *m_env.subDisplayFile() << "In MonteCarloSGOptions::scanOptionsValues()"
                             << ": after reading values of options with prefix '" << m_prefix
                             << "', state of object is:"
                             << "\n" << *this
                             << std::endl;
   }
 
   // dakota
 #ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
   if (m_ov.m_pseqComputeStats) m_pseqStatisticalOptionsObj =
     new SequenceStatisticalOptions(m_env,m_prefix + "pseq_");
   if (m_ov.m_qseqComputeStats) m_qseqStatisticalOptionsObj =
     new SequenceStatisticalOptions(m_env,m_prefix + "qseq_");
 #endif
   return;
 }