PythonInterface::PythonInterface(const ProblemDescDB& problem_db)
: DirectApplicInterface(problem_db),
userNumpyFlag(problem_db.get_bool("interface.python.numpy"))
{
Py_Initialize();
if (Py_IsInitialized()) {
if (outputLevel >= NORMAL_OUTPUT)
Cout << "Python interpreter initialized for direct function evaluation."
<< std::endl;
}
else {
Cerr << "Error: Could not initialize Python for direct function "
<< "evaluation." << std::endl;
abort_handler(-1);
}
if (userNumpyFlag) {
#ifdef DAKOTA_PYTHON_NUMPY
import_array();
#else
Cerr << "\nError: Direct Python interface 'numpy' option requested, but "
<< "not available." << std::endl;
abort_handler(-1);
#endif
}
// prepend sys.path (env PYTHONPATH) with empty string to find module in pwd
// This assumes any directory changing in the driver is reversed
// between function evaluations
PyRun_SimpleString("import sys\nsys.path.insert(0,\"\")");
}
SharedSurfpackApproxData::
SharedSurfpackApproxData(ProblemDescDB& problem_db, size_t num_vars):
SharedApproxData(BaseConstructor(), problem_db, num_vars),
exportModelName(problem_db.get_string("model.surrogate.export_model_file")),
diagnosticSet(problem_db.get_sa("model.metrics")),
crossValidateFlag(problem_db.get_bool("model.surrogate.cross_validate")),
numFolds(problem_db.get_int("model.surrogate.folds")),
percentFold(problem_db.get_real("model.surrogate.percent")),
pressFlag(problem_db.get_bool("model.surrogate.press"))
{
// For Polynomial surface fits
if (approxType == "global_polynomial")
approxOrder = problem_db.get_short("model.surrogate.polynomial_order");
else if (approxType == "global_kriging") {
const String& trend_string =
problem_db.get_string("model.surrogate.trend_order");
if (trend_string == "constant") approxOrder = 0;
else if (trend_string == "linear") approxOrder = 1;
else approxOrder = 2; // empty, reduced_quadratic, quadratic
}
}
SharedPecosApproxData::
SharedPecosApproxData(ProblemDescDB& problem_db, size_t num_vars):
SharedApproxData(BaseConstructor(), problem_db, num_vars)
{
short basis_type; approx_type_to_basis_type(approxType, basis_type);
UShortArray approx_order;
if (basis_type == Pecos::GLOBAL_ORTHOGONAL_POLYNOMIAL)
approx_order = problem_db.get_usa("method.nond.expansion_order");
// override selected ConfigOptions defaults, as supported by SharedApproxData
// API. All options are updated later in NonD*::initialize_u_space_model(),
// so this step is not strictly required and is more for completeness.
Pecos::ExpansionConfigOptions ec_options; // set defaults
Pecos::BasisConfigOptions bc_options; // set defaults
ec_options.outputLevel = outputLevel;
bc_options.useDerivs = (buildDataOrder > 1);
pecosSharedData =
Pecos::SharedBasisApproxData(basis_type, approx_order, numVars,
ec_options, bc_options);
pecosSharedDataRep
= (Pecos::SharedPolyApproxData*)pecosSharedData.data_rep();
}
// Define interface class
TriKota::ThyraDirectApplicInterface::ThyraDirectApplicInterface(
ProblemDescDB& problem_db_,
const Teuchos::RCP<Thyra::ModelEvaluatorDefaultBase<double> > App_)
: Dakota::DirectApplicInterface(problem_db_),
App(App_),
orientation(MEB::DERIV_MV_BY_COL)
{
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
if (App != Teuchos::null) {
model_p = Thyra::createMember<double>(App->get_p_space(0));
model_g = Thyra::createMember<double>(App->get_g_space(0));
Thyra::DetachedVectorView<double> my_p(model_p);
Thyra::DetachedVectorView<double> my_g(model_g);
numParameters = my_p.subDim();
numResponses = my_g.subDim();
*out << "TriKota:: ModeEval has " << numParameters <<
" parameters and " << numResponses << " responses." << std::endl;
MEB::DerivativeSupport supportDgDp = App->createOutArgs().supports(MEB::OUT_ARG_DgDp, 0, 0);
supportsSensitivities = !(supportDgDp.none());
// Create the MultiVector, then the Derivative object
if (supportsSensitivities) {
*out << "TriKota:: ModeEval supports gradients calculation." << std::endl;
if (supportDgDp.supports(MEB::DERIV_TRANS_MV_BY_ROW)) {
orientation = MEB::DERIV_TRANS_MV_BY_ROW;
model_dgdp = Thyra::createMembers<double>(App->get_p_space(0), numResponses);
}
else if (supportDgDp.supports(MEB::DERIV_MV_BY_COL)) {
orientation = MEB::DERIV_MV_BY_COL;
model_dgdp = Thyra::createMembers<double>(App->get_g_space(0), numParameters);
}
else {
TEST_FOR_EXCEPTION(!supportDgDp.none(), std::logic_error,
"TriKota Adapter Error: DgDp data type not implemented");
}
}
*out << "TriKota:: Setting initial guess from Model Evaluator to Dakota " << std::endl;
const Thyra::ConstDetachedVectorView<double> my_pinit(App->getNominalValues().get_p(0));
for (unsigned int i=0; i<numParameters; i++) my_p[i] = my_pinit[i];
Model& first_model = *(problem_db_.model_list().begin());
unsigned int num_dakota_vars = first_model.acv();
Dakota::RealVector drv(num_dakota_vars);
TEST_FOR_EXCEPTION(num_dakota_vars > numParameters, std::logic_error,
"TriKota Adapter Error: number of parameters in ModelEvaluator "
<< numParameters << "\n is less then the number of continuous variables\n"
<< " specified in the dakota.in input file " << num_dakota_vars << "\n" );
for (unsigned int i=0; i<num_dakota_vars; i++) drv[i] = my_p[i];
first_model.continuous_variables(drv);
}
else {
*out << "Warning in TriKota::ThyraDirectApplicInterface constructor\n"
<< "\tModelEvaluator is null. This is OK iff Dakota has assigned"
<< " MPI_COMM_NULL to this Proc " << std::endl;
}
}
/** In this class, a relaxed data approach is used in which continuous
and discrete arrays are combined into a single continuous array
(integrality is relaxed; the converse of truncating reals is not
currently supported but could be in the future if needed).
Iterators which use this class include: BranchBndOptimizer. */
RelaxedVarConstraints::
RelaxedVarConstraints(const ProblemDescDB& problem_db,
const SharedVariablesData& svd):
Constraints(BaseConstructor(), problem_db, svd)
{
const SizetArray& vc_totals = svd.components_totals();
size_t num_cdv = vc_totals[0], num_cauv = vc_totals[3],
num_ceuv = vc_totals[6], num_csv = vc_totals[9],
num_ddrv = sharedVarsData.vc_lookup(DISCRETE_DESIGN_RANGE),
num_ddsiv = sharedVarsData.vc_lookup(DISCRETE_DESIGN_SET_INT),
num_dauiv = vc_totals[4], num_deuiv = vc_totals[7],
num_dsrv = sharedVarsData.vc_lookup(DISCRETE_STATE_RANGE),
num_dssiv = sharedVarsData.vc_lookup(DISCRETE_STATE_SET_INT),
num_ddsrv = vc_totals[2], num_daurv = vc_totals[5],
num_deurv = vc_totals[8],
num_acv = num_cdv + num_cauv + num_ceuv + num_csv +
vc_totals[1] + num_dauiv + num_deuiv + vc_totals[10] +
num_ddsrv + num_daurv + num_deurv + vc_totals[11];
allContinuousLowerBnds.sizeUninitialized(num_acv);
allContinuousUpperBnds.sizeUninitialized(num_acv);
int start = 0;
copy_data_partial(problem_db.get_rv(
"variables.continuous_design.lower_bounds"), allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.continuous_design.upper_bounds"), allContinuousUpperBnds, start);
start += num_cdv;
merge_data_partial(problem_db.get_iv(
"variables.discrete_design_range.lower_bounds"),
allContinuousLowerBnds, start);
merge_data_partial(problem_db.get_iv(
"variables.discrete_design_range.upper_bounds"),
allContinuousUpperBnds, start);
start += num_ddrv;
merge_data_partial(problem_db.get_iv(
"variables.discrete_design_set_int.lower_bounds"),
allContinuousLowerBnds, start);
merge_data_partial(problem_db.get_iv(
"variables.discrete_design_set_int.upper_bounds"),
allContinuousUpperBnds, start);
start += num_ddsiv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_design_set_real.lower_bounds"),
allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.discrete_design_set_real.upper_bounds"),
allContinuousUpperBnds, start);
start += num_ddsrv;
copy_data_partial(problem_db.get_rv(
"variables.continuous_aleatory_uncertain.lower_bounds"),
allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.continuous_aleatory_uncertain.upper_bounds"),
allContinuousUpperBnds, start);
start += num_cauv;
merge_data_partial(problem_db.get_iv(
"variables.discrete_aleatory_uncertain_int.lower_bounds"),
allContinuousLowerBnds, start);
merge_data_partial(problem_db.get_iv(
"variables.discrete_aleatory_uncertain_int.upper_bounds"),
allContinuousUpperBnds, start);
start += num_dauiv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_aleatory_uncertain_real.lower_bounds"),
allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.discrete_aleatory_uncertain_real.upper_bounds"),
allContinuousUpperBnds, start);
start += num_daurv;
copy_data_partial(problem_db.get_rv(
"variables.continuous_epistemic_uncertain.lower_bounds"),
allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.continuous_epistemic_uncertain.upper_bounds"),
allContinuousUpperBnds, start);
start += num_ceuv;
merge_data_partial(problem_db.get_iv(
"variables.discrete_epistemic_uncertain_int.lower_bounds"),
allContinuousLowerBnds, start);
merge_data_partial(problem_db.get_iv(
"variables.discrete_epistemic_uncertain_int.upper_bounds"),
allContinuousUpperBnds, start);
start += num_deuiv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_epistemic_uncertain_real.lower_bounds"),
allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.discrete_epistemic_uncertain_real.upper_bounds"),
allContinuousUpperBnds, start);
start += num_deurv;
copy_data_partial(problem_db.get_rv(
"variables.continuous_state.lower_bounds"), allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.continuous_state.upper_bounds"), allContinuousUpperBnds, start);
start += num_csv;
merge_data_partial(problem_db.get_iv(
"variables.discrete_state_range.lower_bounds"),
allContinuousLowerBnds, start);
merge_data_partial(problem_db.get_iv(
"variables.discrete_state_range.upper_bounds"),
allContinuousUpperBnds, start);
start += num_dsrv;
merge_data_partial(problem_db.get_iv(
"variables.discrete_state_set_int.lower_bounds"),
allContinuousLowerBnds, start);
merge_data_partial(problem_db.get_iv(
"variables.discrete_state_set_int.upper_bounds"),
allContinuousUpperBnds, start);
start += num_dssiv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_state_set_real.lower_bounds"),
allContinuousLowerBnds, start);
copy_data_partial(problem_db.get_rv(
"variables.discrete_state_set_real.upper_bounds"),
allContinuousUpperBnds, start);
// Construct active/inactive views of all arrays
build_views();
// Manage linear constraints.
manage_linear_constraints(problem_db);
#ifdef REFCOUNT_DEBUG
Cout << "Letter instantiated: variablesView active = " << variablesView.first
<< " inactive = " << variablesView.second << std::endl;
#endif
}
/** In this class, the distinct approach is used (design, uncertain, and
state variable types and continuous and discrete domain types are
distinct). Most iterators/strategies use this approach. */
MixedVariables::
MixedVariables(const ProblemDescDB& problem_db,
const std::pair<short,short>& view):
Variables(BaseConstructor(), problem_db, view)
{
const SizetArray& vc_totals = sharedVarsData.components_totals();
size_t num_cdv = vc_totals[0], num_cauv = vc_totals[3],
num_ceuv = vc_totals[6],
num_acv = num_cdv + num_cauv + num_ceuv + vc_totals[9],
num_ddrv = sharedVarsData.vc_lookup(DISCRETE_DESIGN_RANGE),
num_ddsiv = sharedVarsData.vc_lookup(DISCRETE_DESIGN_SET_INT),
num_dauiv = vc_totals[4], num_deuiv = vc_totals[7],
num_dsrv = sharedVarsData.vc_lookup(DISCRETE_STATE_RANGE),
num_adiv = vc_totals[1] + num_dauiv + num_deuiv + vc_totals[10],
num_daurv = vc_totals[5], num_deurv = vc_totals[8],
num_ddsrv = vc_totals[2],
num_adrv = num_ddsrv + num_daurv + num_deurv + vc_totals[11];
allContinuousVars.sizeUninitialized(num_acv);
allDiscreteIntVars.sizeUninitialized(num_adiv);
allDiscreteRealVars.sizeUninitialized(num_adrv);
int start = 0;
copy_data_partial(problem_db.get_rv(
"variables.continuous_design.initial_point"), allContinuousVars, start);
start += num_cdv;
copy_data_partial(problem_db.get_rv(
"variables.continuous_aleatory_uncertain.initial_point"),
allContinuousVars, start);
start += num_cauv;
copy_data_partial(problem_db.get_rv(
"variables.continuous_epistemic_uncertain.initial_point"),
allContinuousVars, start);
start += num_ceuv;
copy_data_partial(problem_db.get_rv(
"variables.continuous_state.initial_state"), allContinuousVars, start);
start = 0;
copy_data_partial(problem_db.get_iv(
"variables.discrete_design_range.initial_point"),
allDiscreteIntVars, start);
start += num_ddrv;
copy_data_partial(problem_db.get_iv(
"variables.discrete_design_set_int.initial_point"),
allDiscreteIntVars, start);
start += num_ddsiv;
copy_data_partial(problem_db.get_iv(
"variables.discrete_aleatory_uncertain_int.initial_point"),
allDiscreteIntVars, start);
start += num_dauiv;
copy_data_partial(problem_db.get_iv(
"variables.discrete_epistemic_uncertain_int.initial_point"),
allDiscreteIntVars, start);
start += num_deuiv;
copy_data_partial(problem_db.get_iv(
"variables.discrete_state_range.initial_state"), allDiscreteIntVars, start);
start += num_dsrv;
copy_data_partial(problem_db.get_iv(
"variables.discrete_state_set_int.initial_state"),
allDiscreteIntVars, start);
start = 0;
copy_data_partial(problem_db.get_rv(
"variables.discrete_design_set_real.initial_point"),
allDiscreteRealVars, start);
start += num_ddsrv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_aleatory_uncertain_real.initial_point"),
allDiscreteRealVars, start);
start += num_daurv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_epistemic_uncertain_real.initial_point"),
allDiscreteRealVars, start);
start += num_deurv;
copy_data_partial(problem_db.get_rv(
"variables.discrete_state_set_real.initial_state"),
allDiscreteRealVars, start);
// construct active/inactive views of all arrays
build_views();
#ifdef REFCOUNT_DEBUG
Cout << "Letter instantiated: variablesView active = " << variablesView.first
<< " inactive = " << variablesView.second << std::endl;
#endif
}
// Define interface class
TriKota::DirectApplicInterface::DirectApplicInterface(
ProblemDescDB& problem_db_,
const Teuchos::RCP<EpetraExt::ModelEvaluator> App_,
int p_index_, int g_index_)
: Dakota::DirectApplicInterface(problem_db_),
App(App_),
p_index(p_index_),
g_index(g_index_),
orientation(EEME::DERIV_MV_BY_COL)
{
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
if (App != Teuchos::null) {
model_p = Teuchos::rcp(new Epetra_Vector(*(App->get_p_init(p_index))));
// model_g = Teuchos::rcp(new Epetra_Vector(*(App->get_g_map(g_index))));
model_g = Teuchos::rcp(new Epetra_Vector((const Epetra_BlockMap&) *(App->get_g_map(g_index)), true));
numParameters = model_p->GlobalLength();
numResponses = model_g->GlobalLength();
*out << "TriKota:: ModeEval has " << numParameters <<
" parameters and " << numResponses << " responses." << std::endl;
EEME::DerivativeSupport supportDgDp = App->createOutArgs().supports(EEME::OUT_ARG_DgDp, g_index, p_index);
supportsSensitivities = !(supportDgDp.none());
// Create the MultiVector, then the Derivative object
if (supportsSensitivities) {
*out << "TriKota:: ModeEval supports gradients calculation." << std::endl;
if (supportDgDp.supports(EEME::DERIV_TRANS_MV_BY_ROW)) {
orientation = EEME::DERIV_TRANS_MV_BY_ROW;
model_dgdp = Teuchos::rcp(new Epetra_MultiVector(model_p->Map(), numResponses ));
}
else if (supportDgDp.supports(EEME::DERIV_MV_BY_COL)) {
orientation = EEME::DERIV_MV_BY_COL;
model_dgdp = Teuchos::rcp(new Epetra_MultiVector(model_g->Map(), numParameters));
}
else {
TEUCHOS_TEST_FOR_EXCEPTION(!supportDgDp.none(), std::logic_error,
"TriKota Adapter Error: DgDp data type not implemented");
}
}
*out << "TriKota:: Setting initial guess from Model Evaluator to Dakota " << std::endl;
Model& first_model = *(problem_db_.model_list().begin());
unsigned int num_dakota_vars = first_model.acv();
Dakota::RealVector drv(num_dakota_vars);
TEUCHOS_TEST_FOR_EXCEPTION(num_dakota_vars > numParameters, std::logic_error,
"TriKota Adapter Error: number of parameters in ModelEvaluator "
<< numParameters << "\n is less then the number of continuous variables\n"
<< " specified in the dakota.in input file " << num_dakota_vars << "\n" );
for (unsigned int i=0; i<num_dakota_vars; i++) drv[i] = (*model_p)[i];
first_model.continuous_variables(drv);
}
else {
*out << "Warning in TriKota::DirectApplicInterface constructor\n"
<< "\tModelEvaluator is null. This is OK iff Dakota has assigned"
<< " MPI_COMM_NULL to this Proc " << std::endl;
}
}
TriKota::MPDirectApplicInterface::
MPDirectApplicInterface(
ProblemDescDB& problem_db_,
const Teuchos::RCP<Piro::Epetra::StokhosMPSolver>& model_,
int p_index_, int g_index_) :
Dakota::DirectApplicInterface(problem_db_),
model(model_),
p_index(p_index_),
g_index(g_index_),
orientation(EEME::DERIV_MV_BY_COL)
{
out = Teuchos::VerboseObjectBase::getDefaultOStream();
if (model != Teuchos::null) {
// Make sure we support multi-point
TEUCHOS_TEST_FOR_EXCEPTION(
!model->createInArgs().supports(EEME::IN_ARG_p_mp, p_index),
std::logic_error,
"Model does not support multi-point parameter " << g_index << "!");
TEUCHOS_TEST_FOR_EXCEPTION(
!model->createOutArgs().supports(EEME::OUT_ARG_g_mp, g_index),
std::logic_error,
"Model does not support multi-point response " << g_index << "!");
// Create product vectors
model_p = model->create_p_mp(p_index);
model_g = model->create_g_mp(g_index);
numParameters = (*model_p)[0].GlobalLength();
numResponses = (*model_g)[0].GlobalLength();
block_size = model_p->map()->NumMyElements();
*out << "TriKota:: ModeEval has " << numParameters <<
" parameters and " << numResponses << " responses." << std::endl;
// Create dg/dp
EEME::DerivativeSupport supportDgDp =
model->createOutArgs().supports(EEME::OUT_ARG_DgDp_mp, g_index, p_index);
supportsSensitivities =
supportDgDp.supports(EEME::DERIV_TRANS_MV_BY_ROW) ||
supportDgDp.supports(EEME::DERIV_MV_BY_COL);
if (supportsSensitivities) {
*out << "TriKota:: ModeEval supports gradients calculation." << std::endl;
if (supportDgDp.supports(EEME::DERIV_TRANS_MV_BY_ROW)) {
orientation = EEME::DERIV_TRANS_MV_BY_ROW;
model_dgdp = model->create_p_mv_mp(p_index, numResponses);
}
else {
orientation = EEME::DERIV_MV_BY_COL;
model_dgdp = model->create_g_mv_mp(g_index, numParameters);
}
}
*out << "TriKota:: Setting initial guess from Model Evaluator to Dakota "
<< std::endl;
Model& first_model = *(problem_db_.model_list().begin());
unsigned int num_dakota_vars = first_model.acv();
Dakota::RealVector drv(num_dakota_vars);
TEUCHOS_TEST_FOR_EXCEPTION(
num_dakota_vars > numParameters, std::logic_error,
"TriKota Adapter Error: number of parameters in ModelEvaluator "
<< numParameters
<< "\n is less then the number of continuous variables\n"
<< " specified in the dakota.in input file " << num_dakota_vars << "\n" );
for (unsigned int i=0; i<num_dakota_vars; i++)
drv[i] = (*model_p)[0][i];
first_model.continuous_variables(drv);
}
else {
*out << "Warning in TriKota::MPDirectmodellicInterface constructor\n"
<< "\tModelEvaluator is null. This is OK iff Dakota has assigned"
<< " MPI_COMM_NULL to this Proc " << std::endl;
}
}