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 );
72 ValidateFunction<Real>& validator,
77 const std::vector<std::string>& methods ) {
80 check( con_check, validator, uo, un, z, methods );
83 static void check( DynamicConstraint_CheckInterface<Real>& con_check,
84 ValidateFunction<Real>& validator,
88 const std::vector<std::string>& methods ) {
93 auto l = uo.
dual().clone();
100 auto update_uo = con_check.update_uo( un, z );
101 auto update_un = con_check.update_un( uo, z );
102 auto update_z = con_check.update_z( un, uo );
104 auto value_uo = con_check.value_uo( un, z );
105 auto value_un = con_check.value_un( uo, z );
106 auto value_z = con_check.value_z( uo, un );
110 if( std::find(methods.begin(),methods.end(),
"applyJacobian_uo") != methods.end() ) {
111 auto J = con_check.jacobian_uo( un, z );
112 validator.derivative_check( value_uo, J, update_uo, *c, *vu, uo,
"norm(J_uo*vec)" );
115 if( std::find(methods.begin(),methods.end(),
"applyJacobian_un") != methods.end() ) {
116 auto J = con_check.jacobian_un( uo, z );
117 validator.derivative_check( value_un, J, update_un, *c, *vu, un,
"norm(J_un*vec)" );
120 if( std::find(methods.begin(),methods.end(),
"applyJacobian_z") != methods.end() ) {
121 auto J = con_check.jacobian_z( uo, un );
122 validator.derivative_check( value_z, J, update_z, *c, *vz, z,
"norm(J_z*vec)" );
128 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_uo") != methods.end() ) {
129 auto J = con_check.jacobian_uo( un, z );
130 auto aJ = con_check.adjointJacobian_uo( un, z );
131 validator.adjoint_consistency_check( J, aJ, update_uo, *c, *vu, uo,
132 "Jacobian with respect to uo",
"J_uo");
135 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_un") != methods.end() ) {
136 auto J = con_check.jacobian_un( uo, z );
137 auto aJ = con_check.adjointJacobian_un( uo, z );
138 validator.adjoint_consistency_check( J, aJ, update_un, *c, *vu, un,
139 "Jacobian with respect to un",
"J_un");
142 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_z") != methods.end() ) {
143 auto J = con_check.jacobian_z( uo, un );
144 auto aJ = con_check.adjointJacobian_z( uo, un );
145 validator.adjoint_consistency_check( J, aJ, update_z, *vz, *c, z,
146 "Jacobian with respect to z",
"J_z");
152 if( std::find(methods.begin(),methods.end(),
"solve") != methods.end() ) {
153 auto S = con_check.solve_un( uo, z );
154 validator.solve_check( S, value_un, update_un, *c, un,
"Dynamic Constraint");
158 if( std::find(methods.begin(),methods.end(),
"applyInverseJacobian_un") != methods.end() ) {
159 auto J = con_check.jacobian_un( uo, z );
160 auto iJ = con_check.inverseJacobian_un( uo, z );
161 validator.inverse_check( J, iJ, update_un, *vu, un,
162 "Jacobian with respect to un",
"J_un");
166 if( std::find(methods.begin(),methods.end(),
"applyInverseAdjointJacobian_un") != methods.end() ) {
167 auto aJ = con_check.adjointJacobian_un( uo, z );
168 auto iaJ = con_check.inverseAdjointJacobian_un( uo, z );
169 validator.inverse_check( aJ, iaJ, update_un, *vu, un,
170 "adjoint Jacobian with respect to un",
"aJ_un");
176 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_uo") != methods.end() ) {
177 auto aJ = con_check.adjointJacobian_uo_uo( un, z );
178 auto aJl = fix_direction( aJ, *l );
179 auto aH = con_check.adjointHessian_uo_uo( un, z, *l );
180 validator.derivative_check( aJl, aH, update_uo, *c, *vu, uo,
"H_uo_uo");
183 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_un") != methods.end() ) {
184 auto aJ = con_check.adjointJacobian_un_uo( un, z );
185 auto aJl = fix_direction( aJ, *l );
186 auto aH = con_check.adjointHessian_uo_un( un, z, *l );
187 validator.derivative_check( aJl, aH, update_uo, *c, *vu, uo,
"H_uo_un");
190 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_z") != methods.end() ) {
191 auto aJ = con_check.adjointJacobian_z_uo( un, z );
192 auto aJl = fix_direction( aJ, *l );
193 auto aH = con_check.adjointHessian_uo_z( un, z, *l );
194 validator.derivative_check( aJl, aH, update_uo, *vz, *vu, uo,
"H_uo_z");
199 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_uo") != methods.end() ) {
200 auto aJ = con_check.adjointJacobian_uo_un( uo, z );
201 auto aJl = fix_direction( aJ, *l );
202 auto aH = con_check.adjointHessian_un_uo( uo, z, *l );
203 validator.derivative_check( aJl, aH, update_un, *c, *vu, un,
"H_un_uo");
206 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_un") != methods.end() ) {
207 auto aJ = con_check.adjointJacobian_un_un( uo, z );
208 auto aJl = fix_direction( aJ, *l );
209 auto aH = con_check.adjointHessian_un_un( uo, z, *l );
210 validator.derivative_check( aJl, aH, update_un, *c, *vu, un,
"H_un_un");
213 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_z") != methods.end() ) {
214 auto aJ = con_check.adjointJacobian_z_un( uo, z );
215 auto aJl = fix_direction( aJ, *l );
216 auto aH = con_check.adjointHessian_un_z( un, z, *l );
217 validator.derivative_check( aJl, aH, update_un, *vz, *vu, un,
"H_un_z");
222 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_uo") != methods.end() ) {
223 auto aJ = con_check.adjointJacobian_uo_z( uo, un );
224 auto aJl = fix_direction( aJ, *l );
225 auto aH = con_check.adjointHessian_z_uo( uo, un, *l );
226 validator.derivative_check( aJl, aH, update_z, *c, *vz, z,
"H_z_uo");
229 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_un") != methods.end() ) {
230 auto aJ = con_check.adjointJacobian_un_z( uo, un );
231 auto aJl = fix_direction( aJ, *l );
232 auto aH = con_check.adjointHessian_z_un( uo, un, *l );
233 validator.derivative_check( aJl, aH, update_z, *c, *vz, z,
"H_z_un");
236 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_z") != methods.end() ) {
237 auto aJ = con_check.adjointJacobian_z_z( uo, un );
238 auto aJl = fix_direction( aJ, *l );
239 auto aH = con_check.adjointHessian_z_z( uo, un, *l );
240 validator.derivative_check( aJl, aH, update_z, *vz, *vz, z,
"H_z_z");
246 ValidateFunction<Real>& validator,
250 std::vector<std::string> methods = {
"applyJacobian_uo",
253 "applyAdjointJacobian_uo",
254 "applyAdjointJacobian_un",
255 "applyAdjointJacobian_z",
257 "applyInverseJacobian_un",
258 "applyInverseAdjointJacobian_un",
259 "applyAdjointHessian_uo_uo",
260 "applyAdjointHessian_uo_un",
261 "applyAdjointHessian_uo_z",
262 "applyAdjointHessian_un_uo",
263 "applyAdjointHessian_un_un",
264 "applyAdjointHessian_un_z",
265 "applyAdjointHessian_z_uo",
266 "applyAdjointHessian_z_un",
267 "applyAdjointHessian_z_z"};
268 check(con, validator, uo, un, z, methods);
272 ValidateFunction<Real>& validator,
277 std::vector<std::string> methods = {
"applyJacobian_uo",
280 "applyAdjointJacobian_uo",
281 "applyAdjointJacobian_un",
282 "applyAdjointJacobian_z",
284 "applyInverseJacobian_un",
285 "applyInverseAdjointJacobian_un",
286 "applyAdjointHessian_uo_uo",
287 "applyAdjointHessian_uo_un",
288 "applyAdjointHessian_uo_z",
289 "applyAdjointHessian_un_uo",
290 "applyAdjointHessian_un_un",
291 "applyAdjointHessian_un_z",
292 "applyAdjointHessian_z_uo",
293 "applyAdjointHessian_z_un",
294 "applyAdjointHessian_z_z"};
295 check(con, validator, uo, un, z, ts, methods);
303 #endif // ROL_DYNAMICCONSTRAINTCHECK_HPP
virtual const Vector & dual() const
Return dual representation of , for example, the result of applying a Riesz map, or change of basis...
virtual ROL::Ptr< Vector > clone() const =0
Clone to make a new (uninitialized) vector.
Defines the time-dependent constraint operator interface for simulation-based optimization.
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)
Defines the linear algebra or vector space interface.
static void check(DynamicConstraint< Real > &con, ValidateFunction< Real > &validator, const Vector< Real > &uo, const Vector< Real > &un, const Vector< Real > &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)
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)
static void check(DynamicConstraint< Real > &con, ValidateFunction< Real > &validator, const Vector< Real > &uo, const Vector< Real > &un, const Vector< Real > &z, TimeStamp< Real > &ts)
DynamicConstraint_CheckInterface< Real > make_check(DynamicConstraint< Real > &con)