// ***************************************************************** // ***************************************************************** 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; }
// ***************************************************************** // ***************************************************************** 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; }
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 int overall_status=0; // 0 = pass, failures are incremented over multiple tests bool success=true; // Initialize MPI Teuchos::GlobalMPISession mpiSession(&argc,&argv); int Proc=mpiSession.getRank(); #ifdef HAVE_MPI MPI_Comm appComm = MPI_COMM_WORLD; #else int appComm=0; #endif using Teuchos::RCP; using Teuchos::rcp; std::string inputFile; bool doAll = (argc==1); if (argc>1) doAll = !strcmp(argv[1],"-v"); for (int iTest=0; iTest<3; iTest++) { if (doAll) { switch (iTest) { case 0: inputFile="input_Solve_VV.xml"; break; case 1: inputFile="input_Solve_TR.xml"; break; case 2: inputFile="input_Solve_NB.xml"; break; default : std::cout << "iTest logic error " << std::endl; exit(-1); } } else { inputFile=argv[1]; iTest = 999; } if (Proc==0) std::cout << "===================================================\n" << "====== Running input file: "<< inputFile <<"\n" << "===================================================\n" << std::endl; try { // Create (1) a Model Evaluator and (2) a ParameterList RCP<EpetraExt::ModelEvaluator> Model = rcp(new MockModelEval_B(appComm)); RCP<Teuchos::ParameterList> piroParams = rcp(new Teuchos::ParameterList("Piro Parameters")); Teuchos::updateParametersFromXmlFile(inputFile, piroParams.ptr()); // Use these two objects to construct a Piro solved application // EpetraExt::ModelEvaluator is base class of all Piro::Epetra solvers RCP<EpetraExt::ModelEvaluator> piro; std::string& solver = piroParams->get("Solver Type","NOX"); RCP<NOX::Epetra::Observer> observer = rcp(new ObserveSolution_Epetra()); if (solver=="NOX") { piro = rcp(new Piro::Epetra::NOXSolver(piroParams, Model, observer)); } else if (solver=="Velocity Verlet") { piro = rcp(new Piro::Epetra::VelocityVerletSolver( piroParams, Model, observer)); } else if (solver=="Trapezoid Rule") { piro = rcp(new Piro::Epetra::TrapezoidRuleSolver( piroParams, Model, observer)); } else if (solver=="Newmark") { piro = rcp(new Piro::Epetra::NewmarkSolver( piroParams, Model, observer)); } else TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Error: Unknown Piro Solver : " << solver); // Now the (somewhat cumbersome) setting of inputs and outputs EpetraExt::ModelEvaluator::InArgs inArgs = piro->createInArgs(); TEUCHOS_ASSERT(inArgs.Np() > 0); // Number of *vectors* of parameters RCP<Epetra_Vector> p1 = rcp(new Epetra_Vector(*(piro->get_p_init(0)))); inArgs.set_p(0,p1); // Set output arguments to evalModel call EpetraExt::ModelEvaluator::OutArgs outArgs = piro->createOutArgs(); TEUCHOS_ASSERT(outArgs.Ng() >= 2); // Number of *vectors* of responses RCP<Epetra_Vector> g1 = rcp(new Epetra_Vector(*(piro->get_g_map(0)))); outArgs.set_g(0,g1); // Solution vector is returned as extra respons vector RCP<Epetra_Vector> gx = rcp(new Epetra_Vector(*(piro->get_g_map(1)))); outArgs.set_g(1,gx); // Now, solve the problem and return the responses piro->evalModel(inArgs, outArgs); // Print out everything if (Proc == 0) std::cout << "Finished Model Evaluation: Printing everything {Exact in brackets}" << "\n-----------------------------------------------------------------" << std::setprecision(9) << std::endl; p1->Print(std::cout << "\nParameters! {1}\n"); g1->Print(std::cout << "\nResponses! {0.0}\n"); gx->Print(std::cout << "\nSolution! {0.0}\n"); if (Proc == 0) std::cout << "\n-----------------------------------------------------------------\n"; } TEUCHOS_STANDARD_CATCH_STATEMENTS(true, std::cerr, success); if (!success) status=10; else status=0; overall_status += status; } if (Proc==0) { if (overall_status==0) std::cout << "\nTEST PASSED\n" << std::endl; else std::cout << "\nTEST Failed: " << overall_status << std::endl; } return status; }
int main(int argc, char *argv[]) { int status=0; // 0 = pass, failures are incremented // Initialize MPI and timer int Proc=0; #ifdef HAVE_MPI MPI_Init(&argc,&argv); double total_time = -MPI_Wtime(); (void) MPI_Comm_rank(MPI_COMM_WORLD, &Proc); MPI_Comm appComm = MPI_COMM_WORLD; #else int appComm=0; #endif using Teuchos::RCP; using Teuchos::rcp; // Command-line argument for input file //char* defaultfile="input_1.xml"; try { RCP<EpetraExt::ModelEvaluator> Model = rcp(new MockModelEval_A(appComm)); // Set input arguments to evalModel call EpetraExt::ModelEvaluator::InArgs inArgs = Model->createInArgs(); RCP<Epetra_Vector> x = rcp(new Epetra_Vector(*(Model->get_x_init()))); inArgs.set_x(x); int num_p = inArgs.Np(); // Number of *vectors* of parameters RCP<Epetra_Vector> p1; if (num_p > 0) { p1 = rcp(new Epetra_Vector(*(Model->get_p_init(0)))); inArgs.set_p(0,p1); } int numParams = p1->MyLength(); // Number of parameters in p1 vector // Set output arguments to evalModel call EpetraExt::ModelEvaluator::OutArgs outArgs = Model->createOutArgs(); RCP<Epetra_Vector> f = rcp(new Epetra_Vector(x->Map())); outArgs.set_f(f); int num_g = outArgs.Ng(); // Number of *vectors* of responses RCP<Epetra_Vector> g1; if (num_g > 0) { g1 = rcp(new Epetra_Vector(*(Model->get_g_map(0)))); outArgs.set_g(0,g1); } RCP<Epetra_Operator> W_op = Model->create_W(); outArgs.set_W(W_op); RCP<Epetra_MultiVector> dfdp = rcp(new Epetra_MultiVector( *(Model->get_x_map()), numParams)); outArgs.set_DfDp(0, dfdp); RCP<Epetra_MultiVector> dgdp = rcp(new Epetra_MultiVector(g1->Map(), numParams)); outArgs.set_DgDp(0, 0, dgdp); RCP<Epetra_MultiVector> dgdx = rcp(new Epetra_MultiVector(x->Map(), g1->MyLength())); outArgs.set_DgDx(0, dgdx); // Now, evaluate the model! Model->evalModel(inArgs, outArgs); // Print out everything if (Proc == 0) cout << "Finished Model Evaluation: Printing everything {Exact in brackets}" << "\n-----------------------------------------------------------------" << std::setprecision(9) << endl; x->Print(cout << "\nSolution vector! {3,3,3,3}\n"); if (num_p>0) p1->Print(cout << "\nParameters! {1,1}\n"); f->Print(cout << "\nResidual! {8,5,0,-7}\n"); if (num_g>0) g1->Print(cout << "\nResponses! {2}\n"); RCP<Epetra_CrsMatrix> W = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_op, true); W->Print(cout << "\nJacobian! {6 on diags}\n"); dfdp->Print(cout << "\nDfDp sensitivity MultiVector! {-1,0,0,0}{0,-4,-6,-8}\n"); dgdp->Print(cout << "\nDgDp response sensitivity MultiVector!{2,2}\n"); dgdx->Print(cout << "\nDgDx^T response gradient MultiVector! {-2,-2,-2,-2}\n"); if (Proc == 0) cout << "\n-----------------------------------------------------------------\n"; } catch (std::exception& e) { cout << e.what() << endl; status = 10; } catch (string& s) { cout << s << endl; status = 20; } catch (char *s) { cout << s << endl; status = 30; } catch (...) { cout << "Caught unknown exception!" << endl; status = 40; } #ifdef HAVE_MPI total_time += MPI_Wtime(); MPI_Barrier(MPI_COMM_WORLD); if (Proc==0) cout << "\n\nTOTAL TIME " << total_time << endl; MPI_Finalize() ; #endif if (Proc==0) { if (status==0) cout << "TEST PASSED" << endl; else cout << "TEST Failed" << endl; } return status; }
void EpetraExt::MultiPointModelEvaluator::evalModel( const InArgs& inArgs, const OutArgs& outArgs ) const { EpetraExt::ModelEvaluator::InArgs underlyingInArgs = underlyingME->createInArgs(); EpetraExt::ModelEvaluator::OutArgs underlyingOutArgs = underlyingME->createOutArgs(); //temp code for multipoint param q vec /* Teuchos::RefCountPtr<Epetra_Vector> q = Teuchos::rcp(new Epetra_Vector(*(underlyingME->get_p_map(1)))); */ // Parse InArgs Teuchos::RefCountPtr<const Epetra_Vector> p_in = inArgs.get_p(0); if (p_in.get()) underlyingInArgs.set_p(0, p_in); Teuchos::RefCountPtr<const Epetra_Vector> x_in = inArgs.get_x(); block_x->Epetra_Vector::operator=(*x_in); //copy into block vector // Parse OutArgs Teuchos::RefCountPtr<Epetra_Vector> f_out = outArgs.get_f(); Teuchos::RefCountPtr<Epetra_Operator> W_out = outArgs.get_W(); Teuchos::RefCountPtr<EpetraExt::BlockCrsMatrix> W_block = Teuchos::rcp_dynamic_cast<EpetraExt::BlockCrsMatrix>(W_out); Teuchos::RefCountPtr<Epetra_Vector> g_out; if (underlyingNg) g_out = outArgs.get_g(0); if (g_out.get()) g_out->PutScalar(0.0); EpetraExt::ModelEvaluator::Derivative DfDp_out = outArgs.get_DfDp(0); EpetraExt::ModelEvaluator::Derivative DgDx_out; EpetraExt::ModelEvaluator::Derivative DgDp_out; if (underlyingNg) { DgDx_out = outArgs.get_DgDx(0); DgDp_out = outArgs.get_DgDp(0,0); if (!DgDx_out.isEmpty()) DgDx_out.getMultiVector()->PutScalar(0.0); if (!DgDp_out.isEmpty()) DgDp_out.getMultiVector()->PutScalar(0.0); } // For mathcingProblems, g is needed to calc DgDx DgDp, so ask for // g even if it isn't requested. bool need_g = g_out.get(); if (matchingProblem) if ( !DgDx_out.isEmpty() || !DgDp_out.isEmpty() ) need_g = true; // Begin loop over Points (steps) owned on this proc for (int i=0; i < timeStepsOnTimeDomain; i++) { // Set MultiPoint parameter vector underlyingInArgs.set_p(1, (*q_vec)[i]); // Set InArgs if(longlong) { #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES block_x->ExtractBlockValues(*split_x, (*rowIndex_LL)[i]); #endif } else { #ifndef EPETRA_NO_32BIT_GLOBAL_INDICES block_x->ExtractBlockValues(*split_x, (*rowIndex_int)[i]); #endif } underlyingInArgs.set_x(split_x); // Set OutArgs if (f_out.get()) underlyingOutArgs.set_f(split_f); if (need_g) underlyingOutArgs.set_g(0, split_g); if (W_out.get()) underlyingOutArgs.set_W(split_W); if (!DfDp_out.isEmpty()) underlyingOutArgs.set_DfDp(0, *deriv_DfDp); if (!DgDx_out.isEmpty()) underlyingOutArgs.set_DgDx(0, *deriv_DgDx); if (!DgDp_out.isEmpty()) underlyingOutArgs.set_DgDp(0, 0, *deriv_DgDp); //********Eval Model ********/ underlyingME->evalModel(underlyingInArgs, underlyingOutArgs); //********Eval Model ********/ // If matchingProblem, modify all g-related quantitites G = 0.5*(g-g*)^2 / g*^2 if (matchingProblem) { if (need_g) { double diff = (*split_g)[0] - (*(*matching_vec)[i])[0]; double nrmlz = fabs((*(*matching_vec)[i])[0]) + 1.0e-6; (*split_g)[0] = 0.5 * diff * diff/(nrmlz*nrmlz); if (!DgDx_out.isEmpty()) split_DgDx->Scale(diff/(nrmlz*nrmlz)); if (!DgDp_out.isEmpty()) split_DgDp->Scale(diff/(nrmlz*nrmlz)); } } // Repackage block components into global block matrx/vector/multivector if(longlong) { #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES if (f_out.get()) block_f->LoadBlockValues(*split_f, (*rowIndex_LL)[i]); if (W_out.get()) W_block->LoadBlock(*split_W, i, 0); // note: split_DfDp points inside deriv_DfDp if (!DfDp_out.isEmpty()) block_DfDp->LoadBlockValues(*split_DfDp, (*rowIndex_LL)[i]); if (!DgDx_out.isEmpty()) block_DgDx->LoadBlockValues(*split_DgDx, (*rowIndex_LL)[i]); #endif } else { #ifndef EPETRA_NO_32BIT_GLOBAL_INDICES if (f_out.get()) block_f->LoadBlockValues(*split_f, (*rowIndex_int)[i]); if (W_out.get()) W_block->LoadBlock(*split_W, i, 0); // note: split_DfDp points inside deriv_DfDp if (!DfDp_out.isEmpty()) block_DfDp->LoadBlockValues(*split_DfDp, (*rowIndex_int)[i]); if (!DgDx_out.isEmpty()) block_DgDx->LoadBlockValues(*split_DgDx, (*rowIndex_int)[i]); #endif } // Assemble multiple steps on this domain into g and dgdp(0) vectors if (g_out.get()) g_out->Update(1.0, *split_g, 1.0); if (!DgDp_out.isEmpty()) DgDp_out.getMultiVector()->Update(1.0, *split_DgDp, 1.0); } // End loop over multiPoint steps on this domain/cluster //Copy block vectors into *_out vectors of same size if (f_out.get()) f_out->operator=(*block_f); if (!DfDp_out.isEmpty()) DfDp_out.getMultiVector()->operator=(*block_DfDp); if (!DgDx_out.isEmpty()) DgDx_out.getMultiVector()->operator=(*block_DgDx); //Sum together obj fn contributions from differnt Domains (clusters). if (numTimeDomains > 1) { double factorToZeroOutCopies = 0.0; if (globalComm->SubDomainComm().MyPID()==0) factorToZeroOutCopies = 1.0; if (g_out.get()) { (*g_out).Scale(factorToZeroOutCopies); double* vPtr = &((*g_out)[0]); Epetra_Vector tmp = *(g_out.get()); globalComm->SumAll( &(tmp[0]), vPtr, num_g0); } if (!DgDp_out.isEmpty()) { DgDp_out.getMultiVector()->Scale(factorToZeroOutCopies); double* mvPtr = (*DgDp_out.getMultiVector())[0]; Epetra_MultiVector tmp = *(DgDp_out.getMultiVector()); globalComm->SumAll(tmp[0], mvPtr, num_dg0dp0); } } }
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; }
Piro::Epetra::NOXSolver::NOXSolver( Teuchos::RCP<Teuchos::ParameterList> piroParams_, Teuchos::RCP<EpetraExt::ModelEvaluator> model_, Teuchos::RCP<NOX::Epetra::Observer> observer_, Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> custom_interface, Teuchos::RCP<NOX::Epetra::LinearSystem> custom_linsys ) : piroParams(piroParams_), model(model_), observer(observer_), utils(piroParams->sublist("NOX").sublist("Printing")) { Teuchos::RCP<Teuchos::ParameterList> noxParams = Teuchos::rcp(&(piroParams->sublist("NOX")),false); Teuchos::ParameterList& printParams = noxParams->sublist("Printing"); std::string jacobianSource = piroParams->get("Jacobian Operator", "Have Jacobian"); bool leanMatrixFree = piroParams->get("Lean Matrix Free",false); Teuchos::ParameterList& noxstratlsParams = noxParams-> sublist("Direction").sublist("Newton").sublist("Stratimikos Linear Solver"); // Inexact Newton must be set in a second sublist when using // Stratimikos: This code snippet sets it automatically bool inexact = (noxParams->sublist("Direction").sublist("Newton"). get("Forcing Term Method", "Constant") != "Constant"); if (inexact) noxstratlsParams.sublist("NOX Stratimikos Options"). set("Use Linear Solve Tolerance From NOX", inexact); if (jacobianSource == "Matrix-Free") { if (piroParams->isParameter("Matrix-Free Perturbation")) { model = Teuchos::rcp(new Piro::Epetra::MatrixFreeDecorator(model, piroParams->get<double>("Matrix-Free Perturbation"))); } else model = Teuchos::rcp(new Piro::Epetra::MatrixFreeDecorator(model)); } // Grab some modelEval stuff from underlying model EpetraExt::ModelEvaluator::InArgs inargs = model->createInArgs(); num_p = inargs.Np(); EpetraExt::ModelEvaluator::OutArgs outargs = model->createOutArgs(); num_g = outargs.Ng(); // Create initial guess Teuchos::RCP<const Epetra_Vector> u = model->get_x_init(); currentSolution = Teuchos::rcp(new NOX::Epetra::Vector(*u)); // Create NOX interface from model evaluator if (custom_interface != Teuchos::null) interface = custom_interface; else interface = Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(model)); Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = interface; // Create the Jacobian matrix (unless flag is set to do it numerically) Teuchos::RCP<Epetra_Operator> A; Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac; if (jacobianSource == "Have Jacobian" || jacobianSource == "Matrix-Free") { A = model->create_W(); iJac = interface; } else if (jacobianSource == "Finite Difference") { A = Teuchos::rcp(new NOX::Epetra::FiniteDifference(printParams, iReq, *currentSolution)); iJac = Teuchos::rcp_dynamic_cast<NOX::Epetra::Interface::Jacobian>(A); } else TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter, "Error in Piro::Epetra::NOXSolver " << "Invalid value for parameter \" Jacobian Operator\"= " << jacobianSource << std::endl); // Create separate preconditioner if the model supports it /* NOTE: How do we want to decide between using an * available preconditioner: (1) If the model supports * it, then we use it, or (2) if a parameter list says * User_Defined ? [Below, logic is ooption (1).] */ Teuchos::RCP<EpetraExt::ModelEvaluator::Preconditioner> WPrec; if (outargs.supports(EpetraExt::ModelEvaluator::OUT_ARG_WPrec)) WPrec = model->create_WPrec(); // Create the linear system if (custom_linsys != Teuchos::null) linsys = custom_linsys; else { if (WPrec != Teuchos::null) { Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec = interface; linsys = Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos( printParams, noxstratlsParams, iJac, A, iPrec, WPrec->PrecOp, *currentSolution, WPrec->isAlreadyInverted)); } else { linsys = Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos( printParams, noxstratlsParams, iJac, A, *currentSolution)); } } // Build NOX group grp = Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *currentSolution, linsys)); // Saves one resid calculation per solve, but not as safe if (leanMatrixFree) grp->disableLinearResidualComputation(true); // Create the Solver convergence test Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests"); Teuchos::RCP<NOX::StatusTest::Generic> statusTests = NOX::StatusTest::buildStatusTests(statusParams, utils); // Create the solver solver = NOX::Solver::buildSolver(grp, statusTests, noxParams); // Create transpose linear solver Teuchos::RCP<LOCA::Abstract::Factory> epetraFactory = Teuchos::rcp(new LOCA::Epetra::Factory); globalData = LOCA::createGlobalData(piroParams, epetraFactory); LOCA::Epetra::TransposeLinearSystem::Factory tls_factory(globalData); tls_strategy = tls_factory.create(piroParams, linsys); }