44 #ifndef ROL_REDUCED_OBJECTIVE_SIMOPT_DEF_H
45 #define ROL_REDUCED_OBJECTIVE_SIMOPT_DEF_H
49 template<
typename Real>
57 const bool useFDhessVec)
58 :
obj_(obj), con_(con),
59 storage_(storage), useFDhessVec_(useFDhessVec),
60 nupda_(0), nvalu_(0), ngrad_(0), nhess_(0), nprec_(0),
61 nstat_(0), nadjo_(0), nssen_(0), nasen_(0),
63 newUpdate_(false), isUpdated_(true) {
66 state_ = state->clone(); state_->set(*state);
76 template<
typename Real>
87 const bool useFDhessVec)
88 :
obj_(obj), con_(con),
89 storage_(storage), useFDhessVec_(useFDhessVec),
90 nupda_(0), nvalu_(0), ngrad_(0), nhess_(0), nprec_(0),
91 nstat_(0), nadjo_(0), nssen_(0), nasen_(0),
93 newUpdate_(false), isUpdated_(true) {
96 state_ = state->clone(); state_->set(*state);
106 template<
typename Real>
115 const bool useFDhessVec)
116 :
obj_(obj), con_(con), stateStore_(stateStore),
117 storage_(storage), useFDhessVec_(useFDhessVec),
118 nupda_(0), nvalu_(0), ngrad_(0), nhess_(0), nprec_(0),
119 nstat_(0), nadjo_(0), nssen_(0), nasen_(0),
121 newUpdate_(false), isUpdated_(true) {
123 state_ = state->clone(); state_->set(*state);
133 template<
typename Real>
145 const bool useFDhessVec)
146 :
obj_(obj), con_(con), stateStore_(stateStore),
147 storage_(storage), useFDhessVec_(useFDhessVec),
148 nupda_(0), nvalu_(0), ngrad_(0), nhess_(0), nprec_(0),
149 nstat_(0), nadjo_(0), nssen_(0), nasen_(0),
151 newUpdate_(false), isUpdated_(true) {
153 state_ = state->clone(); state_->set(*state);
163 template<
typename Real>
170 stateStore_->objectiveUpdate(
true);
171 adjointStore_->objectiveUpdate(flag);
174 template<
typename Real>
181 stateStore_->objectiveUpdate(type);
182 adjointStore_->objectiveUpdate(type);
185 template<
typename Real>
189 solve_state_equation(z,tol);
191 return obj_->value(*state_,z,tol);
194 template<
typename Real>
198 solve_state_equation(z,tol);
200 solve_adjoint_equation(z,tol);
202 obj_->gradient_2(*dualcontrol_,*state_,z,tol);
204 con_->applyAdjointJacobian_2(g,*adjoint_,*state_,z,tol);
205 g.
plus(*dualcontrol_);
208 template<
typename Real>
211 if ( useFDhessVec_ ) {
216 solve_state_equation(z,tol);
218 solve_adjoint_equation(z,tol);
220 solve_state_sensitivity(v,z,tol);
222 solve_adjoint_sensitivity(v,z,tol);
224 con_->applyAdjointJacobian_2(hv,*adjoint_sens_,*state_,z,tol);
225 obj_->hessVec_21(*dualcontrol_,*state_sens_,*state_,z,tol);
226 hv.
plus(*dualcontrol_);
227 obj_->hessVec_22(*dualcontrol_,v,*state_,z,tol);
228 hv.
plus(*dualcontrol_);
229 con_->applyAdjointHessian_12(*dualcontrol_,*adjoint_,*state_sens_,*state_,z,tol);
230 hv.
plus(*dualcontrol_);
231 con_->applyAdjointHessian_22(*dualcontrol_,*adjoint_,v,*state_,z,tol);
232 hv.
plus(*dualcontrol_);
236 template<
typename Real>
242 template<
typename Real>
245 con_->setParameter(param);
246 obj_->setParameter(param);
249 template<
typename Real>
251 int nupda(0), nvalu(0), ngrad(0), nhess(0), nprec(0), nstat(0), nadjo(0), nssen(0), nasen(0);
252 if (bman == nullPtr) {
264 auto sumAll = [bman](
int val) {
265 Real global(0), local(val);
266 bman->sumAll(&local,&global,1);
267 return static_cast<int>(global);
269 nupda = sumAll(nupda_);
270 nvalu = sumAll(nvalu_);
271 ngrad = sumAll(ngrad_);
272 nhess = sumAll(nhess_);
273 nprec = sumAll(nprec_);
274 nstat = sumAll(nstat_);
275 nadjo = sumAll(nadjo_);
276 nssen = sumAll(nssen_);
277 nasen = sumAll(nasen_);
280 stream << std::string(80,
'=') << std::endl;
281 stream <<
" ROL::Reduced_Objective_SimOpt::summarize" << std::endl;
282 stream <<
" Number of calls to update: " << nupda << std::endl;
283 stream <<
" Number of calls to value: " << nvalu << std::endl;
284 stream <<
" Number of calls to gradient: " << ngrad << std::endl;
285 stream <<
" Number of calls to hessvec: " << nhess << std::endl;
286 stream <<
" Number of calls to precond: " << nprec << std::endl;
287 stream <<
" Number of state solves: " << nstat << std::endl;
288 stream <<
" Number of adjoint solves: " << nadjo << std::endl;
289 stream <<
" Number of state sensitivity solves: " << nssen << std::endl;
290 stream <<
" Number of adjoint sensitivity solves: " << nasen << std::endl;
291 stream << std::string(80,
'=') << std::endl;
295 template<
typename Real>
297 nupda_ = 0; nvalu_ = 0; ngrad_ = 0; nhess_ = 0; nprec_ = 0;
298 nstat_ = 0; nadjo_ = 0; nssen_ = 0; nasen_ = 0;
301 template<
typename Real>
305 if (newUpdate_) con_->update_2(z,updateType_,updateIter_);
306 else con_->update_2(z,updateFlag_,updateIter_);
311 if (!isComputed || !storage_) {
313 con_->solve(*dualadjoint_,*state_,z,tol);
320 if (newUpdate_) con_->update_1(*state_,updateType_,updateIter_);
321 else con_->update_1(*state_,updateFlag_,updateIter_);
323 if (newUpdate_)
obj_->update(*state_,z,updateType_,updateIter_);
324 else obj_->update(*state_,z,updateFlag_,updateIter_);
329 template<
typename Real>
334 if (!isComputed || !storage_) {
336 obj_->gradient_1(*dualstate_,*state_,z,tol);
338 con_->applyInverseAdjointJacobian_1(*adjoint_,*dualstate_,*state_,z,tol);
339 adjoint_->scale(static_cast<Real>(-1));
346 template<
typename Real>
349 con_->applyJacobian_2(*dualadjoint_,v,*state_,z,tol);
350 dualadjoint_->scale(static_cast<Real>(-1));
351 con_->applyInverseJacobian_1(*state_sens_,*dualadjoint_,*state_,z,tol);
355 template<
typename Real>
358 obj_->hessVec_11(*dualstate_,*state_sens_,*state_,z,tol);
359 obj_->hessVec_12(*dualstate1_,v,*state_,z,tol);
360 dualstate_->plus(*dualstate1_);
362 con_->applyAdjointHessian_11(*dualstate1_,*adjoint_,*state_sens_,*state_,z,tol);
363 dualstate_->plus(*dualstate1_);
364 con_->applyAdjointHessian_21(*dualstate1_,*adjoint_,v,*state_,z,tol);
365 dualstate_->plus(*dualstate1_);
367 dualstate_->scale(static_cast<Real>(-1));
368 con_->applyInverseAdjointJacobian_1(*adjoint_sens_,*dualstate_,*state_,z,tol);
Provides the interface to evaluate objective functions.
Provides the interface to evaluate simulation-based objective functions.
Ptr< Vector< Real > > dualstate_
virtual const Vector & dual() const
Return dual representation of , for example, the result of applying a Riesz map, or change of basis...
virtual void plus(const Vector &x)=0
Compute , where .
Ptr< Vector< Real > > state_
void summarize(std::ostream &stream, const Ptr< BatchManager< Real >> &bman=nullPtr) const
virtual void hessVec(Vector< Real > &hv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Apply Hessian approximation to vector.
Ptr< Vector< Real > > dualstate1_
void solve_state_equation(const Vector< Real > &z, Real &tol)
Defines the linear algebra or vector space interface.
Ptr< VectorController< Real > > adjointStore_
virtual void precond(Vector< Real > &Pv, const Vector< Real > &v, const Vector< Real > &z, Real &tol) override
Apply a reduced Hessian preconditioner.
void solve_adjoint_sensitivity(const Vector< Real > &v, const Vector< Real > &z, Real &tol)
Given , the adjoint variable , and a direction , solve the adjoint sensitvity equation for ...
Ptr< VectorController< Real > > stateStore_
Ptr< Vector< Real > > dualcontrol_
Real value(const Vector< Real > &z, Real &tol) override
Given , evaluate the objective function where solves .
Ptr< Vector< Real > > dualadjoint_
void update(const Vector< Real > &z, bool flag=true, int iter=-1) override
Update the SimOpt objective function and equality constraint.
Ptr< Vector< Real > > adjoint_
void solve_adjoint_equation(const Vector< Real > &z, Real &tol)
Given which solves the state equation, solve the adjoint equation for .
Ptr< Vector< Real > > state_sens_
virtual void setParameter(const std::vector< Real > ¶m)
void setParameter(const std::vector< Real > ¶m) override
virtual void set(const Vector &x)
Set where .
void gradient(Vector< Real > &g, const Vector< Real > &z, Real &tol) override
Given , evaluate the gradient of the objective function where solves .
Defines the constraint operator interface for simulation-based optimization.
void hessVec(Vector< Real > &hv, const Vector< Real > &v, const Vector< Real > &z, Real &tol) override
Given , evaluate the Hessian of the objective function in the direction .
Reduced_Objective_SimOpt(const Ptr< Objective_SimOpt< Real >> &obj, const Ptr< Constraint_SimOpt< Real >> &con, const Ptr< Vector< Real >> &state, const Ptr< Vector< Real >> &control, const Ptr< Vector< Real >> &adjoint, const bool storage=true, const bool useFDhessVec=false)
Constructor.
void solve_state_sensitivity(const Vector< Real > &v, const Vector< Real > &z, Real &tol)
Given which solves the state equation and a direction , solve the state senstivity equation for ...
Ptr< Vector< Real > > adjoint_sens_