int main(int argc, char *argv[]) {
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
/*** Initialize communicator. ***/
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
const int myRank = comm->getRank();
if ((iprint > 0) && (myRank == 0)) {
outStream = Teuchos::rcp(&std::cout, false);
}
else {
outStream = Teuchos::rcp(&bhs, false);
}
int errorFlag = 0;
// *** Example body.
try {
/*** Read in XML input ***/
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
/*** Initialize main data structure. ***/
Teuchos::RCP<MeshManager<RealT> > meshMgr
= Teuchos::rcp(new MeshManager_BackwardFacingStepChannel<RealT>(*parlist));
// Initialize PDE describing Navier-Stokes equations.
Teuchos::RCP<PDE_NavierStokes<RealT> > pde
= Teuchos::rcp(new PDE_NavierStokes<RealT>(*parlist));
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > con
= Teuchos::rcp(new PDE_Constraint<RealT>(pde,meshMgr,comm,*parlist,*outStream));
// Cast the constraint and get the assembler.
Teuchos::RCP<PDE_Constraint<RealT> > pdecon
= Teuchos::rcp_dynamic_cast<PDE_Constraint<RealT> >(con);
Teuchos::RCP<Assembler<RealT> > assembler = pdecon->getAssembler();
con->setSolveParameters(*parlist);
// Create state vector and set to zeroes
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = assembler->createStateVector();
u_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > up
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(u_rcp,pde,assembler));
Teuchos::RCP<Tpetra::MultiVector<> > p_rcp = assembler->createStateVector();
p_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > pp
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(p_rcp,pde,assembler));
// Create control vector and set to ones
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = assembler->createControlVector();
z_rcp->randomize(); //putScalar(1.0);
Teuchos::RCP<ROL::Vector<RealT> > zp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(z_rcp,pde,assembler));
// Create residual vector and set to zeros
Teuchos::RCP<Tpetra::MultiVector<> > r_rcp = assembler->createResidualVector();
r_rcp->putScalar(0.0);
Teuchos::RCP<ROL::Vector<RealT> > rp
= Teuchos::rcp(new PDE_DualSimVector<RealT>(r_rcp,pde,assembler));
// Create state direction vector and set to random
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = assembler->createStateVector();
du_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > dup
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(du_rcp,pde,assembler));
// Create control direction vector and set to random
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = assembler->createControlVector();
dz_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > dzp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(dz_rcp,pde,assembler));
// Create ROL SimOpt vectors
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
// Initialize quadratic objective function.
std::vector<Teuchos::RCP<QoI<RealT> > > qoi_vec(2,Teuchos::null);
qoi_vec[0] = Teuchos::rcp(new QoI_State_NavierStokes<RealT>(*parlist,
pde->getVelocityFE(),
pde->getPressureFE(),
pde->getFieldHelper()));
qoi_vec[1] = Teuchos::rcp(new QoI_L2Penalty_NavierStokes<RealT>(pde->getVelocityFE(),
pde->getPressureFE(),
pde->getVelocityBdryFE(),
pde->getBdryCellLocIds(),
pde->getFieldHelper()));
Teuchos::RCP<StdObjective_NavierStokes<RealT> > std_obj
= Teuchos::rcp(new StdObjective_NavierStokes<RealT>(*parlist));
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > obj
= Teuchos::rcp(new PDE_Objective<RealT>(qoi_vec,std_obj,assembler));
Teuchos::RCP<ROL::Reduced_Objective_SimOpt<RealT> > robj
= Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(obj, con, up, zp, pp, true, false));
up->zero();
zp->zero();
//z_rcp->putScalar(1.e0);
//dz_rcp->putScalar(0);
// Run derivative checks
bool checkDeriv = parlist->sublist("Problem").get("Check derivatives",false);
if ( checkDeriv ) {
obj->checkGradient(x,d,true,*outStream);
obj->checkHessVec(x,d,true,*outStream);
con->checkApplyJacobian(x,d,*up,true,*outStream);
con->checkApplyAdjointHessian(x,*dup,d,x,true,*outStream);
con->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
con->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
con->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
robj->checkGradient(*zp,*dzp,true,*outStream);
robj->checkHessVec(*zp,*dzp,true,*outStream);
}
bool useCompositeStep = parlist->sublist("Problem").get("Full space",false);
Teuchos::RCP<ROL::Algorithm<RealT> > algo;
if ( useCompositeStep ) {
algo = Teuchos::rcp(new ROL::Algorithm<RealT>("Composite Step",*parlist,false));
algo->run(x,*rp,*obj,*con,true,*outStream);
}
else {
algo = Teuchos::rcp(new ROL::Algorithm<RealT>("Trust Region",*parlist,false));
algo->run(*zp,*robj,true,*outStream);
}
// Output.
assembler->printMeshData(*outStream);
RealT tol(1.e-8);
Teuchos::Array<RealT> res(1,0);
con->solve(*rp,*up,*zp,tol);
pdecon->outputTpetraVector(u_rcp,"state.txt");
pdecon->outputTpetraVector(z_rcp,"control.txt");
con->value(*rp,*up,*zp,tol);
r_rcp->norm2(res.view(0,1));
*outStream << "Residual Norm: " << res[0] << std::endl;
errorFlag += (res[0] > 1.e-6 ? 1 : 0);
//pdecon->outputTpetraData();
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char *argv[]) {
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
/*** Initialize communicator. ***/
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
const int myRank = comm->getRank();
if ((iprint > 0) && (myRank == 0)) {
outStream = Teuchos::rcp(&std::cout, false);
}
else {
outStream = Teuchos::rcp(&bhs, false);
}
int errorFlag = 0;
// *** Example body.
try {
/*** Read in XML input ***/
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
/*** Initialize main data structure. ***/
Teuchos::RCP<MeshManager<RealT> > meshMgr
= Teuchos::rcp(new MeshManager_Stefan_Boltzmann<RealT>(*parlist));
std::cout << "Created mesh manager" << std::endl;
// Initialize PDE describe Stefan Boltzmann's equation
Teuchos::RCP<PDE_Stefan_Boltzmann<RealT> > pde
= Teuchos::rcp(new PDE_Stefan_Boltzmann<RealT>(*parlist));
std::cout << "Created PDE" << std::endl;
Teuchos::RCP<PDE_Constraint<RealT> > con
= Teuchos::rcp(new PDE_Constraint<RealT>(pde,meshMgr,comm,*parlist,*outStream));
std::cout << "Created constraint" << std::endl;
con->getAssembler()->printMeshData(*outStream);
// Initialize quadratic objective function
std::vector<Teuchos::RCP<QoI<RealT> > > qoi_vec(2,Teuchos::null);
qoi_vec[0] = Teuchos::rcp(new QoI_L2Tracking_Stefan_Boltzmann<RealT>(pde->getFE_VOL()));
qoi_vec[1] = Teuchos::rcp(new QoI_L2Penalty_Stefan_Boltzmann <RealT>(pde->getFE_VOL()));
Teuchos::RCP<StdObjective_Stefan_Boltzmann<RealT> > std_obj
= Teuchos::rcp(new StdObjective_Stefan_Boltzmann<RealT>(*parlist));
Teuchos::RCP<PDE_Objective<RealT> > obj
= Teuchos::rcp(new PDE_Objective<RealT>(qoi_vec,std_obj,con->getAssembler()));
// Create state vector and set to zeroes
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = con->getAssembler()->createStateVector();
u_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > up
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(u_rcp,pde,con->getAssembler()));
// Create control vector and set to ones
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = con->getAssembler()->createControlVector();
z_rcp->putScalar(1.0);
Teuchos::RCP<ROL::Vector<RealT> > zp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(z_rcp,pde,con->getAssembler()));
// Create residual vector and set to zeros
Teuchos::RCP<Tpetra::MultiVector<> > r_rcp = con->getAssembler()->createResidualVector();
r_rcp->putScalar(0.0);
Teuchos::RCP<ROL::Vector<RealT> > rp
= Teuchos::rcp(new PDE_DualSimVector<RealT>(r_rcp,pde,con->getAssembler()));
// Create state direction vector and set to random
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = con->getAssembler()->createStateVector();
du_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > dup
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(du_rcp,pde,con->getAssembler()));
// Create control direction vector and set to random
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = con->getAssembler()->createControlVector();
dz_rcp->putScalar(0.0);
//dz_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > dzp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(dz_rcp,pde,con->getAssembler()));
// Create ROL SimOpt vectors
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
// Run derivative checks
obj->checkGradient(x,d,true,*outStream);
obj->checkHessVec(x,d,true,*outStream);
con->checkApplyJacobian(x,d,*up,true,*outStream);
con->checkApplyAdjointHessian(x,*dup,d,x,true,*outStream);
con->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
con->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
con->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
ROL::Algorithm<RealT> algo("Composite Step",*parlist,false);
algo.run(x,*rp,*obj,*con,true,*outStream);
RealT tol(1.e-8);
con->solve(*rp,*up,*zp,tol);
con->getAssembler()->outputTpetraVector(u_rcp,"state.txt");
con->getAssembler()->outputTpetraVector(z_rcp,"control.txt");
Teuchos::Array<RealT> res(1,0);
con->value(*rp,*up,*zp,tol);
r_rcp->norm2(res.view(0,1));
*outStream << "Residual Norm: " << res[0] << std::endl;
errorFlag += (res[0] > 1.e-6 ? 1 : 0);
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char *argv[]) {
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
/*** Initialize communicator. ***/
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
const int myRank = comm->getRank();
if ((iprint > 0) && (myRank == 0)) {
outStream = Teuchos::rcp(&std::cout, false);
}
else {
outStream = Teuchos::rcp(&bhs, false);
}
int errorFlag = 0;
// *** Example body.
try {
RealT tol(1e-8), one(1);
/*** Read in XML input ***/
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
// Retrieve parameters.
const RealT domainWidth = parlist->sublist("Geometry").get("Width", 1.0);
const RealT domainHeight = parlist->sublist("Geometry").get("Height", 1.0);
const RealT volFraction = parlist->sublist("Problem").get("Volume Fraction", 0.4);
const RealT objFactor = parlist->sublist("Problem").get("Objective Scaling", 1e-4);
/*** Initialize main data structure. ***/
Teuchos::RCP<MeshManager<RealT> > meshMgr
= Teuchos::rcp(new MeshManager_TopoOpt<RealT>(*parlist));
// Initialize PDE describing elasticity equations.
Teuchos::RCP<PDE_TopoOpt<RealT> > pde
= Teuchos::rcp(new PDE_TopoOpt<RealT>(*parlist));
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > con
= Teuchos::rcp(new PDE_Constraint<RealT>(pde,meshMgr,comm,*parlist,*outStream));
// Initialize the filter PDE.
Teuchos::RCP<PDE_Filter<RealT> > pdeFilter
= Teuchos::rcp(new PDE_Filter<RealT>(*parlist));
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > conFilter
= Teuchos::rcp(new Linear_PDE_Constraint<RealT>(pdeFilter,meshMgr,comm,*parlist,*outStream));
// Cast the constraint and get the assembler.
Teuchos::RCP<PDE_Constraint<RealT> > pdecon
= Teuchos::rcp_dynamic_cast<PDE_Constraint<RealT> >(con);
Teuchos::RCP<Assembler<RealT> > assembler = pdecon->getAssembler();
con->setSolveParameters(*parlist);
// Create state vector.
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = assembler->createStateVector();
u_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > up
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(u_rcp,pde,assembler,*parlist));
Teuchos::RCP<Tpetra::MultiVector<> > p_rcp = assembler->createStateVector();
p_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > pp
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(p_rcp,pde,assembler,*parlist));
// Create control vector.
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = assembler->createControlVector();
//z_rcp->randomize();
z_rcp->putScalar(volFraction);
//z_rcp->putScalar(0);
Teuchos::RCP<ROL::Vector<RealT> > zp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(z_rcp,pde,assembler,*parlist));
// Create residual vector.
Teuchos::RCP<Tpetra::MultiVector<> > r_rcp = assembler->createResidualVector();
r_rcp->putScalar(0.0);
Teuchos::RCP<ROL::Vector<RealT> > rp
= Teuchos::rcp(new PDE_DualSimVector<RealT>(r_rcp,pde,assembler,*parlist));
// Create state direction vector.
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = assembler->createStateVector();
du_rcp->randomize();
//du_rcp->putScalar(0);
Teuchos::RCP<ROL::Vector<RealT> > dup
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(du_rcp,pde,assembler,*parlist));
// Create control direction vector.
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = assembler->createControlVector();
dz_rcp->randomize();
dz_rcp->scale(0.01);
Teuchos::RCP<ROL::Vector<RealT> > dzp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(dz_rcp,pde,assembler,*parlist));
// Create control test vector.
Teuchos::RCP<Tpetra::MultiVector<> > rz_rcp = assembler->createControlVector();
rz_rcp->randomize();
Teuchos::RCP<ROL::Vector<RealT> > rzp
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(rz_rcp,pde,assembler,*parlist));
Teuchos::RCP<Tpetra::MultiVector<> > dualu_rcp = assembler->createStateVector();
Teuchos::RCP<ROL::Vector<RealT> > dualup
= Teuchos::rcp(new PDE_DualSimVector<RealT>(dualu_rcp,pde,assembler,*parlist));
Teuchos::RCP<Tpetra::MultiVector<> > dualz_rcp = assembler->createControlVector();
Teuchos::RCP<ROL::Vector<RealT> > dualzp
= Teuchos::rcp(new PDE_DualOptVector<RealT>(dualz_rcp,pde,assembler,*parlist));
// Create ROL SimOpt vectors.
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
// Initialize "filtered" of "unfiltered" constraint.
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pdeWithFilter;
bool useFilter = parlist->sublist("Problem").get("Use Filter", true);
if (useFilter) {
pdeWithFilter = Teuchos::rcp(new ROL::CompositeEqualityConstraint_SimOpt<RealT>(con, conFilter, *rp, *rp, *up, *zp, *zp));
}
else {
pdeWithFilter = con;
}
pdeWithFilter->setSolveParameters(*parlist);
// Initialize compliance objective function.
Teuchos::ParameterList list(*parlist);
list.sublist("Vector").sublist("Sim").set("Use Riesz Map",true);
list.sublist("Vector").sublist("Sim").set("Lump Riesz Map",false);
// Has state Riesz map enabled for mesh-independent compliance scaling.
Teuchos::RCP<Tpetra::MultiVector<> > f_rcp = assembler->createResidualVector();
f_rcp->putScalar(0.0);
Teuchos::RCP<ROL::Vector<RealT> > fp
= Teuchos::rcp(new PDE_DualSimVector<RealT>(f_rcp,pde,assembler,list));
up->zero();
con->value(*fp, *up, *zp, tol);
RealT objScaling = objFactor, fnorm2 = fp->dot(*fp);
if (fnorm2 > 1e2*ROL::ROL_EPSILON<RealT>()) {
objScaling /= fnorm2;
}
u_rcp->randomize();
std::vector<Teuchos::RCP<QoI<RealT> > > qoi_vec(1,Teuchos::null);
qoi_vec[0] = Teuchos::rcp(new QoI_TopoOpt<RealT>(pde->getFE(),
pde->getLoad(),
pde->getFieldHelper(),
objScaling));
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > obj
= Teuchos::rcp(new PDE_Objective<RealT>(qoi_vec,assembler));
// Initialize volume constraint,
Teuchos::RCP<QoI<RealT> > qoi_vol
= Teuchos::rcp(new QoI_Volume_TopoOpt<RealT>(pde->getFE(),pde->getFieldHelper(),*parlist));
Teuchos::RCP<IntegralOptConstraint<RealT> > vcon
= Teuchos::rcp(new IntegralOptConstraint<RealT>(qoi_vol,assembler));
// Create volume constraint vector and set to zero
RealT vecScaling = one / std::pow(domainWidth*domainHeight*(one-volFraction), 2);
Teuchos::RCP<std::vector<RealT> > scalevec_rcp = Teuchos::rcp(new std::vector<RealT>(1,vecScaling));
Teuchos::RCP<std::vector<RealT> > c1_rcp = Teuchos::rcp(new std::vector<RealT>(1,0));
Teuchos::RCP<ROL::Vector<RealT> > c1p = Teuchos::rcp(new ROL::PrimalScaledStdVector<RealT>(c1_rcp, scalevec_rcp));
Teuchos::RCP<std::vector<RealT> > c2_rcp = Teuchos::rcp(new std::vector<RealT>(1,1));
Teuchos::RCP<ROL::Vector<RealT> > c2p = Teuchos::rcp(new ROL::DualScaledStdVector<RealT>(c2_rcp, scalevec_rcp));
// Initialize bound constraints.
Teuchos::RCP<Tpetra::MultiVector<> > lo_rcp = assembler->createControlVector();
Teuchos::RCP<Tpetra::MultiVector<> > hi_rcp = assembler->createControlVector();
lo_rcp->putScalar(0.0); hi_rcp->putScalar(1.0);
Teuchos::RCP<ROL::Vector<RealT> > lop
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(lo_rcp,pde,assembler));
Teuchos::RCP<ROL::Vector<RealT> > hip
= Teuchos::rcp(new PDE_PrimalOptVector<RealT>(hi_rcp,pde,assembler));
Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd
= Teuchos::rcp(new ROL::BoundConstraint<RealT>(lop,hip));
// Initialize Augmented Lagrangian functional.
bool storage = parlist->sublist("Problem").get("Use state storage",true);
Teuchos::RCP<ROL::SimController<RealT> > stateStore
= Teuchos::rcp(new ROL::SimController<RealT>());
Teuchos::RCP<ROL::Reduced_Objective_SimOpt<RealT> > objRed
= Teuchos::rcp(new
ROL::Reduced_Objective_SimOpt<RealT>(obj,pdeWithFilter,
stateStore,up,zp,pp,
storage));
ROL::AugmentedLagrangian<RealT> augLag(objRed,vcon,*c2p,1,
*zp,*c1p,*parlist);
// Run derivative checks
bool checkDeriv = parlist->sublist("Problem").get("Check derivatives",false);
if ( checkDeriv ) {
*outStream << "\n\nCheck Opt Vector\n";
zp->checkVector(*dzp,*rzp,true,*outStream);
*outStream << "\n\nCheck Gradient of Full Objective Function\n";
obj->checkGradient(x,d,true,*outStream);
*outStream << "\n\nCheck Hessian of Full Objective Function\n";
obj->checkHessVec(x,d,true,*outStream);
*outStream << "\n\nCheck Full Jacobian of PDE Constraint\n";
con->checkApplyJacobian(x,d,*rp,true,*outStream);
*outStream << "\n\nCheck Jacobian_1 of PDE Constraint\n";
con->checkApplyJacobian_1(*up,*zp,*dup,*rp,true,*outStream);
*outStream << "\n\nCheck Jacobian_2 of PDE Constraint\n";
con->checkApplyJacobian_2(*up,*zp,*dzp,*rp,true,*outStream);
*outStream << "\n\nCheck Full Hessian of PDE Constraint\n";
con->checkApplyAdjointHessian(x,*pp,d,x,true,*outStream);
*outStream << "\n\nCheck Hessian_11 of PDE Constraint\n";
con->checkApplyAdjointHessian_11(*up,*zp,*pp,*dup,*dualup,true,*outStream);
*outStream << "\n\nCheck Hessian_21 of PDE Constraint\n";
con->checkApplyAdjointHessian_21(*up,*zp,*pp,*dzp,*dualup,true,*outStream);
*outStream << "\n\nCheck Hessian_12 of PDE Constraint\n";
con->checkApplyAdjointHessian_12(*up,*zp,*pp,*dup,*dualzp,true,*outStream);
*outStream << "\n\nCheck Hessian_22 of PDE Constraint\n";
con->checkApplyAdjointHessian_22(*up,*zp,*pp,*dzp,*dualzp,true,*outStream);
*outStream << "\n";
con->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
*outStream << "\n";
con->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
*outStream << "\n";
con->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
*outStream << "\n\nCheck Full Jacobian of Filter\n";
conFilter->checkApplyJacobian(x,d,*rp,true,*outStream);
*outStream << "\n\nCheck Jacobian_1 of Filter\n";
conFilter->checkApplyJacobian_1(*up,*zp,*dup,*rp,true,*outStream);
*outStream << "\n\nCheck Jacobian_2 of Filter\n";
conFilter->checkApplyJacobian_2(*up,*zp,*dzp,*rp,true,*outStream);
*outStream << "\n\nCheck Full Hessian of Filter\n";
conFilter->checkApplyAdjointHessian(x,*pp,d,x,true,*outStream);
*outStream << "\n\nCheck Hessian_11 of Filter\n";
conFilter->checkApplyAdjointHessian_11(*up,*zp,*pp,*dup,*dualup,true,*outStream);
*outStream << "\n\nCheck Hessian_21 of Filter\n";
conFilter->checkApplyAdjointHessian_21(*up,*zp,*pp,*dzp,*dualup,true,*outStream);
*outStream << "\n\nCheck Hessian_12 of Filter\n";
conFilter->checkApplyAdjointHessian_12(*up,*zp,*pp,*dup,*dualzp,true,*outStream);
*outStream << "\n\nCheck Hessian_22 of Filter\n";
conFilter->checkApplyAdjointHessian_22(*up,*zp,*pp,*dzp,*dualzp,true,*outStream);
*outStream << "\n";
conFilter->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
*outStream << "\n";
conFilter->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
*outStream << "\n";
conFilter->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
*outStream << "\n\nCheck Full Jacobian of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyJacobian(x,d,*rp,true,*outStream);
*outStream << "\n\nCheck Jacobian_1 of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyJacobian_1(*up,*zp,*dup,*rp,true,*outStream);
*outStream << "\n\nCheck Jacobian_2 of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyJacobian_2(*up,*zp,*dzp,*rp,true,*outStream);
*outStream << "\n\nCheck Full Hessian of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyAdjointHessian(x,*pp,d,x,true,*outStream);
*outStream << "\n\nCheck Hessian_11 of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyAdjointHessian_11(*up,*zp,*pp,*dup,*dualup,true,*outStream);
*outStream << "\n\nCheck Hessian_21 of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyAdjointHessian_21(*up,*zp,*pp,*dzp,*dualup,true,*outStream);
*outStream << "\n\nCheck Hessian_12 of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyAdjointHessian_12(*up,*zp,*pp,*dup,*dualzp,true,*outStream);
*outStream << "\n\nCheck Hessian_22 of Filtered PDE Constraint\n";
pdeWithFilter->checkApplyAdjointHessian_22(*up,*zp,*pp,*dzp,*dualzp,true,*outStream);
*outStream << "\n";
pdeWithFilter->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
*outStream << "\n";
pdeWithFilter->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
*outStream << "\n";
pdeWithFilter->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
*outStream << "\n\nCheck Gradient of Reduced Objective Function\n";
objRed->checkGradient(*zp,*dzp,true,*outStream);
*outStream << "\n\nCheck Hessian of Reduced Objective Function\n";
objRed->checkHessVec(*zp,*dzp,true,*outStream);
*outStream << "\n\nCheck Full Jacobian of Volume Constraint\n";
vcon->checkApplyJacobian(*zp,*dzp,*c1p,true,*outStream);
*outStream << "\n";
vcon->checkAdjointConsistencyJacobian(*c1p,*dzp,*zp,true,*outStream);
*outStream << "\n\nCheck Full Hessian of Volume Constraint\n";
vcon->checkApplyAdjointHessian(*zp,*c2p,*dzp,*zp,true,*outStream);
*outStream << "\n\nCheck Gradient of Augmented Lagrangian Function\n";
augLag.checkGradient(*zp,*dzp,true,*outStream);
*outStream << "\n\nCheck Hessian of Augmented Lagrangian Function\n";
augLag.checkHessVec(*zp,*dzp,true,*outStream);
*outStream << "\n";
}
ROL::Algorithm<RealT> algo("Augmented Lagrangian",*parlist,false);
Teuchos::Time algoTimer("Algorithm Time", true);
algo.run(*zp,*c2p,augLag,*vcon,*bnd,true,*outStream);
algoTimer.stop();
*outStream << "Total optimization time = " << algoTimer.totalElapsedTime() << " seconds.\n";
// Output.
pdecon->printMeshData(*outStream);
con->solve(*rp,*up,*zp,tol);
pdecon->outputTpetraVector(u_rcp,"state.txt");
pdecon->outputTpetraVector(z_rcp,"density.txt");
//Teuchos::Array<RealT> res(1,0);
//con->value(*rp,*up,*zp,tol);
//r_rcp->norm2(res.view(0,1));
//*outStream << "Residual Norm: " << res[0] << std::endl;
//errorFlag += (res[0] > 1.e-6 ? 1 : 0);
//pdecon->outputTpetraData();
// Get a summary from the time monitor.
Teuchos::TimeMonitor::summarize();
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char *argv[]) {
// feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
/*** Initialize communicator. ***/
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
Teuchos::RCP<const Teuchos::Comm<int> > serial_comm
= Teuchos::rcp(new Teuchos::SerialComm<int>());
const int myRank = comm->getRank();
if ((iprint > 0) && (myRank == 0)) {
outStream = Teuchos::rcp(&std::cout, false);
}
else {
outStream = Teuchos::rcp(&bhs, false);
}
int errorFlag = 0;
// *** Example body.
try {
/*** Read in XML input ***/
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
// Problem dimensions
const int stochDim = 32, controlDim = 1;
const RealT one(1);
/*************************************************************************/
/***************** BUILD GOVERNING PDE ***********************************/
/*************************************************************************/
/*** Initialize main data structure. ***/
Teuchos::RCP<MeshManager<RealT> > meshMgr
= Teuchos::rcp(new MeshManager_BackwardFacingStepChannel<RealT>(*parlist));
// = Teuchos::rcp(new StochasticStefanBoltzmannMeshManager<RealT>(*parlist));
// Initialize PDE describing advection-diffusion equation
Teuchos::RCP<StochasticStefanBoltzmannPDE<RealT> > pde
= Teuchos::rcp(new StochasticStefanBoltzmannPDE<RealT>(*parlist));
Teuchos::RCP<ROL::ParametrizedEqualityConstraint_SimOpt<RealT> > con
= Teuchos::rcp(new PDE_Constraint<RealT>(pde,meshMgr,serial_comm,*parlist,*outStream));
// Get the assembler.
Teuchos::RCP<Assembler<RealT> > assembler
= (Teuchos::rcp_dynamic_cast<PDE_Constraint<RealT> >(con))->getAssembler();
con->setSolveParameters(*parlist);
assembler->printMeshData(*outStream);
/*************************************************************************/
/***************** BUILD VECTORS *****************************************/
/*************************************************************************/
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = assembler->createStateVector();
Teuchos::RCP<Tpetra::MultiVector<> > p_rcp = assembler->createStateVector();
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = assembler->createStateVector();
u_rcp->randomize(); //u_rcp->putScalar(static_cast<RealT>(1));
p_rcp->randomize(); //p_rcp->putScalar(static_cast<RealT>(1));
du_rcp->randomize(); //du_rcp->putScalar(static_cast<RealT>(0));
Teuchos::RCP<ROL::Vector<RealT> > up
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(u_rcp,pde,assembler));
Teuchos::RCP<ROL::Vector<RealT> > pp
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(p_rcp,pde,assembler));
Teuchos::RCP<ROL::Vector<RealT> > dup
= Teuchos::rcp(new PDE_PrimalSimVector<RealT>(du_rcp,pde,assembler));
// Create residual vectors
Teuchos::RCP<Tpetra::MultiVector<> > r_rcp = assembler->createResidualVector();
r_rcp->randomize(); //r_rcp->putScalar(static_cast<RealT>(1));
Teuchos::RCP<ROL::Vector<RealT> > rp
= Teuchos::rcp(new PDE_DualSimVector<RealT>(r_rcp,pde,assembler));
// Create control vector and set to ones
Teuchos::RCP<std::vector<RealT> > z_rcp = Teuchos::rcp(new std::vector<RealT>(controlDim));
Teuchos::RCP<std::vector<RealT> > dz_rcp = Teuchos::rcp(new std::vector<RealT>(controlDim));
Teuchos::RCP<std::vector<RealT> > yz_rcp = Teuchos::rcp(new std::vector<RealT>(controlDim));
// Create control direction vector and set to random
for (int i = 0; i < controlDim; ++i) {
(*z_rcp)[i] = random<RealT>(*comm);
(*dz_rcp)[i] = 1e-3*random<RealT>(*comm);
(*yz_rcp)[i] = random<RealT>(*comm);
}
Teuchos::RCP<ROL::Vector<RealT> > zp
= Teuchos::rcp(new PDE_OptVector<RealT>(Teuchos::rcp(new ROL::StdVector<RealT>(z_rcp))));
Teuchos::RCP<ROL::Vector<RealT> > dzp
= Teuchos::rcp(new PDE_OptVector<RealT>(Teuchos::rcp(new ROL::StdVector<RealT>(dz_rcp))));
Teuchos::RCP<ROL::Vector<RealT> > yzp
= Teuchos::rcp(new PDE_OptVector<RealT>(Teuchos::rcp(new ROL::StdVector<RealT>(yz_rcp))));
//Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = assembler->createControlVector();
//Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = assembler->createControlVector();
//Teuchos::RCP<Tpetra::MultiVector<> > yz_rcp = assembler->createControlVector();
//z_rcp->randomize(); z_rcp->putScalar(static_cast<RealT>(280));
//dz_rcp->randomize(); //dz_rcp->putScalar(static_cast<RealT>(0));
//yz_rcp->randomize(); //yz_rcp->putScalar(static_cast<RealT>(0));
//Teuchos::RCP<ROL::TpetraMultiVector<RealT> > zpde
// = Teuchos::rcp(new PDE_PrimalOptVector<RealT>(z_rcp,pde,assembler));
//Teuchos::RCP<ROL::TpetraMultiVector<RealT> > dzpde
// = Teuchos::rcp(new PDE_PrimalOptVector<RealT>(dz_rcp,pde,assembler));
//Teuchos::RCP<ROL::TpetraMultiVector<RealT> > yzpde
// = Teuchos::rcp(new PDE_PrimalOptVector<RealT>(yz_rcp,pde,assembler));
//Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(new PDE_OptVector<RealT>(zpde));
//Teuchos::RCP<ROL::Vector<RealT> > dzp = Teuchos::rcp(new PDE_OptVector<RealT>(dzpde));
//Teuchos::RCP<ROL::Vector<RealT> > yzp = Teuchos::rcp(new PDE_OptVector<RealT>(yzpde));
// Create ROL SimOpt vectors
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
/*************************************************************************/
/***************** BUILD COST FUNCTIONAL *********************************/
/*************************************************************************/
std::vector<Teuchos::RCP<QoI<RealT> > > qoi_vec(2,Teuchos::null);
qoi_vec[0] = Teuchos::rcp(new QoI_StateCost<RealT>(pde->getVolFE(),*parlist));
//qoi_vec[1] = Teuchos::rcp(new QoI_ControlCost<RealT>(
// pde->getVolFE(),pde->getBdryFE(0),pde->getBdryCellLocIds(0),*parlist));
qoi_vec[1] = Teuchos::rcp(new QoI_AdvectionCost<RealT>());
Teuchos::RCP<StochasticStefanBoltzmannStdObjective<RealT> > std_obj
= Teuchos::rcp(new StochasticStefanBoltzmannStdObjective<RealT>(*parlist));
Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<RealT> > obj
= Teuchos::rcp(new PDE_Objective<RealT>(qoi_vec,std_obj,assembler));
Teuchos::RCP<ROL::Reduced_ParametrizedObjective_SimOpt<RealT> > objReduced
= Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<RealT>(obj, con, up, pp, true, false));
/*************************************************************************/
/***************** BUILD BOUND CONSTRAINT ********************************/
/*************************************************************************/
RealT upper = parlist->sublist("Problem").get("Upper Advection Bound", 100.0);
RealT lower = parlist->sublist("Problem").get("Lower Advection Bound",-100.0);
Teuchos::RCP<std::vector<RealT> > zlo_rcp = Teuchos::rcp(new std::vector<RealT>(controlDim,lower));
Teuchos::RCP<std::vector<RealT> > zhi_rcp = Teuchos::rcp(new std::vector<RealT>(controlDim,upper));
Teuchos::RCP<ROL::Vector<RealT> > zlop
= Teuchos::rcp(new PDE_OptVector<RealT>(Teuchos::rcp(new ROL::StdVector<RealT>(zlo_rcp))));
Teuchos::RCP<ROL::Vector<RealT> > zhip
= Teuchos::rcp(new PDE_OptVector<RealT>(Teuchos::rcp(new ROL::StdVector<RealT>(zhi_rcp))));
//Teuchos::RCP<Tpetra::MultiVector<> > zlo_rcp = assembler->createControlVector();
//Teuchos::RCP<Tpetra::MultiVector<> > zhi_rcp = assembler->createControlVector();
//zlo_rcp->putScalar(static_cast<RealT>(280));
//zhi_rcp->putScalar(static_cast<RealT>(370));
//Teuchos::RCP<ROL::TpetraMultiVector<RealT> > zlopde
// = Teuchos::rcp(new PDE_PrimalOptVector<RealT>(zlo_rcp,pde,assembler));
//Teuchos::RCP<ROL::TpetraMultiVector<RealT> > zhipde
// = Teuchos::rcp(new PDE_PrimalOptVector<RealT>(zhi_rcp,pde,assembler));
//Teuchos::RCP<ROL::Vector<RealT> > zlop = Teuchos::rcp(new PDE_OptVector<RealT>(zlopde));
//Teuchos::RCP<ROL::Vector<RealT> > zhip = Teuchos::rcp(new PDE_OptVector<RealT>(zhipde));
Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd
= Teuchos::rcp(new ROL::BoundConstraint<RealT>(zlop,zhip));
/*************************************************************************/
/***************** BUILD SAMPLER *****************************************/
/*************************************************************************/
int nsamp = parlist->sublist("Problem").get("Number of Samples",100);
std::vector<RealT> tmp = {-one,one};
std::vector<std::vector<RealT> > bounds(stochDim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman
= Teuchos::rcp(new PDE_OptVector_BatchManager<RealT>(comm));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
= Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nsamp,bounds,bman));
/*************************************************************************/
/***************** BUILD STOCHASTIC PROBLEM ******************************/
/*************************************************************************/
ROL::StochasticProblem<RealT> opt(*parlist,objReduced,sampler,zp,bnd);
opt.setSolutionStatistic(one);
/*************************************************************************/
/***************** RUN VECTOR AND DERIVATIVE CHECKS **********************/
/*************************************************************************/
bool checkDeriv = parlist->sublist("Problem").get("Check Derivatives",false);
if ( checkDeriv ) {
up->checkVector(*pp,*dup,true,*outStream);
zp->checkVector(*yzp,*dzp,true,*outStream);
obj->checkGradient(x,d,true,*outStream);
obj->checkHessVec(x,d,true,*outStream);
con->checkApplyJacobian(x,d,*up,true,*outStream);
con->checkApplyAdjointHessian(x,*dup,d,x,true,*outStream);
con->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
con->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
con->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
objReduced->checkGradient(*zp,*dzp,true,*outStream);
objReduced->checkHessVec(*zp,*dzp,true,*outStream);
opt.checkObjectiveGradient(*dzp,true,*outStream);
opt.checkObjectiveHessVec(*dzp,true,*outStream);
}
/*************************************************************************/
/***************** SOLVE OPTIMIZATION PROBLEM ****************************/
/*************************************************************************/
ROL::Algorithm<RealT> algo("Trust Region",*parlist,false);
(*z_rcp)[0] = parlist->sublist("Problem").get("Advection Magnitude",0.0);
u_rcp->putScalar(450.0);
std::clock_t timer = std::clock();
algo.run(opt,true,*outStream);
*outStream << "Optimization time: "
<< static_cast<RealT>(std::clock()-timer)/static_cast<RealT>(CLOCKS_PER_SEC)
<< " seconds." << std::endl << std::endl;
/*************************************************************************/
/***************** OUTPUT RESULTS ****************************************/
/*************************************************************************/
std::clock_t timer_print = std::clock();
// Output control to file
//assembler->outputTpetraVector(z_rcp,"control.txt");
*outStream << std::endl << "Advection value: " << (*z_rcp)[0] << std::endl;
// Output expected state and samples to file
*outStream << std::endl << "Print Expected Value of State" << std::endl;
up->zero(); pp->zero(); dup->zero();
RealT tol(1.e-8);
Teuchos::RCP<ROL::BatchManager<RealT> > bman_Eu
= Teuchos::rcp(new ROL::TpetraTeuchosBatchManager<RealT>(comm));
std::vector<RealT> sample(stochDim);
std::stringstream name_samp;
name_samp << "samples_" << bman->batchID() << ".txt";
std::ofstream file_samp;
file_samp.open(name_samp.str());
file_samp << std::scientific << std::setprecision(15);
for (int i = 0; i < sampler->numMySamples(); ++i) {
*outStream << "Sample i = " << i << std::endl;
sample = sampler->getMyPoint(i);
con->setParameter(sample);
con->solve(*rp,*dup,*zp,tol);
up->axpy(sampler->getMyWeight(i),*dup);
for (int j = 0; j < stochDim; ++j) {
file_samp << std::setw(25) << std::left << sample[j];
}
file_samp << std::endl;
}
file_samp.close();
bman_Eu->sumAll(*up,*pp);
assembler->outputTpetraVector(p_rcp,"mean_state.txt");
// Build objective function distribution
*outStream << std::endl << "Print Objective CDF" << std::endl;
RealT val1(0), val2(0);
int nsamp_dist = parlist->sublist("Problem").get("Number of Output Samples",100);
Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<RealT> > stateCost
= Teuchos::rcp(new IntegralObjective<RealT>(qoi_vec[0],assembler));
Teuchos::RCP<ROL::Reduced_ParametrizedObjective_SimOpt<RealT> > redStateCost
= Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<RealT>(stateCost, con, up, pp, true, false));
Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<RealT> > ctrlCost
= Teuchos::rcp(new IntegralObjective<RealT>(qoi_vec[1],assembler));
Teuchos::RCP<ROL::Reduced_ParametrizedObjective_SimOpt<RealT> > redCtrlCost
= Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<RealT>(ctrlCost, con, up, pp, true, false));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler_dist
= Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nsamp_dist,bounds,bman));
std::stringstream name;
name << "obj_samples_" << bman->batchID() << ".txt";
std::ofstream file;
file.open(name.str());
file << std::scientific << std::setprecision(15);
for (int i = 0; i < sampler_dist->numMySamples(); ++i) {
sample = sampler_dist->getMyPoint(i);
redStateCost->setParameter(sample);
val1 = redStateCost->value(*zp,tol);
redCtrlCost->setParameter(sample);
val2 = redCtrlCost->value(*zp,tol);
for (int j = 0; j < stochDim; ++j) {
file << std::setw(25) << std::left << sample[j];
}
file << std::setw(25) << std::left << val1;
file << std::setw(25) << std::left << val2 << std::endl;
}
file.close();
*outStream << "Output time: "
<< static_cast<RealT>(std::clock()-timer_print)/static_cast<RealT>(CLOCKS_PER_SEC)
<< " seconds." << std::endl << std::endl;
Teuchos::Array<RealT> res(1,0);
con->value(*rp,*up,*zp,tol);
r_rcp->norm2(res.view(0,1));
/*************************************************************************/
/***************** CHECK RESIDUAL NORM ***********************************/
/*************************************************************************/
*outStream << "Residual Norm: " << res[0] << std::endl << std::endl;
errorFlag += (res[0] > 1.e-6 ? 1 : 0);
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
