svMultiPhysics
Loading...
Searching...
No Matches
set_equation_props.h
1// SPDX-FileCopyrightText: Copyright (c) Stanford University, The Regents of the University of California, and others.
2// SPDX-License-Identifier: BSD-3-Clause
3
4/// @brief The 'set_equation_props' map defined here sets equation
5/// properties from values read in from a file.
6///
7/// This replaces the 'SELECT CASE (eqName)' statement in the Fortran 'READEQ()' subroutine.
8//
9using SetEquationPropertiesMapType = std::map<consts::EquationType, std::function<void(Simulation*, EquationParameters*,
10 eqType&, EquationProps&, EquationOutputs&, EquationNdop&)>>;
11
12//--------------------
13// set_equation_props
14//--------------------
15//
16SetEquationPropertiesMapType set_equation_props = {
17
18//---------------------------//
19// phys_CEP //
20//---------------------------//
21//
22{consts::EquationType::phys_CEP, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
23 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
24{
25 using namespace consts;
26 auto& cep_mod = simulation->get_cep_mod();
27 lEq.phys = consts::EquationType::phys_CEP;
28
29 propL[0][0] = PhysicalPropertyType::fluid_density;
30 propL[1][0] = PhysicalPropertyType::backflow_stab;
31 propL[2][0] = PhysicalPropertyType::f_x;
32 propL[3][0] = PhysicalPropertyType::f_y;
33
34 if (simulation->com_mod.nsd == 3) {
35 propL[4][0] = PhysicalPropertyType::f_z;
36 }
37
38 cep_mod.cepEq = true;
39
40 read_domain(simulation, eq_params, lEq, propL);
41
42 nDOP = {1, 1, 0, 0};
43 outPuts[0] = OutputNameType::out_voltage;
44
45 // Set solver parameters.
46 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
47
48} },
49
50//---------------------------//
51// phys_CMM //
52//---------------------------//
53//
54{consts::EquationType::phys_CMM, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
55 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
56{
57 using namespace consts;
58 auto& com_mod = simulation->get_com_mod();
59 lEq.phys = consts::EquationType::phys_CMM;
60
61 bool pstEq = eq_params->prestress.defined() && eq_params->prestress.value();
62
63 com_mod.cmmBdry.resize(com_mod.gtnNo);
64 if (eq_params->initialize.defined()) {
65 com_mod.cmmInit = true;
66
67 if (com_mod.nEq > 1) {
68 throw std::runtime_error("More than one eqn. is not allowed while initializing CMM.");
69 }
70
71 // Determine is there is a pre-stress.
72 //
73 auto init_str = eq_params->initialize();
74 std::transform(init_str.begin(), init_str.end(), init_str.begin(), ::tolower);
75
76 if (std::set<std::string>{"inflate", "inf"}.count(init_str) != 0) {
77 com_mod.pstEq = false;
78 } else if (std::set<std::string>{"prestress", "prest"}.count(init_str) != 0) {
79 com_mod.pstEq = true;
80 } else {
81 throw std::runtime_error("Unknown CMM initialize type '" + init_str + "'.");
82 }
83
84 // Set cmmBdry vector to be edge nodes of the wall
85 for (int iM = 0; iM < com_mod.nMsh; iM++) {
86 set_cmm_bdry(com_mod.msh[iM], com_mod.cmmBdry);
87 }
88 }
89
90 // Set variable wall properties.
91 //
92 if (eq_params->variable_wall_properties.defined()) {
93 com_mod.cmmVarWall = true;
94
95 if (com_mod.varWallProps.size() == 0) {
96 // varWallProps = array of size 2 x total number of nodes across all meshes and all processors; first column is thickness and second column is elastic modulus
97 com_mod.varWallProps.resize(2, com_mod.gtnNo);
98 }
99
100 auto mesh_name = eq_params->variable_wall_properties.mesh_name.value();
101 int iM = 0;
102 int iFa = 0;
103 if (com_mod.cmmInit) {
104 all_fun::find_msh(com_mod.msh, mesh_name, iM);
105 } else {
106 all_fun::find_face(com_mod.msh, mesh_name, iM, iFa);
107 }
108 auto file_path = eq_params->variable_wall_properties.wall_properties_file_path.value();
109 read_wall_props_ff(com_mod, file_path, iM, iFa);
110 }
111
112 if (!com_mod.cmmInit) {
113 propL[0][0] = PhysicalPropertyType::fluid_density;
114 propL[1][0] = PhysicalPropertyType::backflow_stab;
115 propL[2][0] = PhysicalPropertyType::solid_density;
116 propL[3][0] = PhysicalPropertyType::poisson_ratio;
117 propL[4][0] = PhysicalPropertyType::damping;
118
119 if (!com_mod.cmmVarWall) {
120 propL[5][0] = PhysicalPropertyType::shell_thickness;
121 propL[6][0] = PhysicalPropertyType::elasticity_modulus;
122 }
123
124 propL[7][0] = PhysicalPropertyType::f_x;
125 propL[8][0] = PhysicalPropertyType::f_y;
126 if (simulation->com_mod.nsd == 3) {
127 propL[9][0] = PhysicalPropertyType::f_z;
128 }
129
130 nDOP = {12, 4, 3, 0};
131 outPuts = {
132 OutputNameType::out_velocity,
133 OutputNameType::out_pressure,
134 OutputNameType::out_WSS,
135 OutputNameType::out_displacement,
136 OutputNameType::out_energyFlux,
137 OutputNameType::out_traction,
138 OutputNameType::out_vorticity,
139 OutputNameType::out_vortex,
140 OutputNameType::out_strainInv,
141 OutputNameType::out_viscosity,
142 OutputNameType::out_divergence,
143 OutputNameType::out_acceleration
144 };
145
146 } else {
147 propL[0][0] = PhysicalPropertyType::poisson_ratio;
148 if (!com_mod.cmmVarWall) {
149 propL[1][0] = PhysicalPropertyType::shell_thickness;
150 propL[2][0] = PhysicalPropertyType::elasticity_modulus;
151 }
152
153 propL[7][0] = PhysicalPropertyType::f_x;
154 propL[8][0] = PhysicalPropertyType::f_y;
155 if (simulation->com_mod.nsd == 3) {
156 propL[9][0] = PhysicalPropertyType::f_z;
157 }
158
159 if (pstEq) {
160 nDOP = {2, 2, 0, 0};
161 outPuts = { OutputNameType::out_displacement, OutputNameType::out_stress };
162 } else {
163 nDOP = {1, 1, 0, 0};
164 outPuts[0] = OutputNameType::out_displacement;
165 }
166 }
167
168 read_domain(simulation, eq_params, lEq, propL);
169
170 if (com_mod.cmmInit) {
171 for (auto& domain : lEq.dmn) {
172 domain.prop[PhysicalPropertyType::solid_density] = 0.0;
173 }
174 }
175
176 // Set solver parameters.
177 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
178
179} },
180
181//---------------------------//
182// phys_fluid //
183//---------------------------//
184//
185{consts::EquationType::phys_fluid, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
186 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
187{
188 using namespace consts;
189 auto& com_mod = simulation->get_com_mod();
190 lEq.phys = consts::EquationType::phys_fluid;
191
192 propL[0][0] = PhysicalPropertyType::fluid_density;
193 propL[1][0] = PhysicalPropertyType::backflow_stab;
194 propL[2][0] = PhysicalPropertyType::brinkman_inverse_permeability;
195 propL[3][0] = PhysicalPropertyType::f_x;
196 propL[4][0] = PhysicalPropertyType::f_y;
197
198 if (simulation->com_mod.nsd == 3) {
199 propL[5][0] = PhysicalPropertyType::f_z;
200 }
201
202 // Set fluid domain properties.
203 read_domain(simulation, eq_params, lEq, propL);
204
205 nDOP = {11, 2, 3, 0};
206
207 outPuts = {
208 OutputNameType::out_velocity,
209 OutputNameType::out_pressure,
210 OutputNameType::out_WSS,
211 OutputNameType::out_traction,
212 OutputNameType::out_vorticity,
213 OutputNameType::out_vortex,
214 OutputNameType::out_strainInv,
215 OutputNameType::out_energyFlux,
216 OutputNameType::out_viscosity,
217 OutputNameType::out_divergence,
218 OutputNameType::out_acceleration
219 };
220
221 // Set solver parameters.
222 read_ls(simulation, eq_params, SolverType::lSolver_NS, lEq);
223
224} },
225
226//---------------------------//
227// phys_heatF //
228//---------------------------//
229//
230{consts::EquationType::phys_heatF, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
231 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
232{
233 using namespace consts;
234 auto& com_mod = simulation->get_com_mod();
235 lEq.phys = consts::EquationType::phys_heatF;
236
237 propL[0][0] = PhysicalPropertyType::conductivity;
238 propL[1][0] = PhysicalPropertyType::source_term;
239
240 read_domain(simulation, eq_params, lEq, propL);
241
242 nDOP = {3,1,1,0};
243 outPuts = {OutputNameType::out_temperature,
244 OutputNameType::out_heatFlux,
245 OutputNameType::out_velocity};
246
247 // Set solver parameters.
248 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
249
250} },
251
252//---------------------------//
253// phys_heatS //
254//---------------------------//
255//
256{consts::EquationType::phys_heatS, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
257 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
258{
259 using namespace consts;
260 auto& com_mod = simulation->get_com_mod();
261 lEq.phys = consts::EquationType::phys_heatS;
262
263 propL[0][0] = PhysicalPropertyType::conductivity;
264 propL[1][0] = PhysicalPropertyType::source_term;
265 propL[2][0] = PhysicalPropertyType::solid_density;
266
267 read_domain(simulation, eq_params, lEq, propL);
268
269 nDOP = {2,1,1,0};
270 outPuts = {OutputNameType::out_temperature, OutputNameType::out_heatFlux};
271
272 // Set solver parameters.
273 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
274
275} },
276
277//---------------------------//
278// phys_darcy //
279//---------------------------//
280{consts::EquationType::phys_darcy, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
281 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
282{
283 using namespace consts;
284 auto& com_mod = simulation->get_com_mod();
285 lEq.phys = consts::EquationType::phys_darcy;
286
287 propL[0][0] = PhysicalPropertyType::darcy_permeability;
288 propL[1][0] = PhysicalPropertyType::source_term;
289 propL[2][0] = PhysicalPropertyType::fluid_density;
290 propL[3][0] = PhysicalPropertyType::darcy_compressibility;
291 propL[4][0] = PhysicalPropertyType::darcy_fluid_viscosity;
292
293 read_domain(simulation, eq_params, lEq, propL);
294
295 for (const auto& domain : lEq.dmn) {
296 darcy::validate_material_properties(domain);
297 }
298
299 nDOP = {2,1,1,0};
300 outPuts = {OutputNameType::out_darcyPressure, OutputNameType::out_darcyFlux};
301
302 // Set solver parameters.
303 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
304} },
305
306
307//---------------------------//
308// phys_FSI //
309//---------------------------//
310//
311{consts::EquationType::phys_FSI, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
312 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
313{
314 using namespace consts;
315 auto& com_mod = simulation->get_com_mod();
316 lEq.phys = consts::EquationType::phys_FSI;
317 com_mod.mvMsh = true;
318
319 // Set the possible equations for fsi: fluid (required), struct/ustruct/lElas
320 EquationPhys phys { EquationType::phys_fluid, EquationType::phys_struct, EquationType::phys_ustruct, EquationType::phys_lElas };
321
322 // Set fluid properties.
323 int n = 0;
324 propL[0][n] = PhysicalPropertyType::fluid_density;
325 propL[1][n] = PhysicalPropertyType::backflow_stab;
326 propL[2][n] = PhysicalPropertyType::f_x;
327 propL[3][n] = PhysicalPropertyType::f_y;
328 if (simulation->com_mod.nsd == 3) {
329 propL[4][n] = PhysicalPropertyType::f_z;
330 }
331
332 // Set struct properties.
333 n += 1;
334 propL[0][n] = PhysicalPropertyType::solid_density;
335 propL[1][n] = PhysicalPropertyType::elasticity_modulus;
336 propL[2][n] = PhysicalPropertyType::poisson_ratio;
337 propL[3][n] = PhysicalPropertyType::damping;
338 propL[4][n] = PhysicalPropertyType::f_x;
339 propL[5][n] = PhysicalPropertyType::f_y;
340 if (simulation->com_mod.nsd == 3) {
341 propL[6][n] = PhysicalPropertyType::f_z;
342 }
343
344 // Set ustruct properties.
345 n += 1;
346 propL[0][n] = PhysicalPropertyType::solid_density;
347 propL[1][n] = PhysicalPropertyType::elasticity_modulus;
348 propL[2][n] = PhysicalPropertyType::poisson_ratio;
349 propL[3][n] = PhysicalPropertyType::ctau_M;
350 propL[4][n] = PhysicalPropertyType::ctau_C;
351 propL[5][n] = PhysicalPropertyType::f_x;
352 propL[6][n] = PhysicalPropertyType::f_y;
353 if (simulation->com_mod.nsd == 3) {
354 propL[7][n] = PhysicalPropertyType::f_z;
355 }
356
357 // Set lElas properties.
358 n += 1;
359 propL[0][n] = PhysicalPropertyType::solid_density;
360 propL[1][n] = PhysicalPropertyType::elasticity_modulus;
361 propL[2][n] = PhysicalPropertyType::poisson_ratio;
362 propL[3][n] = PhysicalPropertyType::f_x;
363 propL[4][n] = PhysicalPropertyType::f_y;
364 if (simulation->com_mod.nsd == 3) {
365 propL[5][n] = PhysicalPropertyType::f_z;
366 }
367
368 // Set lEq properties.
369 read_domain(simulation, eq_params, lEq, propL, phys);
370
371 nDOP = {22, 4, 2, 0};
372 outPuts = {
373 OutputNameType::out_velocity,
374 OutputNameType::out_pressure,
375 OutputNameType::out_displacement,
376 OutputNameType::out_mises,
377
378 OutputNameType::out_WSS,
379 OutputNameType::out_traction,
380 OutputNameType::out_vorticity,
381 OutputNameType::out_vortex,
382 OutputNameType::out_strainInv,
383 OutputNameType::out_energyFlux,
384 OutputNameType::out_viscosity,
385 OutputNameType::out_absVelocity,
386 OutputNameType::out_stress,
387 OutputNameType::out_cauchy,
388 OutputNameType::out_strain,
389 OutputNameType::out_jacobian,
390 OutputNameType::out_defGrad,
391 OutputNameType::out_integ,
392 OutputNameType::out_fibDir,
393 OutputNameType::out_fibAlign,
394
395 OutputNameType::out_divergence,
396 OutputNameType::out_acceleration
397 };
398
399 // Set solver parameters.
400 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
401
402 if (com_mod.rmsh.isReqd && !com_mod.resetSim) {
403 read_rmsh(simulation, eq_params);
404 }
405
406} },
407
408//---------------------------//
409// phys_lElas //
410//---------------------------//
411//
412{consts::EquationType::phys_lElas, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
413 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
414{
415 using namespace consts;
416 auto& com_mod = simulation->get_com_mod();
417 lEq.phys = consts::EquationType::phys_lElas;
418
419 propL[0][0] = PhysicalPropertyType::solid_density;
420 propL[1][0] = PhysicalPropertyType::elasticity_modulus;
421 propL[2][0] = PhysicalPropertyType::poisson_ratio;
422 propL[3][0] = PhysicalPropertyType::f_x;
423 propL[4][0] = PhysicalPropertyType::f_y;
424 if (simulation->com_mod.nsd == 3) {
425 propL[5][0] = PhysicalPropertyType::f_z;
426 }
427
428 read_domain(simulation, eq_params, lEq, propL);
429
430 if (eq_params->prestress.defined() && eq_params->prestress.value()) {
431 nDOP = {3,2,0,0};
432 outPuts = {OutputNameType::out_displacement, OutputNameType::out_stress, OutputNameType::out_strain};
433 } else {
434 nDOP = {8,2,0,0};
435 outPuts = {
436 OutputNameType::out_displacement, OutputNameType::out_mises, OutputNameType::out_stress,
437 OutputNameType::out_strain, OutputNameType::out_velocity, OutputNameType::out_acceleration,
438 OutputNameType::out_integ, OutputNameType::out_jacobian
439 };
440 }
441
442 // Set solver parameters.
443 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
444
445} },
446
447//---------------------------//
448// phys_mesh //
449//---------------------------//
450//
451{consts::EquationType::phys_mesh, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
452 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
453{
454 using namespace consts;
455 auto& com_mod = simulation->get_com_mod();
456 lEq.phys = consts::EquationType::phys_mesh;
457
458 propL[0][0] = PhysicalPropertyType::solid_density;
459 propL[1][0] = PhysicalPropertyType::elasticity_modulus;
460 propL[2][0] = PhysicalPropertyType::poisson_ratio;
461 propL[3][0] = PhysicalPropertyType::f_x;
462 propL[4][0] = PhysicalPropertyType::f_y;
463 if (simulation->com_mod.nsd == 3) {
464 propL[5][0] = PhysicalPropertyType::f_z;
465 }
466
467 read_domain(simulation, eq_params, lEq, propL);
468
469 for (auto& domain : lEq.dmn) {
470 domain.prop[PhysicalPropertyType::solid_density] = 0.0;
471 domain.prop[PhysicalPropertyType::elasticity_modulus] = 1.0;
472 }
473
474 nDOP = {3, 1, 0, 0};
475 outPuts = {OutputNameType::out_displacement, OutputNameType::out_velocity, OutputNameType::out_acceleration };
476
477 lEq.ls.relTol = 0.2;
478
479 // Set solver parameters.
480 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
481
482} },
483
484//---------------------------//
485// phys_shell //
486//---------------------------//
487//
488{consts::EquationType::phys_shell, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
489 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
490{
491 using namespace consts;
492 auto& com_mod = simulation->get_com_mod();
493 lEq.phys = consts::EquationType::phys_shell;
494 com_mod.shlEq = true;
495
496 propL[0][0] = PhysicalPropertyType::solid_density;
497 propL[1][0] = PhysicalPropertyType::damping;
498 propL[2][0] = PhysicalPropertyType::elasticity_modulus;
499 propL[3][0] = PhysicalPropertyType::poisson_ratio;
500 propL[4][0] = PhysicalPropertyType::shell_thickness;
501 propL[5][0] = PhysicalPropertyType::f_x;
502 propL[6][0] = PhysicalPropertyType::f_y;
503 propL[7][0] = PhysicalPropertyType::f_z;
504
505 read_domain(simulation, eq_params, lEq, propL);
506
507 nDOP = {9,1,0,0};
508 outPuts = {
509 OutputNameType::out_displacement,
510 OutputNameType::out_stress,
511 OutputNameType::out_strain,
512 OutputNameType::out_jacobian,
513 OutputNameType::out_defGrad,
514 OutputNameType::out_velocity,
515 OutputNameType::out_integ,
516 OutputNameType::out_CGstrain,
517 OutputNameType::out_CGInv1
518 };
519
520 // Set solver parameters.
521 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
522
523} },
524
525//---------------------------//
526// phys_stokes //
527//---------------------------//
528//
529{consts::EquationType::phys_stokes, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
530 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
531{
532 using namespace consts;
533 auto& com_mod = simulation->get_com_mod();
534 lEq.phys = consts::EquationType::phys_stokes;
535
536 propL[0][0] = PhysicalPropertyType::ctau_M;
537 propL[1][0] = PhysicalPropertyType::f_x;
538 propL[2][0] = PhysicalPropertyType::f_y;
539 if (simulation->com_mod.nsd == 3) {
540 propL[3][0] = PhysicalPropertyType::f_z;
541 }
542 read_domain(simulation, eq_params, lEq, propL);
543
544 nDOP = {8, 2, 3, 0};
545 outPuts = {
546 OutputNameType::out_velocity,
547 OutputNameType::out_pressure,
548 OutputNameType::out_WSS,
549 OutputNameType::out_vorticity,
550 OutputNameType::out_traction,
551 OutputNameType::out_strainInv,
552 OutputNameType::out_viscosity,
553 OutputNameType::out_divergence
554 };
555
556 // Set solver parameters.
557 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
558
559} },
560
561//---------------------------//
562// phys_struct //
563//---------------------------//
564//
565{consts::EquationType::phys_struct, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
566 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
567{
568 using namespace consts;
569 auto& com_mod = simulation->get_com_mod();
570 lEq.phys = consts::EquationType::phys_struct;
571
572 propL[0][0] = PhysicalPropertyType::solid_density;
573 propL[1][0] = PhysicalPropertyType::damping;
574 propL[2][0] = PhysicalPropertyType::elasticity_modulus;
575 propL[3][0] = PhysicalPropertyType::poisson_ratio;
576 propL[4][0] = PhysicalPropertyType::f_x;
577 propL[5][0] = PhysicalPropertyType::f_y;
578 if (simulation->com_mod.nsd == 3) {
579 propL[6][0] = PhysicalPropertyType::f_z;
580 }
581
582 read_domain(simulation, eq_params, lEq, propL);
583
584 if (eq_params->prestress.defined() && eq_params->prestress.value()) {
585 nDOP = {4,2,0,0};
586 outPuts = {OutputNameType::out_displacement, OutputNameType::out_stress, OutputNameType::out_cauchy, OutputNameType::out_strain};
587 //simulation->com_mod.pstEq = true;
588 } else {
589 nDOP = {17, 2, 0, 0};
590 outPuts = {OutputNameType::out_displacement,
591 OutputNameType::out_mises,
592 OutputNameType::out_stress,
593 OutputNameType::out_cauchy,
594 OutputNameType::out_strain,
595 OutputNameType::out_jacobian,
596 OutputNameType::out_defGrad,
597 OutputNameType::out_integ,
598 OutputNameType::out_fibDir,
599 OutputNameType::out_fibAlign,
600 OutputNameType::out_velocity,
601 OutputNameType::out_acceleration,
602 OutputNameType::out_fibStretch,
603 OutputNameType::out_fibStretchRate,
604 OutputNameType::out_activeTensionFibers,
605 OutputNameType::out_activeTensionSheets,
606 OutputNameType::out_activeTensionNormal};
607 }
608
609 // Set solver parameters.
610 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
611
612} },
613
614//---------------------------//
615// phys_ustruct //
616//---------------------------//
617//
618{consts::EquationType::phys_ustruct, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
619 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
620{
621 using namespace consts;
622 auto& com_mod = simulation->get_com_mod();
623
624 lEq.phys = consts::EquationType::phys_ustruct;
625 com_mod.sstEq = true;
626
627 propL[0][0] = PhysicalPropertyType::solid_density;
628 propL[1][0] = PhysicalPropertyType::elasticity_modulus;
629 propL[2][0] = PhysicalPropertyType::poisson_ratio;
630 propL[3][0] = PhysicalPropertyType::ctau_M;
631 propL[4][0] = PhysicalPropertyType::ctau_C;
632 propL[5][0] = PhysicalPropertyType::f_x;
633 propL[6][0] = PhysicalPropertyType::f_y;
634 if (simulation->com_mod.nsd == 3) {
635 propL[7][0] = PhysicalPropertyType::f_z;
636 }
637
638 read_domain(simulation, eq_params, lEq, propL);
639
640 nDOP = {19, 2, 0, 0};
641 outPuts = {OutputNameType::out_displacement,
642 OutputNameType::out_mises,
643 OutputNameType::out_stress,
644 OutputNameType::out_cauchy,
645 OutputNameType::out_strain,
646 OutputNameType::out_jacobian,
647 OutputNameType::out_defGrad,
648 OutputNameType::out_integ,
649 OutputNameType::out_fibDir,
650 OutputNameType::out_fibAlign,
651 OutputNameType::out_velocity,
652 OutputNameType::out_pressure,
653 OutputNameType::out_acceleration,
654 OutputNameType::out_divergence,
655 OutputNameType::out_fibStretch,
656 OutputNameType::out_fibStretchRate,
657 OutputNameType::out_activeTensionFibers,
658 OutputNameType::out_activeTensionSheets,
659 OutputNameType::out_activeTensionNormal};
660
661 // Set solver parameters.
662 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
663
664} },
665};
666
EquationParameters
The EquationParameters class stores parameters for the 'Add_equation' XML element used to specify an ...
Definition Parameters.h:1748
Simulation
Definition Simulation.h:19
eqType
Equation type.
Definition ComMod.h:1084
darcy::validate_material_properties
void validate_material_properties(const dmnType &domain)
Definition darcy.cpp:15
Generated by doxygen 1.9.8