Debian Codegraph @

packages/panzer/adapters-stk/test/model_evaluator/model_evaluator.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 "Panzer_STK_Version.hpp"
24 #include "PanzerAdaptersSTK_config.hpp"
25 #include "Panzer_STK_Interface.hpp"
26 #include "Panzer_STK_SquareQuadMeshFactory.hpp"
27 #include "Panzer_STK_SetupUtilities.hpp"
28 #include "Panzer_STK_WorksetFactory.hpp"
29 #include "Panzer_Workset_Builder.hpp"
30 #include "Panzer_FieldManagerBuilder.hpp"
31 #include "Panzer_STKConnManager.hpp"
32 #include "Panzer_BlockedEpetraLinearObjFactory.hpp"
33 #include "Panzer_AssemblyEngine.hpp"
34 #include "Panzer_AssemblyEngine_TemplateManager.hpp"
35 #include "Panzer_AssemblyEngine_TemplateBuilder.hpp"
36 #include "Panzer_DOFManagerFactory.hpp"
37 #include "Panzer_ModelEvaluator.hpp"
38 #include "Panzer_ModelEvaluator_Epetra.hpp"
39 #include "Panzer_ResponseLibrary.hpp"
40 #include "Panzer_GlobalData.hpp"
41 #include "Panzer_WorksetContainer.hpp"
42 #include "Panzer_PauseToAttach.hpp"
43 #include "Panzer_ResponseEvaluatorFactory_Functional.hpp"
44 #include "user_app_EquationSetFactory.hpp"
45 #include "user_app_ClosureModel_Factory_TemplateBuilder.hpp"
46 #include "user_app_BCStrategy_Factory.hpp"
47
48 #include "Teuchos_DefaultMpiComm.hpp"
49 #include "Teuchos_OpaqueWrapper.hpp"
50 #include "Teuchos_CommHelpers.hpp"
51
52 #include <cstdio> // for get char
53 #include <fstream>
54
55 namespace panzer {
56
57 struct AssemblyPieces {
58 RCP<panzer::FieldManagerBuilder> fmb;
59 RCP<panzer::ResponseLibrary<panzer::Traits> > rLibrary;
60 RCP<panzer::GlobalData> gd;
61 RCP<panzer::BlockedEpetraLinearObjFactory<panzer::Traits,int> > ep_lof;
62 RCP<panzer::GlobalIndexer> dofManager;
63 Teuchos::ParameterList user_data;
64 std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
65 Teuchos::RCP<panzer::EquationSetFactory> eqset_factory;
66 panzer::ClosureModelFactory_TemplateManager<panzer::Traits> cm_factory;
67 Teuchos::ParameterList closure_models;
68 };
69
70 RCP<Epetra_Vector> basic_ss_f;
71 RCP<Epetra_Vector> basic_trans_f;
72 RCP<Epetra_CrsMatrix> basic_ss_J;
73 RCP<Epetra_CrsMatrix> basic_trans_J;
74
75 struct RespFactoryFunc_Builder {
76 MPI_Comm comm;
77 Teuchos::RCP<panzer::LinearObjFactory<panzer::Traits> > linearObjFactory;
78 Teuchos::RCP<const panzer::GlobalIndexer> globalIndexer;
79
80 template <typename T>
81 Teuchos::RCP<ResponseEvaluatorFactoryBase> build() const
82 { return Teuchos::rcp(new ResponseEvaluatorFactory_Functional<T,int,int>(comm,1,true,"",linearObjFactory)); }
83 };
84
85 // store steady-state me for testing parameters
86 // RCP<panzer::ModelEvaluator_Epetra> ss_me;
87 Teuchos::RCP<panzer::GlobalIndexer> dofManager_null;
88
89 void testInitialzation(const Teuchos::RCP<Teuchos::ParameterList>& ipb,
90 std::vector<panzer::BC>& bcs);
91
92 bool testEqualityOfEpetraVectorValues(Epetra_Vector& a, Epetra_Vector& b, double tolerance, bool write_to_cout = false);
93
94 void buildAssemblyPieces(bool parameter_on, AssemblyPieces & ap);
95
96 TEUCHOS_UNIT_TEST(model_evaluator, basic)
97 {
98 using Teuchos::RCP;
99
100
101 // panzer::pauseToAttach();
102
103 bool parameter_on = true;
104 AssemblyPieces ap;
105
106 buildAssemblyPieces(parameter_on,ap);
107
108 // Test a transient me
109 {
110 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
111 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
112 bool build_transient_support = true;
113 RCP<panzer::ModelEvaluator_Epetra> me = Teuchos::rcp(new panzer::ModelEvaluator_Epetra(ap.fmb,ap.rLibrary,ap.ep_lof,p_names,p_values,ap.gd,build_transient_support));
114
115 EpetraExt::ModelEvaluator::InArgs in_args = me->createInArgs();
116 EpetraExt::ModelEvaluator::OutArgs out_args = me->createOutArgs();
117
118 TEST_ASSERT(in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x));
119 TEST_ASSERT(in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot));
120 TEST_ASSERT(in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha));
121 TEST_ASSERT(in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_beta));
122 TEST_ASSERT(out_args.supports(EpetraExt::ModelEvaluator::OUT_ARG_f));
123 TEST_ASSERT(out_args.supports(EpetraExt::ModelEvaluator::OUT_ARG_W));
124
125 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x_sg));
126 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot_sg));
127
128
129 RCP<Epetra_Vector> x = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
130 RCP<Epetra_Vector> x_dot = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
131 x->Update(1.0, *(me->get_x_init()), 0.0);
132 x_dot->PutScalar(0.0);
133 in_args.set_x(x);
134 in_args.set_x_dot(x_dot);
135 in_args.set_alpha(0.0);
136 in_args.set_beta(1.0);
137
138 RCP<Epetra_Vector> f = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
139 RCP<Epetra_Operator> J_tmp = me->create_W();
140 RCP<Epetra_CrsMatrix> J = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(J_tmp);
141 TEST_ASSERT(!Teuchos::is_null(J));
142 out_args.set_f(f);
143 out_args.set_W(J);
144
145 me->evalModel(in_args, out_args);
146
147 // compare or save residual vector for comparison with SG version
148 if(basic_trans_f==Teuchos::null)
149 basic_trans_f = out_args.get_f();
150 else {
151 double norm=0.0, diff=0.0;
152 f->Norm2(&norm);
153 f->Update(-1.0,*basic_trans_f,1.0);
154 f->Norm2(&diff);
155 TEST_ASSERT(diff/norm <= 1e-15);
156 }
157 }
158
159 // Test a steady-state me
160 {
161 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names(1);
162 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values(1);
163 p_names[0] = Teuchos::rcp(new Teuchos::Array<std::string>(1));
164 (*p_names[0])[0] = "SOURCE_TEMPERATURE";
165 p_values[0] = Teuchos::rcp(new Teuchos::Array<double>(1));
166 (*p_values[0])[0] = 1.0;
167 bool build_transient_support = false;
168 RCP<panzer::ModelEvaluator_Epetra> me = Teuchos::rcp(new panzer::ModelEvaluator_Epetra(ap.fmb,ap.rLibrary,ap.ep_lof,p_names,p_values,ap.gd,build_transient_support));
169
170 // store to test parameter capabilities
171 // ss_me = me;
172
173 EpetraExt::ModelEvaluator::InArgs in_args = me->createInArgs();
174 EpetraExt::ModelEvaluator::OutArgs out_args = me->createOutArgs();
175
176 TEST_ASSERT(in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x));
177 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot));
178 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha));
179 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_beta));
180 TEST_ASSERT(out_args.supports(EpetraExt::ModelEvaluator::OUT_ARG_f));
181 TEST_ASSERT(out_args.supports(EpetraExt::ModelEvaluator::OUT_ARG_W));
182
183 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x_sg));
184 TEST_ASSERT(!in_args.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot_sg));
185
186 RCP<Epetra_Vector> x = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
187 x->Update(1.0, *(me->get_x_init()), 0.0);
188 in_args.set_x(x);
189
190 RCP<Epetra_Vector> f = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
191 RCP<Epetra_Operator> J_tmp = me->create_W();
192 RCP<Epetra_CrsMatrix> J = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(J_tmp);
193 TEST_ASSERT(!Teuchos::is_null(J));
194 out_args.set_f(f);
195 out_args.set_W(J);
196
197 me->evalModel(in_args, out_args);
198
199 // compare or save residual vector for comparison with SG version
200 if(basic_ss_f==Teuchos::null)
201 basic_ss_f = out_args.get_f();
202 else {
203 double norm=0.0, diff=0.0;
204 f->Norm2(&norm);
205 f->Update(-1.0,*basic_ss_f,1.0);
206 f->Norm2(&diff);
207 out << diff << " " << norm << std::endl;
208 TEST_ASSERT(diff/norm <= 1e-15);
209 }
210 }
211
212 }
213
214 TEUCHOS_UNIT_TEST(model_evaluator, response)
215 {
216 bool parameter_on = true;
217 AssemblyPieces ap;
218
219
220 buildAssemblyPieces(parameter_on,ap);
221
222 {
223 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names;
224 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values;
225 bool build_transient_support = false;
226 RCP<panzer::ModelEvaluator_Epetra> me = Teuchos::rcp(new panzer::ModelEvaluator_Epetra(ap.fmb,ap.rLibrary,ap.ep_lof,p_names,p_values,ap.gd,build_transient_support));
227
228 RespFactoryFunc_Builder builder;
229 builder.comm = MPI_COMM_WORLD;
230 builder.linearObjFactory = ap.ep_lof;
231 builder.globalIndexer = ap.dofManager;
232
233 std::vector<panzer::WorksetDescriptor> blocks;
234 blocks.push_back(panzer::blockDescriptor("eblock-0_0"));
235 blocks.push_back(panzer::blockDescriptor("eblock-1_0"));
236 me->addResponse("TEMPERATURE",blocks,builder);
237 me->buildResponses(ap.physicsBlocks,*ap.eqset_factory,ap.cm_factory,ap.closure_models,ap.user_data);
238
239 EpetraExt::ModelEvaluator::InArgs in_args = me->createInArgs();
240 EpetraExt::ModelEvaluator::OutArgs out_args = me->createOutArgs();
241
242 RCP<Epetra_Vector> x = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
243 x->PutScalar(0.0);
244 in_args.set_x(x);
245
246 RCP<Epetra_Vector> f = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
247 RCP<Epetra_Vector> g = Teuchos::rcp(new Epetra_Vector(*me->get_g_map(0)));
248 RCP<Epetra_Vector> DgDx = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
249 out_args.set_f(f);
250 out_args.set_g(0,g);
251 out_args.set_DgDx(0,EpetraExt::ModelEvaluator::Derivative(Teuchos::rcp_static_cast<Epetra_MultiVector>(DgDx)));
252
253 me->evalModel(in_args, out_args);
254
255 out << "RESPONSE = " << std::endl;
256 g->Print(out);
257
258 out << "RESIDUAL | RESPONSE DERIVATIVE = " << std::endl;
259 for(int i=0;i<DgDx->MyLength();i++)
260 out << (*f)[i] << " " << (*DgDx)[i] << std::endl;
261 }
262 }
263
264 // Test for parameters and residual consistency
265 /////////////////////////////////////////////
266
267 TEUCHOS_UNIT_TEST(model_evaluator, parameter_library)
268 {
269 // NOTE: this test must be run AFTER the basic test above so that
270 // ss_me is created!
271 // RCP<panzer::ModelEvaluator_Epetra> me = ss_me; This appears to cause seg faults for some reason!!!!
272
273
274 RCP<panzer::ModelEvaluator_Epetra> me;
275 {
276 bool parameter_on = true;
277 AssemblyPieces ap;
278
279 buildAssemblyPieces(parameter_on,ap);
280 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names(1);
281 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values(1);
282 p_names[0] = Teuchos::rcp(new Teuchos::Array<std::string>(1));
283 (*p_names[0])[0] = "SOURCE_TEMPERATURE";
284 p_values[0] = Teuchos::rcp(new Teuchos::Array<double>(1));
285 (*p_values[0])[0] = 1.0;
286 bool build_transient_support = false;
287 me = Teuchos::rcp(new panzer::ModelEvaluator_Epetra(ap.fmb,ap.rLibrary,ap.ep_lof,p_names,p_values,ap.gd,build_transient_support));
288 }
289
290 TEUCHOS_ASSERT(nonnull(me));
291
292 EpetraExt::ModelEvaluator::InArgs in_args = me->createInArgs();
293 EpetraExt::ModelEvaluator::OutArgs out_args = me->createOutArgs();
294
295 // solution
296 RCP<Epetra_Vector> x = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
297 x->PutScalar(1.0);
298
299 // parameter
300 TEST_ASSERT(in_args.Np() == 1);
301 RCP<Epetra_Vector> p = Teuchos::rcp(new Epetra_Vector(*me->get_p_map(0)));
302 p->PutScalar(1.0);
303
304 // create f
305 RCP<Epetra_Vector> f1 = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
306 RCP<Epetra_Vector> f2 = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
307 RCP<Epetra_Vector> f3 = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
308 RCP<Epetra_Vector> f4 = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
309
310 RCP<Epetra_Vector> dfdp = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
311
312 // set values and evaluate
313 in_args.set_x(x);
314 in_args.set_p(0,p);
315
316 out << "evalModel(f1)" << std::endl;
317 out_args.set_f(f1);
318 out_args.set_DfDp(0,EpetraExt::ModelEvaluator::Derivative());
319 me->evalModel(in_args,out_args);
320
321 out << "evalModel(f2)" << std::endl;
322 out_args.set_f(f2);
323 out_args.set_DfDp(0,EpetraExt::ModelEvaluator::Derivative());
324 me->evalModel(in_args,out_args);
325
326 out << "evalModel(f3)" << std::endl;
327 p->PutScalar(20.0);
328 out_args.set_f(f3);
329 out_args.set_DfDp(0,EpetraExt::ModelEvaluator::Derivative());
330 me->evalModel(in_args,out_args);
331
332 out << "evalModel(f4)" << std::endl;
333 p->PutScalar(1.0);
334 out_args.set_f(f4);
335 out_args.set_DfDp(0,EpetraExt::ModelEvaluator::Derivative());
336 me->evalModel(in_args,out_args);
337
338 // f1 == f2 == f4, f3 is evaluated with p=20 instead of p=1
339
340 double tol = 10.0 * Teuchos::ScalarTraits<double>::eps();
341
342 // f1 == f2
343 TEST_EQUALITY_CONST(testEqualityOfEpetraVectorValues(*f1,*f2,tol), true);
344
345 // f2 == f4
346 TEST_EQUALITY_CONST(testEqualityOfEpetraVectorValues(*f2,*f4,tol), true);
347
348 // f2 != f3
349 TEST_EQUALITY_CONST(testEqualityOfEpetraVectorValues(*f2,*f3,tol), false);
350
351
352 // TEST DfDp
353 /////////////////////////////////////////////////////
354
355 x->PutScalar(0.0);
356 f1->PutScalar(0.0);
357
358 out << "evalModel(f2)" << std::endl;
359 p->PutScalar(20.0);
360 out_args.set_f(f1);
361 out_args.set_DfDp(0,EpetraExt::ModelEvaluator::Derivative(dfdp,EpetraExt::ModelEvaluator::DERIV_MV_BY_COL));
362 me->evalModel(in_args,out_args);
363
364 for(int i=0;i<f1->MyLength();i++) {
365 if((*dfdp)[i]!=0.0)
366 { TEST_FLOATING_EQUALITY((*f1)[i],20.0*(*dfdp)[i],1e-10); }
367 out << (*f1)[i] << " " << (*dfdp)[i] << std::endl;
368 }
369
370 }
371
372 // Testing Ditributed Parameter Support
373 TEUCHOS_UNIT_TEST(model_evaluator, distributed_parameters)
374 {
375
376 RCP<panzer::ModelEvaluator_Epetra> me;
377 int distributed_parameter_index = -1;
378 Teuchos::RCP<Epetra_Vector> ghosted_distributed_parameter;
379 {
380 bool parameter_on = true;
381 AssemblyPieces ap;
382
383 buildAssemblyPieces(parameter_on,ap);
384 std::vector<Teuchos::RCP<Teuchos::Array<std::string> > > p_names(1);
385 std::vector<Teuchos::RCP<Teuchos::Array<double> > > p_values(1);
386 p_names[0] = Teuchos::rcp(new Teuchos::Array<std::string>(1));
387 (*p_names[0])[0] = "SOURCE_TEMPERATURE";
388 p_values[0] = Teuchos::rcp(new Teuchos::Array<double>(1));
389 (*p_values[0])[0] = 1.0;
390 bool build_transient_support = false;
391 me = Teuchos::rcp(new panzer::ModelEvaluator_Epetra(ap.fmb,ap.rLibrary,ap.ep_lof,p_names,p_values,ap.gd,build_transient_support));
392
393 // add a distributed parameter
394 ghosted_distributed_parameter = Teuchos::rcp(new Epetra_Vector(*ap.ep_lof->getGhostedMap(0)));
395
396 distributed_parameter_index = me->addDistributedParameter("Transient Predictor",
397 ap.ep_lof->getMap(0),
398 ap.ep_lof->getGhostedImport(0),
399 ghosted_distributed_parameter);
400 }
401
402 TEUCHOS_ASSERT(nonnull(me));
403
404 // solution
405 RCP<Epetra_Vector> x = Teuchos::rcp(new Epetra_Vector(*me->get_x_map()));
406 x->PutScalar(1.0);
407
408 // locally replicated scalar parameter
409 RCP<Epetra_Vector> p = Teuchos::rcp(new Epetra_Vector(*me->get_p_map(0)));
410 p->PutScalar(1.0);
411
412 RCP<Epetra_Vector> f = Teuchos::rcp(new Epetra_Vector(*me->get_f_map()));
413
414 // Test that the distributed parameter is updated correctly
415 {
416 EpetraExt::ModelEvaluator::InArgs in_args = me->createInArgs();
417 EpetraExt::ModelEvaluator::OutArgs out_args = me->createOutArgs();
418
419 TEST_ASSERT(in_args.Np() == 2);
420
421 in_args.set_x(x);
422 in_args.set_p(0,p);
423
424 // Set ghosted distributed parameter to 0
425 ghosted_distributed_parameter->PutScalar(0.0);
426
427 // Set global distributed parameter to 1 in in_args
428 RCP<Epetra_Vector> global_distributed_parameter =
429 Teuchos::rcp(new Epetra_Vector(*me->get_p_map(distributed_parameter_index)));
430 global_distributed_parameter->PutScalar(1.0);
431 in_args.set_p(distributed_parameter_index,global_distributed_parameter);
432
433 out_args.set_f(f);
434 me->evalModel(in_args,out_args);
435
436 // Export should have performed global to ghost, ghosted values should be 1
437 // Create a gold standard to compare against
438 RCP<Epetra_Vector> gold_standard = Teuchos::rcp(new Epetra_Vector(ghosted_distributed_parameter->Map()));
439 gold_standard->PutScalar(1.0);
440
441 double tol = 10.0 * Teuchos::ScalarTraits<double>::eps();
442
443 TEST_EQUALITY_CONST(testEqualityOfEpetraVectorValues(*ghosted_distributed_parameter,*gold_standard,tol), true);
444 }
445
446 }
447
448 void testInitialzation(const Teuchos::RCP<Teuchos::ParameterList>& ipb,
449 std::vector<panzer::BC>& bcs)
450 {
451 // Physics block
452 Teuchos::ParameterList& physics_block = ipb->sublist("test physics");
453 {
454 Teuchos::ParameterList& p = physics_block.sublist("a");
455 p.set("Type","Energy");
456 p.set("Prefix","");
457 p.set("Model ID","solid");
458 p.set("Basis Type","HGrad");
459 p.set("Basis Order",1);
460 p.set("Integration Order",1);
461 }
462 {
463 Teuchos::ParameterList& p = physics_block.sublist("b");
464 p.set("Type","Energy");
465 p.set("Prefix","ION_");
466 p.set("Model ID","ion solid");
467 p.set("Basis Type","HGrad");
468 p.set("Basis Order",1);
469 p.set("Integration Order",1);
470 }
471
472
473 {
474 std::size_t bc_id = 0;
475 panzer::BCType neumann = BCT_Dirichlet;
476 std::string sideset_id = "left";
477 std::string element_block_id = "eblock-0_0";
478 std::string dof_name = "TEMPERATURE";
479 std::string strategy = "Constant";
480 double value = 5.0;
481 Teuchos::ParameterList p;
482 p.set("Value",value);
483 panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
484 strategy, p);
485 bcs.push_back(bc);
486 }
487 {
488 std::size_t bc_id = 1;
489 panzer::BCType neumann = BCT_Dirichlet;
490 std::string sideset_id = "right";
491 std::string element_block_id = "eblock-1_0";
492 std::string dof_name = "TEMPERATURE";
493 std::string strategy = "Constant";
494 double value = 5.0;
495 Teuchos::ParameterList p;
496 p.set("Value",value);
497 panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
498 strategy, p);
499 bcs.push_back(bc);
500 }
501 {
502 std::size_t bc_id = 2;
503 panzer::BCType neumann = BCT_Dirichlet;
504 std::string sideset_id = "top";
505 std::string element_block_id = "eblock-1_0";
506 std::string dof_name = "TEMPERATURE";
507 std::string strategy = "Constant";
508 double value = 5.0;
509 Teuchos::ParameterList p;
510 p.set("Value",value);
511 panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
512 strategy, p);
513 bcs.push_back(bc);
514 }
515 }
516
517 /** Compares Epetra_Vector values and returns true if difference is
518 less than tolerance
519 */
520 bool testEqualityOfEpetraVectorValues(Epetra_Vector& a, Epetra_Vector& b, double tolerance, bool write_to_cout)
521 {
522 bool is_equal = true;
523
524 TEUCHOS_ASSERT(a.Map().NumMyElements() == b.Map().NumMyElements());
525
526 for (int i = 0; i < a.Map().NumMyElements(); ++i) {
527
528 std::string output = " equal!: ";
529
530 if (std::fabs(a[i] - b[i]) > tolerance) {
531 is_equal = false;
532 output = "NOT equal!: ";
533 }
534
535 if (write_to_cout)
536 std::cout << output << a[i] << " - " << b[i] << " = " << (a[i] - b[i]) << std::endl;
537 }
538
539 int globalSuccess = -1;
540 Teuchos::RCP<const Teuchos::Comm<Teuchos::Ordinal> > comm = Teuchos::DefaultComm<Teuchos::Ordinal>::getComm();
541 Teuchos::reduceAll( *comm, Teuchos::REDUCE_SUM, is_equal ? 0 : 1, Teuchos::outArg(globalSuccess) );
542 return (globalSuccess==0);
543 }
544
545 void buildAssemblyPieces(bool parameter_on,
546 AssemblyPieces & ap)
547 {
548 using Teuchos::RCP;
549
550 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
551 pl->set("X Blocks",2);
552 pl->set("Y Blocks",1);
553 pl->set("X Elements",6);
554 pl->set("Y Elements",4);
555
556 panzer_stk::SquareQuadMeshFactory factory;
557 factory.setParameterList(pl);
558 RCP<panzer_stk::STK_Interface> mesh = factory.buildMesh(MPI_COMM_WORLD);
559 RCP<const Teuchos::MpiComm<int> > tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
560
561 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList("Physics Blocks");
562 std::vector<panzer::BC> bcs;
563 testInitialzation(ipb, bcs);
564
565 ap.fmb = Teuchos::rcp(new panzer::FieldManagerBuilder);
566
567 // build physics blocks
568 //////////////////////////////////////////////////////////////
569 const std::size_t workset_size = 20;
570 ap.eqset_factory = Teuchos::rcp(new user_app::MyFactory);
571 user_app::BCFactory bc_factory;
572 ap.gd = panzer::createGlobalData();
573 {
574 std::map<std::string,std::string> block_ids_to_physics_ids;
575 block_ids_to_physics_ids["eblock-0_0"] = "test physics";
576 block_ids_to_physics_ids["eblock-1_0"] = "test physics";
577
578 std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
579 block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0");
580 block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0");
581
582 int default_integration_order = 1;
583
584 bool build_transient_support = true;
585 panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
586 block_ids_to_cell_topo,
587 ipb,
588 default_integration_order,
589 workset_size,
590 ap.eqset_factory,
591 ap.gd,
592 build_transient_support,
593 ap.physicsBlocks);
594 }
595
596 // build worksets
597 //////////////////////////////////////////////////////////////
598 // build WorksetContainer
599 Teuchos::RCP<panzer_stk::WorksetFactory> wkstFactory
600 = Teuchos::rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory
601 Teuchos::RCP<panzer::WorksetContainer> wkstContainer // attach it to a workset container (uses lazy evaluation)
602 = Teuchos::rcp(new panzer::WorksetContainer);
603 wkstContainer->setFactory(wkstFactory);
604 for(size_t i=0;i<ap.physicsBlocks.size();i++)
605 wkstContainer->setNeeds(ap.physicsBlocks[i]->elementBlockID(),ap.physicsBlocks[i]->getWorksetNeeds());
606 wkstContainer->setWorksetSize(workset_size);
607
608 // build DOF Manager
609 /////////////////////////////////////////////////////////////
610
611 // build the connection manager
612 const Teuchos::RCP<panzer::ConnManager>
613 conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
614
615 panzer::DOFManagerFactory globalIndexerFactory;
616 ap.dofManager = globalIndexerFactory.buildGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),ap.physicsBlocks,conn_manager);
617
618 Teuchos::RCP<panzer::LinearObjFactory<panzer::Traits> > linObjFactory;
619 ap.ep_lof = Teuchos::rcp(new panzer::BlockedEpetraLinearObjFactory<panzer::Traits,int>(tComm.getConst(),ap.dofManager));
620 linObjFactory = ap.ep_lof;
621
622 ap.rLibrary = Teuchos::rcp(new panzer::ResponseLibrary<panzer::Traits>(wkstContainer,ap.dofManager,linObjFactory));
623
624 // setup field manager build
625 /////////////////////////////////////////////////////////////
626
627 // Add in the application specific closure model factory
628 user_app::MyModelFactory_TemplateBuilder cm_builder;
629 ap.cm_factory.buildObjects(cm_builder);
630
631 Teuchos::ParameterList closure_models("Closure Models");
632 if(parameter_on)
633 closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set<std::string>("Type","Parameter");
634 else
635 closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set<double>("Value",1.0);
636 closure_models.sublist("solid").sublist("DENSITY").set<double>("Value",1.0);
637 closure_models.sublist("solid").sublist("HEAT_CAPACITY").set<double>("Value",1.0);
638 closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set<double>("Value",1.0);
639 closure_models.sublist("ion solid").sublist("ION_DENSITY").set<double>("Value",1.0);
640 closure_models.sublist("ion solid").sublist("ION_DENSITY").set<double>("Value",1.0);
641 closure_models.sublist("ion solid").sublist("ION_HEAT_CAPACITY").set<double>("Value",1.0);
642 ap.closure_models = closure_models;
643
644 ap.user_data = Teuchos::ParameterList("User Data");
645
646 ap.fmb->setWorksetContainer(wkstContainer);
647 ap.fmb->setupVolumeFieldManagers(ap.physicsBlocks,ap.cm_factory,closure_models,*linObjFactory,ap.user_data);
648 ap.fmb->setupBCFieldManagers(bcs,ap.physicsBlocks,*ap.eqset_factory,ap.cm_factory,bc_factory,closure_models,*linObjFactory,ap.user_data);
649 }
650
651
652 }