// I/O methods---------------------------------------
void
EnvironmentOptions::scanOptionsValues()
{
queso_deprecated();
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
queso_require_msg(m_optionsDesc, "m_optionsDesc variable is NULL");
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
defineMyOptions (*m_optionsDesc);
m_env.scanInputFileForMyOptions(*m_optionsDesc);
getMyOptionValues (*m_optionsDesc);
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
// 'm_subDisplayOutputFile' is still not available at this moment. Use 'std::cout'
//if (m_env.subScreenFile() != NULL) {
// *m_env.subScreenFile()
if ((m_env.fullRank() == 0) && (m_env.displayVerbosity() >= 3)) {
std::cout << "In EnvironmentOptions::scanOptionsValues()"
<< ": after reading values of options with prefix '" << m_prefix
<< "', state of object is:"
<< "\n" << *this
<< std::endl;
}
return;
}
// Stats methods-------------------------------------
const std::vector<double>&
FiniteDistribution::weights() const
{
queso_deprecated();
return m_weights;
}
// Private methods ----------------------------------
void
EnvironmentOptions::defineMyOptions(boost::program_options::options_description& optionsDesc) const
{
queso_deprecated();
#ifdef QUESO_MEMORY_DEBUGGING
std::cout << "In EnvOptions::defineMyOptions(), before add_options()" << std::endl;
#endif
optionsDesc.add_options()
(m_option_help.c_str(), "produce help message for environment" )
(m_option_numSubEnvironments.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_ENV_NUM_SUB_ENVIRONMENTS_ODV), "number of subEnvironments" )
(m_option_subDisplayFileName.c_str(), boost::program_options::value<std::string >()->default_value(UQ_ENV_SUB_DISPLAY_FILE_NAME_ODV), "output filename for subscreen writing" )
(m_option_subDisplayAllowAll.c_str(), boost::program_options::value<bool >()->default_value(UQ_ENV_SUB_DISPLAY_ALLOW_ALL_ODV), "Allow all processors to write to output file" )
(m_option_subDisplayAllowInter0.c_str(), boost::program_options::value<bool >()->default_value(UQ_ENV_SUB_DISPLAY_ALLOW_INTER0_ODV), "Allow all inter0 nodes to write to output file")
(m_option_subDisplayAllowedSet.c_str(), boost::program_options::value<std::string >()->default_value(UQ_ENV_SUB_DISPLAY_ALLOWED_SET_ODV), "subEnvs that will write to output file" )
(m_option_displayVerbosity.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_ENV_DISPLAY_VERBOSITY_ODV), "set verbosity" )
(m_option_syncVerbosity.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_ENV_SYNC_VERBOSITY_ODV), "set sync verbosity" )
(m_option_checkingLevel.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_ENV_CHECKING_LEVEL_ODV), "set checking level" )
(m_option_rngType.c_str(), boost::program_options::value<std::string >()->default_value(UQ_ENV_RNG_TYPE_ODV), "set rngType" )
(m_option_seed.c_str(), boost::program_options::value<int >()->default_value(UQ_ENV_SEED_ODV), "set seed" )
(m_option_platformName.c_str(), boost::program_options::value<std::string >()->default_value(UQ_ENV_PLATFORM_NAME_ODV), "platform name" )
(m_option_identifyingString.c_str(), boost::program_options::value<std::string >()->default_value(UQ_ENV_IDENTIFYING_STRING_ODV), "identifying string" )
//(m_option_numDebugParams.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_ENV_NUM_DEBUG_PARAMS_ODV), "set number of debug parameters" )
;
#ifdef QUESO_MEMORY_DEBUGGING
std::cout << "In EnvOptions::defineMyOptions(), after add_options()" << std::endl;
#endif
return;
}
// Destructor ---------------------------------------
FiniteDistribution::~FiniteDistribution()
{
queso_deprecated();
m_map.empty();
m_weights.clear();
}
// Misc methods--------------------------------------
const BaseEnvironment&
FiniteDistribution::env() const
{
queso_deprecated();
return m_env;
}
// Constructor with alternative values --------------
EnvironmentOptions::EnvironmentOptions(
const BaseEnvironment& env,
const char* prefix,
const EnvOptionsValues& alternativeOptionsValues)
:
m_ov (alternativeOptionsValues),
m_env (env),
m_prefix ((std::string)(prefix) + "env_"),
m_optionsDesc (NULL),
m_option_help (m_prefix + "help" ),
m_option_numSubEnvironments (m_prefix + "numSubEnvironments" ),
m_option_subDisplayFileName (m_prefix + "subDisplayFileName" ),
m_option_subDisplayAllowAll (m_prefix + "subDisplayAllowAll" ),
m_option_subDisplayAllowInter0(m_prefix + "subDisplayAllowInter0"),
m_option_subDisplayAllowedSet (m_prefix + "subDisplayAllowedSet" ),
m_option_displayVerbosity (m_prefix + "displayVerbosity" ),
m_option_syncVerbosity (m_prefix + "syncVerbosity" ),
m_option_checkingLevel (m_prefix + "checkingLevel" ),
m_option_rngType (m_prefix + "rngType" ),
m_option_seed (m_prefix + "seed" ),
m_option_platformName (m_prefix + "platformName" ),
m_option_identifyingString (m_prefix + "identifyingString" )
{
queso_deprecated();
queso_require_equal_to_msg(m_env.optionsInputFileName(), "", "this constructor is incompatible with the existence of an options input file");
if (m_env.subDisplayFile() != NULL) {
*m_env.subDisplayFile() << "In EnvironmentOptions::constructor(2)"
<< ": after setting values of options with prefix '" << m_prefix
<< "', state of object is:"
<< "\n" << *this
<< std::endl;
}
}
GpmsaComputerModelOptions::GpmsaComputerModelOptions(
const BaseEnvironment& env,
const char* prefix)
:
m_ov (),
m_prefix ((std::string)(prefix) + "gcm_"),
m_env (env),
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
m_optionsDesc (new boost::program_options::options_description("Mixed Inverse Problem options")),
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
m_option_help (m_prefix + "help" ),
m_option_checkAgainstPreviousSample (m_prefix + "checkAgainstPreviousSample" ),
m_option_dataOutputFileName (m_prefix + "dataOutputFileName" ),
m_option_dataOutputAllowAll (m_prefix + "dataOutputAllowAll" ),
m_option_dataOutputAllowedSet (m_prefix + "dataOutputAllowedSet" ),
m_option_priorSeqNumSamples (m_prefix + "priorSeqNumSamples" ),
m_option_priorSeqDataOutputFileName (m_prefix + "priorSeqDataOutputFileName" ),
m_option_priorSeqDataOutputFileType (m_prefix + "priorSeqDataOutputFileType" ),
m_option_priorSeqDataOutputAllowAll (m_prefix + "priorSeqDataOutputAllowAll" ),
m_option_priorSeqDataOutputAllowedSet (m_prefix + "priorSeqDataOutputAllowedSet" ),
m_option_nuggetValueForBtWyB (m_prefix + "nuggetValueForBtWyB" ),
m_option_nuggetValueForBtWyBInv (m_prefix + "nuggetValueForBtWyBInv" ),
m_option_formCMatrix (m_prefix + "formCMatrix" ),
m_option_useTildeLogicForRankDefficientC(m_prefix + "useTildeLogicForRankDefficientC"),
m_option_predLag (m_prefix + "predLag" ),
m_option_predVUsBySamplingRVs (m_prefix + "predVUsBySamplingRVs" ),
m_option_predVUsBySummingRVs (m_prefix + "predVUsBySummingRVs" ),
m_option_predVUsAtKeyPoints (m_prefix + "predVUsAtKeyPoints" ),
m_option_predWsBySamplingRVs (m_prefix + "predWsBySamplingRVs" ),
m_option_predWsBySummingRVs (m_prefix + "predWsBySummingRVs" ),
m_option_predWsAtKeyPoints (m_prefix + "predWsAtKeyPoints" )
{
queso_deprecated();
queso_require_not_equal_to_msg(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the abscense of an options input file"));
}
void
GpmsaComputerModelOptions::scanOptionsValues()
{
queso_deprecated();
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
queso_require_msg(m_optionsDesc, "m_optionsDesc variable is NULL");
defineMyOptions (*m_optionsDesc);
m_env.scanInputFileForMyOptions(*m_optionsDesc);
//std::cout << "scan 000\n"
// << std::endl;
getMyOptionValues (*m_optionsDesc);
//std::cout << "scan 001\n"
// << std::endl;
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
if (m_env.subDisplayFile() != NULL) {
*m_env.subDisplayFile() << "In GpmsaComputerModelOptions::scanOptionsValues()"
<< ": after reading values of options with prefix '" << m_prefix
<< "', state of object is:"
<< "\n" << *this
<< std::endl;
}
return;
}
void
GpmsaComputerModelOptions::defineMyOptions(boost::program_options::options_description& optionsDesc) const
{
queso_deprecated();
optionsDesc.add_options()
(m_option_help.c_str(), "produce help message for mixed inverse problem")
(m_option_checkAgainstPreviousSample.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_CHECK_AGAINST_PREVIOUS_SAMPLE_ODV ), "check against previous sample" )
(m_option_dataOutputFileName.c_str(), boost::program_options::value<std::string >()->default_value(UQ_GCM_DATA_OUTPUT_FILE_NAME_ODV ), "name of data output file" )
(m_option_dataOutputAllowAll.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_DATA_OUTPUT_ALLOW_ALL_ODV ), "allow all or not" )
(m_option_dataOutputAllowedSet.c_str(), boost::program_options::value<std::string >()->default_value(UQ_GCM_DATA_OUTPUT_ALLOWED_SET_ODV ), "subEnvs that will write to data output file" )
(m_option_priorSeqNumSamples.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_GCM_PRIOR_SEQ_NUM_SAMPLES_ODV ), "prior sequence size" )
(m_option_priorSeqDataOutputFileName.c_str(), boost::program_options::value<std::string >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_FILE_NAME_ODV ), "prior sequence data output filename" )
(m_option_priorSeqDataOutputFileType.c_str(), boost::program_options::value<std::string >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_FILE_TYPE_ODV ), "prior sequence data output filetype" )
(m_option_priorSeqDataOutputAllowAll.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_ALLOW_ALL_ODV ), "allow all or not" )
(m_option_priorSeqDataOutputAllowedSet.c_str(), boost::program_options::value<std::string >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_ALLOWED_SET_ODV ), "subEnvs that will write to data output file" )
(m_option_nuggetValueForBtWyB.c_str(), boost::program_options::value<double >()->default_value(UQ_GCM_NUGGET_VALUE_FOR_BT_WY_B_ODV ), "nugget value for Bt_Wy_W matrix" )
(m_option_nuggetValueForBtWyBInv.c_str(), boost::program_options::value<double >()->default_value(UQ_GCM_NUGGET_VALUE_FOR_BT_WY_B_INV_ODV ), "nugget value for Bt_Wy_W inverse matrix" )
(m_option_formCMatrix.c_str(), boost::program_options::value<double >()->default_value(UQ_GCM_FORM_C_MATRIX_ODV ), "form C matrix" )
(m_option_useTildeLogicForRankDefficientC.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_USE_TILDE_LOGIC_FOR_RANK_DEFFICIENT_C_ODV), "use tilde logic for rank defficient C" )
(m_option_predLag.c_str(), boost::program_options::value<unsigned int>()->default_value(UQ_GCM_PRED_LAG_ODV ), "predLag" )
(m_option_predVUsBySamplingRVs.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRED_VUS_BY_SAMPLING_RVS_ODV ), "predVUsBySamplingRVs" )
(m_option_predVUsBySummingRVs.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRED_VUS_BY_SUMMING_RVS_ODV ), "predVUsBySummingRVs" )
(m_option_predVUsAtKeyPoints.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRED_VUS_AT_KEY_POINTS_ODV ), "predVUsAtKeyPoints" )
(m_option_predWsBySamplingRVs.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRED_WS_BY_SAMPLING_RVS_ODV ), "predWsBySamplingRVs" )
(m_option_predWsBySummingRVs.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRED_WS_BY_SUMMING_RVS_ODV ), "predWsBySummingRVs" )
(m_option_predWsAtKeyPoints.c_str(), boost::program_options::value<bool >()->default_value(UQ_GCM_PRED_WS_AT_KEY_POINTS_ODV ), "predWsAtKeyPoints" )
;
return;
}
void
GpmsaComputerModelOptions::print(std::ostream& os) const
{
queso_deprecated();
os << "\n" << m_option_checkAgainstPreviousSample << " = " << m_ov.m_checkAgainstPreviousSample
<< "\n" << m_option_dataOutputFileName << " = " << m_ov.m_dataOutputFileName
<< "\n" << m_option_dataOutputAllowAll << " = " << m_ov.m_dataOutputAllowAll
<< "\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_priorSeqNumSamples << " = " << m_ov.m_priorSeqNumSamples
<< "\n" << m_option_priorSeqDataOutputFileName << " = " << m_ov.m_priorSeqDataOutputFileName
<< "\n" << m_option_priorSeqDataOutputFileType << " = " << m_ov.m_priorSeqDataOutputFileType
<< "\n" << m_option_priorSeqDataOutputAllowAll << " = " << m_ov.m_priorSeqDataOutputAllowAll
<< "\n" << m_option_priorSeqDataOutputAllowedSet << " = ";
for (std::set<unsigned int>::iterator setIt = m_ov.m_priorSeqDataOutputAllowedSet.begin(); setIt != m_ov.m_priorSeqDataOutputAllowedSet.end(); ++setIt) {
os << *setIt << " ";
}
os << "\n" << m_option_nuggetValueForBtWyB << " = " << m_ov.m_nuggetValueForBtWyB
<< "\n" << m_option_nuggetValueForBtWyBInv << " = " << m_ov.m_nuggetValueForBtWyBInv
<< "\n" << m_option_formCMatrix << " = " << m_ov.m_formCMatrix
<< "\n" << m_option_useTildeLogicForRankDefficientC << " = " << m_ov.m_useTildeLogicForRankDefficientC
<< "\n" << m_option_predLag << " = " << m_ov.m_predLag
<< "\n" << m_option_predVUsBySamplingRVs << " = " << m_ov.m_predVUsBySamplingRVs
<< "\n" << m_option_predVUsBySummingRVs << " = " << m_ov.m_predVUsBySummingRVs
<< "\n" << m_option_predVUsAtKeyPoints << " = " << m_ov.m_predVUsAtKeyPoints
<< "\n" << m_option_predWsBySamplingRVs << " = " << m_ov.m_predWsBySamplingRVs
<< "\n" << m_option_predWsBySummingRVs << " = " << m_ov.m_predWsBySummingRVs
<< "\n" << m_option_predWsAtKeyPoints << " = " << m_ov.m_predWsAtKeyPoints
<< std::endl;
return;
}
// Default constructor ------------------------------
EnvironmentOptions::EnvironmentOptions(
const BaseEnvironment& env,
const char* prefix)
:
m_ov (),
m_env (env),
m_prefix ((std::string)(prefix) + "env_"),
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
m_optionsDesc (new boost::program_options::options_description("Environment options")),
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
m_option_help (m_prefix + "help" ),
m_option_numSubEnvironments (m_prefix + "numSubEnvironments" ),
m_option_subDisplayFileName (m_prefix + "subDisplayFileName" ),
m_option_subDisplayAllowAll (m_prefix + "subDisplayAllowAll" ),
m_option_subDisplayAllowInter0(m_prefix + "subDisplayAllowInter0"),
m_option_subDisplayAllowedSet (m_prefix + "subDisplayAllowedSet" ),
m_option_displayVerbosity (m_prefix + "displayVerbosity" ),
m_option_syncVerbosity (m_prefix + "syncVerbosity" ),
m_option_checkingLevel (m_prefix + "checkingLevel" ),
m_option_rngType (m_prefix + "rngType" ),
m_option_seed (m_prefix + "seed" ),
m_option_platformName (m_prefix + "platformName" ),
m_option_identifyingString (m_prefix + "identifyingString" )
{
queso_deprecated();
queso_require_not_equal_to_msg(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the abscense of an options input file"));
}
// Destructor ---------------------------------------
EnvironmentOptions::~EnvironmentOptions()
{
queso_deprecated();
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
if (m_optionsDesc) delete m_optionsDesc;
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
}
std::ostream& operator<<(std::ostream& os, const GpmsaComputerModelOptions& obj)
{
queso_deprecated();
obj.print(os);
return os;
}
// Operator outside class definition ----------------
std::ostream& operator<<(std::ostream& os, const EnvironmentOptions& obj)
{
queso_deprecated();
obj.print(os);
return os;
}
GpmsaComputerModelOptions::~GpmsaComputerModelOptions()
{
queso_deprecated();
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
if (m_optionsDesc) delete m_optionsDesc;
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
}
GpmsaComputerModelOptions::GpmsaComputerModelOptions(
const BaseEnvironment& env,
const char* prefix,
const GcmOptionsValues& alternativeOptionsValues)
:
m_ov (alternativeOptionsValues),
m_prefix ((std::string)(prefix) + "gcm_"),
m_env (env),
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
m_optionsDesc (NULL),
#endif // DISABLE_BOOST_PROGRAM_OPTIONS
m_option_help (m_prefix + "help" ),
m_option_checkAgainstPreviousSample (m_prefix + "checkAgainstPreviousSample" ),
m_option_dataOutputFileName (m_prefix + "dataOutputFileName" ),
m_option_dataOutputAllowAll (m_prefix + "dataOutputAllowAll" ),
m_option_dataOutputAllowedSet (m_prefix + "dataOutputAllowedSet" ),
m_option_priorSeqNumSamples (m_prefix + "priorSeqNumSamples" ),
m_option_priorSeqDataOutputFileName (m_prefix + "priorSeqDataOutputFileName" ),
m_option_priorSeqDataOutputFileType (m_prefix + "priorSeqDataOutputFileType" ),
m_option_priorSeqDataOutputAllowAll (m_prefix + "priorSeqDataOutputAllowAll" ),
m_option_priorSeqDataOutputAllowedSet (m_prefix + "priorSeqDataOutputAllowedSet" ),
m_option_nuggetValueForBtWyB (m_prefix + "nuggetValueForBtWyB" ),
m_option_nuggetValueForBtWyBInv (m_prefix + "nuggetValueForBtWyBInv" ),
m_option_formCMatrix (m_prefix + "formCMatrix" ),
m_option_useTildeLogicForRankDefficientC(m_prefix + "useTildeLogicForRankDefficientC"),
m_option_predLag (m_prefix + "predLag" ),
m_option_predVUsBySamplingRVs (m_prefix + "predVUsBySamplingRVs" ),
m_option_predVUsBySummingRVs (m_prefix + "predVUsBySummingRVs" ),
m_option_predVUsAtKeyPoints (m_prefix + "predVUsAtKeyPoints" ),
m_option_predWsBySamplingRVs (m_prefix + "predWsBySamplingRVs" ),
m_option_predWsBySummingRVs (m_prefix + "predWsBySummingRVs" ),
m_option_predWsAtKeyPoints (m_prefix + "predWsAtKeyPoints" )
{
queso_deprecated();
queso_require_equal_to_msg(m_env.optionsInputFileName(), std::string(""), std::string("this constructor is incompatible with the existence of an options input file"));
if (m_env.subDisplayFile() != NULL) {
*m_env.subDisplayFile() << "In GpmsaComputerModelOptions::constructor(2)"
<< ": after setting values of options with prefix '" << m_prefix
<< "', state of object is:"
<< "\n" << *this
<< std::endl;
}
}
GslOptimizer::SolverType GslOptimizer::string_to_enum( std::string& solver )
{
SolverType solver_type;
if( solver == std::string("fletcher_reeves_cg") )
solver_type = FLETCHER_REEVES_CG;
else if( solver == std::string("polak_ribiere_cg") )
solver_type = POLAK_RIBIERE_CG;
else if( solver == std::string("bfgs") )
solver_type = BFGS;
else if( solver == std::string("bfgs2") )
solver_type = BFGS2;
else if( solver == std::string("steepest_decent") ) {
queso_deprecated();
solver_type = STEEPEST_DESCENT;
}
else if( solver == std::string("steepest_descent") )
solver_type = STEEPEST_DESCENT;
else if( solver == std::string("nelder_mead") )
solver_type = NELDER_MEAD;
else if( solver == std::string("nelder_mead2") )
solver_type = NELDER_MEAD2;
else if( solver == std::string("nelder_mead2_rand") )
solver_type = NELDER_MEAD2_RAND;
else
{
if( m_objectiveFunction.domainSet().env().fullRank() == 0 )
{
std::cerr << "Error: Invalid GslOptimizer solver name: " << solver << std::endl
<< " Valids choices are: fletcher_reeves_cg" << std::endl
<< " polak_ribiere_cg" << std::endl
<< " bfgs" << std::endl
<< " bfgs2" << std::endl
<< " steepest_descent" << std::endl
<< " nelder_mead" << std::endl
<< " nelder_mead2" << std::endl
<< " nelder_mead2_rand" << std::endl;
}
queso_error();
}
return solver_type;
}
//---------------------------------------------------
unsigned int
FiniteDistribution::sample() const
{
queso_deprecated();
unsigned int result = 0;
double aux = m_env.rngObject()->uniformSample();
queso_require_msg(!((aux < 0) || (aux > 1.)), "invalid uniform");
if (aux == 0.) {
result = 0;
}
else if (aux == 1.) {
result = m_map.find(aux)->second;
}
else {
result = m_map.upper_bound(aux)->second;
//if (m_map.upper_bound(aux)->second == 0) {
// result = 0;
//}
//else {
// result = m_map.upper_bound(aux)->second-1;
//}
}
#if 0 // WE insert 'i' in map, not 'j'. So, the tests below don't make sense
if (result >= m_map.size()) {
std::cerr << "In FiniteDistribution::sample()"
<< ": aux = " << aux
<< ", m_map.size() = " << m_map.size()
<< ", result = " << result
<< std::endl;
}
queso_require_less_msg(result, m_map.size(), "invalid result");
#endif
return result;
}
// --------------------------------------------------
void
EnvironmentOptions::print(std::ostream& os) const
{
queso_deprecated();
os << m_option_numSubEnvironments << " = " << m_ov.m_numSubEnvironments
<< "\n" << m_option_subDisplayFileName << " = " << m_ov.m_subDisplayFileName
<< "\n" << m_option_subDisplayAllowAll << " = " << m_ov.m_subDisplayAllowAll
//<< "\n" << m_option_subDisplayAllowInter0 << " = " << m_ov.m_subDisplayAllowInter0
<< "\n" << m_option_subDisplayAllowedSet << " = ";
for (std::set<unsigned int>::iterator setIt = m_ov.m_subDisplayAllowedSet.begin(); setIt != m_ov.m_subDisplayAllowedSet.end(); ++setIt) {
os << *setIt << " ";
}
os << "\n" << m_option_displayVerbosity << " = " << m_ov.m_displayVerbosity
<< "\n" << m_option_syncVerbosity << " = " << m_ov.m_syncVerbosity
<< "\n" << m_option_checkingLevel << " = " << m_ov.m_checkingLevel
<< "\n" << m_option_rngType << " = " << m_ov.m_rngType
<< "\n" << m_option_seed << " = " << m_ov.m_seed
<< "\n" << m_option_platformName << " = " << m_ov.m_platformName
<< "\n" << m_option_identifyingString << " = " << m_ov.m_identifyingString
//<< "\n" << m_option_numDebugParams << " = " << m_ov.m_numDebugParams
<< std::endl;
return;
}
void GslOptimizer::set_solver_type( SolverType solver )
{
queso_deprecated();
m_solver_type = solver;
}
void GslOptimizer::set_step_size( double step_size )
{
queso_deprecated();
m_fdfstep_size = step_size;
}
void
GpmsaComputerModelOptions::getMyOptionValues(boost::program_options::options_description& optionsDesc)
{
queso_deprecated();
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_checkAgainstPreviousSample)) {
m_ov.m_checkAgainstPreviousSample = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_checkAgainstPreviousSample]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_dataOutputFileName)) {
m_ov.m_dataOutputFileName = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_dataOutputFileName]).as<std::string>();
}
if (m_env.allOptionsMap().count(m_option_dataOutputAllowAll)) {
m_ov.m_dataOutputAllowAll = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_dataOutputAllowAll]).as<bool>();
}
if (m_ov.m_dataOutputAllowAll) {
m_ov.m_dataOutputAllowedSet.insert(m_env.subId());
}
else 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]);
}
}
}
//std::cout << "In GpmsaComputerModelOptions::getMyOptionValues(), m_option_priorSeqNumSamples = " << m_option_priorSeqNumSamples << "___" << std::endl;
if (m_env.allOptionsMap().count(m_option_priorSeqNumSamples)) {
//std::cout << "In GpmsaComputerModelOptions::getMyOptionValues(), going to read m_option_priorSeqNumSamples..." << std::endl;
m_ov.m_priorSeqNumSamples = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_priorSeqNumSamples]).as<unsigned int>();
//std::cout << "In GpmsaComputerModelOptions::getMyOptionValues(), just read m_option_priorSeqNumSamples = " << m_ov.m_priorSeqNumSamples << std::endl;
}
if (m_env.allOptionsMap().count(m_option_priorSeqDataOutputFileName)) {
m_ov.m_priorSeqDataOutputFileName = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_priorSeqDataOutputFileName]).as<std::string>();
}
if (m_env.allOptionsMap().count(m_option_priorSeqDataOutputFileType)) {
m_ov.m_priorSeqDataOutputFileType = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_priorSeqDataOutputFileType]).as<std::string>();
}
if (m_env.allOptionsMap().count(m_option_priorSeqDataOutputAllowAll)) {
m_ov.m_priorSeqDataOutputAllowAll = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_priorSeqDataOutputAllowAll]).as<bool>();
}
if (m_ov.m_priorSeqDataOutputAllowAll) {
m_ov.m_priorSeqDataOutputAllowedSet.insert(m_env.subId());
}
else if (m_env.allOptionsMap().count(m_option_priorSeqDataOutputAllowedSet)) {
m_ov.m_priorSeqDataOutputAllowedSet.clear();
std::vector<double> tmpAllow(0,0.);
std::string inputString = m_env.allOptionsMap()[m_option_priorSeqDataOutputAllowedSet].as<std::string>();
MiscReadDoublesFromString(inputString,tmpAllow);
if (tmpAllow.size() > 0) {
for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
m_ov.m_priorSeqDataOutputAllowedSet.insert((unsigned int) tmpAllow[i]);
}
}
}
if (m_env.allOptionsMap().count(m_option_nuggetValueForBtWyB)) {
m_ov.m_nuggetValueForBtWyB = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_nuggetValueForBtWyB]).as<double>();
}
if (m_env.allOptionsMap().count(m_option_nuggetValueForBtWyBInv)) {
m_ov.m_nuggetValueForBtWyBInv = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_nuggetValueForBtWyBInv]).as<double>();
}
if (m_env.allOptionsMap().count(m_option_formCMatrix)) {
m_ov.m_formCMatrix = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_formCMatrix]).as<double>();
}
if (m_env.allOptionsMap().count(m_option_useTildeLogicForRankDefficientC)) {
m_ov.m_useTildeLogicForRankDefficientC = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_useTildeLogicForRankDefficientC]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_predLag)) {
m_ov.m_predLag = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predLag]).as<unsigned int>();
}
if (m_env.allOptionsMap().count(m_option_predVUsBySamplingRVs)) {
m_ov.m_predVUsBySamplingRVs = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predVUsBySamplingRVs]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_predVUsBySummingRVs)) {
m_ov.m_predVUsBySummingRVs = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predVUsBySummingRVs]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_predVUsAtKeyPoints)) {
m_ov.m_predVUsAtKeyPoints = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predVUsAtKeyPoints]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_predWsBySamplingRVs)) {
m_ov.m_predWsBySamplingRVs = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predWsBySamplingRVs]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_predWsBySummingRVs)) {
m_ov.m_predWsBySummingRVs = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predWsBySummingRVs]).as<bool>();
}
if (m_env.allOptionsMap().count(m_option_predWsAtKeyPoints)) {
m_ov.m_predWsAtKeyPoints = ((const boost::program_options::variable_value&) m_env.allOptionsMap()[m_option_predWsAtKeyPoints]).as<bool>();
}
return;
}
void GslOptimizer::set_solver_type( std::string& solver )
{
queso_deprecated()
this->set_solver_type( this->string_to_enum(solver) );
}
// Destructor ---------------------------------------
EnvironmentOptions::~EnvironmentOptions()
{
queso_deprecated();
if (m_optionsDesc) delete m_optionsDesc;
}
// --------------------------------------------------
void
EnvironmentOptions::getMyOptionValues(boost::program_options::options_description& optionsDesc)
{
queso_deprecated();
#ifdef QUESO_MEMORY_DEBUGGING
std::cout << "Entering EnvOptions::getMyOptionsValues()" << std::endl;
#endif
if (m_env.allOptionsMap().count(m_option_help.c_str())) {
// 'm_subDisplayOutputFile' is still not available at this moment. Use 'std::cout'
if (m_env.fullRank() == 0) std::cout << optionsDesc
<< std::endl;
}
if (m_env.allOptionsMap().count(m_option_numSubEnvironments.c_str())) {
m_ov.m_numSubEnvironments = m_env.allOptionsMap()[m_option_numSubEnvironments].as<unsigned int>();
}
if ((m_env.fullComm().NumProc()%m_ov.m_numSubEnvironments) != 0) {
std::cerr << "In BaseEnvironment::getMyOptionValues()"
<< ": m_env.fullComm().NumProc() = " << m_env.fullComm().NumProc()
<< ", m_numSubEnvironments = " << m_ov.m_numSubEnvironments
<< std::endl;
}
queso_require_equal_to_msg((m_env.fullComm().NumProc()%m_ov.m_numSubEnvironments), 0, "total number of processors in environment must be multiple of the specified number of subEnvironments");
if (m_env.allOptionsMap().count(m_option_subDisplayFileName.c_str())) {
m_ov.m_subDisplayFileName = m_env.allOptionsMap()[m_option_subDisplayFileName].as<std::string>();
}
if (m_env.allOptionsMap().count(m_option_subDisplayAllowAll.c_str())) {
m_ov.m_subDisplayAllowAll = m_env.allOptionsMap()[m_option_subDisplayAllowAll].as<bool>();
}
if (m_env.allOptionsMap().count(m_option_subDisplayAllowInter0.c_str())) {
m_ov.m_subDisplayAllowInter0 = m_env.allOptionsMap()[m_option_subDisplayAllowInter0].as<bool>();
}
if (m_ov.m_subDisplayAllowAll) {
m_ov.m_subDisplayAllowedSet.clear();
// The line below is commented because 'm_subId' is not set at this point yet
//m_subDisplayAllowedSet.insert((unsigned int) m_subId);
}
else if (m_ov.m_subDisplayAllowInter0) {
m_ov.m_subDisplayAllowedSet.clear();
}
else if (m_env.allOptionsMap().count(m_option_subDisplayAllowedSet.c_str())) {
m_ov.m_subDisplayAllowedSet.clear();
std::vector<double> tmpAllow(0,0.);
std::string inputString = m_env.allOptionsMap()[m_option_subDisplayAllowedSet].as<std::string>();
MiscReadDoublesFromString(inputString,tmpAllow);
//if (m_subDisplayOutputFile) {
// *m_subDisplayOutputFile << "In EnvironmentOptions::getMyOptionValues(): allow = ";
// for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
// *m_subDisplayOutputFile << " " << tmpAllow[i];
// }
// *m_subDisplayOutputFile << std::endl;
//}
if (tmpAllow.size() > 0) {
for (unsigned int i = 0; i < tmpAllow.size(); ++i) {
m_ov.m_subDisplayAllowedSet.insert((unsigned int) tmpAllow[i]);
}
}
}
if (m_env.allOptionsMap().count(m_option_displayVerbosity.c_str())) {
m_ov.m_displayVerbosity = m_env.allOptionsMap()[m_option_displayVerbosity].as<unsigned int>();
}
if (m_env.allOptionsMap().count(m_option_syncVerbosity.c_str())) {
m_ov.m_syncVerbosity = m_env.allOptionsMap()[m_option_syncVerbosity].as<unsigned int>();
}
if (m_env.allOptionsMap().count(m_option_checkingLevel.c_str())) {
m_ov.m_checkingLevel = m_env.allOptionsMap()[m_option_checkingLevel].as<unsigned int>();
}
if (m_env.allOptionsMap().count(m_option_rngType.c_str())) {
m_ov.m_rngType = m_env.allOptionsMap()[m_option_rngType].as<std::string>();
}
if (m_env.allOptionsMap().count(m_option_seed.c_str())) {
m_ov.m_seed = m_env.allOptionsMap()[m_option_seed].as<int>();
}
if (m_env.allOptionsMap().count(m_option_platformName.c_str())) {
m_ov.m_platformName = m_env.allOptionsMap()[m_option_platformName].as<std::string>();
}
if (m_env.allOptionsMap().count(m_option_identifyingString.c_str())) {
m_ov.m_identifyingString = m_env.allOptionsMap()[m_option_identifyingString].as<std::string>();
}
//if (m_env.allOptionsMap().count(m_option_numDebugParams.c_str())) {
// m_numDebugParams = m_env.allOptionsMap()[m_option_numDebugParams].as<unsigned int>();
//}
#ifdef QUESO_MEMORY_DEBUGGING
std::cout << "Leaving EnvOptions::getMyOptionsValues()" << std::endl;
#endif
return;
}
// Default constructor -----------------------------
FiniteDistribution::FiniteDistribution(
const BaseEnvironment& env,
const char* prefix,
const std::vector<double>& inpWeights)
:
m_env (env),
m_prefix ((std::string)(prefix)+"fd_"),
m_weights(inpWeights.size(),0.)
{
queso_deprecated();
if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
*m_env.subDisplayFile() << "Entering FiniteDistribution::constructor()"
<< ": prefix = " << m_prefix
<< ", inpWeights.size() = " << inpWeights.size()
<< std::endl;
}
unsigned int numOfZeroWeights = 0;
unsigned int numRareCases = 0;
double sumCheck = 0.;
unsigned int j = 0;
m_map.empty(); // prudenci 2010-08-11
for (unsigned int i = 0; i < inpWeights.size(); ++i) {
double previousSum = sumCheck;
sumCheck += inpWeights[i];
if (sumCheck == previousSum) {
numOfZeroWeights++;
}
else {
if ((sumCheck - 1) > 1.e-8) {
std::cerr << "In FiniteDistribution::constructor()"
<< ": sumCheck - 1 = " << sumCheck - 1.
<< std::endl;
}
queso_require_less_equal_msg((sumCheck - 1), 1.e-8, "weights sum is too bigger than 1.");
if (sumCheck > 1.) sumCheck = 1.;
m_weights[j] = inpWeights[i];
std::pair<std::map<double,unsigned int>::iterator,bool> ret;
ret = m_map.insert(std::map<double,unsigned int>::value_type(sumCheck,i));
if (ret.second == true) {
j++;
}
else {
numRareCases++;
if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 2)) {
*m_env.subDisplayFile() << "In FiniteDistribution::constructor()"
<< ": WARNING, map insertion failed"
<< std::endl;
}
}
}
}
m_weights.resize(j,0.);
if ((1 - sumCheck) > 1.e-8) {
std::cerr << "In FiniteDistribution::constructor()"
<< ": 1 - sumCheck = " << 1. - sumCheck
<< std::endl;
}
queso_require_less_equal_msg((1 - sumCheck), 1.e-8, "weights sum is too smaller than 1.");
if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 3)) {
*m_env.subDisplayFile() << "In FiniteDistribution::constructor()"
<< ": inpWeights.size() = " << inpWeights.size()
<< ", numOfZeroWeights = " << numOfZeroWeights
<< ", numRareCases = " << numRareCases
<< ", m_map.size() = " << m_map.size()
<< ", m_weights.size() = " << m_weights.size()
<< std::endl;
}
queso_require_equal_to_msg(inpWeights.size(), (m_weights.size()+numOfZeroWeights+numRareCases), "number of input weights was not conserved");
queso_require_equal_to_msg(m_map.size(), m_weights.size(), "map and inpWeights have different sizes");
if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
*m_env.subDisplayFile() << "Leaving FiniteDistribution::constructor()"
<< ": prefix = " << m_prefix
<< std::endl;
}
}
void GslOptimizer::set_step_size( const GslVector& step_size )
{
queso_deprecated();
m_fstep_size = step_size;
}
