46 #ifndef ROL_DYNAMICCONSTRAINTCHECK_HPP 47 #define ROL_DYNAMICCONSTRAINTCHECK_HPP 50 #include "ROL_ValidateFunction.hpp" 58 template<
typename Real>
62 ValidateFunction<Real>& validator,
66 const std::vector<std::string>& methods ) {
71 auto l = uo.
dual().clone();
82 auto update_uo = con_check.update_uo( un, z );
83 auto update_un = con_check.update_un( uo, z );
84 auto update_z = con_check.update_z( un, uo );
86 auto value_uo = con_check.value_uo( un, z );
87 auto value_un = con_check.value_un( uo, z );
88 auto value_z = con_check.value_z( uo, un );
92 if( std::find(methods.begin(),methods.end(),
"applyJacobian_uo") != methods.end() ) {
93 auto J = con_check.jacobian_uo( un, z );
94 validator.derivative_check( value_uo, J, update_uo, *c, *vu, uo,
"norm(J_uo*vec)" );
97 if( std::find(methods.begin(),methods.end(),
"applyJacobian_un") != methods.end() ) {
98 auto J = con_check.jacobian_un( uo, z );
99 validator.derivative_check( value_un, J, update_un, *c, *vu, un,
"norm(J_un*vec)" );
102 if( std::find(methods.begin(),methods.end(),
"applyJacobian_z") != methods.end() ) {
103 auto J = con_check.jacobian_z( uo, un );
104 validator.derivative_check( value_z, J, update_z, *c, *vz, z,
"norm(J_z*vec)" );
110 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_uo") != methods.end() ) {
111 auto J = con_check.jacobian_uo( un, z );
112 auto aJ = con_check.adjointJacobian_uo( un, z );
113 validator.adjoint_consistency_check( J, aJ, update_uo, *c, *vu, uo,
114 "Jacobian with respect to uo",
"J_uo");
117 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_un") != methods.end() ) {
118 auto J = con_check.jacobian_un( uo, z );
119 auto aJ = con_check.adjointJacobian_un( uo, z );
120 validator.adjoint_consistency_check( J, aJ, update_un, *c, *vu, un,
121 "Jacobian with respect to un",
"J_un");
124 if( std::find(methods.begin(),methods.end(),
"applyAdjointJacobian_z") != methods.end() ) {
125 auto J = con_check.jacobian_z( uo, un );
126 auto aJ = con_check.adjointJacobian_z( uo, un );
127 validator.adjoint_consistency_check( J, aJ, update_z, *vz, *c, z,
128 "Jacobian with respect to z",
"J_z");
134 if( std::find(methods.begin(),methods.end(),
"solve") != methods.end() ) {
135 auto S = con_check.solve_un( uo, z );
136 validator.solve_check( S, value_un, update_un, *c, un,
"Dynamic Constraint");
140 if( std::find(methods.begin(),methods.end(),
"applyInverseJacobian_un") != methods.end() ) {
141 auto J = con_check.jacobian_un( uo, z );
142 auto iJ = con_check.inverseJacobian_un( uo, z );
143 validator.inverse_check( J, iJ, update_un, *vu, un,
144 "Jacobian with respect to un",
"J_un");
148 if( std::find(methods.begin(),methods.end(),
"applyInverseAdjointJacobian_un") != methods.end() ) {
149 auto aJ = con_check.adjointJacobian_un( uo, z );
150 auto iaJ = con_check.inverseAdjointJacobian_un( uo, z );
151 validator.inverse_check( aJ, iaJ, update_un, *vu, un,
152 "adjoint Jacobian with respect to un",
"aJ_un");
158 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_uo") != methods.end() ) {
159 auto aJ = con_check.adjointJacobian_uo_uo( un, z );
160 auto aJl = fix_direction( aJ, *l );
161 auto aH = con_check.adjointHessian_uo_uo( un, z, *l );
162 validator.derivative_check( aJl, aH, update_uo, *c, *vu, uo,
"H_uo_uo");
165 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_un") != methods.end() ) {
166 auto aJ = con_check.adjointJacobian_un_uo( un, z );
167 auto aJl = fix_direction( aJ, *l );
168 auto aH = con_check.adjointHessian_uo_un( un, z, *l );
169 validator.derivative_check( aJl, aH, update_uo, *c, *vu, uo,
"H_uo_un");
172 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_uo_z") != methods.end() ) {
173 auto aJ = con_check.adjointJacobian_z_uo( un, z );
174 auto aJl = fix_direction( aJ, *l );
175 auto aH = con_check.adjointHessian_uo_z( un, z, *l );
176 validator.derivative_check( aJl, aH, update_uo, *vz, *vu, uo,
"H_uo_z");
181 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_uo") != methods.end() ) {
182 auto aJ = con_check.adjointJacobian_uo_un( uo, z );
183 auto aJl = fix_direction( aJ, *l );
184 auto aH = con_check.adjointHessian_un_uo( uo, z, *l );
185 validator.derivative_check( aJl, aH, update_un, *c, *vu, un,
"H_un_uo");
188 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_un") != methods.end() ) {
189 auto aJ = con_check.adjointJacobian_un_un( uo, z );
190 auto aJl = fix_direction( aJ, *l );
191 auto aH = con_check.adjointHessian_un_un( uo, z, *l );
192 validator.derivative_check( aJl, aH, update_un, *c, *vu, un,
"H_un_un");
195 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_un_z") != methods.end() ) {
196 auto aJ = con_check.adjointJacobian_z_un( uo, z );
197 auto aJl = fix_direction( aJ, *l );
198 auto aH = con_check.adjointHessian_un_z( un, z, *l );
199 validator.derivative_check( aJl, aH, update_un, *vz, *vu, un,
"H_un_z");
204 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_uo") != methods.end() ) {
205 auto aJ = con_check.adjointJacobian_uo_z( uo, un );
206 auto aJl = fix_direction( aJ, *l );
207 auto aH = con_check.adjointHessian_z_uo( uo, un, *l );
208 validator.derivative_check( aJl, aH, update_z, *c, *vz, z,
"H_z_uo");
211 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_un") != methods.end() ) {
212 auto aJ = con_check.adjointJacobian_un_z( uo, un );
213 auto aJl = fix_direction( aJ, *l );
214 auto aH = con_check.adjointHessian_z_un( uo, un, *l );
215 validator.derivative_check( aJl, aH, update_z, *c, *vz, z,
"H_z_un");
218 if( std::find(methods.begin(),methods.end(),
"applyAdjointHessian_z_z") != methods.end() ) {
219 auto aJ = con_check.adjointJacobian_z_z( uo, un );
220 auto aJl = fix_direction( aJ, *l );
221 auto aH = con_check.adjointHessian_z_z( uo, un, *l );
222 validator.derivative_check( aJl, aH, update_z, *vz, *vz, z,
"H_z_z");
228 ValidateFunction<Real>& validator,
232 std::vector<std::string> methods = {
"applyJacobian_uo",
235 "applyAdjointJacobian_uo",
236 "applyAdjointJacobian_un",
237 "applyAdjointJacobian_z",
239 "applyInverseJacobian_un",
240 "applyInverseAdjointJacobian_un",
241 "applyAdjointHessian_uo_uo",
242 "applyAdjointHessian_uo_un",
243 "applyAdjointHessian_uo_z",
244 "applyAdjointHessian_un_uo",
245 "applyAdjointHessian_un_un",
246 "applyAdjointHessian_un_z",
247 "applyAdjointHessian_z_uo",
248 "applyAdjointHessian_z_un",
249 "applyAdjointHessian_z_z"};
250 check(con, validator, uo, un, z, methods);
258 #endif // ROL_DYNAMICCONSTRAINTCHECK_HPP 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.
void RandomizeVector(Vector< Real > &x, const Real &lower=0.0, const Real &upper=1.0)
Fill a ROL::Vector with uniformly-distributed random numbers in the interval [lower,upper].
Defines the linear algebra or vector space interface.
virtual const Vector & dual() const
Return dual representation of , for example, the result of applying a Riesz map, or change of basis...
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)
DynamicConstraint_CheckInterface< Real > make_check(DynamicConstraint< Real > &con)