MonteCarloSGOptions.C

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// QUESO - a library to support the Quantification of Uncertainty
// for Estimation, Simulation and Optimization
//
// Copyright (C) 2008,2009,2010,2011,2012,2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-

#include <queso/MonteCarloSGOptions.h>
#include <queso/Miscellaneous.h>

// -------------------------------------------------
// McOptionsValues --------------------------
// -------------------------------------------------

namespace QUESO {

// Default constructor -----------------------------
McOptionsValues::McOptionsValues(
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  const SsOptionsValues* alternativePSsOptionsValues,
  const SsOptionsValues* alternativeQSsOptionsValues
#endif
  )
  :
  m_dataOutputFileName         (UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV     ),
//m_dataOutputAllowedSet       (),
  m_pseqDataOutputPeriod       (UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV   ),
  m_pseqDataOutputFileName     (UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV),
  m_pseqDataOutputFileType     (UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV),
//m_pseqDataOutputAllowedSet   (),
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_pseqComputeStats           (UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV        ),
#endif
  m_qseqDataInputFileName      (UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV ),
  m_qseqDataInputFileType      (UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV ),
  m_qseqSize                   (UQ_MOC_SG_QSEQ_SIZE_ODV                 ),
  m_qseqDisplayPeriod          (UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV       ),
  m_qseqMeasureRunTimes        (UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV    ),
  m_qseqDataOutputPeriod       (UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV   ),
  m_qseqDataOutputFileName     (UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV),
  m_qseqDataOutputFileType     (UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV)
//m_qseqDataOutputAllowedSet   (),
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  ,
  m_qseqComputeStats           (UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV        ),
  m_alternativePSsOptionsValues(),
  m_alternativeQSsOptionsValues()
#endif
{
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  if (alternativePSsOptionsValues) m_alternativePSsOptionsValues = *alternativePSsOptionsValues;
  if (alternativeQSsOptionsValues) m_alternativeQSsOptionsValues = *alternativeQSsOptionsValues;
#endif
}
// Copy constructor --------------------------------
McOptionsValues::McOptionsValues(const McOptionsValues& src)
{
  this->copy(src);
}
// Destructor ---------------------------------------
McOptionsValues::~McOptionsValues()
{
}
// Set methods --------------------------------------
McOptionsValues&
McOptionsValues::operator=(const McOptionsValues& rhs)
{
  this->copy(rhs);
  return *this;
}
// Private methods-----------------------------------
void
McOptionsValues::copy(const McOptionsValues& src)
{
  m_dataOutputFileName          = src.m_dataOutputFileName;
  m_dataOutputAllowedSet        = src.m_dataOutputAllowedSet;
  m_pseqDataOutputPeriod        = src.m_pseqDataOutputPeriod;
  m_pseqDataOutputFileName      = src.m_pseqDataOutputFileName;
  m_pseqDataOutputFileType      = src.m_pseqDataOutputFileType;
  m_pseqDataOutputAllowedSet    = src.m_pseqDataOutputAllowedSet; 
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_pseqComputeStats            = src.m_pseqComputeStats;
#endif
  m_qseqDataInputFileName       = src.m_qseqDataInputFileName;
  m_qseqDataInputFileType       = src.m_qseqDataInputFileType;
  m_qseqSize                    = src.m_qseqSize;
  m_qseqDisplayPeriod           = src.m_qseqDisplayPeriod;
  m_qseqMeasureRunTimes         = src.m_qseqMeasureRunTimes;
  m_qseqDataOutputPeriod        = src.m_qseqDataOutputPeriod;
  m_qseqDataOutputFileName      = src.m_qseqDataOutputFileName;
  m_qseqDataOutputFileType      = src.m_qseqDataOutputFileType;
  m_qseqDataOutputAllowedSet    = src.m_qseqDataOutputAllowedSet; 
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_qseqComputeStats            = src.m_qseqComputeStats;
#endif

#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  m_alternativePSsOptionsValues = src.m_alternativePSsOptionsValues;
  m_alternativeQSsOptionsValues = src.m_alternativeQSsOptionsValues;
#endif

  return;
}

// --------------------------------------------------
//MonteCarloSGOptions ------------------------
// --------------------------------------------------

// Default constructor -----------------------------
MonteCarloSGOptions::MonteCarloSGOptions(
  const BaseEnvironment& env, 
  const char*                   prefix)
  :
#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");
}
// Constructor 2 -----------------------------------
MonteCarloSGOptions::MonteCarloSGOptions(
  const BaseEnvironment& env, 
  const char*                   prefix,
  const McOptionsValues& alternativeOptionsValues)
  :
  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
}
// Destructor --------------------------------------
MonteCarloSGOptions::~MonteCarloSGOptions()
{
#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;
} 
// I/O methods -------------------------------------
void
MonteCarloSGOptions::scanOptionsValues()
{
  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;
}
// Private methods ---------------------------------
void
MonteCarloSGOptions::defineMyOptions(po::options_description& optionsDesc) const
{
  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
MonteCarloSGOptions::getMyOptionValues(po::options_description& optionsDesc)
{
  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
MonteCarloSGOptions::print(std::ostream& os) const
{
  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;
}

std::ostream& operator<<(std::ostream& os, const MonteCarloSGOptions& obj)
{
  obj.print(os);

  return os;
}

}  // End namespace QUESO