// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER #ifndef MULTIMAT_COMPLIANCE_ROBJ_H #define MULTIMAT_COMPLIANCE_ROBJ_H #include "ROL_Objective.hpp" #include "ROL_VectorController.hpp" #include "ROL_SecantFactory.hpp" #include "../../../TOOLS/pde.hpp" #include "../../../TOOLS/assembler.hpp" #include "../../../TOOLS/solver.hpp" #include "../../../TOOLS/pdevector.hpp" template class MultiMat_Compliance_Objective : public ROL::Objective { private: // Elasticity PDE const ROL::Ptr> pde_; ROL::Ptr> assembler_; ROL::Ptr> solver_, solver_cache_, solver_tmp_; ROL::Ptr> matJ1_, matJ1_cache_, matJ1_tmp_; ROL::Ptr> matJ2_, matJ2_cache_, matJ2_tmp_; ROL::Ptr> matH22_; bool assembleJ1_, assembleJ2_, assembleH22_, assembleF_; // Output information const std::string uname_, dname_; // Vector Storage ROL::Ptr> F_data_, state_sens_data_; ROL::Ptr> dstat_data_, dctrl_data_; ROL::Ptr> state_, dctrl_; ROL::Ptr> stateStore_; bool storage_; Real cmpScale_; bool nuke_; int printFreq_; unsigned nstat_, nsens_; unsigned nupda_, nfval_, ngrad_, nhess_, nprec_; unsigned napJ1_, nasJ1_, napJ2_, nasJ2_, napH2_, nasH2_, nasLo_; public: MultiMat_Compliance_Objective( const ROL::Ptr> &pde, const ROL::Ptr> &mesh, const ROL::Ptr> &comm, ROL::ParameterList &list, std::ostream &stream = std::cout, std::string uname = "state", std::string dname = "density") : pde_(pde), assembleJ1_(true), assembleJ2_(true), assembleH22_(true), assembleF_(true), uname_(uname), dname_(dname), nstat_(0), nsens_(0), nupda_(0), nfval_(0), ngrad_(0), nhess_(0), nprec_(0), napJ1_(0), nasJ1_(0), napJ2_(0), nasJ2_(0), napH2_(0), nasH2_(0), nasLo_(0) { // Elasticity PDE assembler_ = ROL::makePtr>(pde_->getFields(), pde_->getFields2(), mesh,comm,list,stream); assembler_->setCellNodes(*pde_); solver_ = ROL::makePtr>(list.sublist("Solver")); solver_cache_ = ROL::makePtr>(list.sublist("Solver")); // Vector storage F_data_ = assembler_->createResidualVector(); state_sens_data_ = assembler_->createStateVector(); dstat_data_ = assembler_->createResidualVector(); dctrl_data_ = assembler_->createControlVector(); state_ = ROL::makePtr>(assembler_->createStateVector(),pde_,assembler_,list); dctrl_ = ROL::makePtr>(dctrl_data_,pde_,assembler_,list); stateStore_ = ROL::makePtr>(); storage_ = list.sublist("Problem").get("Use state storage", true); cmpScale_ = list.sublist("Problem").get("Compliance Scaling", 1.0); nuke_ = list.sublist("Problem").get("Use Basic Update",false); printFreq_ = list.sublist("Problem").get("Output Frequency",0); initialize(); } const ROL::Ptr> getAssembler(void) const { return assembler_; } void update(const ROL::Vector &z, ROL::UpdateType type, int iter = -1) { nupda_++; stateStore_->objectiveUpdate(type); if (nuke_) { update_temp(z,iter); } else { switch (type) { case ROL::UpdateType::Initial: update_initial(z,iter); break; case ROL::UpdateType::Accept: update_accept(z,iter); break; case ROL::UpdateType::Revert: update_revert(z,iter); break; case ROL::UpdateType::Trial: update_trial(z,iter); break; case ROL::UpdateType::Temp: update_temp(z,iter); break; } } // Print if (printFreq_ > 0 && iter%printFreq_ == 0) { std::stringstream ufile, zfile; ufile << uname_ << "_" << iter << ".txt"; zfile << dname_ << "_" << iter << ".txt"; ROL::Ptr> z_data = getConstField(z); ROL::Ptr> u_data = getConstField(*state_); assembler_->outputTpetraVector(u_data, ufile.str()); assembler_->outputTpetraVector(z_data, zfile.str()); } } void update( const ROL::Vector &z, bool flag = true, int iter = -1 ) { nupda_++; stateStore_->objectiveUpdate(true); if (nuke_) { update_temp(z,iter); } else { // Trial: flag = false, iter = -1 // Check: flag = true, iter = -1 // Reject: flag = false, iter > -1 // Accept: flag = true, iter > -1 if (flag) { if (iter > -1) { update_accept(z,iter); } else { update_temp(z,iter); } } else { if (iter > -1) { update_revert(z,iter); } else { update_trial(z,iter); } } } } Real normalize(const ROL::Vector &z, Real &tol) { update(z,ROL::UpdateType::Temp); Real val = value(z,tol); cmpScale_ /= val; return cmpScale_; } void printToFile(const ROL::Vector &z, std::ostream &stream = std::cout, const std::string ufile = "state.txt", const std::string dfile = "density.txt") { update(z,ROL::UpdateType::Temp); ROL::Ptr> z_data = getConstField(z); ROL::Ptr> u_data = getField(*state_); solve_state_equation(u_data, z_data); assembler_->outputTpetraVector(u_data, ufile); assembler_->outputTpetraVector(z_data, dfile); assembler_->printMeshData(stream); } Real value( const ROL::Vector &z, Real &tol ) { nfval_++; ROL::Ptr> z_data = getConstField(z); ROL::Ptr> u_data = getField(*state_); // Solve state equation solve_state_equation(*state_,z); // Compute compliance Teuchos::Array cmp(1,0); F_data_->dot(*u_data, cmp.view(0,1)); return cmpScale_*cmp[0]; } void gradient( ROL::Vector &g, const ROL::Vector &z, Real &tol ) { ngrad_++; ROL::Ptr> g_data = getField(g); ROL::Ptr> z_data = getConstField(z); ROL::Ptr> u_data = getField(*state_); // Solve state equation solve_state_equation(*state_,z); // Apply adjoint density jacobian assembleJ2(u_data, z_data); applyJacobian2(g_data, u_data, true); g_data->scale(-cmpScale_); } void hessVec( ROL::Vector &hv, const ROL::Vector &v, const ROL::Vector &z, Real &tol ) { nhess_++; ROL::Ptr> h_data = getField(hv); ROL::Ptr> v_data = getConstField(v); ROL::Ptr> z_data = getConstField(z); ROL::Ptr> u_data = getField(*state_); // Solve state equation solve_state_equation(*state_,z); // Solve state sensitivity equation assembleJ2(u_data, z_data); solve_state_sensitivity(state_sens_data_, v_data); // Apply density hessian to direction assembleH22(u_data, z_data); applyHessian22(h_data, v_data); // Apply adjoint density jacobian to state sensitivity applyJacobian2(dctrl_data_, state_sens_data_, true); h_data->update(static_cast(2)*cmpScale_,*dctrl_data_,-cmpScale_); } /** \brief Apply a reduced Hessian preconditioner. */ virtual void precond( ROL::Vector &Pv, const ROL::Vector &v, const ROL::Vector &z, Real &tol ) { nprec_++; Pv.set(v.dual()); } void summarize(std::ostream &stream) const { stream << std::endl; stream << std::string(114,'=') << std::endl; stream << " Objective_Compliance::summarize" << std::endl; stream << " Number of calls to update: " << nupda_ << std::endl; stream << " Number of calls to value: " << nfval_ << std::endl; stream << " Number of calls to gradient: " << ngrad_ << std::endl; stream << " Number of calls to hessVec: " << nhess_ << std::endl; stream << " Number of calls to precond: " << nprec_ << std::endl; stream << " Number of state solves: " << nstat_ << std::endl; stream << " Number of state sensitivity solves: " << nsens_ << std::endl; stream << " Number of load assemblies: " << nasLo_ << std::endl; stream << " Number of Jacobian_1 assemblies: " << nasJ1_ << std::endl; stream << " Number of Jacobian_1 sovles: " << napJ1_ << std::endl; stream << " Number of Jacobian_2 assemblies: " << nasJ2_ << std::endl; stream << " Number of Jacobian_2 applies: " << napJ2_ << std::endl; stream << " Number of Hessian_22 assemblies: " << nasH2_ << std::endl; stream << " Number of Hessian_22 applies: " << napH2_ << std::endl; stream << std::string(114,'=') << std::endl; stream << std::endl; } // For parametrized (stochastic) objective functions and constraints public: void setParameter(const std::vector ¶m) { ROL::Objective::setParameter(param); pde_->setParameter(param); assembleF_ = true; } private: ROL::Ptr> getConstField(const ROL::Vector &x) const { ROL::Ptr> xp; try { xp = dynamic_cast&>(x).getVector(); } catch (std::exception &e) { try { ROL::Ptr> xvec = dynamic_cast&>(x).getField(); if (xvec == ROL::nullPtr) { xp = ROL::nullPtr; } else { xp = xvec->getVector(); } } catch (std::exception &ee) { xp = ROL::nullPtr; } } return xp; } ROL::Ptr> getField(ROL::Vector &x) const { ROL::Ptr> xp; try { xp = dynamic_cast&>(x).getVector(); } catch (std::exception &e) { try { ROL::Ptr> xvec = dynamic_cast&>(x).getField(); if ( xvec == ROL::nullPtr ) { xp = ROL::nullPtr; } else { xp = xvec->getVector(); } } catch (std::exception &ee) { xp = ROL::nullPtr; } } return xp; } void initialize(void) { ROL::Ptr> u_data = getField(*state_); u_data->putScalar(0.0); dctrl_data_->putScalar(1.0); assembleJ1_ = true; assembleJ2_ = true; assembleJ1(u_data, dctrl_data_,false); assembleJ2(u_data, dctrl_data_); matJ1_tmp_ = matJ1_; matJ2_tmp_ = matJ2_; matJ1_ = matJ1_cache_; matJ2_ = matJ2_cache_; assembleJ1_ = true; assembleJ2_ = true; assembleJ1(u_data, dctrl_data_,false); assembleJ2(u_data, dctrl_data_); matJ1_cache_ = matJ1_; matJ2_cache_ = matJ2_; solver_tmp_ = solver_; solver_ = solver_cache_; assembleJ1_ = true; assembleJ2_ = true; // Upon exit, matJ1, matJ2 and solver are set to their cached versions } // Assemble load vector void assembleF(void) { if (assembleF_) { nasLo_++; ROL::Ptr> u0 = assembler_->createStateVector(); ROL::Ptr> z1 = assembler_->createControlVector(); u0->putScalar(0.0); z1->putScalar(1.0); assembler_->assemblePDEResidual(F_data_,pde_,u0,z1); F_data_->scale(static_cast(-1)); assembleF_ = false; } } void assembleJ2(const ROL::Ptr> &u, const ROL::Ptr> &z) { if (assembleJ2_) { nasJ2_++; assembler_->assemblePDEJacobian2(matJ2_,pde_,u,z); assembleJ2_ = false; } } void applyJacobian2(ROL::Ptr> &Jv, const ROL::Ptr> &v, const bool transpose) { napJ2_++; if (transpose) { matJ2_->apply(*v,*Jv,Teuchos::TRANS); } else { matJ2_->apply(*v,*Jv); } } void assembleH22(const ROL::Ptr> &u, const ROL::Ptr> &z) { if (assembleH22_) { nasH2_++; assembler_->assemblePDEHessian22(matH22_,pde_,u,u,z); assembleH22_ = false; } } void applyHessian22(ROL::Ptr> &Hv, const ROL::Ptr> &v) { matH22_->apply(*v,*Hv); napH2_++; } void assembleJ1(const ROL::Ptr> &u, const ROL::Ptr> &z, bool setSolve = true) { if (assembleJ1_) { nasJ1_++; assembler_->assemblePDEJacobian1(matJ1_,pde_,u,z); if (setSolve) { solver_->setA(matJ1_); } assembleJ1_ = false; } } void solve(ROL::Ptr> &x, const ROL::Ptr> &b) { napJ1_++; solver_->solve(x,b,false); } void solve_state_equation(ROL::Vector &u, const ROL::Vector &z) { bool isComputed = false; if (storage_) { isComputed = stateStore_->get(u, ROL::Objective::getParameter()); } if (!isComputed || !storage_) { ROL::Ptr> z_data = getConstField(z); ROL::Ptr> u_data = getField(u); solve_state_equation(u_data,z_data); if (storage_) { stateStore_->set(u, ROL::Objective::getParameter()); } } } void solve_state_equation(ROL::Ptr> &u, const ROL::Ptr> &z) { nstat_++; assembleF(); assembleJ1(u,z,true); solve(u,F_data_); } void solve_state_sensitivity(ROL::Ptr> &s, const ROL::Ptr> &v) { // This assumes that assembleJ1 and assemble J2 were called nsens_++; applyJacobian2(dstat_data_, v, false); solve(s, dstat_data_); } void update_initial( const ROL::Vector &z, int iter ) { assembleJ1_ = true; assembleJ2_ = true; assembleH22_ = true; } void update_accept( const ROL::Vector &z, int iter ) { // Push trial state storage into base state storage. solver_tmp_ = solver_cache_; solver_cache_ = solver_; matJ1_tmp_ = matJ1_cache_; matJ1_cache_ = matJ1_; matJ2_tmp_ = matJ2_cache_; matJ2_cache_ = matJ2_; assembleJ1_ = false; // If assembleJ2 was not called, then assembleJ2_ = true assembleH22_ = true; } void update_temp( const ROL::Vector &z, int iter ) { assembleJ1_ = true; assembleJ2_ = true; assembleH22_ = true; } void update_trial( const ROL::Vector &z, int iter ) { solver_ = solver_tmp_; matJ1_ = matJ1_tmp_; matJ2_ = matJ2_tmp_; assembleJ1_ = true; assembleJ2_ = true; assembleH22_ = false; } void update_revert( const ROL::Vector &z, int iter ) { solver_ = solver_cache_; matJ1_ = matJ1_cache_; matJ2_ = matJ2_cache_; assembleJ1_ = false; // If assembleJ2 was not called, then assembleJ2_ = true assembleH22_ = false; // If gradient was not called, then computeGrad_ = true } }; // class Compliance_Objective #endif