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<StefanBoltzmannData<RealT> > data = Teuchos::rcp(new StefanBoltzmannData<RealT>(comm, parlist, outStream));
/*** Build vectors and dress them up as ROL vectors. ***/
Teuchos::RCP<const Tpetra::Map<> > vecmap_u = data->getMatA()->getDomainMap();
Teuchos::RCP<const Tpetra::Map<> > vecmap_z = data->getMatB()->getDomainMap();
Teuchos::RCP<const Tpetra::Map<> > vecmap_c = data->getMatA()->getRangeMap();
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > c_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_c, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > Eu_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > Vu_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
// Set all values to 1 in u, z and c.
u_rcp->putScalar(1.0);
z_rcp->putScalar(1.0);
c_rcp->putScalar(1.0);
// Randomize d vectors.
du_rcp->randomize();
dz_rcp->randomize();
// Create ROL::TpetraMultiVectors.
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_rcp));
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_rcp));
Teuchos::RCP<ROL::Vector<RealT> > cp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(c_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(du_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dzp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dz_rcp));
Teuchos::RCP<ROL::Vector<RealT> > Eup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(Eu_rcp));
Teuchos::RCP<ROL::Vector<RealT> > Vup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(Vu_rcp));
// Create ROL SimOpt vectors.
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
/*** Build objective function, constraint and reduced objective function. ***/
Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<RealT> > obj =
Teuchos::rcp(new Objective_PDEOPT_StefanBoltzmann<RealT>(data, parlist));
Teuchos::RCP<ROL::ParametrizedEqualityConstraint_SimOpt<RealT> > con =
Teuchos::rcp(new EqualityConstraint_PDEOPT_StefanBoltzmann<RealT>(data, parlist));
Teuchos::RCP<ROL::Reduced_ParametrizedObjective_SimOpt<RealT> > objReduced =
Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<RealT>(obj, con, up, up));
/*** Build stochastic functionality. ***/
int sdim = parlist->sublist("Problem").get("Stochastic Dimension",4);
// Build sampler
int nsamp = parlist->sublist("Problem").get("Number of Monte Carlo Samples",100);
std::vector<RealT> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
std::vector<std::vector<RealT> > bounds(sdim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman
= Teuchos::rcp(new ROL::BatchManager<RealT>());
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
= Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nsamp,bounds,bman,false,false,100));
// Build stochastic problem
ROL::StochasticProblem<RealT> opt(*parlist,objReduced,sampler,zp);
/*** Check functional interface. ***/
std::vector<RealT> par(sdim,1.0);
obj->setParameter(par);
con->setParameter(par);
objReduced->setParameter(par);
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_tr("Trust Region",*parlist,false);
zp->zero(); // set zero initial guess
algo_tr.run(opt, true, *outStream);
*outStream << " Solution Statistic: S(z) = " << opt.getSolutionStatistic() << "\n";
data->outputTpetraVector(z_rcp, "control.txt");
RealT w = 0.0, tol = 1.e-8;
ROL::Elementwise::Power<RealT> sqr(2.0);
Eup->zero(); Vup->zero();
Teuchos::RCP<ROL::Vector<RealT> > up2 = up->clone();
for (int i = 0; i < sampler->numMySamples(); i++) {
// Get samples and weights
par = sampler->getMyPoint(i);
w = sampler->getMyWeight(i);
// Solve state equation at current sample
con->setParameter(par);
con->solve(*cp,*up,*zp,tol);
// Accumulate expected value
Eup->axpy(w,*up);
// Accumulate variance
up2->set(*up); up2->applyUnary(sqr);
Vup->axpy(w,*up2);
}
up2->set(*Eup); up2->applyUnary(sqr);
Vup->axpy(-1.0,*up2);
if (sampler->numMySamples() > 1) {
Vup->scale((RealT)sampler->numMySamples()/(RealT)(sampler->numMySamples()-1));
}
data->outputTpetraVector(Eu_rcp, "expected_value_state.txt");
data->outputTpetraVector(Vu_rcp, "variance_state.txt");
}
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() );
RealT z_lo_bound = parlist->sublist("Problem").get("Control lower bound", ROL::ROL_NINF<RealT>());
RealT z_up_bound = parlist->sublist("Problem").get("Control upper bound", ROL::ROL_INF<RealT>());
RealT u_lo_bound = parlist->sublist("Problem").get("State lower bound", ROL::ROL_NINF<RealT>());
RealT u_up_bound = parlist->sublist("Problem").get("State upper bound", ROL::ROL_INF<RealT>());
/*** Initialize main data structure. ***/
Teuchos::RCP<PoissonData<RealT> > data = Teuchos::rcp(new PoissonData<RealT>(comm, parlist, outStream));
/*** Build vectors and dress them up as ROL vectors. ***/
Teuchos::RCP<const Tpetra::Map<> > vecmap_u = data->getMatA()->getDomainMap();
Teuchos::RCP<const Tpetra::Map<> > vecmap_z = data->getMatB()->getDomainMap();
Teuchos::RCP<const Tpetra::Map<> > vecmap_c = data->getMatA()->getRangeMap();
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > u_lo_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > u_up_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > z_lo_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > z_up_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > c_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_c, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
// Set all values to 1 in u, z and c.
u_rcp->putScalar(1.0);
u_lo_rcp->putScalar(u_lo_bound);
u_up_rcp->putScalar(u_up_bound);
z_rcp->putScalar(1.0);
z_lo_rcp->putScalar(z_lo_bound);
z_up_rcp->putScalar(z_up_bound);
c_rcp->putScalar(1.0);
// Randomize d vectors.
du_rcp->randomize();
dz_rcp->randomize();
// Create ROL::TpetraMultiVectors.
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_rcp));
Teuchos::RCP<ROL::Vector<RealT> > u_lo_p = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_lo_rcp));
Teuchos::RCP<ROL::Vector<RealT> > u_up_p = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_up_rcp));
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_rcp));
Teuchos::RCP<ROL::Vector<RealT> > z_lo_p = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_lo_rcp));
Teuchos::RCP<ROL::Vector<RealT> > z_up_p = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_up_rcp));
Teuchos::RCP<ROL::Vector<RealT> > cp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(c_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(du_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dzp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dz_rcp));
// Create ROL SimOpt vectors.
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
/*** Build objective function, equality constraint, reduced objective function and bound constraint. ***/
Teuchos::RCP<Objective_PDEOPT_Poisson<RealT> > obj =
Teuchos::rcp(new Objective_PDEOPT_Poisson<RealT>(data, parlist));
Teuchos::RCP<EqualityConstraint_PDEOPT_Poisson<RealT> > con =
Teuchos::rcp(new EqualityConstraint_PDEOPT_Poisson<RealT>(data, parlist));
Teuchos::RCP<ROL::Reduced_Objective_SimOpt<RealT> > objReduced =
Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(obj, con, up, up));
Teuchos::RCP<ROL::BoundConstraint<RealT> > bcon =
Teuchos::rcp(new ROL::BoundConstraint<RealT>(z_lo_p, z_up_p));
Teuchos::RCP<ROL::BoundConstraint<RealT> > bcon_null =
Teuchos::rcp(new ROL::BoundConstraint<RealT>(u_lo_p, u_up_p));
// Initialize SimOpt bound constraint.
Teuchos::RCP<ROL::BoundConstraint<RealT> > bcon_simopt =
Teuchos::rcp(new ROL::BoundConstraint_SimOpt<RealT>(bcon_null,bcon));
/*** Check functional interface. ***/
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);
/*** Solve optimization problem. ***/
ROL::Algorithm<RealT> algo_tr("Trust Region",*parlist,false);
zp->zero(); // set zero initial guess
algo_tr.run(*zp, *objReduced, *bcon, true, *outStream);
RealT tol = 1e-8;
con->solve(*cp, *up, *zp, tol);
data->outputTpetraVector(u_rcp, "state.txt");
data->outputTpetraVector(z_rcp, "control.txt");
ROL::MoreauYosidaPenalty<RealT> obj_my(obj, bcon_simopt, x, 10.0);
ROL::Algorithm<RealT> algo_my("Moreau-Yosida Penalty", *parlist, false);
x.zero(); // set zero initial guess
std::vector<std::string> algo_output;
algo_output = algo_my.run(x, *cp, obj_my, *con, *bcon_simopt, true, *outStream);
for (unsigned i=0; i<algo_output.size(); ++i) {
*outStream << algo_output[i];
}
//ROL::Algorithm<RealT> algo_cs("Composite Step",*parlist,false);
//x.zero(); // set zero initial guess
//algo_cs.run(x, *cp, *obj, *con, true, *outStream);
data->outputTpetraVector(u_rcp, "stateFS.txt");
data->outputTpetraVector(z_rcp, "controlFS.txt");
*outStream << std::endl << "|| u_approx - u_analytic ||_L2 = " << data->computeStateError(u_rcp) << std::endl;
}
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);
// 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)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
// *** Example body.
try {
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
RealT V_th = parlist->get("Thermal Voltage", 0.02585);
RealT lo_Vsrc = parlist->get("Source Voltage Lower Bound", 0.0);
RealT up_Vsrc = parlist->get("Source Voltage Upper Bound", 1.0);
RealT step_Vsrc = parlist->get("Source Voltage Step", 1.e-2);
RealT true_Is = parlist->get("True Saturation Current", 1.e-12);
RealT true_Rs = parlist->get("True Saturation Resistance", 0.25);
RealT init_Is = parlist->get("Initial Saturation Current", 1.e-12);
RealT init_Rs = parlist->get("Initial Saturation Resistance", 0.25);
RealT lo_Is = parlist->get("Saturation Current Lower Bound", 1.e-16);
RealT up_Is = parlist->get("Saturation Current Upper Bound", 1.e-1);
RealT lo_Rs = parlist->get("Saturation Resistance Lower Bound", 1.e-2);
RealT up_Rs = parlist->get("Saturation Resistance Upper Bound", 30.0);
// bool use_lambertw = parlist->get("Use Analytical Solution",true);
bool use_scale = parlist->get("Use Scaling For Epsilon-Active Sets",true);
bool use_sqp = parlist->get("Use SQP", true);
// bool use_linesearch = parlist->get("Use Line Search", true);
// bool datatype = parlist->get("Get Data From Input File",false);
// bool use_adjoint = parlist->get("Use Adjoint Gradient Computation",false);
// int use_hessvec = parlist->get("Use Hessian-Vector Implementation",1); // 0 - FD, 1 - exact, 2 - GN
// bool plot = parlist->get("Generate Plot Data",false);
// RealT noise = parlist->get("Measurement Noise",0.0);
EqualityConstraint_DiodeCircuit<RealT> con(V_th,lo_Vsrc,up_Vsrc,step_Vsrc);
RealT alpha = 1.e-4; // regularization parameter (unused)
int ns = 101; // number of Vsrc components
int nz = 2; // number of optimization variables
Objective_DiodeCircuit<RealT> obj(alpha,ns,nz);
// Initialize iteration vectors.
Teuchos::RCP<std::vector<RealT> > z_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
Teuchos::RCP<std::vector<RealT> > yz_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
Teuchos::RCP<std::vector<RealT> > soln_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
(*z_rcp)[0] = init_Is;
(*z_rcp)[1] = init_Rs;
(*yz_rcp)[0] = init_Is;
(*yz_rcp)[1] = init_Rs;
(*soln_rcp)[0] = true_Is;
(*soln_rcp)[1] = true_Rs;
ROL::StdVector<RealT> z(z_rcp);
ROL::StdVector<RealT> yz(yz_rcp);
ROL::StdVector<RealT> soln(soln_rcp);
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(&z,false);
Teuchos::RCP<ROL::Vector<RealT> > yzp = Teuchos::rcp(&yz,false);
Teuchos::RCP<std::vector<RealT> > u_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
Teuchos::RCP<std::vector<RealT> > yu_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
std::ifstream input_file("measurements.dat");
RealT temp, temp_scale;
for (int i=0; i<ns; i++) {
input_file >> temp;
input_file >> temp;
temp_scale = pow(10,int(log10(temp)));
(*u_rcp)[i] = temp_scale*(RealT)rand()/(RealT)RAND_MAX;
(*yu_rcp)[i] = temp_scale*(RealT)rand()/(RealT)RAND_MAX;
}
input_file.close();
ROL::StdVector<RealT> u(u_rcp);
ROL::StdVector<RealT> yu(yu_rcp);
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<RealT> > yup = Teuchos::rcp(&yu,false);
Teuchos::RCP<std::vector<RealT> > jv_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 1.0) );
ROL::StdVector<RealT> jv(jv_rcp);
Teuchos::RCP<ROL::Vector<RealT> > jvp = Teuchos::rcp(&jv,false);
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> y(yup,yzp);
// Check derivatives
obj.checkGradient(x,x,y,true,*outStream);
obj.checkHessVec(x,x,y,true,*outStream);
con.checkApplyJacobian(x,y,jv,true,*outStream);
con.checkApplyAdjointJacobian(x,yu,jv,x,true,*outStream);
con.checkApplyAdjointHessian(x,yu,y,x,true,*outStream);
// Check consistency of Jacobians and adjoint Jacobians.
con.checkAdjointConsistencyJacobian_1(jv,yu,u,z,true,*outStream);
con.checkAdjointConsistencyJacobian_2(jv,yz,u,z,true,*outStream);
// Check consistency of solves.
con.checkSolve(u,z,jv,true,*outStream);
con.checkInverseJacobian_1(jv,yu,u,z,true,*outStream);
con.checkInverseAdjointJacobian_1(yu,jv,u,z,true,*outStream);
// Initialize reduced objective function.
Teuchos::RCP<std::vector<RealT> > p_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
ROL::StdVector<RealT> p(p_rcp);
Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(&p,false);
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > pobj = Teuchos::rcp(&obj,false);
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pcon = Teuchos::rcp(&con,false);
ROL::Reduced_Objective_SimOpt<RealT> robj(pobj,pcon,up,pp);
// Check derivatives.
*outStream << "Derivatives of reduced objective" << std::endl;
robj.checkGradient(z,z,yz,true,*outStream);
robj.checkHessVec(z,z,yz,true,*outStream);
// Bound constraints
RealT tol = 1.e-12;
Teuchos::RCP<std::vector<RealT> > g0_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );;
ROL::StdVector<RealT> g0p(g0_rcp);
robj.gradient(g0p,z,tol);
*outStream << std::scientific << "Initial gradient = " << (*g0_rcp)[0] << " " << (*g0_rcp)[1] << "\n";
*outStream << std::scientific << "Norm of Gradient = " << g0p.norm() << "\n";
// Define scaling for epsilon-active sets (used in inequality constraints)
RealT scale;
if(use_scale){ scale = 1.0e-2/g0p.norm();}
else{ scale = 1.0;}
*outStream << std::scientific << "Scaling: " << scale << "\n";
/// Define constraints on Is and Rs
BoundConstraint_DiodeCircuit<RealT> bcon(scale,lo_Is,up_Is,lo_Rs,up_Rs);
//bcon.deactivate();
// Optimization
*outStream << "\n Initial guess " << (*z_rcp)[0] << " " << (*z_rcp)[1] << std::endl;
if (!use_sqp){
// Trust Region
ROL::Algorithm<RealT> algo_tr("Trust Region",*parlist);
std::clock_t timer_tr = std::clock();
algo_tr.run(z,robj,bcon,true,*outStream);
*outStream << "\n Solution " << (*z_rcp)[0] << " " << (*z_rcp)[1] << "\n" << std::endl;
*outStream << "Trust-Region required " << (std::clock()-timer_tr)/(RealT)CLOCKS_PER_SEC
<< " seconds.\n";
}
else{
// SQP.
//Teuchos::RCP<std::vector<RealT> > gz_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
//ROL::StdVector<RealT> gz(gz_rcp);
//Teuchos::RCP<ROL::Vector<RealT> > gzp = Teuchos::rcp(&gz,false);
Teuchos::RCP<std::vector<RealT> > gu_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
ROL::StdVector<RealT> gu(gu_rcp);
Teuchos::RCP<ROL::Vector<RealT> > gup = Teuchos::rcp(&gu,false);
//ROL::Vector_SimOpt<RealT> g(gup,gzp);
ROL::Vector_SimOpt<RealT> g(gup,zp);
Teuchos::RCP<std::vector<RealT> > c_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
Teuchos::RCP<std::vector<RealT> > l_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
ROL::StdVector<RealT> c(c_rcp);
ROL::StdVector<RealT> l(l_rcp);
ROL::Algorithm<RealT> algo_cs("Composite Step",*parlist);
//x.zero();
std::clock_t timer_cs = std::clock();
algo_cs.run(x,g,l,c,obj,con,true,*outStream);
*outStream << "\n Solution " << (*z_rcp)[0] << " " << (*z_rcp)[1] << "\n" << std::endl;
*outStream << "Composite Step required " << (std::clock()-timer_cs)/(RealT)CLOCKS_PER_SEC
<< " seconds.\n";
}
soln.axpy(-1.0, z);
*outStream << "Norm of error: " << soln.norm() << std::endl;
if (soln.norm() > 1e4*ROL::ROL_EPSILON) {
errorFlag = 1;
}
}
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<PoissonData<RealT> > data = Teuchos::rcp(new PoissonData<RealT>(comm, parlist, outStream));
// Get random weights parameter.
RealT fnzw = parlist->sublist("Problem").get("Fraction of nonzero weights", 0.5);
fnzw = 1.0 - 2.0*fnzw;
/*** Build vectors and dress them up as ROL vectors. ***/
Teuchos::RCP<const Tpetra::Map<> > vecmap_u = data->getMatA()->getDomainMap();
Teuchos::RCP<const Tpetra::Map<> > vecmap_z = data->getMatB()->getDomainMap();
Teuchos::RCP<const Tpetra::Map<> > vecmap_c = data->getMatA()->getRangeMap();
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > p_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > w_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > c_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_c, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
// Set all values to 1 in u, z and c.
u_rcp->putScalar(1.0);
p_rcp->putScalar(1.0);
w_rcp->randomize();
z_rcp->putScalar(1.0);
c_rcp->putScalar(1.0);
// Randomize d vectors.
du_rcp->randomize();
dz_rcp->randomize();
// Create ROL::TpetraMultiVectors.
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_rcp));
Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(p_rcp));
Teuchos::RCP<ROL::Vector<RealT> > wp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(w_rcp));
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_rcp));
Teuchos::RCP<ROL::Vector<RealT> > cp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(c_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(du_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dzp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dz_rcp));
// Create ROL SimOpt vectors.
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
/*** Build objective function, constraint and reduced objective function. ***/
wp->applyUnary(IsGreaterThan<RealT>(fnzw));
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > obj =
Teuchos::rcp(new Objective_PDEOPT_Poisson<RealT>(data, w_rcp, parlist));
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > con =
Teuchos::rcp(new EqualityConstraint_PDEOPT_Poisson<RealT>(data, parlist));
Teuchos::RCP<ROL::Objective<RealT> > objReduced =
Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(obj, con, up, zp, pp));
/*** Check functional interface. ***/
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);
RealT tol = 1e-8;
zp->zero();
con->solve(*cp, *up, *zp, tol);
data->outputTpetraVector(u_rcp, "data.txt");
data->outputTpetraVector(data->getVecF(), "sources.txt");
data->setVecUd(u_rcp);
data->zeroRHS();
/*** Solve optimization problem. ***/
ROL::Algorithm<RealT> algo_tr("Trust Region",*parlist,false);
zp->zero(); // set zero initial guess
algo_tr.run(*zp, *objReduced, true, *outStream);
con->solve(*cp, *up, *zp, tol);
//ROL::Algorithm<RealT> algo_cs("Composite Step",*parlist,false);
//x.zero(); // set zero initial guess
//algo_cs.run(x, *cp, *obj, *con, true, *outStream);
//*outStream << std::endl << "|| u_approx - u_analytic ||_L2 = " << data->computeStateError(u_rcp) << std::endl;
data->outputTpetraVector(u_rcp, "state.txt");
data->outputTpetraVector(z_rcp, "control.txt");
data->outputTpetraVector(w_rcp, "weights.txt");
//data->outputTpetraVector(data->getVecWeights(), "weights.txt");
//data->outputTpetraVector(data->getVecF(), "control.txt");
//data->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;
}
