Debian Codegraph @

packages/panzer/adapters-stk/test/model_evaluator/model_evaluator_hessians.cpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Panzer: A partial differential equation assembly
4 // engine for strongly coupled complex multiphysics systems
5 //
6 // Copyright 2011 NTESS and the Panzer contributors.
7 // SPDX-License-Identifier: BSD-3-Clause
8 // *****************************************************************************
9 // @HEADER
10
11 #include <Teuchos_ConfigDefs.hpp>
12 #include <Teuchos_UnitTestHarness.hpp>
13 #include <Teuchos_RCP.hpp>
14 #include <Teuchos_TimeMonitor.hpp>
15
16 using Teuchos::RCP;
17 using Teuchos::rcp;
18
19 #include "Panzer_NodeType.hpp"
20 #include "Teuchos_DefaultComm.hpp"
21 #include "Teuchos_GlobalMPISession.hpp"
22
23 #include "Thyra_VectorStdOps.hpp"
24 #include "Thyra_LinearOpTester.hpp"
25 #include "Thyra_DefaultScaledAdjointLinearOp.hpp"
26
27 #include "Panzer_STK_Version.hpp"
28 #include "PanzerAdaptersSTK_config.hpp"
29 #include "Panzer_STK_Interface.hpp"
30 #include "Panzer_STK_SquareQuadMeshFactory.hpp"
31 #include "Panzer_STK_SetupUtilities.hpp"
32 #include "Panzer_STK_WorksetFactory.hpp"
33 #include "Panzer_Workset_Builder.hpp"
34 #include "Panzer_FieldManagerBuilder.hpp"
35 #include "Panzer_STKConnManager.hpp"
36 #include "Panzer_TpetraLinearObjFactory.hpp"
37 #include "Panzer_BlockedEpetraLinearObjFactory.hpp"
38 #include "Panzer_AssemblyEngine.hpp"
39 #include "Panzer_AssemblyEngine_TemplateManager.hpp"
40 #include "Panzer_AssemblyEngine_TemplateBuilder.hpp"
41 #include "Panzer_DOFManagerFactory.hpp"
42 #include "Panzer_ModelEvaluator.hpp"
43 #include "Panzer_ResponseLibrary.hpp"
44 #include "Panzer_GlobalData.hpp"
45 #include "Panzer_LOCPair_GlobalEvaluationData.hpp"
46 #include "Panzer_WorksetContainer.hpp"
47 #include "Panzer_PauseToAttach.hpp"
48 #include "Panzer_ResponseEvaluatorFactory_Functional.hpp"
49 #include "Panzer_ParameterLibraryUtilities.hpp"
50 #include "Panzer_ThyraObjContainer.hpp"
51 #include "Panzer_DOFManager.hpp"
52 #include "Panzer_EpetraVector_ReadOnly_GlobalEvaluationData.hpp"
53 #include "Panzer_GlobalIndexer_Utilities.hpp"
54
55 #include "user_app_EquationSetFactory.hpp"
56 #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp"
57 #include "user_app_BCStrategy_Factory.hpp"
58
59 #include "Epetra_MpiComm.h"
60
61 #include "Teuchos_DefaultMpiComm.hpp"
62 #include "Teuchos_OpaqueWrapper.hpp"
63
64 #include <cstdio> // for get char
65 #include <fstream>
66
67 namespace panzer {
68
69 void testInitialzation(const Teuchos::RCP<Teuchos::ParameterList>& ipb,
70 std::vector<panzer::BC>& bcs);
71
72 struct AssemblyPieces {
73 RCP<panzer::FieldManagerBuilder> fmb;
74 RCP<panzer::ResponseLibrary<panzer::Traits> > rLibrary;
75 RCP<panzer::GlobalData> gd;
76 RCP<panzer::LinearObjFactory<panzer::Traits> > lof;
77 RCP<panzer::LinearObjFactory<panzer::Traits> > param_lof;
78 RCP<panzer::GlobalIndexer> dofManager;
79 RCP<panzer::GlobalIndexer> param_dofManager;
80 Teuchos::RCP<panzer::WorksetContainer> wkstContainer;
81 Teuchos::ParameterList user_data;
82 std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
83 Teuchos::RCP<panzer::EquationSetFactory> eqset_factory;
84 panzer::ClosureModelFactory_TemplateManager<panzer::Traits> cm_factory;
85 Teuchos::ParameterList closure_models;
86 Teuchos::RCP<EpetraVector_ReadOnly_GlobalEvaluationData> param_ged;
87 std::vector<panzer::BC> bcs;
88 Teuchos::RCP<panzer::BCStrategyFactory> bc_factory;
89 };
90
91 void buildAssemblyPieces(bool distr_parameter_on,
92 AssemblyPieces & ap,
93 const std::vector<std::string>& tangentParamNames = std::vector<std::string>());
94
95 bool testEqualityOfVectorValues(const Thyra::VectorBase<double> & a,
96 const Thyra::VectorBase<double> & b,
97 double tolerance, bool write_to_cout=false);
98
99 // Testing Parameter Support
100 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2g_dx2)
101 {
102 typedef panzer::Traits::RealType RealType;
103 typedef Thyra::VectorBase<RealType> VectorType;
104 typedef Thyra::SpmdVectorBase<RealType> SpmdVectorType;
105
106 using Teuchos::RCP;
107 using Teuchos::rcp_dynamic_cast;
108
109 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
110 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
111 typedef panzer::ModelEvaluator<double> PME;
112
113
114 bool distr_param_on = true;
115 AssemblyPieces ap;
116 buildAssemblyPieces(distr_param_on,ap);
117
118 int rIndex = -1;
119
120 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
121 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
122 bool build_transient_support = true;
123 RCP<PME> me
124 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
125
126 const double DENSITY_VALUE = 3.7;
127 const double TEMPERATURE_VALUE = 2.0;
128 const double PERTURB_VALUE = 0.1;
129
130 // add in a flexible response
131 {
132 Teuchos::RCP<panzer::FunctionalResponse_Builder<int,int> > builder
133 = Teuchos::rcp(new panzer::FunctionalResponse_Builder<int,int>);
134
135 builder->comm = MPI_COMM_WORLD; // good enough
136 builder->cubatureDegree = 1;
137 builder->requiresCellIntegral = true;
138 builder->quadPointField = "";
139
140 std::vector<panzer::WorksetDescriptor> blocks;
141 blocks.push_back(panzer::blockDescriptor("eblock-0_0"));
142 blocks.push_back(panzer::blockDescriptor("eblock-1_0"));
143 rIndex = me->addFlexibleResponse("INTEGRAND",blocks,builder); // integrate the density
144 }
145
146 // add distributed parameter
147 {
148 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
149
150 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
151 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
152 me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
153 ap.param_ged,param_density,ap.param_dofManager);
154 }
155
156 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
157 *ap.eqset_factory,
158 *ap.bc_factory,
159 ap.cm_factory,
160 ap.cm_factory,
161 ap.closure_models,
162 ap.user_data,false,"");
163
164 // test value
165 {
166 RCP<VectorType> g = Thyra::createMember(*me->get_g_space(rIndex));
167
168 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
169 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
170
171 InArgs in_args = me->createInArgs();
172 in_args.set_x(x);
173
174 OutArgs out_args = me->createOutArgs();
175 out_args.set_g(0,g);
176
177 me->evalModel(in_args, out_args);
178
179 out << "RESPONSE = " << std::endl;
180 out << Teuchos::describe(*g,Teuchos::VERB_EXTREME) << std::endl;
181
182 Teuchos::ArrayRCP<const double> g_data;
183 rcp_dynamic_cast<Thyra::SpmdVectorBase<double> >(g)->getLocalData(Teuchos::ptrFromRef(g_data));
184 TEST_FLOATING_EQUALITY(g_data[0],TEMPERATURE_VALUE*TEMPERATURE_VALUE*DENSITY_VALUE*DENSITY_VALUE*DENSITY_VALUE,1e-12);
185 // Volume of integral is 1.0, then just compute the integrand
186 }
187
188 RCP<VectorType> D2gDx2 = Thyra::createMember(*me->get_x_space());
189
190 // test hessian
191 {
192
193 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
194 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
195
196 RCP<VectorType> dx = Thyra::createMember(*me->get_x_space());
197 Thyra::assign(dx.ptr(),PERTURB_VALUE);
198
199 InArgs in_args = me->createInArgs();
200 in_args.set_x(x);
201
202 me->evalModel_D2gDx2(rIndex,in_args,dx,D2gDx2);
203
204 out << "D2gDx2 = \n" << Teuchos::describe(*D2gDx2,Teuchos::VERB_EXTREME) << std::endl;
205 }
206
207 Teuchos::ArrayRCP<const double> D2gDx2_data;
208 RCP<const SpmdVectorType> spmd_D2gDx2 = rcp_dynamic_cast<const SpmdVectorType>(D2gDx2);
209 rcp_dynamic_cast<const SpmdVectorType>(D2gDx2)->getLocalData(Teuchos::ptrFromRef(D2gDx2_data));
210 double scale = 2.0*DENSITY_VALUE*DENSITY_VALUE*DENSITY_VALUE*PERTURB_VALUE;
211 double int_phi = 1.0/192.0;
212 for(int i=0;i<D2gDx2_data.size();i++) {
213 out << D2gDx2_data[i] << " " << D2gDx2_data[i]/(scale*int_phi) << std::endl;
214 bool a = std::fabs(D2gDx2_data[i]-scale*int_phi)/(scale*int_phi) <= 1e-14;
215 bool b = std::fabs(D2gDx2_data[i]-2.0*scale*int_phi)/(2.0*scale*int_phi) <= 1e-14;
216 bool c = std::fabs(D2gDx2_data[i]-4.0*scale*int_phi)/(4.0*scale*int_phi) <= 1e-14;
217 bool d = (D2gDx2_data[i]==0.0);
218
219 TEST_ASSERT(a || b || c || d);
220 }
221 }
222
223 // Testing Parameter Support
224 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2g_dp2)
225 {
226 typedef panzer::Traits::RealType RealType;
227 typedef Thyra::VectorBase<RealType> VectorType;
228 typedef Thyra::SpmdVectorBase<RealType> SpmdVectorType;
229
230 using Teuchos::RCP;
231 using Teuchos::rcp_dynamic_cast;
232
233 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
234 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
235 typedef panzer::ModelEvaluator<double> PME;
236
237
238 bool distr_param_on = true;
239 AssemblyPieces ap;
240 buildAssemblyPieces(distr_param_on,ap);
241
242 int pIndex = -1;
243 int rIndex = -1;
244
245 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
246 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
247 bool build_transient_support = true;
248 RCP<PME> me
249 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
250
251 const double DENSITY_VALUE = 3.7;
252 const double TEMPERATURE_VALUE = 2.0;
253 const double PERTURB_VALUE = 0.1;
254
255 // add in a flexible response
256 {
257 Teuchos::RCP<panzer::FunctionalResponse_Builder<int,int> > builder
258 = Teuchos::rcp(new panzer::FunctionalResponse_Builder<int,int>);
259
260 builder->comm = MPI_COMM_WORLD; // good enough
261 builder->cubatureDegree = 1;
262 builder->requiresCellIntegral = true;
263 builder->quadPointField = "";
264
265 std::vector<panzer::WorksetDescriptor> blocks;
266 blocks.push_back(panzer::blockDescriptor("eblock-0_0"));
267 blocks.push_back(panzer::blockDescriptor("eblock-1_0"));
268 rIndex = me->addFlexibleResponse("INTEGRAND",blocks,builder); // integrate the density
269 }
270
271 // add distributed parameter
272 {
273 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
274
275 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
276 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
277 pIndex = me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
278 ap.param_ged,param_density,ap.param_dofManager);
279 }
280
281 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
282 *ap.eqset_factory,
283 *ap.bc_factory,
284 ap.cm_factory,
285 ap.cm_factory,
286 ap.closure_models,
287 ap.user_data,false,"");
288
289 // test value
290 {
291 RCP<VectorType> g = Thyra::createMember(*me->get_g_space(rIndex));
292
293 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
294 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
295
296 InArgs in_args = me->createInArgs();
297 in_args.set_x(x);
298
299 OutArgs out_args = me->createOutArgs();
300 out_args.set_g(0,g);
301
302 me->evalModel(in_args, out_args);
303
304 out << "RESPONSE = " << std::endl;
305 out << Teuchos::describe(*g,Teuchos::VERB_EXTREME) << std::endl;
306
307 Teuchos::ArrayRCP<const double> g_data;
308 rcp_dynamic_cast<Thyra::SpmdVectorBase<double> >(g)->getLocalData(Teuchos::ptrFromRef(g_data));
309 TEST_FLOATING_EQUALITY(g_data[0],TEMPERATURE_VALUE*TEMPERATURE_VALUE*DENSITY_VALUE*DENSITY_VALUE*DENSITY_VALUE,1e-12);
310 // Volume of integral is 1.0, then just compute the integrand
311 }
312
313 RCP<VectorType> D2gDp2 = Thyra::createMember(*me->get_p_space(pIndex));
314
315 // test hessian
316 {
317
318 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
319 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
320
321 RCP<VectorType> dp = Thyra::createMember(*me->get_p_space(pIndex));
322 Thyra::assign(dp.ptr(),PERTURB_VALUE);
323
324 InArgs in_args = me->createInArgs();
325 in_args.set_x(x);
326
327 me->evalModel_D2gDp2(rIndex,pIndex,in_args,dp,D2gDp2);
328
329 out << "D2gDp2 = \n" << Teuchos::describe(*D2gDp2,Teuchos::VERB_EXTREME) << std::endl;
330 }
331
332 Teuchos::ArrayRCP<const double> D2gDp2_data;
333 RCP<const SpmdVectorType> spmd_D2gDp2 = rcp_dynamic_cast<const SpmdVectorType>(D2gDp2);
334 rcp_dynamic_cast<const SpmdVectorType>(D2gDp2)->getLocalData(Teuchos::ptrFromRef(D2gDp2_data));
335 double scale = 6.0*TEMPERATURE_VALUE*TEMPERATURE_VALUE*DENSITY_VALUE*PERTURB_VALUE;
336 double int_phi = 1.0/192.0;
337 for(int i=0;i<D2gDp2_data.size();i++) {
338 out << D2gDp2_data[i] << " " << D2gDp2_data[i]/(scale*int_phi) << std::endl;
339 bool a = std::fabs(D2gDp2_data[i]-scale*int_phi)/(scale*int_phi) <= 1e-14;
340 bool b = std::fabs(D2gDp2_data[i]-2.0*scale*int_phi)/(2.0*scale*int_phi) <= 1e-14;
341 bool c = std::fabs(D2gDp2_data[i]-4.0*scale*int_phi)/(4.0*scale*int_phi) <= 1e-14;
342 bool d = (D2gDp2_data[i]==0.0);
343
344 TEST_ASSERT(a || b || c || d);
345 }
346 }
347
348 // Testing Parameter Support
349 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2g_dpdx)
350 {
351 typedef panzer::Traits::RealType RealType;
352 typedef Thyra::VectorBase<RealType> VectorType;
353 typedef Thyra::SpmdVectorBase<RealType> SpmdVectorType;
354
355 using Teuchos::RCP;
356 using Teuchos::rcp_dynamic_cast;
357
358 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
359 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
360 typedef panzer::ModelEvaluator<double> PME;
361
362
363 bool distr_param_on = true;
364 AssemblyPieces ap;
365 buildAssemblyPieces(distr_param_on,ap);
366
367 int pIndex = -1;
368 int rIndex = -1;
369
370 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
371 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
372 bool build_transient_support = true;
373 RCP<PME> me
374 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
375
376 const double DENSITY_VALUE = 3.7;
377 const double TEMPERATURE_VALUE = 2.0;
378 const double PERTURB_VALUE = 0.1;
379
380 // add in a flexible response
381 {
382 Teuchos::RCP<panzer::FunctionalResponse_Builder<int,int> > builder
383 = Teuchos::rcp(new panzer::FunctionalResponse_Builder<int,int>);
384
385 builder->comm = MPI_COMM_WORLD; // good enough
386 builder->cubatureDegree = 1;
387 builder->requiresCellIntegral = true;
388 builder->quadPointField = "";
389
390 std::vector<panzer::WorksetDescriptor> blocks;
391 blocks.push_back(panzer::blockDescriptor("eblock-0_0"));
392 blocks.push_back(panzer::blockDescriptor("eblock-1_0"));
393 rIndex = me->addFlexibleResponse("INTEGRAND",blocks,builder); // integrate the density
394 }
395
396 // add distributed parameter
397 {
398 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
399
400 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
401 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
402 pIndex = me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
403 ap.param_ged,param_density,ap.param_dofManager);
404 }
405
406 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
407 *ap.eqset_factory,
408 *ap.bc_factory,
409 ap.cm_factory,
410 ap.cm_factory,
411 ap.closure_models,
412 ap.user_data,false,"");
413
414 // test value
415 {
416 RCP<VectorType> g = Thyra::createMember(*me->get_g_space(rIndex));
417
418 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
419 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
420
421 InArgs in_args = me->createInArgs();
422 in_args.set_x(x);
423
424 OutArgs out_args = me->createOutArgs();
425 out_args.set_g(0,g);
426
427 me->evalModel(in_args, out_args);
428
429 out << "RESPONSE = " << std::endl;
430 out << Teuchos::describe(*g,Teuchos::VERB_EXTREME) << std::endl;
431
432 Teuchos::ArrayRCP<const double> g_data;
433 rcp_dynamic_cast<Thyra::SpmdVectorBase<double> >(g)->getLocalData(Teuchos::ptrFromRef(g_data));
434 TEST_FLOATING_EQUALITY(g_data[0],TEMPERATURE_VALUE*TEMPERATURE_VALUE*DENSITY_VALUE*DENSITY_VALUE*DENSITY_VALUE,1e-12);
435 // Volume of integral is 1.0, then just compute the integrand
436 }
437
438 RCP<VectorType> D2gDpDx = Thyra::createMember(*me->get_p_space(pIndex));
439
440 // test hessian
441 {
442
443 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
444 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
445
446 RCP<VectorType> dx = Thyra::createMember(*me->get_x_space());
447 Thyra::assign(dx.ptr(),PERTURB_VALUE);
448
449 InArgs in_args = me->createInArgs();
450 in_args.set_x(x);
451
452 me->evalModel_D2gDpDx(rIndex,pIndex,in_args,dx,D2gDpDx);
453
454 out << "D2gDpDx = \n" << Teuchos::describe(*D2gDpDx,Teuchos::VERB_EXTREME) << std::endl;
455 }
456
457 Teuchos::ArrayRCP<const double> D2gDpDx_data;
458 RCP<const SpmdVectorType> spmd_D2gDpDx = rcp_dynamic_cast<const SpmdVectorType>(D2gDpDx);
459 rcp_dynamic_cast<const SpmdVectorType>(D2gDpDx)->getLocalData(Teuchos::ptrFromRef(D2gDpDx_data));
460 double scale = 6.0*TEMPERATURE_VALUE*DENSITY_VALUE*DENSITY_VALUE*PERTURB_VALUE;
461 double int_phi = 1.0/192.0;
462 for(int i=0;i<D2gDpDx_data.size();i++) {
463 out << D2gDpDx_data[i] << " " << D2gDpDx_data[i]/(scale*int_phi) << std::endl;
464 bool a = std::fabs(D2gDpDx_data[i]-scale*int_phi)/(scale*int_phi) <= 1e-14;
465 bool b = std::fabs(D2gDpDx_data[i]-2.0*scale*int_phi)/(2.0*scale*int_phi) <= 1e-14;
466 bool c = std::fabs(D2gDpDx_data[i]-4.0*scale*int_phi)/(4.0*scale*int_phi) <= 1e-14;
467 bool d = (D2gDpDx_data[i]==0.0);
468
469 TEST_ASSERT(a || b || c || d);
470 }
471 }
472
473 // Testing Parameter Support
474 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2g_dxdp)
475 {
476 typedef panzer::Traits::RealType RealType;
477 typedef Thyra::VectorBase<RealType> VectorType;
478 typedef Thyra::SpmdVectorBase<RealType> SpmdVectorType;
479
480 using Teuchos::RCP;
481 using Teuchos::rcp_dynamic_cast;
482
483 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
484 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
485 typedef panzer::ModelEvaluator<double> PME;
486
487
488 bool distr_param_on = true;
489 AssemblyPieces ap;
490 buildAssemblyPieces(distr_param_on,ap);
491
492 int pIndex = -1;
493 int rIndex = -1;
494
495 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
496 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
497 bool build_transient_support = true;
498 RCP<PME> me
499 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
500
501 const double DENSITY_VALUE = 3.7;
502 const double TEMPERATURE_VALUE = 2.0;
503 const double PERTURB_VALUE = 0.1;
504
505 // add in a flexible response
506 {
507 Teuchos::RCP<panzer::FunctionalResponse_Builder<int,int> > builder
508 = Teuchos::rcp(new panzer::FunctionalResponse_Builder<int,int>);
509
510 builder->comm = MPI_COMM_WORLD; // good enough
511 builder->cubatureDegree = 1;
512 builder->requiresCellIntegral = true;
513 builder->quadPointField = "";
514
515 std::vector<panzer::WorksetDescriptor> blocks;
516 blocks.push_back(panzer::blockDescriptor("eblock-0_0"));
517 blocks.push_back(panzer::blockDescriptor("eblock-1_0"));
518 rIndex = me->addFlexibleResponse("INTEGRAND",blocks,builder); // integrate the density
519 }
520
521 // add distributed parameter
522 {
523 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
524
525 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
526 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
527 pIndex = me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
528 ap.param_ged,param_density,ap.param_dofManager);
529 }
530
531 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
532 *ap.eqset_factory,
533 *ap.bc_factory,
534 ap.cm_factory,
535 ap.cm_factory,
536 ap.closure_models,
537 ap.user_data,false,"");
538
539 // test value
540 {
541 RCP<VectorType> g = Thyra::createMember(*me->get_g_space(rIndex));
542
543 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
544 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
545
546 InArgs in_args = me->createInArgs();
547 in_args.set_x(x);
548
549 OutArgs out_args = me->createOutArgs();
550 out_args.set_g(0,g);
551
552 me->evalModel(in_args, out_args);
553
554 out << "RESPONSE = " << std::endl;
555 out << Teuchos::describe(*g,Teuchos::VERB_EXTREME) << std::endl;
556
557 Teuchos::ArrayRCP<const double> g_data;
558 rcp_dynamic_cast<Thyra::SpmdVectorBase<double> >(g)->getLocalData(Teuchos::ptrFromRef(g_data));
559 TEST_FLOATING_EQUALITY(g_data[0],TEMPERATURE_VALUE*TEMPERATURE_VALUE*DENSITY_VALUE*DENSITY_VALUE*DENSITY_VALUE,1e-12);
560 // Volume of integral is 1.0, then just compute the integrand
561 }
562
563 RCP<VectorType> D2gDxDp = Thyra::createMember(*me->get_x_space());
564
565 // test hessian
566 {
567
568 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
569 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
570
571 RCP<VectorType> dp = Thyra::createMember(*me->get_p_space(pIndex));
572 Thyra::assign(dp.ptr(),PERTURB_VALUE);
573
574 InArgs in_args = me->createInArgs();
575 in_args.set_x(x);
576
577 me->evalModel_D2gDxDp(rIndex,pIndex,in_args,dp,D2gDxDp);
578
579 out << "D2gDxDp = \n" << Teuchos::describe(*D2gDxDp,Teuchos::VERB_EXTREME) << std::endl;
580 }
581
582 Teuchos::ArrayRCP<const double> D2gDxDp_data;
583 RCP<const SpmdVectorType> spmd_D2gDxDp = rcp_dynamic_cast<const SpmdVectorType>(D2gDxDp);
584 rcp_dynamic_cast<const SpmdVectorType>(D2gDxDp)->getLocalData(Teuchos::ptrFromRef(D2gDxDp_data));
585 double scale = 6.0*TEMPERATURE_VALUE*DENSITY_VALUE*DENSITY_VALUE*PERTURB_VALUE;
586 double int_phi = 1.0/192.0;
587 for(int i=0;i<D2gDxDp_data.size();i++) {
588 out << D2gDxDp_data[i] << " " << D2gDxDp_data[i]/(scale*int_phi) << std::endl;
589 bool a = std::fabs(D2gDxDp_data[i]-scale*int_phi)/(scale*int_phi) <= 1e-14;
590 bool b = std::fabs(D2gDxDp_data[i]-2.0*scale*int_phi)/(2.0*scale*int_phi) <= 1e-14;
591 bool c = std::fabs(D2gDxDp_data[i]-4.0*scale*int_phi)/(4.0*scale*int_phi) <= 1e-14;
592 bool d = (D2gDxDp_data[i]==0.0);
593
594 TEST_ASSERT(a || b || c || d);
595 }
596 }
597
598 // Testing Parameter Support
599 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2f_dx2)
600 {
601 typedef panzer::Traits::RealType RealType;
602 typedef Thyra::VectorBase<RealType> VectorType;
603 typedef Thyra::LinearOpBase<RealType> OperatorType;
604
605 using Teuchos::RCP;
606 using Teuchos::rcp_dynamic_cast;
607
608 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
609 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
610 typedef panzer::ModelEvaluator<double> PME;
611
612
613 bool distr_param_on = true;
614 AssemblyPieces ap;
615 buildAssemblyPieces(distr_param_on,ap);
616
617 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
618 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
619 bool build_transient_support = true;
620 RCP<PME> me
621 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
622
623 const double DENSITY_VALUE = 3.7;
624 const double TEMPERATURE_VALUE = 2.0;
625 const double PERTURB_VALUE = 0.1;
626
627 // add distributed parameter
628 {
629 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
630
631 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
632 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
633 me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
634 ap.param_ged,param_density,ap.param_dofManager);
635 }
636
637 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
638 *ap.eqset_factory,
639 *ap.bc_factory,
640 ap.cm_factory,
641 ap.cm_factory,
642 ap.closure_models,
643 ap.user_data,false,"");
644
645 panzer::printMeshTopology(out,*ap.dofManager);
646
647
648 RCP<OperatorType> D2fDx2 = me->create_W_op();
649
650 // test hessian
651 {
652
653 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
654 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
655
656 RCP<VectorType> dx = Thyra::createMember(*me->get_x_space());
657 Thyra::assign(dx.ptr(),PERTURB_VALUE);
658
659 InArgs in_args = me->createInArgs();
660 in_args.set_x(x);
661 in_args.set_alpha(1.0/0.1);
662 in_args.set_beta(1.0);
663
664 me->evalModel_D2fDx2(in_args,dx,D2fDx2);
665
666 out << "D2fDx2 = \n" << Teuchos::describe(*D2fDx2,Teuchos::VERB_EXTREME) << std::endl;
667 }
668
669 RCP<OperatorType> W = me->create_W_op();
670 {
671 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
672 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
673
674 InArgs in_args = me->createInArgs();
675 in_args.set_x(x);
676 in_args.set_alpha(1.0);
677 in_args.set_beta(0.0);
678
679 OutArgs out_args = me->createOutArgs();
680 out_args.set_W_op(W);
681
682 me->evalModel(in_args,out_args);
683
684 out << "W = \n" << Teuchos::describe(*W,Teuchos::VERB_EXTREME) << std::endl;
685 }
686
687 Thyra::LinearOpTester<double> tester;
688 tester.show_all_tests(true);
689 tester.set_all_error_tol(1e-15);
690 tester.num_random_vectors(20);
691
692 double scaling_of_mass_matrix = -2.0*PERTURB_VALUE*DENSITY_VALUE*DENSITY_VALUE;
693
694 Teuchos::FancyOStream fout(Teuchos::rcpFromRef(std::cout));
695 const bool op_cmp = tester.compare( *Thyra::scaleAndAdjoint(scaling_of_mass_matrix,Thyra::NOTRANS,W.getConst()), *D2fDx2, Teuchos::ptrFromRef(fout));
696 TEST_ASSERT(op_cmp);
697 }
698
699 // Testing Parameter Support
700 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2f_dxdp)
701 {
702 typedef panzer::Traits::RealType RealType;
703 typedef Thyra::VectorBase<RealType> VectorType;
704 typedef Thyra::LinearOpBase<RealType> OperatorType;
705
706 using Teuchos::RCP;
707 using Teuchos::rcp_dynamic_cast;
708
709 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
710 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
711 typedef panzer::ModelEvaluator<double> PME;
712
713
714 bool distr_param_on = true;
715 AssemblyPieces ap;
716 buildAssemblyPieces(distr_param_on,ap);
717
718 int pIndex = -1;
719
720 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
721 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
722 bool build_transient_support = true;
723 RCP<PME> me
724 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
725
726 const double DENSITY_VALUE = 3.7;
727 const double TEMPERATURE_VALUE = 2.0;
728 const double PERTURB_VALUE = 0.1;
729
730 // add distributed parameter
731 {
732 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
733
734 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
735 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
736 pIndex = me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
737 ap.param_ged,param_density,ap.param_dofManager);
738 }
739
740 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
741 *ap.eqset_factory,
742 *ap.bc_factory,
743 ap.cm_factory,
744 ap.cm_factory,
745 ap.closure_models,
746 ap.user_data,false,"");
747
748 panzer::printMeshTopology(out,*ap.dofManager);
749
750
751 RCP<OperatorType> D2fDxDp = me->create_W_op();
752
753 // test hessian
754 {
755
756 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
757 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
758
759 RCP<VectorType> dx = Thyra::createMember(*me->get_x_space());
760 Thyra::assign(dx.ptr(),PERTURB_VALUE);
761
762 InArgs in_args = me->createInArgs();
763 in_args.set_x(x);
764 in_args.set_alpha(1.0/0.1);
765 in_args.set_beta(1.0);
766
767 me->evalModel_D2fDxDp(pIndex,in_args,dx,D2fDxDp);
768
769 out << "D2fDxDp = \n" << Teuchos::describe(*D2fDxDp,Teuchos::VERB_EXTREME) << std::endl;
770 }
771
772 RCP<OperatorType> W = me->create_W_op();
773 {
774 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
775 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
776
777 InArgs in_args = me->createInArgs();
778 in_args.set_x(x);
779 in_args.set_alpha(1.0);
780 in_args.set_beta(0.0);
781
782 OutArgs out_args = me->createOutArgs();
783 out_args.set_W_op(W);
784
785 me->evalModel(in_args,out_args);
786
787 out << "W = \n" << Teuchos::describe(*W,Teuchos::VERB_EXTREME) << std::endl;
788 }
789
790 Thyra::LinearOpTester<double> tester;
791 tester.show_all_tests(true);
792 tester.set_all_error_tol(1e-15);
793 tester.num_random_vectors(20);
794
795 double scaling_of_mass_matrix = -2.0*TEMPERATURE_VALUE*2.0*DENSITY_VALUE*PERTURB_VALUE;
796
797 Teuchos::FancyOStream fout(Teuchos::rcpFromRef(std::cout));
798 const bool op_cmp = tester.compare( *Thyra::scaleAndAdjoint(scaling_of_mass_matrix,Thyra::NOTRANS,W.getConst()), *D2fDxDp, Teuchos::ptrFromRef(fout));
799 TEST_ASSERT(op_cmp);
800 }
801
802 bool testEqualityOfVectorValues(const Thyra::VectorBase<double> & a,
803 const Thyra::VectorBase<double> & b,
804 double tolerance, bool write_to_cout)
805 {
806 bool is_equal = true;
807
808 TEUCHOS_ASSERT(a.space()->dim() == b.space()->dim());
809
810 Teuchos::ArrayRCP<const double> a_data,b_data;
811 dynamic_cast<const Thyra::SpmdVectorBase<double> &>(a).getLocalData(Teuchos::ptrFromRef(a_data));
812 dynamic_cast<const Thyra::SpmdVectorBase<double> &>(b).getLocalData(Teuchos::ptrFromRef(b_data));
813
814 for (int i = 0; i < a_data.size(); ++i) {
815
816 std::string output = " equal!: ";
817
818 if (std::fabs(a_data[i] - b_data[i]) > tolerance) {
819 is_equal = false;
820 output = "NOT equal!: ";
821 }
822
823 if (write_to_cout)
824 std::cout << output << a_data[i] << " - " << b_data[i] << " = " << (a_data[i] - b_data[i]) << std::endl;
825 }
826
827 int globalSuccess = -1;
828 Teuchos::RCP<const Teuchos::Comm<Teuchos::Ordinal> > comm = Teuchos::DefaultComm<Teuchos::Ordinal>::getComm();
829 Teuchos::reduceAll( *comm, Teuchos::REDUCE_SUM, is_equal ? 0 : 1, Teuchos::outArg(globalSuccess) );
830 return (globalSuccess==0);
831 }
832
833 // Testing Parameter Support
834 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2f_dpdx)
835 {
836 typedef panzer::Traits::RealType RealType;
837 typedef Thyra::VectorBase<RealType> VectorType;
838 typedef Thyra::LinearOpBase<RealType> OperatorType;
839
840 using Teuchos::RCP;
841 using Teuchos::rcp_dynamic_cast;
842
843 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
844 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
845 typedef panzer::ModelEvaluator<double> PME;
846
847
848 bool distr_param_on = true;
849 AssemblyPieces ap;
850 buildAssemblyPieces(distr_param_on,ap);
851
852 int pIndex = -1;
853
854 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
855 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
856 bool build_transient_support = true;
857 RCP<PME> me
858 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
859
860 const double DENSITY_VALUE = 3.7;
861 const double TEMPERATURE_VALUE = 2.0;
862 const double PERTURB_VALUE = 0.1;
863
864 // add distributed parameter
865 {
866 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
867
868 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
869 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
870 pIndex = me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
871 ap.param_ged,param_density,ap.param_dofManager);
872 }
873
874 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
875 *ap.eqset_factory,
876 *ap.bc_factory,
877 ap.cm_factory,
878 ap.cm_factory,
879 ap.closure_models,
880 ap.user_data,false,"");
881
882 panzer::printMeshTopology(out,*ap.dofManager);
883
884
885 RCP<OperatorType> D2fDpDx = me->create_DfDp_op(pIndex);
886
887 // test hessian
888 {
889
890 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
891 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
892
893 RCP<VectorType> dx = Thyra::createMember(*me->get_x_space());
894 Thyra::assign(dx.ptr(),PERTURB_VALUE);
895
896 InArgs in_args = me->createInArgs();
897 in_args.set_x(x);
898 in_args.set_alpha(1.0/0.1);
899 in_args.set_beta(1.0);
900
901 me->evalModel_D2fDpDx(pIndex,in_args,dx,D2fDpDx);
902
903 out << "D2fDpDx = \n" << Teuchos::describe(*D2fDpDx,Teuchos::VERB_EXTREME) << std::endl;
904 }
905
906 RCP<OperatorType> W = me->create_DfDp_op(pIndex);
907 {
908 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
909 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
910
911 InArgs in_args = me->createInArgs();
912 in_args.set_x(x);
913 in_args.set_alpha(1.0);
914 in_args.set_beta(0.0);
915
916 OutArgs out_args = me->createOutArgs();
917 out_args.set_DfDp(pIndex,W);
918
919 me->evalModel(in_args,out_args);
920
921 out << "W = \n" << Teuchos::describe(*W,Teuchos::VERB_EXTREME) << std::endl;
922 }
923
924 Thyra::LinearOpTester<double> tester;
925 tester.show_all_tests(true);
926 tester.set_all_error_tol(1e-15);
927 tester.num_random_vectors(20);
928
929 double scaling_of_dfdp = 2.0*PERTURB_VALUE/TEMPERATURE_VALUE;
930
931 Teuchos::FancyOStream fout(Teuchos::rcpFromRef(std::cout));
932 const bool op_cmp = tester.compare( *Thyra::scaleAndAdjoint(scaling_of_dfdp,Thyra::NOTRANS,W.getConst()), *D2fDpDx, Teuchos::ptrFromRef(fout));
933 TEST_ASSERT(op_cmp);
934 }
935
936 // Testing Parameter Support
937 TEUCHOS_UNIT_TEST(model_evaluator_hessians, d2f_dp2)
938 {
939 typedef panzer::Traits::RealType RealType;
940 typedef Thyra::VectorBase<RealType> VectorType;
941 typedef Thyra::LinearOpBase<RealType> OperatorType;
942
943 using Teuchos::RCP;
944 using Teuchos::rcp_dynamic_cast;
945
946 typedef Thyra::ModelEvaluatorBase::InArgs<double> InArgs;
947 typedef Thyra::ModelEvaluatorBase::OutArgs<double> OutArgs;
948 typedef panzer::ModelEvaluator<double> PME;
949
950
951 bool distr_param_on = true;
952 AssemblyPieces ap;
953 buildAssemblyPieces(distr_param_on,ap);
954
955 int pIndex = -1;
956
957 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
958 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
959 bool build_transient_support = true;
960 RCP<PME> me
961 = Teuchos::rcp(new PME(ap.fmb,ap.rLibrary,ap.lof,p_names,p_values,Teuchos::null,ap.gd,build_transient_support,0.0));
962
963 const double DENSITY_VALUE = 3.7;
964 const double TEMPERATURE_VALUE = 2.0;
965 const double PERTURB_VALUE = 0.1;
966
967 // add distributed parameter
968 {
969 RCP<ThyraObjFactory<double> > th_param_lof = rcp_dynamic_cast<ThyraObjFactory<double> >(ap.param_lof);
970
971 RCP<VectorType> param_density = Thyra::createMember(th_param_lof->getThyraDomainSpace());
972 Thyra::assign(param_density.ptr(),DENSITY_VALUE);
973 pIndex = me->addDistributedParameter("DENSITY_P",th_param_lof->getThyraDomainSpace(),
974 ap.param_ged,param_density,ap.param_dofManager);
975 }
976
977 me->setupModel(ap.wkstContainer,ap.physicsBlocks,ap.bcs,
978 *ap.eqset_factory,
979 *ap.bc_factory,
980 ap.cm_factory,
981 ap.cm_factory,
982 ap.closure_models,
983 ap.user_data,false,"");
984
985 panzer::printMeshTopology(out,*ap.dofManager);
986
987
988 RCP<OperatorType> D2fDp2 = me->create_DfDp_op(pIndex);
989
990 // test hessian
991 {
992
993 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
994 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
995
996 RCP<VectorType> dx = Thyra::createMember(*me->get_x_space());
997 Thyra::assign(dx.ptr(),PERTURB_VALUE);
998
999 InArgs in_args = me->createInArgs();
1000 in_args.set_x(x);
1001 in_args.set_alpha(1.0/0.1);
1002 in_args.set_beta(1.0);
1003
1004 me->evalModel_D2fDp2(pIndex,in_args,dx,D2fDp2);
1005
1006 out << "D2fDp2 = \n" << Teuchos::describe(*D2fDp2,Teuchos::VERB_EXTREME) << std::endl;
1007 }
1008
1009 RCP<OperatorType> W = me->create_DfDp_op(pIndex);
1010 {
1011 RCP<VectorType> x = Thyra::createMember(*me->get_x_space());
1012 Thyra::assign(x.ptr(),TEMPERATURE_VALUE);
1013
1014 InArgs in_args = me->createInArgs();
1015 in_args.set_x(x);
1016 in_args.set_alpha(1.0);
1017 in_args.set_beta(0.0);
1018
1019 OutArgs out_args = me->createOutArgs();
1020 out_args.set_DfDp(pIndex,W);
1021
1022 me->evalModel(in_args,out_args);
1023
1024 out << "W = \n" << Teuchos::describe(*W,Teuchos::VERB_EXTREME) << std::endl;
1025 }
1026
1027 Thyra::LinearOpTester<double> tester;
1028 tester.show_all_tests(true);
1029 tester.set_all_error_tol(1e-15);
1030 tester.num_random_vectors(20);
1031
1032 double scaling_of_dfdp = PERTURB_VALUE/DENSITY_VALUE;
1033
1034 Teuchos::FancyOStream fout(Teuchos::rcpFromRef(std::cout));
1035 const bool op_cmp = tester.compare( *Thyra::scaleAndAdjoint(scaling_of_dfdp,Thyra::NOTRANS,W.getConst()), *D2fDp2, Teuchos::ptrFromRef(fout));
1036 TEST_ASSERT(op_cmp);
1037 }
1038
1039 void testInitialzation(const Teuchos::RCP<Teuchos::ParameterList>& ipb,
1040 std::vector<panzer::BC>& bcs)
1041 {
1042 // Physics block
1043 Teuchos::ParameterList& physics_block = ipb->sublist("test physics");
1044 {
1045 Teuchos::ParameterList& p = physics_block.sublist("a");
1046 p.set("Type","Energy");
1047 p.set("Prefix","");
1048 p.set("Model ID","solid");
1049 p.set("Basis Type","HGrad");
1050 p.set("Basis Order",1);
1051 p.set("Integration Order",1);
1052 }
1053 {
1054 Teuchos::ParameterList& p = physics_block.sublist("b");
1055 p.set("Type","Energy");
1056 p.set("Prefix","ION_");
1057 p.set("Model ID","ion solid");
1058 p.set("Basis Type","HGrad");
1059 p.set("Basis Order",1);
1060 p.set("Integration Order",1);
1061 }
1062
1063
1064 {
1065 std::size_t bc_id = 0;
1066 panzer::BCType neumann = BCT_Dirichlet;
1067 std::string sideset_id = "left";
1068 std::string element_block_id = "eblock-0_0";
1069 std::string dof_name = "TEMPERATURE";
1070 std::string strategy = "Constant";
1071 double value = 5.0;
1072 Teuchos::ParameterList p;
1073 p.set("Value",value);
1074 panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
1075 strategy, p);
1076 bcs.push_back(bc);
1077 }
1078 {
1079 std::size_t bc_id = 1;
1080 panzer::BCType neumann = BCT_Dirichlet;
1081 std::string sideset_id = "right";
1082 std::string element_block_id = "eblock-1_0";
1083 std::string dof_name = "TEMPERATURE";
1084 std::string strategy = "Constant";
1085 double value = 5.0;
1086 Teuchos::ParameterList p;
1087 p.set("Value",value);
1088 panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
1089 strategy, p);
1090 bcs.push_back(bc);
1091 }
1092 {
1093 std::size_t bc_id = 2;
1094 panzer::BCType neumann = BCT_Dirichlet;
1095 std::string sideset_id = "top";
1096 std::string element_block_id = "eblock-1_0";
1097 std::string dof_name = "TEMPERATURE";
1098 std::string strategy = "Constant";
1099 double value = 5.0;
1100 Teuchos::ParameterList p;
1101 p.set("Value",value);
1102 panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
1103 strategy, p);
1104 bcs.push_back(bc);
1105 }
1106 }
1107
1108 void buildAssemblyPieces(bool distr_parameter_on,
1109 AssemblyPieces & ap,
1110 const std::vector<std::string>& tangentParamNames)
1111 {
1112 using Teuchos::RCP;
1113
1114 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
1115 pl->set("X Blocks",2);
1116 pl->set("Y Blocks",1);
1117 pl->set("X Elements",6);
1118 pl->set("Y Elements",4);
1119
1120 panzer_stk::SquareQuadMeshFactory factory;
1121 factory.setParameterList(pl);
1122 RCP<panzer_stk::STK_Interface> mesh = factory.buildMesh(MPI_COMM_WORLD);
1123 Teuchos::RCP<const Teuchos::Comm<int> > Comm = Teuchos::DefaultComm<int>::getComm();
1124 Teuchos::RCP<const Teuchos::MpiComm<int> > mpiComm
1125 = Teuchos::rcp_dynamic_cast<const Teuchos::MpiComm<int> >(Comm);
1126
1127 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList("Physics Blocks");
1128 std::vector<panzer::BC> bcs;
1129 testInitialzation(ipb, bcs);
1130
1131 ap.fmb = Teuchos::rcp(new panzer::FieldManagerBuilder);
1132 ap.bcs = bcs;
1133
1134 // build physics blocks
1135 //////////////////////////////////////////////////////////////
1136 const std::size_t workset_size = 20;
1137 ap.eqset_factory = Teuchos::rcp(new user_app::MyFactory);
1138 ap.bc_factory = Teuchos::rcp(new user_app::BCFactory);
1139 ap.gd = panzer::createGlobalData();
1140 {
1141 std::map<std::string,std::string> block_ids_to_physics_ids;
1142 block_ids_to_physics_ids["eblock-0_0"] = "test physics";
1143 block_ids_to_physics_ids["eblock-1_0"] = "test physics";
1144
1145 std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
1146 block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0");
1147 block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0");
1148
1149 int default_integration_order = 1;
1150
1151 bool build_transient_support = true;
1152 panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
1153 block_ids_to_cell_topo,
1154 ipb,
1155 default_integration_order,
1156 workset_size,
1157 ap.eqset_factory,
1158 ap.gd,
1159 build_transient_support,
1160 ap.physicsBlocks,
1161 tangentParamNames);
1162 }
1163
1164 // build worksets
1165 //////////////////////////////////////////////////////////////
1166 // build WorksetContainer
1167 Teuchos::RCP<panzer_stk::WorksetFactory> wkstFactory
1168 = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory
1169 Teuchos::RCP<panzer::WorksetContainer> wkstContainer // attach it to a workset container (uses lazy evaluation)
1170 = Teuchos::rcp(new panzer::WorksetContainer);
1171 wkstContainer->setFactory(wkstFactory);
1172 for(size_t i=0;i<ap.physicsBlocks.size();i++)
1173 wkstContainer->setNeeds(ap.physicsBlocks[i]->elementBlockID(),ap.physicsBlocks[i]->getWorksetNeeds());
1174 wkstContainer->setWorksetSize(workset_size);
1175 ap.wkstContainer = wkstContainer;
1176
1177 // build DOF Manager
1178 /////////////////////////////////////////////////////////////
1179
1180 // build the connection manager
1181 const Teuchos::RCP<panzer::ConnManager>
1182 conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
1183
1184 // build the state dof manager and LOF
1185 {
1186 panzer::DOFManagerFactory globalIndexerFactory;
1187 RCP<panzer::GlobalIndexer> dofManager
1188 = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),ap.physicsBlocks,conn_manager);
1189 ap.dofManager = dofManager;
1190
1191 Teuchos::RCP<panzer::LinearObjFactory<panzer::Traits> > linObjFactory
1192 = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory<panzer::Traits,int>(mpiComm,dofManager));
1193 ap.lof = linObjFactory;
1194 }
1195
1196 // build the dof manager and LOF for DENSITY control
1197 if(distr_parameter_on) {
1198 Teuchos::RCP<panzer::DOFManager> dofManager
1199 = Teuchos::rcp(new panzer::DOFManager(conn_manager,MPI_COMM_WORLD));
1200
1201 Teuchos::RCP<Intrepid2FieldPattern> fp
1202 = Teuchos::rcp(new Intrepid2FieldPattern(panzer::createIntrepid2Basis<PHX::exec_space,double,double>("HGrad",1,mesh->getCellTopology("eblock-0_0"))));
1203 dofManager->addField("eblock-0_0","DENSITY_P",fp);
1204 dofManager->addField("eblock-1_0","DENSITY_P",fp);
1205
1206 dofManager->setOrientationsRequired(false);
1207 dofManager->buildGlobalUnknowns();
1208
1209 // build a nonsquare LOF for the parameter vector
1210 Teuchos::RCP<panzer::BlockedEpetraLinearObjFactory<panzer::Traits,int> > linObjFactory
1211 = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory<panzer::Traits,int>(mpiComm,ap.dofManager,dofManager));
1212
1213 Teuchos::RCP<Epetra_Map> ownedMap = linObjFactory->getColMap(0);
1214 Teuchos::RCP<Epetra_Map> ghostedMap = linObjFactory->getGhostedColMap(0);
1215 Teuchos::RCP<Epetra_Import> importer = Teuchos::rcp(new Epetra_Import(*ghostedMap,*ownedMap));
1216
1217 ap.param_dofManager = dofManager;
1218 ap.param_ged = Teuchos::rcp(new EpetraVector_ReadOnly_GlobalEvaluationData(importer,ghostedMap,ownedMap));
1219 ap.param_lof = linObjFactory;
1220 }
1221
1222 ap.rLibrary = Teuchos::rcp(new panzer::ResponseLibrary<panzer::Traits>(wkstContainer,ap.dofManager,ap.lof));
1223
1224 // setup field manager build
1225 /////////////////////////////////////////////////////////////
1226
1227 // Add in the application specific closure model factory
1228 user_app::MyModelFactory_TemplateBuilder cm_builder;
1229 cm_builder.setDistributedParameterLOF(ap.param_lof);
1230 ap.cm_factory.buildObjects(cm_builder);
1231
1232 Teuchos::ParameterList closure_models("Closure Models");
1233 closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set<std::string>("Type","Product");
1234 closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set<std::string>("Term Names","TEMPERATURE,TEMPERATURE,DENSITY_P,DENSITY_P");
1235 closure_models.sublist("solid").sublist("DENSITY").set<double>("Value",1.0);
1236 closure_models.sublist("solid").sublist("HEAT_CAPACITY").set<double>("Value",1.0);
1237 closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set<std::string>("Type","Product");
1238 closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set<std::string>("Term Names","ION_TEMPERATURE,ION_TEMPERATURE,DENSITY_P,DENSITY_P");
1239 closure_models.sublist("ion solid").sublist("ION_DENSITY").set<double>("Value",1.0);
1240 closure_models.sublist("ion solid").sublist("ION_DENSITY").set<double>("Value",1.0);
1241 closure_models.sublist("ion solid").sublist("ION_HEAT_CAPACITY").set<double>("Value",1.0);
1242
1243 closure_models.sublist("solid").sublist("DENSITY_P").set("Type","Distributed Parameter");
1244 closure_models.sublist("solid").sublist("INTEGRAND").set<std::string>("Type","Product");
1245 closure_models.sublist("solid").sublist("INTEGRAND").set<std::string>("Term Names","TEMPERATURE,TEMPERATURE,DENSITY_P,DENSITY_P,DENSITY_P");
1246
1247 ap.closure_models = closure_models;
1248
1249 ap.user_data = Teuchos::ParameterList("User Data");
1250
1251 ap.fmb->setWorksetContainer(wkstContainer);
1252 ap.fmb->setupVolumeFieldManagers(ap.physicsBlocks,ap.cm_factory,closure_models,*ap.lof,ap.user_data);
1253 ap.fmb->setupBCFieldManagers(bcs,ap.physicsBlocks,*ap.eqset_factory,ap.cm_factory,*ap.bc_factory,
1254 closure_models,*ap.lof,ap.user_data);
1255 }
1256
1257
1258 }