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] = PhysicalProperyType::fluid_density;
30 propL[1][0] = PhysicalProperyType::backflow_stab;
31 propL[2][0] = PhysicalProperyType::f_x;
32 propL[3][0] = PhysicalProperyType::f_y;
33
34 if (simulation->com_mod.nsd == 3) {
35 propL[4][0] = PhysicalProperyType::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] = PhysicalProperyType::fluid_density;
114 propL[1][0] = PhysicalProperyType::backflow_stab;
115 propL[2][0] = PhysicalProperyType::solid_density;
116 propL[3][0] = PhysicalProperyType::poisson_ratio;
117 propL[4][0] = PhysicalProperyType::damping;
118
119 if (!com_mod.cmmVarWall) {
120 propL[5][0] = PhysicalProperyType::shell_thickness;
121 propL[6][0] = PhysicalProperyType::elasticity_modulus;
122 }
123
124 propL[7][0] = PhysicalProperyType::f_x;
125 propL[8][0] = PhysicalProperyType::f_y;
126 if (simulation->com_mod.nsd == 3) {
127 propL[9][0] = PhysicalProperyType::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] = PhysicalProperyType::poisson_ratio;
148 if (!com_mod.cmmVarWall) {
149 propL[1][0] = PhysicalProperyType::shell_thickness;
150 propL[2][0] = PhysicalProperyType::elasticity_modulus;
151 }
152
153 propL[7][0] = PhysicalProperyType::f_x;
154 propL[8][0] = PhysicalProperyType::f_y;
155 if (simulation->com_mod.nsd == 3) {
156 propL[9][0] = PhysicalProperyType::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[PhysicalProperyType::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] = PhysicalProperyType::fluid_density;
193 propL[1][0] = PhysicalProperyType::backflow_stab;
194 propL[2][0] = PhysicalProperyType::inverse_darcy_permeability;
195 propL[3][0] = PhysicalProperyType::f_x;
196 propL[4][0] = PhysicalProperyType::f_y;
197
198 if (simulation->com_mod.nsd == 3) {
199 propL[5][0] = PhysicalProperyType::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] = PhysicalProperyType::conductivity;
238 propL[1][0] = PhysicalProperyType::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] = PhysicalProperyType::conductivity;
264 propL[1][0] = PhysicalProperyType::source_term;
265 propL[2][0] = PhysicalProperyType::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_FSI //
279//---------------------------//
280//
281{consts::EquationType::phys_FSI, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
282 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
283{
284 using namespace consts;
285 auto& com_mod = simulation->get_com_mod();
286 lEq.phys = consts::EquationType::phys_FSI;
287 com_mod.mvMsh = true;
288
289 // Set the possible equations for fsi: fluid (required), struct/ustruct/lElas
290 EquationPhys phys { EquationType::phys_fluid, EquationType::phys_struct, EquationType::phys_ustruct, EquationType::phys_lElas };
291
292 // Set fluid properties.
293 int n = 0;
294 propL[0][n] = PhysicalProperyType::fluid_density;
295 propL[1][n] = PhysicalProperyType::backflow_stab;
296 propL[2][n] = PhysicalProperyType::f_x;
297 propL[3][n] = PhysicalProperyType::f_y;
298 if (simulation->com_mod.nsd == 3) {
299 propL[4][n] = PhysicalProperyType::f_z;
300 }
301
302 // Set struct properties.
303 n += 1;
304 propL[0][n] = PhysicalProperyType::solid_density;
305 propL[1][n] = PhysicalProperyType::elasticity_modulus;
306 propL[2][n] = PhysicalProperyType::poisson_ratio;
307 propL[3][n] = PhysicalProperyType::damping;
308 propL[4][n] = PhysicalProperyType::f_x;
309 propL[5][n] = PhysicalProperyType::f_y;
310 if (simulation->com_mod.nsd == 3) {
311 propL[6][n] = PhysicalProperyType::f_z;
312 }
313
314 // Set ustruct properties.
315 n += 1;
316 propL[0][n] = PhysicalProperyType::solid_density;
317 propL[1][n] = PhysicalProperyType::elasticity_modulus;
318 propL[2][n] = PhysicalProperyType::poisson_ratio;
319 propL[3][n] = PhysicalProperyType::ctau_M;
320 propL[4][n] = PhysicalProperyType::ctau_C;
321 propL[5][n] = PhysicalProperyType::f_x;
322 propL[6][n] = PhysicalProperyType::f_y;
323 if (simulation->com_mod.nsd == 3) {
324 propL[7][n] = PhysicalProperyType::f_z;
325 }
326
327 // Set lElas properties.
328 n += 1;
329 propL[0][n] = PhysicalProperyType::solid_density;
330 propL[1][n] = PhysicalProperyType::elasticity_modulus;
331 propL[2][n] = PhysicalProperyType::poisson_ratio;
332 propL[3][n] = PhysicalProperyType::f_x;
333 propL[4][n] = PhysicalProperyType::f_y;
334 if (simulation->com_mod.nsd == 3) {
335 propL[5][n] = PhysicalProperyType::f_z;
336 }
337
338 // Set lEq properties.
339 read_domain(simulation, eq_params, lEq, propL, phys);
340
341 nDOP = {22, 4, 2, 0};
342 outPuts = {
343 OutputNameType::out_velocity,
344 OutputNameType::out_pressure,
345 OutputNameType::out_displacement,
346 OutputNameType::out_mises,
347
348 OutputNameType::out_WSS,
349 OutputNameType::out_traction,
350 OutputNameType::out_vorticity,
351 OutputNameType::out_vortex,
352 OutputNameType::out_strainInv,
353 OutputNameType::out_energyFlux,
354 OutputNameType::out_viscosity,
355 OutputNameType::out_absVelocity,
356 OutputNameType::out_stress,
357 OutputNameType::out_cauchy,
358 OutputNameType::out_strain,
359 OutputNameType::out_jacobian,
360 OutputNameType::out_defGrad,
361 OutputNameType::out_integ,
362 OutputNameType::out_fibDir,
363 OutputNameType::out_fibAlign,
364
365 OutputNameType::out_divergence,
366 OutputNameType::out_acceleration
367 };
368
369 // Set solver parameters.
370 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
371
372 if (com_mod.rmsh.isReqd && !com_mod.resetSim) {
373 read_rmsh(simulation, eq_params);
374 }
375
376} },
377
378//---------------------------//
379// phys_lElas //
380//---------------------------//
381//
382{consts::EquationType::phys_lElas, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
383 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
384{
385 using namespace consts;
386 auto& com_mod = simulation->get_com_mod();
387 lEq.phys = consts::EquationType::phys_lElas;
388
389 propL[0][0] = PhysicalProperyType::solid_density;
390 propL[1][0] = PhysicalProperyType::elasticity_modulus;
391 propL[2][0] = PhysicalProperyType::poisson_ratio;
392 propL[3][0] = PhysicalProperyType::f_x;
393 propL[4][0] = PhysicalProperyType::f_y;
394 if (simulation->com_mod.nsd == 3) {
395 propL[5][0] = PhysicalProperyType::f_z;
396 }
397
398 read_domain(simulation, eq_params, lEq, propL);
399
400 if (eq_params->prestress.defined() && eq_params->prestress.value()) {
401 nDOP = {3,2,0,0};
402 outPuts = {OutputNameType::out_displacement, OutputNameType::out_stress, OutputNameType::out_strain};
403 } else {
404 nDOP = {8,2,0,0};
405 outPuts = {
406 OutputNameType::out_displacement, OutputNameType::out_mises, OutputNameType::out_stress,
407 OutputNameType::out_strain, OutputNameType::out_velocity, OutputNameType::out_acceleration,
408 OutputNameType::out_integ, OutputNameType::out_jacobian
409 };
410 }
411
412 // Set solver parameters.
413 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
414
415} },
416
417//---------------------------//
418// phys_mesh //
419//---------------------------//
420//
421{consts::EquationType::phys_mesh, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
422 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
423{
424 using namespace consts;
425 auto& com_mod = simulation->get_com_mod();
426 lEq.phys = consts::EquationType::phys_mesh;
427
428 propL[0][0] = PhysicalProperyType::solid_density;
429 propL[1][0] = PhysicalProperyType::elasticity_modulus;
430 propL[2][0] = PhysicalProperyType::poisson_ratio;
431 propL[3][0] = PhysicalProperyType::f_x;
432 propL[4][0] = PhysicalProperyType::f_y;
433 if (simulation->com_mod.nsd == 3) {
434 propL[5][0] = PhysicalProperyType::f_z;
435 }
436
437 read_domain(simulation, eq_params, lEq, propL);
438
439 for (auto& domain : lEq.dmn) {
440 domain.prop[PhysicalProperyType::solid_density] = 0.0;
441 domain.prop[PhysicalProperyType::elasticity_modulus] = 1.0;
442 }
443
444 nDOP = {3, 1, 0, 0};
445 outPuts = {OutputNameType::out_displacement, OutputNameType::out_velocity, OutputNameType::out_acceleration };
446
447 lEq.ls.relTol = 0.2;
448
449 // Set solver parameters.
450 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
451
452} },
453
454//---------------------------//
455// phys_shell //
456//---------------------------//
457//
458{consts::EquationType::phys_shell, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
459 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
460{
461 using namespace consts;
462 auto& com_mod = simulation->get_com_mod();
463 lEq.phys = consts::EquationType::phys_shell;
464 com_mod.shlEq = true;
465
466 propL[0][0] = PhysicalProperyType::solid_density;
467 propL[1][0] = PhysicalProperyType::damping;
468 propL[2][0] = PhysicalProperyType::elasticity_modulus;
469 propL[3][0] = PhysicalProperyType::poisson_ratio;
470 propL[4][0] = PhysicalProperyType::shell_thickness;
471 propL[5][0] = PhysicalProperyType::f_x;
472 propL[6][0] = PhysicalProperyType::f_y;
473 propL[7][0] = PhysicalProperyType::f_z;
474
475 read_domain(simulation, eq_params, lEq, propL);
476
477 nDOP = {9,1,0,0};
478 outPuts = {
479 OutputNameType::out_displacement,
480 OutputNameType::out_stress,
481 OutputNameType::out_strain,
482 OutputNameType::out_jacobian,
483 OutputNameType::out_defGrad,
484 OutputNameType::out_velocity,
485 OutputNameType::out_integ,
486 OutputNameType::out_CGstrain,
487 OutputNameType::out_CGInv1
488 };
489
490 // Set solver parameters.
491 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
492
493} },
494
495//---------------------------//
496// phys_stokes //
497//---------------------------//
498//
499{consts::EquationType::phys_stokes, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
500 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
501{
502 using namespace consts;
503 auto& com_mod = simulation->get_com_mod();
504 lEq.phys = consts::EquationType::phys_stokes;
505
506 propL[0][0] = PhysicalProperyType::ctau_M;
507 propL[1][0] = PhysicalProperyType::f_x;
508 propL[2][0] = PhysicalProperyType::f_y;
509 if (simulation->com_mod.nsd == 3) {
510 propL[3][0] = PhysicalProperyType::f_z;
511 }
512 read_domain(simulation, eq_params, lEq, propL);
513
514 nDOP = {8, 2, 3, 0};
515 outPuts = {
516 OutputNameType::out_velocity,
517 OutputNameType::out_pressure,
518 OutputNameType::out_WSS,
519 OutputNameType::out_vorticity,
520 OutputNameType::out_traction,
521 OutputNameType::out_strainInv,
522 OutputNameType::out_viscosity,
523 OutputNameType::out_divergence
524 };
525
526 // Set solver parameters.
527 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
528
529} },
530
531//---------------------------//
532// phys_struct //
533//---------------------------//
534//
535{consts::EquationType::phys_struct, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
536 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
537{
538 using namespace consts;
539 auto& com_mod = simulation->get_com_mod();
540 lEq.phys = consts::EquationType::phys_struct;
541
542 propL[0][0] = PhysicalProperyType::solid_density;
543 propL[1][0] = PhysicalProperyType::damping;
544 propL[2][0] = PhysicalProperyType::elasticity_modulus;
545 propL[3][0] = PhysicalProperyType::poisson_ratio;
546 propL[4][0] = PhysicalProperyType::f_x;
547 propL[5][0] = PhysicalProperyType::f_y;
548 if (simulation->com_mod.nsd == 3) {
549 propL[6][0] = PhysicalProperyType::f_z;
550 }
551
552 read_domain(simulation, eq_params, lEq, propL);
553
554 if (eq_params->prestress.defined() && eq_params->prestress.value()) {
555 nDOP = {4,2,0,0};
556 outPuts = {OutputNameType::out_displacement, OutputNameType::out_stress, OutputNameType::out_cauchy, OutputNameType::out_strain};
557 //simulation->com_mod.pstEq = true;
558 } else {
559 nDOP = {12,2,0,0};
560 outPuts = {
561 OutputNameType::out_displacement, OutputNameType::out_mises, OutputNameType::out_stress,
562 OutputNameType::out_cauchy, OutputNameType::out_strain, OutputNameType::out_jacobian,
563 OutputNameType::out_defGrad, OutputNameType::out_integ, OutputNameType::out_fibDir,
564 OutputNameType::out_fibAlign, OutputNameType::out_velocity, OutputNameType::out_acceleration
565 };
566 }
567
568 // Set solver parameters.
569 read_ls(simulation, eq_params, SolverType::lSolver_CG, lEq);
570
571} },
572
573//---------------------------//
574// phys_ustruct //
575//---------------------------//
576//
577{consts::EquationType::phys_ustruct, [](Simulation* simulation, EquationParameters* eq_params, eqType& lEq, EquationProps& propL,
578 EquationOutputs& outPuts, EquationNdop& nDOP) -> void
579{
580 using namespace consts;
581 auto& com_mod = simulation->get_com_mod();
582
583 lEq.phys = consts::EquationType::phys_ustruct;
584 com_mod.sstEq = true;
585
586 propL[0][0] = PhysicalProperyType::solid_density;
587 propL[1][0] = PhysicalProperyType::elasticity_modulus;
588 propL[2][0] = PhysicalProperyType::poisson_ratio;
589 propL[3][0] = PhysicalProperyType::ctau_M;
590 propL[4][0] = PhysicalProperyType::ctau_C;
591 propL[5][0] = PhysicalProperyType::f_x;
592 propL[6][0] = PhysicalProperyType::f_y;
593 if (simulation->com_mod.nsd == 3) {
594 propL[7][0] = PhysicalProperyType::f_z;
595 }
596
597 read_domain(simulation, eq_params, lEq, propL);
598
599 nDOP = {14, 2, 0, 0};
600 outPuts = {
601 OutputNameType::out_displacement,
602 OutputNameType::out_mises,
603 OutputNameType::out_stress,
604 OutputNameType::out_cauchy,
605 OutputNameType::out_strain,
606 OutputNameType::out_jacobian,
607 OutputNameType::out_defGrad,
608 OutputNameType::out_integ,
609 OutputNameType::out_fibDir,
610 OutputNameType::out_fibAlign,
611 OutputNameType::out_velocity,
612 OutputNameType::out_pressure,
613 OutputNameType::out_acceleration,
614 OutputNameType::out_divergence
615 };
616
617 // Set solver parameters.
618 read_ls(simulation, eq_params, SolverType::lSolver_GMRES, lEq);
619
620} },
621};
622
The EquationParameters class stores parameters for the 'Add_equation' XML element used to specify an ...
Definition Parameters.h:1290
Definition Simulation.h:14
Equation type.
Definition ComMod.h:1069