// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER /*! \file example_01.cpp \brief Shows how to solve the Darcy porosity optimization problem. */ #include "Teuchos_Comm.hpp" #include "ROL_Stream.hpp" #include "Teuchos_GlobalMPISession.hpp" #include "Teuchos_XMLParameterListHelpers.hpp" #include "Tpetra_Core.hpp" #include "Tpetra_Version.hpp" #include #include #include "ROL_TpetraMultiVector.hpp" #include "ROL_Reduced_Objective_SimOpt.hpp" #include "ROL_Bounds.hpp" #include "ROL_Solver.hpp" #include "ROL_SingletonVector.hpp" #include "ROL_ConstraintFromObjective.hpp" #include "../../../../TOOLS/meshreader.hpp" #include "../../../../TOOLS/pdeconstraint.hpp" #include "../../../../TOOLS/pdeobjective.hpp" #include "../../../../TOOLS/pdevector.hpp" #include "../../../../TOOLS/integralconstraint.hpp" #include "pde_darcy.hpp" #include "obj_darcy.hpp" typedef double RealT; 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; ROL::Ptr outStream; ROL::nullstream bhs; // outputs nothing /*** Initialize communicator. ***/ Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs); ROL::Ptr> comm = Tpetra::getDefaultComm(); const int myRank = comm->getRank(); if ((iprint > 0) && (myRank == 0)) { outStream = ROL::makePtrFromRef(std::cout); } else { outStream = ROL::makePtrFromRef(bhs); } int errorFlag = 0; // *** Example body. try { /*** Read in XML input ***/ std::string filename = "input.xml"; Teuchos::RCP parlist = Teuchos::rcp( new Teuchos::ParameterList() ); Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() ); bool output = parlist->sublist("SimOpt").sublist("Solve").get("Output Iteration History",false); output = (iprint > 0) && (myRank==0) && output; parlist->sublist("SimOpt").sublist("Solve").set("Output Iteration History",output); ROL::Ptr> meshMgr; ROL::Ptr> pde; ROL::Ptr> con; ROL::Ptr> pdecon; ROL::Ptr> assembler; /*** Initialize main data structure. ***/ meshMgr = ROL::makePtr>(*parlist); // Initialize PDE describing Darcy equations. pde = ROL::makePtr>(*parlist); con = ROL::makePtr>(pde,meshMgr,comm,*parlist,*outStream); // Cast the constraint and get the assembler. pdecon = ROL::dynamicPtrCast>(con); assembler = pdecon->getAssembler(); con->setSolveParameters(*parlist); // Create state vector and set to zeroes ROL::Ptr> u_ptr, p_ptr, z_ptr, r_ptr; ROL::Ptr> z0_ptr; ROL::Ptr> z0p; ROL::Ptr> z1p; ROL::Ptr> up, pp, zp, rp, xp; bool useParamVar = parlist->sublist("Problem").get("Use Optimal Constant Velocity",false); int dim = 2; u_ptr = assembler->createStateVector(); u_ptr->randomize(); p_ptr = assembler->createStateVector(); p_ptr->randomize(); z_ptr = assembler->createControlVector(); z_ptr->randomize(); r_ptr = assembler->createResidualVector(); r_ptr->putScalar(0.0); if (useParamVar) { z0_ptr = ROL::makePtr>(dim); z0p = ROL::makePtr>(z0_ptr); z1p = ROL::makePtr>(z_ptr,pde,assembler,*parlist); } up = ROL::makePtr>(u_ptr,pde,assembler,*parlist); pp = ROL::makePtr>(p_ptr,pde,assembler,*parlist); if (useParamVar) zp = ROL::makePtr>(z1p,z0p,myRank); else zp = ROL::makePtr>(z_ptr,pde,assembler,*parlist); rp = ROL::makePtr>(r_ptr,pde,assembler,*parlist); xp = ROL::makePtr>(up,zp); // Initialize quadratic objective function. ROL::Ptr> qoi; ROL::Ptr> obj; ROL::Ptr> robj; //qoi = ROL::makePtr>(*parlist, // ROL::staticPtrCast>(pde)->getPressureFE(), // ROL::staticPtrCast>(pde)->getControlFE(), // ROL::staticPtrCast>(pde)->getPressureBdryFE(4), // ROL::staticPtrCast>(pde)->getControlBdryFE(4), // ROL::staticPtrCast>(pde)->getBdryCellLocIds(4), // ROL::staticPtrCast>(pde)->getPermeability()); qoi = ROL::makePtr>(*parlist, ROL::staticPtrCast>(pde)->getPressureFE(), ROL::staticPtrCast>(pde)->getControlFE(), ROL::staticPtrCast>(pde)->getPermeability()); obj = ROL::makePtr>(qoi,assembler); robj = ROL::makePtr>(obj,con,up,zp,pp,true,false); // Build bound constraint ROL::Ptr> lp, hp; ROL::Ptr> bnd; if (useParamVar) { ROL::Ptr> l0p, h0p; ROL::Ptr> l1_ptr, h1_ptr; ROL::Ptr> l1p, h1p; l0p = ROL::makePtr>(dim,ROL::ROL_NINF()); h0p = ROL::makePtr>(dim,ROL::ROL_INF()); l1_ptr = assembler->createControlVector(); h1_ptr = assembler->createControlVector(); l1p = ROL::makePtr>(l1_ptr,pde,assembler,*parlist); h1p = ROL::makePtr>(h1_ptr,pde,assembler,*parlist); l1p->setScalar(0.0); h1p->setScalar(1.0); lp = ROL::makePtr>(l1p,l0p,myRank); hp = ROL::makePtr>(h1p,h0p,myRank); } else { lp = zp->clone(); lp->setScalar(0.0); hp = zp->clone(); hp->setScalar(1.0); } bnd = ROL::makePtr>(lp, hp); // Build optimization problem ROL::Ptr> optProb; optProb = ROL::makePtr>(robj, zp); optProb->addBoundConstraint(bnd); optProb->finalize(false,true,*outStream); // Run derivative checks bool checkDeriv = parlist->sublist("Problem").get("Check derivatives",false); if ( checkDeriv ) { ROL::Ptr> rup = up->clone(); rup->randomize(-1.0,1.0); ROL::Ptr> rzp = zp->clone(); rzp->randomize( 0.0,1.0); ROL::Ptr> rpp = pp->clone(); rpp->randomize(-1.0,1.0); ROL::Ptr> dup = up->clone(); dup->randomize(-1.0,1.0); ROL::Ptr> dzp = zp->clone(); dzp->randomize( 0.0,1.0); con->checkApplyJacobian_1(*rup,*rzp,*dup,*rup,true,*outStream); con->checkApplyJacobian_2(*rup,*rzp,*dzp,*rup,true,*outStream); con->checkInverseJacobian_1(*rup,*rup,*rup,*rzp,true,*outStream); con->checkInverseAdjointJacobian_1(*rup,*rup,*rup,*rzp,true,*outStream); con->checkApplyAdjointHessian_11(*rup,*rzp,*rpp,*dup,*rup,true,*outStream); con->checkApplyAdjointHessian_21(*rup,*rzp,*rpp,*dzp,*rup,true,*outStream); con->checkApplyAdjointHessian_12(*rup,*rzp,*rpp,*dup,*rzp,true,*outStream); con->checkApplyAdjointHessian_22(*rup,*rzp,*rpp,*dzp,*rzp,true,*outStream); obj->checkGradient_1(*rup,*rzp,*dup,true,*outStream); obj->checkGradient_2(*rup,*rzp,*dzp,true,*outStream); obj->checkHessVec_11(*rup,*rzp,*dup,true,*outStream); obj->checkHessVec_12(*rup,*rzp,*dzp,true,*outStream); obj->checkHessVec_21(*rup,*rzp,*dup,true,*outStream); obj->checkHessVec_22(*rup,*rzp,*dzp,true,*outStream); robj->checkGradient(*rzp,*dzp,true,*outStream); robj->checkHessVec(*rzp,*dzp,true,*outStream); //optProb->check(*outStream); } // Solve optimization problem zp->setScalar(0.5); up->zero(); pp->zero(); bool opt = parlist->sublist("Problem").get("Solve Optimization Problem",true); if (opt) { std::ifstream infile("control.txt"); if (infile.good()) assembler->inputTpetraVector(z_ptr,"control.txt"); if (useParamVar) { std::ifstream infile0; infile0.open("target.txt"); if (infile0.good()) { for (int i = 0; i < dim; ++i) infile0 >> (*z0_ptr)[i]; infile0.close(); } } ROL::Solver optSolver(optProb, *parlist); optSolver.solve(*outStream); pdecon->outputTpetraVector(z_ptr,"control.txt"); if (useParamVar) { std::ofstream outfile; outfile.open("target.txt"); for (const auto x : *z0_ptr) { outfile << std::scientific << std::setprecision(16); outfile << x << std::endl; } outfile.close(); } } // Output assembler->printMeshData(*outStream); RealT tol(1.e-8); Teuchos::Array res(1,0); con->solve(*rp,*up,*zp,tol); pdecon->outputTpetraVector(u_ptr,"state.txt"); con->value(*rp,*up,*zp,tol); r_ptr->norm2(res.view(0,1)); *outStream << "Residual Norm: " << res[0] << std::endl; assembler->printCellAveragesPDE(pde,u_ptr,z_ptr); 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; }