46 #ifndef ROL_DYNAMICCONSTRAINTCHECK_HPP 47 #define ROL_DYNAMICCONSTRAINTCHECK_HPP 50 #include "ROL_ValidateFunction.hpp" 57 template<
typename Real>
61 ValidateFunction<Real>& validator,
65 const std::vector<std::string>& methods ) {
68 check( con_check, validator, uo, un, z, methods );
73 ValidateFunction<Real>& validator,
78 const std::vector<std::string>& methods ) {
81 check( con_check, validator, uo, un, z, methods );
85 ValidateFunction<Real>& validator,
89 const std::vector<std::string>& methods ) {
94 auto l = uo.
dual().clone();
101 auto update_uo = con_check.
update_uo( un, z );
102 auto update_un = con_check.
update_un( uo, z );
103 auto update_z = con_check.
update_z( un, uo );
105 auto value_uo = con_check.
value_uo( un, z );
106 auto value_un = con_check.
value_un( uo, z );
107 auto value_z = con_check.
value_z( uo, un );
111 if( std::find(methods.begin(),methods.end(),
"applyJacobian_uo") != methods.end() ) {
113 validator.derivative_check( value_uo, J, update_uo, *c, *vu, uo,
"norm(J_uo*vec)" );
116 if( std::find(methods.begin(),methods.end(),
"applyJacobian_un") != methods.end() ) {
118 validator.derivative_check( value_un, J, update_un, *c, *vu, un,
"norm(J_un*vec)" );
121 if( std::find(methods.begin(),methods.end(),
"applyJacobian_z") != methods.end() ) {
123 validator.derivative_check( value_z, J, update_z, *c, *vz, z,
"norm(J_z*vec)" );
129 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_uo") != methods.end() ) {
132 validator.adjoint_consistency_check( J, aJ, update_uo, *c, *vu, uo,
133 "Jacobian with respect to uo",
"J_uo");
136 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_un") != methods.end() ) {
139 validator.adjoint_consistency_check( J, aJ, update_un, *c, *vu, un,
140 "Jacobian with respect to un",
"J_un");
143 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_z") != methods.end() ) {
146 validator.adjoint_consistency_check( J, aJ, update_z, *vz, *c, z,
147 "Jacobian with respect to z",
"J_z");
153 if( std::find(methods.begin(),methods.end(),
"solve") != methods.end() ) {
154 auto S = con_check.
solve_un( uo, z );
155 validator.solve_check( S, value_un, update_un, *c, un,
"Dynamic Constraint");
159 if( std::find(methods.begin(),methods.end(),
"applyInverseJacobian_un") != methods.end() ) {
162 validator.inverse_check( J, iJ, update_un, *vu, un,
163 "Jacobian with respect to un",
"J_un");
167 if( std::find(methods.begin(),methods.end(),
"applyInverseAdjointJacobian_un") != methods.end() ) {
170 validator.inverse_check( aJ, iaJ, update_un, *vu, un,
171 "adjoint Jacobian with respect to un",
"aJ_un");
177 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_uo") != methods.end() ) {
179 auto aJl = fix_direction( aJ, *l );
181 validator.derivative_check( aJl, aH, update_uo, *c, *vu, uo,
"H_uo_uo");
184 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_un") != methods.end() ) {
186 auto aJl = fix_direction( aJ, *l );
188 validator.derivative_check( aJl, aH, update_uo, *c, *vu, uo,
"H_uo_un");
191 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_z") != methods.end() ) {
193 auto aJl = fix_direction( aJ, *l );
195 validator.derivative_check( aJl, aH, update_uo, *vz, *vu, uo,
"H_uo_z");
200 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_uo") != methods.end() ) {
202 auto aJl = fix_direction( aJ, *l );
204 validator.derivative_check( aJl, aH, update_un, *c, *vu, un,
"H_un_uo");
207 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_un") != methods.end() ) {
209 auto aJl = fix_direction( aJ, *l );
211 validator.derivative_check( aJl, aH, update_un, *c, *vu, un,
"H_un_un");
214 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_z") != methods.end() ) {
216 auto aJl = fix_direction( aJ, *l );
218 validator.derivative_check( aJl, aH, update_un, *vz, *vu, un,
"H_un_z");
223 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_uo") != methods.end() ) {
225 auto aJl = fix_direction( aJ, *l );
227 validator.derivative_check( aJl, aH, update_z, *c, *vz, z,
"H_z_uo");
230 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_un") != methods.end() ) {
232 auto aJl = fix_direction( aJ, *l );
234 validator.derivative_check( aJl, aH, update_z, *c, *vz, z,
"H_z_un");
237 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_z") != methods.end() ) {
239 auto aJl = fix_direction( aJ, *l );
241 validator.derivative_check( aJl, aH, update_z, *vz, *vz, z,
"H_z_z");
247 ValidateFunction<Real>& validator,
251 std::vector<std::string> methods = {
"applyJacobian_uo",
254 "applyAdjointJacobian_uo",
255 "applyAdjointJacobian_un",
256 "applyAdjointJacobian_z",
258 "applyInverseJacobian_un",
259 "applyInverseAdjointJacobian_un",
260 "applyAdjointHessian_uo_uo",
261 "applyAdjointHessian_uo_un",
262 "applyAdjointHessian_uo_z",
263 "applyAdjointHessian_un_uo",
264 "applyAdjointHessian_un_un",
265 "applyAdjointHessian_un_z",
266 "applyAdjointHessian_z_uo",
267 "applyAdjointHessian_z_un",
268 "applyAdjointHessian_z_z"};
269 check(con, validator, uo, un, z, methods);
277 #endif // ROL_DYNAMICCONSTRAINTCHECK_HPP f_dderiv_t< Real > adjointJacobian_un_z(const V &uo, const V &un)
virtual ROL::Ptr< Vector > clone() const =0
Clone to make a new (uninitialized) vector.
f_dderiv_t< Real > adjointJacobian_un(const V &uo, const V &z)
Defines the time-dependent constraint operator interface for simulation-based optimization.
f_dderiv_t< Real > adjointJacobian_uo(const V &un, const V &z)
static void check(DynamicConstraint_CheckInterface< Real > &con_check, ValidateFunction< Real > &validator, const Vector< Real > &uo, const Vector< Real > &un, const Vector< Real > &z, const std::vector< std::string > &methods)
f_dderiv_t< Real > adjointHessian_uo_z(const V &un, const V &z, const V &l)
f_dderiv_t< Real > adjointJacobian_z_un(const V &uo, const V &z)
f_dderiv_t< Real > adjointHessian_un_uo(const V &uo, const V &z, const V &l)
f_solve_t< Real > solve_un(const V &uo, const V &z)
f_dderiv_t< Real > adjointHessian_un_un(const V &uo, const V &z, const V &l)
f_update_t< Real > update_un(const V &uo, const V &z)
Contains local time step information.
Defines the linear algebra or vector space interface.
f_dderiv_t< Real > inverseAdjointJacobian_un(const V &uo, const V &z)
f_dderiv_t< Real > jacobian_z(const V &uo, const V &un)
f_vector_t< Real > value_uo(const V &un, const V &z)
f_dderiv_t< Real > adjointJacobian_un_uo(const V &un, const V &z)
f_vector_t< Real > value_un(const V &uo, const V &z)
f_dderiv_t< Real > adjointJacobian_uo_z(const V &uo, const V &un)
virtual const Vector & dual() const
Return dual representation of , for example, the result of applying a Riesz map, or change of basis...
f_dderiv_t< Real > jacobian_uo(const V &un, const V &z)
f_dderiv_t< Real > adjointHessian_z_z(const V &uo, const V &un, const V &l)
f_vector_t< Real > value_z(const V &uo, const V &un)
f_dderiv_t< Real > inverseJacobian_un(const V &uo, const V &z)
f_dderiv_t< Real > adjointJacobian_z(const V &uo, const V &un)
f_dderiv_t< Real > adjointHessian_uo_uo(const V &un, const V &z, const V &l)
static void check(DynamicConstraint< Real > &con, ValidateFunction< Real > &validator, const Vector< Real > &uo, const Vector< Real > &un, const Vector< Real > &z)
f_dderiv_t< Real > adjointJacobian_uo_un(const V &uo, const V &z)
static void check(DynamicConstraint< Real > &con, ValidateFunction< Real > &validator, const Vector< Real > &uo, const Vector< Real > &un, const Vector< Real > &z, const std::vector< std::string > &methods)
f_dderiv_t< Real > adjointHessian_un_z(const V &uo, const V &z, const V &l)
static void check(DynamicConstraint< Real > &con, ValidateFunction< Real > &validator, const Vector< Real > &uo, const Vector< Real > &un, const Vector< Real > &z, TimeStamp< Real > &timeStamp, const std::vector< std::string > &methods)
f_dderiv_t< Real > adjointJacobian_uo_uo(const V &un, const V &z)
f_update_t< Real > update_z(const V &uo, const V &un)
f_dderiv_t< Real > adjointHessian_uo_un(const V &un, const V &z, const V &l)
f_dderiv_t< Real > adjointHessian_z_uo(const V &uo, const V &un, const V &l)
f_dderiv_t< Real > adjointJacobian_z_uo(const V &un, const V &z)
f_dderiv_t< Real > adjointJacobian_z_z(const V &uo, const V &un)
f_dderiv_t< Real > jacobian_un(const V &uo, const V &z)
f_dderiv_t< Real > adjointJacobian_un_un(const V &uo, const V &z)
f_update_t< Real > update_uo(const V &un, const V &z)
f_dderiv_t< Real > adjointHessian_z_un(const V &uo, const V &un, const V &l)
DynamicConstraint_CheckInterface< Real > make_check(DynamicConstraint< Real > &con)