int main(int argc, char* argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Teuchos::DefaultComm<int>::getComm();
// 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
if (iprint > 0 && Teuchos::rank<int>(*comm)==0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
try {
/**********************************************************************************************/
/************************* CONSTRUCT ROL ALGORITHM ********************************************/
/**********************************************************************************************/
// Get ROL parameterlist
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
// Build ROL algorithm
parlist->sublist("Status Test").set("Gradient Tolerance",1.e-8);
parlist->sublist("Status Test").set("Step Tolerance",1.e-14);
parlist->sublist("Status Test").set("Iteration Limit",100);
Teuchos::RCP<ROL::Algorithm<double> > algo;
/**********************************************************************************************/
/************************* CONSTRUCT VECTORS **************************************************/
/**********************************************************************************************/
// Build control vectors
int nx = 256;
Teuchos::RCP<std::vector<double> > x1_rcp = Teuchos::rcp( new std::vector<double>(nx+2,0.0) );
ROL::StdVector<double> x1(x1_rcp);
Teuchos::RCP<std::vector<double> > x2_rcp = Teuchos::rcp( new std::vector<double>(nx+2,0.0) );
ROL::StdVector<double> x2(x2_rcp);
Teuchos::RCP<std::vector<double> > x3_rcp = Teuchos::rcp( new std::vector<double>(nx+2,0.0) );
ROL::StdVector<double> x3(x3_rcp);
Teuchos::RCP<std::vector<double> > z_rcp = Teuchos::rcp( new std::vector<double>(nx+2,0.0) );
ROL::StdVector<double> z(z_rcp);
Teuchos::RCP<std::vector<double> > xr_rcp = Teuchos::rcp( new std::vector<double>(nx+2,0.0) );
ROL::StdVector<double> xr(xr_rcp);
Teuchos::RCP<std::vector<double> > d_rcp = Teuchos::rcp( new std::vector<double>(nx+2,0.0) );
ROL::StdVector<double> d(d_rcp);
for ( int i = 0; i < nx+2; i++ ) {
(*xr_rcp)[i] = random<double>(comm);
(*d_rcp)[i] = random<double>(comm);
}
// Build state and adjoint vectors
Teuchos::RCP<std::vector<double> > u_rcp = Teuchos::rcp( new std::vector<double>(nx,1.0) );
ROL::StdVector<double> u(u_rcp);
Teuchos::RCP<std::vector<double> > p_rcp = Teuchos::rcp( new std::vector<double>(nx,0.0) );
ROL::StdVector<double> p(p_rcp);
Teuchos::RCP<ROL::Vector<double> > up = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<double> > pp = Teuchos::rcp(&p,false);
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Build samplers
int dim = 4;
int nSamp = 100;
std::vector<double> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
std::vector<std::vector<double> > bounds(dim,tmp);
Teuchos::RCP<ROL::BatchManager<double> > bman
= Teuchos::rcp(new ROL::StdTeuchosBatchManager<double,int>(comm));
Teuchos::RCP<ROL::SampleGenerator<double> > sampler
= Teuchos::rcp(new ROL::MonteCarloGenerator<double>(nSamp,bounds,bman,false,false,100));
/**********************************************************************************************/
/************************* CONSTRUCT OBJECTIVE FUNCTION ***************************************/
/**********************************************************************************************/
// Build risk-averse objective function
double alpha = 1.e-3;
Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<double> > pobjSimOpt
= Teuchos::rcp(new Objective_BurgersControl<double>(alpha,nx));
Teuchos::RCP<ROL::ParametrizedEqualityConstraint_SimOpt<double> > pconSimOpt
= Teuchos::rcp(new EqualityConstraint_BurgersControl<double>(nx));
Teuchos::RCP<ROL::ParametrizedObjective<double> > pObj
= Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<double>(pobjSimOpt,pconSimOpt,up,pp));
Teuchos::RCP<ROL::Objective<double> > obj;
// Test parametrized objective functions
*outStream << "Check Derivatives of Parametrized Objective Function\n";
x1.set(xr);
pObj->setParameter(sampler->getMyPoint(0));
pObj->checkGradient(x1,d,true,*outStream);
pObj->checkHessVec(x1,d,true,*outStream);
/**********************************************************************************************/
/************************* SMOOTHED CVAR 1.e-2 ************************************************/
/**********************************************************************************************/
*outStream << "\nSOLVE SMOOTHED CONDITIONAL VALUE AT RISK WITH TRUST REGION\n";
// Build CVaR objective function
Teuchos::ParameterList list1;
list1.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list1.sublist("SOL").set("Store Sampled Value and Gradient",true);
list1.sublist("SOL").sublist("Risk Measure").set("Name","CVaR");
list1.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Confidence Level",0.99);
list1.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Convex Combination Parameter",1.0);
list1.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Smoothing Parameter",1.e-2);
list1.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").set("Name","Parabolic");
list1.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Parabolic").set("Lower Bound",-0.5);
list1.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Parabolic").set("Upper Bound", 0.5);
// Build stochastic problem
Teuchos::RCP<ROL::Vector<double> > x1p = Teuchos::rcp(&x1,false);
x1p->zero();
ROL::StochasticProblem<double> optProb1(list1,pObj,sampler,x1p);
optProb1.checkObjectiveGradient(d,true,*outStream);
optProb1.checkObjectiveHessVec(d,true,*outStream);
// Run ROL algorithm
algo = Teuchos::rcp(new ROL::Algorithm<double>("Trust Region",*parlist,false));
clock_t start = clock();
algo->run(optProb1,true,*outStream);
*outStream << "Optimization time: " << (double)(clock()-start)/(double)CLOCKS_PER_SEC << " seconds.\n";
/**********************************************************************************************/
/************************* SMOOTHED CVAR 1.e-4 ************************************************/
/**********************************************************************************************/
*outStream << "\nSOLVE SMOOTHED CONDITIONAL VALUE AT RISK WITH TRUST REGION\n";
Teuchos::ParameterList list2;
list2.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list2.sublist("SOL").set("Store Sampled Value and Gradient",true);
list2.sublist("SOL").sublist("Risk Measure").set("Name","CVaR");
list2.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Confidence Level",0.99);
list2.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Convex Combination Parameter",1.0);
list2.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Smoothing Parameter",1.e-4);
list2.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").set("Name","Parabolic");
list2.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Parabolic").set("Lower Bound",-0.5);
list2.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Parabolic").set("Upper Bound", 0.5);
// Build stochastic problem
Teuchos::RCP<ROL::Vector<double> > x2p = Teuchos::rcp(&x2,false);
x2p->set(*x1p);
ROL::StochasticProblem<double> optProb2(list2,pObj,sampler,x2p);
optProb2.setSolutionStatistic(optProb1.getSolutionStatistic());
optProb2.checkObjectiveGradient(d,true,*outStream);
optProb2.checkObjectiveHessVec(d,true,*outStream);
// Run ROL algorithm
algo = Teuchos::rcp(new ROL::Algorithm<double>("Trust Region",*parlist,false));
start = clock();
algo->run(optProb2,true,*outStream);
*outStream << "Optimization time: " << (double)(clock()-start)/(double)CLOCKS_PER_SEC << " seconds.\n";
/**********************************************************************************************/
/************************* SMOOTHED CVAR 1.e-6 ************************************************/
/**********************************************************************************************/
*outStream << "\nSOLVE SMOOTHED CONDITIONAL VALUE AT RISK WITH TRUST REGION\n";
Teuchos::ParameterList list3;
list3.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list3.sublist("SOL").set("Store Sampled Value and Gradient",true);
list3.sublist("SOL").sublist("Risk Measure").set("Name","CVaR");
list3.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Confidence Level",0.99);
list3.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Convex Combination Parameter",1.0);
list3.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Smoothing Parameter",1.e-6);
list3.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").set("Name","Parabolic");
list3.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Parabolic").set("Lower Bound",-0.5);
list3.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Parabolic").set("Upper Bound", 0.5);
// Build stochastic problem
Teuchos::RCP<ROL::Vector<double> > x3p = Teuchos::rcp(&x3,false);
x3p->set(*x2p);
ROL::StochasticProblem<double> optProb3(list3,pObj,sampler,x3p);
optProb3.setSolutionStatistic(optProb2.getSolutionStatistic());
optProb3.checkObjectiveGradient(d,true,*outStream);
optProb3.checkObjectiveHessVec(d,true,*outStream);
// Run ROL algorithm
algo = Teuchos::rcp(new ROL::Algorithm<double>("Trust Region",*parlist,false));
start = clock();
algo->run(optProb3,true,*outStream);
*outStream << "Optimization time: " << (double)(clock()-start)/(double)CLOCKS_PER_SEC << " seconds.\n";
/**********************************************************************************************/
/************************* NONSMOOTH PROBLEM **************************************************/
/**********************************************************************************************/
*outStream << "\nSOLVE NONSMOOTH CVAR PROBLEM WITH BUNDLE TRUST REGION\n";
Teuchos::ParameterList list;
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").set("Store Sampled Value and Gradient",true);
list.sublist("SOL").sublist("Risk Measure").set("Name","CVaR");
list.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Confidence Level",0.99);
list.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Convex Combination Parameter",1.0);
list.sublist("SOL").sublist("Risk Measure").sublist("CVaR").set("Smoothing Parameter",0.);
list.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").set("Name","Dirac");
list.sublist("SOL").sublist("Risk Measure").sublist("CVaR").sublist("Distribution").sublist("Dirac").set("Location",0.);
// Build stochastic problem
Teuchos::RCP<ROL::Vector<double> > zp = Teuchos::rcp(&z,false);
zp->set(*x3p);
ROL::StochasticProblem<double> optProb(list,pObj,sampler,zp);
optProb.setSolutionStatistic(optProb3.getSolutionStatistic());
optProb.checkObjectiveGradient(d,true,*outStream);
optProb.checkObjectiveHessVec(d,true,*outStream);
// Run ROL algorithm
parlist->sublist("Status Test").set("Iteration Limit",1000);
parlist->sublist("Step").sublist("Bundle").set("Epsilon Solution Tolerance",1.e-8);
algo = Teuchos::rcp(new ROL::Algorithm<double>("Bundle",*parlist,false));
start = clock();
algo->run(optProb,true,*outStream);
*outStream << "Optimization time: " << (double)(clock()-start)/(double)CLOCKS_PER_SEC << " seconds.\n";
/**********************************************************************************************/
/************************* COMPUTE ERROR ******************************************************/
/**********************************************************************************************/
*outStream << "\nSUMMARY:\n";
*outStream << " ---------------------------------------------\n";
*outStream << " True Value-At-Risk = " << optProb.getSolutionStatistic() << "\n";
*outStream << " ---------------------------------------------\n";
double VARerror = std::abs(optProb.getSolutionStatistic()-optProb1.getSolutionStatistic());
Teuchos::RCP<ROL::Vector<double> > cErr = x1.clone();
cErr->set(x1); cErr->axpy(-1.0,z);
double CTRLerror = cErr->norm();
double TOTerror1 = std::sqrt(std::pow(VARerror,2)+std::pow(CTRLerror,2));
*outStream << " Value-At-Risk (1.e-2) = " << optProb1.getSolutionStatistic() << "\n";
*outStream << " Value-At-Risk Error = " << VARerror << "\n";
*outStream << " Control Error = " << CTRLerror << "\n";
*outStream << " Total Error = " << TOTerror1 << "\n";
*outStream << " ---------------------------------------------\n";
VARerror = std::abs(optProb.getSolutionStatistic()-optProb2.getSolutionStatistic());
cErr = x2.clone();
cErr->set(x2); cErr->axpy(-1.0,z);
CTRLerror = cErr->norm();
double TOTerror2 = std::sqrt(std::pow(VARerror,2)+std::pow(CTRLerror,2));
*outStream << " Value-At-Risk (1.e-4) = " << optProb2.getSolutionStatistic() << "\n";
*outStream << " Value-At-Risk Error = " << VARerror << "\n";
*outStream << " Control Error = " << CTRLerror << "\n";
*outStream << " Total Error = " << TOTerror2 << "\n";
*outStream << " ---------------------------------------------\n";
VARerror = std::abs(optProb.getSolutionStatistic()-optProb3.getSolutionStatistic());
cErr = x3.clone();
cErr->set(x3); cErr->axpy(-1.0,z);
CTRLerror = cErr->norm();
double TOTerror3 = std::sqrt(std::pow(VARerror,2)+std::pow(CTRLerror,2));
*outStream << " Value-At-Risk (1.e-6) = " << optProb3.getSolutionStatistic() << "\n";
*outStream << " Value-At-Risk Error = " << VARerror << "\n";
*outStream << " Control Error = " << CTRLerror << "\n";
*outStream << " Total Error = " << TOTerror3 << "\n";
*outStream << " ---------------------------------------------\n\n";
// Comparison
errorFlag += ((TOTerror1 < 90.*TOTerror2) && (TOTerror2 < 90.*TOTerror3)) ? 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[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Teuchos::DefaultComm<int>::getComm();
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
bool print = (iprint>0); // && !(comm->getRank());
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (print)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
bool print0 = print && !comm->getRank();
Teuchos::RCP<std::ostream> outStream0;
if (print0)
outStream0 = Teuchos::rcp(&std::cout, false);
else
outStream0 = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
// *** Example body.
try {
/*************************************************************************/
/************* INITIALIZE BURGERS FEM CLASS ******************************/
/*************************************************************************/
int nx = 512; // Set spatial discretization.
RealT alpha = 1.e-3; // Set penalty parameter.
RealT nl = 1.0; // Nonlinearity parameter (1 = Burgers, 0 = linear).
RealT cH1 = 1.0; // Scale for derivative term in H1 norm.
RealT cL2 = 0.0; // Scale for mass term in H1 norm.
Teuchos::RCP<BurgersFEM<RealT> > fem
= Teuchos::rcp(new BurgersFEM<RealT>(nx,nl,cH1,cL2));
fem->test_inverse_mass(*outStream0);
fem->test_inverse_H1(*outStream0);
/*************************************************************************/
/************* INITIALIZE SIMOPT OBJECTIVE FUNCTION **********************/
/*************************************************************************/
Teuchos::RCP<std::vector<RealT> > ud_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<ROL::Vector<RealT> > ud
= Teuchos::rcp(new L2VectorPrimal<RealT>(ud_rcp,fem));
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > pobj
= Teuchos::rcp(new Objective_BurgersControl<RealT>(fem,ud,alpha));
/*************************************************************************/
/************* INITIALIZE SIMOPT EQUALITY CONSTRAINT *********************/
/*************************************************************************/
bool hess = true;
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pcon
= Teuchos::rcp(new EqualityConstraint_BurgersControl<RealT>(fem,hess));
/*************************************************************************/
/************* INITIALIZE VECTOR STORAGE *********************************/
/*************************************************************************/
// INITIALIZE CONTROL VECTORS
Teuchos::RCP<std::vector<RealT> > z_rcp
= Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
Teuchos::RCP<std::vector<RealT> > gz_rcp
= Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
Teuchos::RCP<std::vector<RealT> > yz_rcp
= Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
for (int i=0; i<nx+2; i++) {
(*yz_rcp)[i] = 2.0*random<RealT>(comm)-1.0;
}
Teuchos::RCP<ROL::Vector<RealT> > zp
= Teuchos::rcp(new PrimalControlVector(z_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > gzp
= Teuchos::rcp(new DualControlVector(gz_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > yzp
= Teuchos::rcp(new PrimalControlVector(yz_rcp,fem));
// INITIALIZE STATE VECTORS
Teuchos::RCP<std::vector<RealT> > u_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > gu_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<ROL::Vector<RealT> > up
= Teuchos::rcp(new PrimalStateVector(u_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > gup
= Teuchos::rcp(new DualStateVector(gu_rcp,fem));
// INITIALIZE CONSTRAINT VECTORS
Teuchos::RCP<std::vector<RealT> > c_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > l_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
for (int i=0; i<nx; i++) {
(*l_rcp)[i] = random<RealT>(comm);
}
Teuchos::RCP<ROL::Vector<RealT> > cp
= Teuchos::rcp(new PrimalConstraintVector(c_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > lp
= Teuchos::rcp(new DualConstraintVector(l_rcp,fem));
/*************************************************************************/
/************* INITIALIZE SAMPLE GENERATOR *******************************/
/*************************************************************************/
int dim = 4, nSamp = 1000;
std::vector<RealT> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
std::vector<std::vector<RealT> > bounds(dim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman
= Teuchos::rcp(new L2VectorBatchManager<RealT,int>(comm));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
= Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(
nSamp,bounds,bman,false,false,100));
/*************************************************************************/
/************* INITIALIZE REDUCED OBJECTIVE FUNCTION *********************/
/*************************************************************************/
bool storage = true, fdhess = false;
Teuchos::RCP<ROL::Objective<RealT> > robj
= Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(
pobj,pcon,up,zp,lp,gup,gzp,cp,storage,fdhess));
/*************************************************************************/
/************* INITIALIZE BOUND CONSTRAINTS ******************************/
/*************************************************************************/
std::vector<RealT> Zlo(nx+2,0.0), Zhi(nx+2,10.0);
for (int i = 0; i < nx+2; i++) {
if ( i < (int)((nx+2)/3) ) {
Zlo[i] = -1.0;
Zhi[i] = 1.0;
}
if ( i >= (int)((nx+2)/3) && i < (int)(2*(nx+2)/3) ) {
Zlo[i] = 1.0;
Zhi[i] = 5.0;
}
if ( i >= (int)(2*(nx+2)/3) ) {
Zlo[i] = 5.0;
Zhi[i] = 10.0;
}
}
Teuchos::RCP<ROL::BoundConstraint<RealT> > Zbnd
= Teuchos::rcp(new L2BoundConstraint<RealT>(Zlo,Zhi,fem));
/*************************************************************************/
/************* INITIALIZE OPTIMIZATION PROBLEM ***************************/
/*************************************************************************/
Teuchos::ParameterList SOLlist;
SOLlist.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
SOLlist.sublist("SOL").set("Store Sampled Value and Gradient",storage);
SOLlist.sublist("SOL").sublist("Risk Measure").set("Name","KL Divergence");
SOLlist.sublist("SOL").sublist("Risk Measure").sublist("KL Divergence").set("Threshold",1.e-2);
ROL::StochasticProblem<RealT> optProb(SOLlist,robj,sampler,zp,Zbnd);
/*************************************************************************/
/************* CHECK DERIVATIVES AND CONSISTENCY *************************/
/*************************************************************************/
// CHECK OBJECTIVE DERIVATIVES
bool derivcheck = false;
if (derivcheck) {
int nranks = sampler->numBatches();
for (int pid = 0; pid < nranks; pid++) {
if ( pid == sampler->batchID() ) {
for (int i = sampler->start(); i < sampler->numMySamples(); i++) {
*outStream << "Sample " << i << " Rank " << sampler->batchID() << "\n";
*outStream << "(" << sampler->getMyPoint(i)[0] << ", "
<< sampler->getMyPoint(i)[1] << ", "
<< sampler->getMyPoint(i)[2] << ", "
<< sampler->getMyPoint(i)[3] << ")\n";
pcon->setParameter(sampler->getMyPoint(i));
pcon->checkSolve(*up,*zp,*cp,print,*outStream);
robj->setParameter(sampler->getMyPoint(i));
*outStream << "\n";
robj->checkGradient(*zp,*gzp,*yzp,print,*outStream);
robj->checkHessVec(*zp,*gzp,*yzp,print,*outStream);
*outStream << "\n\n";
}
}
comm->barrier();
}
}
optProb.checkObjectiveGradient(*yzp,print0,*outStream0);
optProb.checkObjectiveHessVec(*yzp,print0,*outStream0);
/*************************************************************************/
/************* RUN OPTIMIZATION ******************************************/
/*************************************************************************/
// READ IN XML INPUT
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist
= Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
// RUN OPTIMIZATION
ROL::Algorithm<RealT> algo("Trust Region",*parlist,false);
zp->zero();
algo.run(optProb,print0,*outStream0);
/*************************************************************************/
/************* PRINT CONTROL AND STATE TO SCREEN *************************/
/*************************************************************************/
if ( print0 ) {
std::ofstream ofs;
ofs.open("output_example_08.txt",std::ofstream::out);
for ( int i = 0; i < nx+2; i++ ) {
ofs << std::scientific << std::setprecision(10);
ofs << std::setw(20) << std::left << (RealT)i/((RealT)nx+1.0);
ofs << std::setw(20) << std::left << (*z_rcp)[i];
ofs << "\n";
}
ofs.close();
}
*outStream0 << "Scalar Parameter: " << optProb.getSolutionStatistic() << "\n\n";
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
comm->barrier();
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[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Teuchos::DefaultComm<int>::getComm();
// 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
if (iprint > 0 && Teuchos::rank<int>(*comm)==0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
try {
/**********************************************************************************************/
/************************* CONSTRUCT ROL ALGORITHM ********************************************/
/**********************************************************************************************/
// Get ROL parameterlist
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
// Build ROL algorithm
parlist->sublist("Status Test").set("Gradient Tolerance",1.e-8);
parlist->sublist("Status Test").set("Step Tolerance",1.e-14);
parlist->sublist("Status Test").set("Iteration Limit",100);
/**********************************************************************************************/
/************************* CONSTRUCT VECTORS **************************************************/
/**********************************************************************************************/
// Build control vectors
int nx = 256;
Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
ROL::StdVector<RealT> x(x_rcp);
Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
ROL::StdVector<RealT> d(d_rcp);
for ( int i = 0; i < nx+2; i++ ) {
(*x_rcp)[i] = random<RealT>(comm);
(*d_rcp)[i] = random<RealT>(comm);
}
Teuchos::RCP<ROL::Vector<RealT> > xp = Teuchos::rcp(&x,false);
// Build state and adjoint vectors
Teuchos::RCP<std::vector<RealT> > u_rcp = Teuchos::rcp( new std::vector<RealT>(nx,1.0) );
ROL::StdVector<RealT> u(u_rcp);
Teuchos::RCP<std::vector<RealT> > p_rcp = Teuchos::rcp( new std::vector<RealT>(nx,0.0) );
ROL::StdVector<RealT> p(p_rcp);
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(&p,false);
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Build samplers
// int dim = 4;
// int nSamp = 100;
// std::vector<RealT> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
// std::vector<std::vector<RealT> > bounds(dim,tmp);
// Teuchos::RCP<ROL::BatchManager<RealT> > bman
// = Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(comm));
// Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
// = Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100));
ROL::QuadratureInfo info;
info.dim = 4;
info.maxLevel = 7;
info.rule1D.clear(); info.rule1D.resize(info.dim,ROL::QUAD_CLENSHAWCURTIS);
info.growth1D.clear(); info.growth1D.resize(info.dim,ROL::GROWTH_DEFAULT);
info.normalized = true;
info.adaptive = false;
Teuchos::RCP<ROL::BatchManager<RealT> > bman
= Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(comm));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
= Teuchos::rcp(new ROL::SparseGridGenerator<RealT>(bman,info));
// Print samples
int width = 21;
std::stringstream name;
name << "samples_" << sampler->batchID() << ".txt";
std::ofstream file(name.str().c_str());
if (file.is_open()) {
file << std::scientific << std::setprecision(12);
for (int i = 0; i < sampler->numMySamples(); ++i) {
std::vector<RealT> pt = sampler->getMyPoint(i);
RealT wt = sampler->getMyWeight(i);
for (int j = 0; j < static_cast<int>(pt.size()); ++j) {
file << std::setw(width) << std::left << pt[j];
}
file << std::setw(width) << std::left << wt << std::endl;
}
file.close();
}
else {
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument,
">>> (adapters/trikota/sol/test/test_01): Unable to open file!");
}
/**********************************************************************************************/
/************************* CONSTRUCT OBJECTIVE FUNCTION ***************************************/
/**********************************************************************************************/
// Build risk-averse objective function
RealT alpha = 1.e-3;
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > pobjSimOpt
= Teuchos::rcp(new Objective_BurgersControl<RealT>(alpha,nx));
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pconSimOpt
= Teuchos::rcp(new EqualityConstraint_BurgersControl<RealT>(nx));
Teuchos::RCP<ROL::Objective<RealT> > pObj
= Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(pobjSimOpt,pconSimOpt,up,xp,pp));
Teuchos::RCP<ROL::Objective<RealT> > obj;
// Test parametrized objective functions
*outStream << "Check Derivatives of Parametrized Objective Function\n";
pObj->setParameter(sampler->getMyPoint(0));
pObj->checkGradient(x,d,true,*outStream);
pObj->checkHessVec(x,d,true,*outStream);
/**********************************************************************************************/
/************************* RISK NEUTRAL *******************************************************/
/**********************************************************************************************/
*outStream << "\nSOLVE RISK NEUTRAL OPTIMAL CONTROL PROBLEM WITH TRUST REGION\n";
// Build CVaR objective function
Teuchos::ParameterList list;
list.sublist("SOL").set("Stochastic Optimization Type","Risk Neutral");
list.sublist("SOL").set("Store Sampled Value and Gradient",true);
// Build stochastic problem
ROL::StochasticProblem<RealT> optProb(list,pObj,sampler,xp);
optProb.checkObjectiveGradient(d,true,*outStream);
optProb.checkObjectiveHessVec(d,true,*outStream);
// Run ROL algorithm
ROL::Algorithm<RealT> algo("Trust Region",*parlist,false);
clock_t start = clock();
xp->zero();
algo.run(optProb,true,*outStream);
*outStream << "Optimization time: " << (RealT)(clock()-start)/(RealT)CLOCKS_PER_SEC << " seconds.\n";
}
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;
}
