// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computeShiftedMatrix(double alpha, double beta, const Epetra_Vector& x,
Epetra_Operator& A)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(-beta); // alpha and beta are switched between LOCA and Thyra
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(alpha);
alpha_prev = -beta; beta_prev = alpha; // prec must know alpha and beta
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
outargs.set_f(eval_f);
outargs.set_W(Teuchos::rcp(&A, false));
model_->evalModel(inargs, outargs);
return true;
}
// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computeJacobian(const Epetra_Vector& x, Epetra_Operator& Jac)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(0.0);
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(1.0);
alpha_prev = 0.0; beta_prev = 1.0; // prec must know alpha and beta
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
outargs.set_f(eval_f);
outargs.set_W(Teuchos::rcp(&Jac, false));
model_->evalModel(inargs, outargs);
return true;
}
// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computeF(const Epetra_Vector& x, Epetra_Vector& F, const FillType fillFlag)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(0.0);
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(1.0);
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
Teuchos::RefCountPtr<Epetra_Vector> f = Teuchos::rcp(&F, false);
if (fillFlag == NOX::Epetra::Interface::Required::Residual)
eval_f.reset(f, EpetraExt::ModelEvaluator::EVAL_TYPE_EXACT);
else if (fillFlag == NOX::Epetra::Interface::Required::Jac)
eval_f.reset(f, EpetraExt::ModelEvaluator::EVAL_TYPE_APPROX_DERIV);
else
eval_f.reset(f, EpetraExt::ModelEvaluator::EVAL_TYPE_VERY_APPROX_DERIV);
outargs.set_f(eval_f);
model_->evalModel(inargs, outargs);
return true;
}
NOX::Abstract::Group::ReturnType
LOCA::Epetra::ModelEvaluatorInterface::
computeDfDp(LOCA::MultiContinuation::AbstractGroup& grp,
const vector<int>& param_ids,
NOX::Abstract::MultiVector& result,
bool isValidF) const
{
// Break result into f and df/dp
NOX::Epetra::Vector& f = dynamic_cast<NOX::Epetra::Vector&>(result[0]);
Epetra_Vector& epetra_f = f.getEpetraVector();
std::vector<int> dfdp_index(result.numVectors()-1);
for (unsigned int i=0; i<dfdp_index.size(); i++)
dfdp_index[i] = i+1;
Teuchos::RefCountPtr<NOX::Epetra::MultiVector> dfdp =
Teuchos::rcp_dynamic_cast<NOX::Epetra::MultiVector>(result.subView(dfdp_index));
Epetra_MultiVector& epetra_dfdp = dfdp->getEpetraMultiVector();
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
const NOX::Epetra::Vector& x =
dynamic_cast<const NOX::Epetra::Vector&>(grp.getX());
const Epetra_Vector& epetra_x = x.getEpetraVector();
inargs.set_x(Teuchos::rcp(&epetra_x, false));
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(epetra_x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
if (!isValidF) {
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
Teuchos::RefCountPtr<Epetra_Vector> F = Teuchos::rcp(&epetra_f, false);
eval_f.reset(F, EpetraExt::ModelEvaluator::EVAL_TYPE_EXACT);
outargs.set_f(eval_f);
}
Teuchos::RefCountPtr<Epetra_MultiVector> DfDp =
Teuchos::rcp(&epetra_dfdp, false);
Teuchos::Array<int> param_indexes(param_ids.size());
for (unsigned int i=0; i<param_ids.size(); i++)
param_indexes[i] = param_ids[i];
EpetraExt::ModelEvaluator::DerivativeMultiVector dmv(DfDp, EpetraExt::ModelEvaluator::DERIV_MV_BY_COL,
param_indexes);
EpetraExt::ModelEvaluator::Derivative deriv(dmv);
outargs.set_DfDp(0, deriv);
model_->evalModel(inargs, outargs);
return NOX::Abstract::Group::Ok;
}
void
LOCA::Epetra::ModelEvaluatorInterface::
postProcessContinuationStep(
LOCA::Abstract::Iterator::StepStatus stepStatus,
LOCA::Epetra::Group& group)
{
// Evaluate responses in model evaluator after successful step
if (stepStatus != LOCA::Abstract::Iterator::Successful) return;
// Create inargs
const NOX::Epetra::Vector& ex = dynamic_cast<const NOX::Epetra::Vector&>(group.getX());
const Epetra_Vector& x = ex.getEpetraVector();
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(0.0);
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(1.0);
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
int num_g = outargs.Ng();
if (num_g > 0) {
Teuchos::RCP<Epetra_Vector> g0 = Teuchos::rcp(new Epetra_Vector(*(model_->get_g_map(0))));
outargs.set_g(0,g0);
model_->evalModel(inargs, outargs);
}
}
// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computePreconditioner(const Epetra_Vector& x,
Epetra_Operator& M,
Teuchos::ParameterList* precParams)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
// alpha and beta are stored from previous matrix computation
// which might have been computeJacobian or computeShiftedMatrix
// This is a state-full hack, but needed since this function
// does not take alpha and beta as arguments. [AGS 01/10]
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(alpha_prev);
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(beta_prev);
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
eval_f.reset(Teuchos::null,
EpetraExt::ModelEvaluator::EVAL_TYPE_VERY_APPROX_DERIV);
outargs.set_f(eval_f);
outargs.set_WPrec(Teuchos::rcp(&M, false));
model_->evalModel(inargs, outargs);
return true;
}
int main(int argc, char *argv[]) {
int status=0; // 0 = pass, failures are incremented
bool success = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
using Teuchos::RCP;
using Teuchos::rcp;
RCP<Teuchos::FancyOStream> out(Teuchos::VerboseObjectBase::getDefaultOStream());
//***********************************************************
// Command-line argument for input file
//***********************************************************
std::string xmlfilename_coupled;
if(argc > 1){
if(!strcmp(argv[1],"--help")){
std::cout << "albany [inputfile.xml]" << std::endl;
std::exit(1);
}
else
xmlfilename_coupled = argv[1];
}
else
xmlfilename_coupled = "input.xml";
try {
RCP<Teuchos::Time> totalTime =
Teuchos::TimeMonitor::getNewTimer("AlbanySG: ***Total Time***");
RCP<Teuchos::Time> setupTime =
Teuchos::TimeMonitor::getNewTimer("AlbanySG: Setup Time");
Teuchos::TimeMonitor totalTimer(*totalTime); //start timer
//***********************************************************
// Set up coupled solver first to setup comm's
//***********************************************************
Teuchos::RCP<Epetra_Comm> globalComm =
Albany::createEpetraCommFromMpiComm(Albany_MPI_COMM_WORLD);
Albany::SolverFactory coupled_slvrfctry(xmlfilename_coupled,
Albany_MPI_COMM_WORLD);
Teuchos::ParameterList& coupledParams = coupled_slvrfctry.getParameters();
Teuchos::ParameterList& coupledSystemParams =
coupledParams.sublist("Coupled System");
Teuchos::Array<std::string> model_filenames =
coupledSystemParams.get<Teuchos::Array<std::string> >("Model XML Files");
int num_models = model_filenames.size();
Teuchos::Array< RCP<Albany::Application> > apps(num_models);
Teuchos::Array< RCP<EpetraExt::ModelEvaluator> > models(num_models);
Teuchos::Array< RCP<Teuchos::ParameterList> > piroParams(num_models);
Teuchos::RCP< Teuchos::ParameterList> coupledPiroParams =
Teuchos::rcp(&(coupledParams.sublist("Piro")),false);
Teuchos::RCP<Piro::Epetra::StokhosSolver> coupledSolver =
Teuchos::rcp(new Piro::Epetra::StokhosSolver(coupledPiroParams,
globalComm));
Teuchos::RCP<const Epetra_Comm> app_comm = coupledSolver->getSpatialComm();
// Set up each model
Teuchos::Array< Teuchos::RCP<NOX::Epetra::Observer> > observers(num_models);
for (int m=0; m<num_models; m++) {
Albany::SolverFactory slvrfctry(
model_filenames[m],
Albany::getMpiCommFromEpetraComm(*app_comm));
models[m] = slvrfctry.createAlbanyAppAndModel(apps[m], app_comm);
Teuchos::ParameterList& appParams = slvrfctry.getParameters();
piroParams[m] = Teuchos::rcp(&(appParams.sublist("Piro")),false);
observers[m] = Teuchos::rcp(new Albany_NOXObserver(apps[m]));
}
// Setup network model
std::string network_name =
coupledSystemParams.get("Network Model", "Param To Response");
RCP<Piro::Epetra::AbstractNetworkModel> network_model;
if (network_name == "Param To Response")
network_model = rcp(new Piro::Epetra::ParamToResponseNetworkModel);
else if (network_name == "Reactor Network")
network_model = rcp(new Albany::ReactorNetworkModel(1));
else
TEUCHOS_TEST_FOR_EXCEPTION(
true, std::logic_error, "Invalid network model name " << network_name);
RCP<EpetraExt::ModelEvaluator> coupledModel =
rcp(new Piro::Epetra::NECoupledModelEvaluator(models, piroParams,
network_model,
coupledPiroParams,
globalComm,
observers));
coupledSolver->setup(coupledModel);
// Solve coupled system
EpetraExt::ModelEvaluator::InArgs inArgs = coupledSolver->createInArgs();
EpetraExt::ModelEvaluator::OutArgs outArgs = coupledSolver->createOutArgs();
for (int i=0; i<inArgs.Np(); i++)
if (inArgs.supports(EpetraExt::ModelEvaluator::IN_ARG_p_sg, i))
inArgs.set_p_sg(i, coupledSolver->get_p_sg_init(i));
for (int i=0; i<outArgs.Ng(); i++)
if (outArgs.supports(EpetraExt::ModelEvaluator::OUT_ARG_g_sg, i)) {
RCP<Stokhos::EpetraVectorOrthogPoly> g_sg =
coupledSolver->create_g_sg(i);
outArgs.set_g_sg(i, g_sg);
}
coupledSolver->evalModel(inArgs, outArgs);
// Print results
bool printResponse =
coupledSystemParams.get("Print Response Expansion", true);
int idx = outArgs.Ng()-1;
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> g_sg =
outArgs.get_g_sg(idx);
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
coupledSolver->get_sg_model();
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> g_sg_local =
//sg_model->import_solution_poly(*(g_sg->getBlockVector()));
g_sg;
Epetra_Vector g_mean(*(g_sg->coefficientMap()));
Epetra_Vector g_std_dev(*(g_sg->coefficientMap()));
g_sg->computeMean(g_mean);
g_sg->computeStandardDeviation(g_std_dev);
RCP<Epetra_Vector> g_mean_local = rcp(&g_mean,false);
RCP<Epetra_Vector> g_std_dev_local = rcp(&g_std_dev,false);
if (g_mean.Map().DistributedGlobal()) {
Epetra_LocalMap local_map(g_mean.GlobalLength(), 0,
g_mean.Map().Comm());
g_mean_local = rcp(new Epetra_Vector(local_map));
g_std_dev_local = rcp(new Epetra_Vector(local_map));
Epetra_Import importer(local_map, g_mean.Map());
g_mean_local->Import(g_mean, importer, Insert);
g_std_dev_local->Import(g_std_dev, importer, Insert);
}
out->precision(16);
*out << std::endl
<< "Final value of coupling variables:" << std::endl
<< "Mean:" << std::endl << *g_mean_local << std::endl
<< "Std. Dev.:" << std::endl << *g_std_dev_local << std::endl;
if (printResponse)
*out << "PCE:" << std::endl << *g_sg_local << std::endl;
status += coupled_slvrfctry.checkSGTestResults(
0,
g_sg_local,
g_mean_local.get(),
g_std_dev_local.get());
*out << "\nNumber of Failed Comparisons: " << status << std::endl;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true, std::cerr, success);
if (!success) status+=10000;
Teuchos::TimeMonitor::summarize(*out,false,true,false/*zero timers*/);
return status;
}