Lethe Open-Source Library version 1.2.0
Developer Guide
Loading...
Searching...
No Matches
simulation_parameters.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) 2019-2026 The Lethe Authors
2// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
3
4#ifndef lethe_simulation_parameters_h
5#define lethe_simulation_parameters_h
6
7#include <core/ale.h>
10#include <core/dimensionality.h>
13#include <core/manifolds.h>
14#include <core/parameters.h>
20
27
28#include <cmath>
29
30template <int dim>
32{
33public:
35 std::map<PhysicsID, Parameters::LinearSolver> linear_solver;
36 std::map<PhysicsID, Parameters::NonLinearSolver> physics_solving_strategy;
37 std::map<CLSSubequationsID, Parameters::LinearSolver>
39 std::map<CLSSubequationsID, Parameters::NonLinearSolver>
44 std::shared_ptr<Parameters::MeshBoxRefinement<dim>> mesh_box_refinement;
45 std::shared_ptr<Parameters::Nitsche<dim>> nitsche;
50 std::shared_ptr<Parameters::Laser<dim>> laser_parameters;
68 std::shared_ptr<Parameters::IBParticles<dim>> particlesParameters;
77
78
80
81 void
82 declare(ParameterHandler &prm,
83 Parameters::SizeOfSubsections size_of_subsections)
84 {
85 prm.declare_entry("dimension",
86 "0",
87 Patterns::Integer(),
88 "Dimension of the problem");
89
90 prm.declare_entry("print parameters",
91 "none",
92 Patterns::Selection("none|only changed|all"),
93 "Print all the parameters, or only"
94 "the changed parameters or none");
95
96 prm.declare_entry(
97 "comment message",
98 "",
99 Patterns::Anything(),
100 "Print a comment at the beginning of the console output.");
101
102 dimensionality.declare_parameters(prm);
104 physical_properties.declare_parameters(prm);
106 nitsche = std::make_shared<Parameters::Nitsche<dim>>();
107 nitsche->declare_parameters(prm);
109 boundary_conditions.declare_parameters(
110 prm, size_of_subsections.boundary_conditions);
111 boundary_conditions_ht.declare_parameters(
112 prm, size_of_subsections.boundary_conditions);
113 tracer_boundary_conditions.declare_parameters(
114 prm, size_of_subsections.boundary_conditions);
115 qmom_boundary_conditions.declare_parameters(
116 prm, size_of_subsections.boundary_conditions);
117 cls_boundary_conditions.declare_parameters(
118 prm, size_of_subsections.boundary_conditions);
119 cahn_hilliard_boundary_conditions.declare_parameters(
120 prm, size_of_subsections.boundary_conditions);
122 prm, size_of_subsections.boundary_conditions);
123
125 initial_condition->declare_parameters(prm);
126
130 laser_parameters = std::make_shared<Parameters::Laser<dim>>();
131 laser_parameters->declare_parameters(prm);
134 std::make_shared<Parameters::MeshBoxRefinement<dim>>();
135 mesh_box_refinement->declare_parameters(prm);
136 for (const auto &physics_name : nonlinear_physics_names)
137 {
140 }
141 for (const auto &physics_name : linear_physics_names)
142 {
144 }
145 for (const auto &cls_subequation_name : cls_subequations_names)
146 {
147 Parameters::LinearSolver::declare_parameters(prm, cls_subequation_name);
149 cls_subequation_name);
150 }
151
152 post_processing.declare_parameters(prm);
154 particlesParameters = std::make_shared<Parameters::IBParticles<dim>>();
155 particlesParameters->declare_parameters(prm);
156 manifolds_parameters.declare_parameters(prm, size_of_subsections.manifolds);
157
159 analytical_solution->declare_parameters(prm);
160 source_term.declare_parameters(prm);
162
164
165 constrain_solid_domain.declare_parameters(prm, 2);
166
168
169 ale.declare_parameters(prm);
170
172
173 multiphysics.declare_parameters(prm);
174
175 tracer_drift_velocity.declare_parameters(prm);
176
177 mortar_parameters.declare_parameters(prm);
178 }
179
180 void
181 parse(ParameterHandler &prm)
182 {
183 dimensionality.parse_parameters(prm);
184 test.parse_parameters(prm);
185
186 for (const auto &physics_name : nonlinear_physics_names)
187 {
188 PhysicsID physics_id = get_physics_id(physics_name);
189 linear_solver[physics_id].parse_parameters(prm, physics_name);
190 physics_solving_strategy[physics_id].parse_parameters(prm,
191 physics_name);
192 }
193 for (const auto &physics_name : linear_physics_names)
194 {
195 PhysicsID physics_id = get_physics_id(physics_name);
196 linear_solver[physics_id].parse_parameters(prm, physics_name);
197 }
198 for (const auto &cls_subequation_name : cls_subequations_names)
199 {
200 CLSSubequationsID cls_subequations_id =
201 get_cls_subequation_id(cls_subequation_name);
202 cls_subequations_linear_solvers[cls_subequations_id].parse_parameters(
203 prm, cls_subequation_name);
204 cls_subequations_non_linear_solvers[cls_subequations_id]
205 .parse_parameters(prm, cls_subequation_name);
206 }
207
208 mesh_adaptation.parse_parameters(prm);
209 mesh.parse_parameters(prm);
210 mesh_box_refinement->parse_parameters(prm);
211 nitsche->parse_parameters(prm);
212 physical_properties.parse_parameters(prm, dimensionality);
213 multiphysics.parse_parameters(prm, dimensionality);
214 timer.parse_parameters(prm);
215 fem_parameters.parse_parameters(prm);
216 laser_parameters->parse_parameters(prm);
217 forces_parameters.parse_parameters(prm);
218 post_processing.parse_parameters(prm);
219 flow_control.parse_parameters(prm);
220 restart_parameters.parse_parameters(prm);
221 boundary_conditions.parse_parameters(prm);
222 boundary_conditions_ht.parse_parameters(prm);
223 tracer_boundary_conditions.parse_parameters(prm);
224 qmom_boundary_conditions.parse_parameters(prm);
225 cls_boundary_conditions.parse_parameters(prm);
226 cahn_hilliard_boundary_conditions.parse_parameters(prm);
228 manifolds_parameters.parse_parameters(prm);
229 initial_condition->parse_parameters(prm);
230 analytical_solution->parse_parameters(prm);
231 source_term.parse_parameters(prm);
232 simulation_control.parse_parameters(prm);
233 velocity_sources.parse_parameters(prm);
234 particlesParameters->parse_parameters(prm);
235 constrain_solid_domain.parse_parameters(prm);
236 stabilization.parse_parameters(prm);
237 ale.parse_parameters(prm);
238 evaporation.parse_parameters(prm);
239 tracer_drift_velocity.parse_parameters(prm);
240 mortar_parameters.parse_parameters(prm);
241
243
244
245 // Check consistency of parameters parsed in different subsections
246 if (multiphysics.CLS && physical_properties.number_of_fluids != 2)
247 {
248 throw std::logic_error(
249 "Inconsistency in .prm!\n with CLS = true\n use: number of fluids = 2");
250 }
251
252 if (not(multiphysics.CLS) && post_processing.postprocessed_fluid ==
254 {
255 throw std::logic_error(
256 "Inconsistency in .prm!\n when CLS = false"
257 "\n use (default value): set postprocessed fluid = both"
258 "\n or: set postprocessed fluid = fluid_0");
259 }
260
261 if (physical_properties.number_of_fluids == 2 &&
262 (!multiphysics.CLS && !multiphysics.cahn_hilliard))
263 {
264 throw std::logic_error(
265 "Inconsistency in .prm!\n "
266 "Number of fluids in 'physical properties' was set to 2,\n "
267 "but neither 'cls' or 'cahn hilliard' is enabled in the 'multiphysics'.\n ");
268 }
269
270 // Interface physical property models consistency check
271 if (multiphysics.cls_parameters.surface_tension_force.enable)
272 {
273 std::string constant_surface_tension_model(
274 " subsection fluid-fluid interaction\n"
275 " set first fluid id = 0\n"
276 " set second fluid id = 1\n"
277 " set surface tension model = constant\n"
278 " set surface tension coefficient = $value_of_coefficient\n"
279 " end\n");
280
281 std::string linear_surface_tension_model(
282 " subsection fluid-fluid interaction\n"
283 " set first fluid id = 0\n"
284 " set second fluid id = 1\n"
285 " set surface tension model = linear\n"
286 " set surface tension coefficient = $value_of_coefficient\n"
287 " set temperature-driven surface tension gradient = $value_of_gradient\n"
288 " end\n");
289
290 std::string phase_change_surface_tension_model(
291 " subsection fluid-fluid interaction\n"
292 " set first fluid id = 0\n"
293 " set second fluid id = 1\n"
294 " set surface tension model = phase change\n"
295 " set surface tension coefficient = $value_of_coefficient\n"
296 " set temperature-driven surface tension gradient = $value_of_gradient\n"
297 " set solidus temperature = $value_of_solidus_temperature\n"
298 " set liquidus temperature = $value_of_liquidus_temperature\n"
299 " end\n");
300 if (!multiphysics.cls_parameters.surface_tension_force
301 .enable_marangoni_effect) // constant surface tension model
302 {
303 if (physical_properties.number_of_material_interactions == 0)
304 {
305 throw std::logic_error(
306 "Inconsistency in .prm!\n "
307 "In subsection CLS, with surface tension force enabled,\n "
308 "but no material interactions specified in\n "
309 "subsection physical properties.\n "
310 "Use:\n\n"
311 " set number of material interactions = 1\n"
312 " subsection material interaction 0\n"
313 " set type = fluid_fluid\n" +
314 constant_surface_tension_model + " end\n");
315 }
316 else if (multiphysics.CLS &&
318 .heat_transfer) // disabled Marangoni effect error
319 {
321 physical_properties.material_interactions))
322 {
323 throw std::logic_error(
324 "Inconsistency in .prm!\n "
325 "In subsection multiphysics, 'cls' and 'heat transfer' enabled,\n "
326 "and in subsection physical properties, a non-constant surface\n "
327 "tension model, but Marangoni effect disabled in subsection\n "
328 "surface tension force of subsection CLS. This is necessary to account\n "
329 "for Marangoni effect. In subsection CLS, use:\n\n "
330 " subsection surface tension force\n"
331 " set enable = true\n"
332 " set enable marangoni effect = true\n"
333 " end\n");
334 }
335 }
336 else
337 {
339 physical_properties.material_interactions))
340 {
341 throw std::logic_error(
342 "Inconsistency in .prm!\n "
343 "in subsection CLS, surface tension force enabled,\n "
344 "but no fluid-fluid material interactions specified in \n "
345 "subsection physical properties\n "
346 "Use:\n\n"
347 " subsection material interaction $material_interaction_id\n"
348 " set type = fluid_fluid\n" +
349 constant_surface_tension_model + " end\n");
350 }
351 }
352 }
353 else // non-constant surface tension model
354 {
355 if (physical_properties.number_of_material_interactions == 0)
356 {
357 throw std::logic_error(
358 "Inconsistency in .prm!\n "
359 "In subsection CLS, marangoni effect enabled,\n "
360 "but no material interactions specified in subsection physical\n "
361 "properties. This is necessary to account for Marangoni \n "
362 "effect. In subsection physical properties, use:\n\n"
363 " set number of material interactions = 1\n"
364 " subsection material interaction 0\n"
365 " set type = fluid_fluid\n" +
366 linear_surface_tension_model +
367 "\n"
368 "or: \n\n"
369 " set number of material interactions = 1\n"
370 " subsection material interaction 0\n"
371 " set type = fluid_fluid\n" +
372 phase_change_surface_tension_model + " end\n");
373 }
374 else
375 {
377 physical_properties.material_interactions))
378 {
379 throw std::logic_error(
380 "Inconsistency in .prm!\n "
381 "In subsection CLS, Marangoni effect enabled,\n "
382 "but no fluid-fluid material interactions specified in subsection\n "
383 "physical properties. This is necessary to account for Marangoni\n "
384 "effect. In subsection physical properties, use:\n\n"
385 " subsection material interaction $material_interaction_id\n"
386 " set type = fluid_fluid\n" +
387 linear_surface_tension_model +
388 "\n"
389 "or:\n\n"
390 " set number of material interactions = 1\n"
391 " subsection material interaction 0\n"
392 " set type = fluid_fluid\n" +
393 phase_change_surface_tension_model + " end\n");
394 }
396 physical_properties.material_interactions))
397 {
398 throw std::logic_error(
399 "Inconsistency in .prm!\n "
400 "In subsection CLS, Marangoni effect enabled,\n "
401 "but a constant surface tension model is specified in subsection\n "
402 "physical properties. This is necessary to account for Marangoni \n "
403 "effect. In subsection physical properties, use:\n\n"
404 " subsection material interaction $material_interaction_id\n"
405 " set type = fluid_fluid\n" +
406 linear_surface_tension_model +
407 "\n"
408 "or:\n\n"
409 " set number of material interactions = 1\n"
410 " subsection material interaction 0\n"
411 " set type = fluid_fluid\n" +
412 phase_change_surface_tension_model + " end\n");
413 }
414 }
415 }
416 }
417
418 if (multiphysics.cahn_hilliard && multiphysics.CLS)
419 {
420 throw std::runtime_error(
421 "Cannot solve a multiphase problem using CLS and Cahn-Hilliard at the same time");
422 }
423
424 if (multiphysics.cahn_hilliard &&
425 physical_properties.number_of_material_interactions == 0)
426 {
427 throw std::logic_error(
428 "Inconsistency in .prm!\n "
429 "cahn hilliard = true, \n "
430 "but no fluid-fluid material interactions specified in\n "
431 "subsection physical properties\n "
432 "Use:\n\n"
433 " subsection material interaction $material_interaction_id\n"
434 " set type = fluid_fluid\n"
435 " subsection fluid-fluid interaction\n"
436 " set first fluid id = 0\n"
437 " set second fluid id = 1\n"
438 " set cahn hilliard mobility model = constant\n"
439 " set cahn hilliard mobility coefficient = $value_of_coefficient\n"
440 " end\n"
441 " end\n");
442 }
443 if (laser_parameters->activate_laser &&
444 (laser_parameters->laser_type ==
446 dim>::LaserType::gaussian_heat_flux_cls_interface ||
447 laser_parameters->laser_type ==
449 dim>::LaserType::uniform_heat_flux_cls_interface) &&
450 !multiphysics.CLS)
451 {
452 throw std::logic_error(
453 "At the moment, the laser surface heat flux is not implemented for 1 fluid simulations."
454 "Please enable the CLS auxiliary physic in the 'multiphysics' subsection, \n"
455 "specify a 2nd fluid in the 'physical properties' subsection,\n"
456 "and define appropriate initial conditions in the 'initial conditions' subsection.");
457 }
458
459 if (!multiphysics.heat_transfer && constrain_solid_domain.enable)
460 {
461 throw std::logic_error(
462 "Inconsistency in .prm!\n "
463 "The apply constraints on a solid domain feature is enabled, however\n "
464 "'heat transfer' was not set to 'true' in the 'multiphysics' subsection.\n ");
465 }
466
467 if (constrain_solid_domain.enable &&
468 physical_properties_manager.get_number_of_fluids() <
469 constrain_solid_domain.number_of_constraints)
470 {
471 std::string n_constraints =
472 Utilities::to_string(constrain_solid_domain.number_of_constraints);
473 std::string n_fluids = Utilities::to_string(
474 physical_properties_manager.get_number_of_fluids());
475 throw std::logic_error(
476 "Inconsistency in .prm!\n "
477 "The number of constraints (" +
478 n_constraints + ") is greater than the number of fluids (" +
479 n_fluids +
480 ").\n "
481 "Only 1 constraint per fluid can be declared.\n ");
482 }
483
484 if (constrain_solid_domain.enable && multiphysics.cahn_hilliard)
485 {
486 throw std::logic_error(
487 "Inconsistency in .prm!\n "
488 "The current implementation for constraining solid domains with\n "
489 "temperature is not implemented for Cahn Hilliard simulations.\n ");
490 }
491
492 if (multiphysics.thermal_buoyancy_force)
493 {
494 for (const auto &fluid : physical_properties.fluids)
495 {
496 AssertThrow(
497 fluid.density_model !=
499 ExcMessage(
500 "Inconsistency in .prm!\n "
501 "Thermal buoyancy force is enabled while the isothermal ideal gas\n "
502 "density model is used. The isothermal ideal gas density model assumes\n "
503 "thermal independence of the density, which is incompatible with the\n "
504 "thermal buoyancy force."));
505 }
506 }
507
508 // The isothermal compressible assemblers, which are used whenever the
509 // density is not constant, do not apply the pressure scaling factor to the
510 // pressure columns of the Jacobian. The pressure degrees of freedom of the
511 // Newton correction would nevertheless be rescaled after the linear solve,
512 // so the factor is rejected rather than ignored.
513 if (!physical_properties_manager.density_is_constant())
514 {
515 constexpr double pressure_scaling_tolerance = 1e-8;
516 AssertThrow(
517 std::abs(stabilization.pressure_scaling_factor - 1.) <
518 pressure_scaling_tolerance,
519 ExcMessage(
520 "Inconsistency in .prm!\n "
521 "The 'pressure scaling factor' parameter of the 'stabilization'\n "
522 "subsection is not supported with a non-constant density model\n "
523 "(isothermal_ideal_gas). Set it to 1."));
524 }
525
526 if (simulation_control.adapt_with_capillary_time_step_ratio)
527 AssertThrow(
528 (multiphysics.cls_parameters.surface_tension_force.enable &&
529 multiphysics.CLS),
530 ExcMessage(
531 "The current implementation only allows the capillary time-step constraint \n "
532 "to be respected for CLS multiphase flows with surface tension.\n "));
533
534 AssertThrow(
535 velocity_sources.fluid_with_phase_change ==
537 multiphysics.CLS,
538 ExcMessage(
539 "Inconsistency in .prm!\n"
540 "The 'cls' multiphysics is disabled and the 'fluid with phase change' parameter (subsection velocity source) has not been to 'fluid_0'."));
541
542 // For isocontour bounding boxes
543 if (post_processing.isocontour_bounding_boxes
544 .ids_and_isocontours_per_variable.contains(Variable::temperature))
545 AssertThrow(
546 multiphysics.heat_transfer,
547 ExcMessage(
548 "You are attempting to monitor temperature isocontours, but 'heat transfer = false' in the 'multiphysics' subsection."));
549 if (post_processing.isocontour_bounding_boxes
550 .ids_and_isocontours_per_variable.contains(Variable::phase))
551 AssertThrow(
552 multiphysics.CLS,
553 ExcMessage(
554 "You are attempting to monitor phase indicator isocontours, but 'cls = false' in the 'multiphysics' subsection."));
555
556 // For postprocessing probes
557 if (post_processing.probing_points.probing_points_per_variable.contains(
559 post_processing.probing_points.probing_points_per_variable.contains(
561 AssertThrow(
562 multiphysics.fluid_dynamics,
563 ExcMessage(
564 "You are attempting to evaluate velocity or pressure values using at least one postprocessing probe, but 'fluid dynamics = false' in the 'multiphysics' subsection."));
565 if (post_processing.probing_points.probing_points_per_variable.contains(
567 AssertThrow(
568 multiphysics.CLS,
569 ExcMessage(
570 "You are attempting to evaluate phase indicator values using at least one postprocessing probe, but 'cls = false' in the 'multiphysics' subsection."));
571 if (post_processing.probing_points.probing_points_per_variable.contains(
573 AssertThrow(
574 multiphysics.heat_transfer,
575 ExcMessage(
576 "You are attempting to evaluate temperature values using at least one postprocessing probe, but 'heat transfer = false' in the 'multiphysics' subsection."));
577 }
578
579 inline bool
581 std::vector<Parameters::MaterialInteractions> &material_interactions)
582 {
583 for (const Parameters::MaterialInteractions &material_interaction :
584 material_interactions)
585 {
586 if (material_interaction.material_interaction_type ==
589 {
590 return false;
591 }
592 }
593 return true;
594 }
595
596 inline bool
598 std::vector<Parameters::MaterialInteractions> &material_interactions)
599 {
600 for (const Parameters::MaterialInteractions &material_interaction :
601 material_interactions)
602 {
603 if (material_interaction.surface_tension_model !=
605 {
606 return false;
607 }
608 }
609 return true;
610 }
611
612private:
614 // names for the physics supported by Lethe
615 std::vector<std::string> nonlinear_physics_names = {
616 "fluid dynamics",
617 "heat transfer",
618 "tracer",
619 "CLS",
620 "cahn hilliard",
621 "void fraction",
622 "continuum solid dynamics",
623 "qmom"};
624 std::vector<std::string> linear_physics_names = {"electromagnetics"};
625 // Names of subequations within CLS that inherits from PhysicsSolver
626 std::vector<std::string> cls_subequations_names = {
627 "CLS PDE-based interface reinitialization"};
628};
629
630#endif
Implements analytical solutions for the Navier-Stokes equations and the other physics supported by le...
This class manages the boundary conditions for CLS solver It introduces the boundary functions and de...
This class manages the boundary conditions for the Cahn-Hilliard solver It introduces the boundary fu...
This class manages the boundary conditions forhe fluid dynamics solver It introduces the boundary fun...
This class manages the boundary conditions for Heat-Transfer solver It introduces the boundary functi...
Boundary conditions of the QMOM physics. They apply to the advective flux of all the QMOM fields (sca...
This class manages the boundary conditions for Time Harmonic Maxwell solver. It introduces the bounda...
This class manages the boundary conditions for Tracer solver It introduces the boundary functions and...
An interface for all the common parameters required to consider a moving frame of reference in a simp...
Definition ale.h:25
Class used to rescale physical properties for cases where the main dimensions of the problems (Length...
Laser parameters - Defines the parameters for the laser heat source.
Manifolds - This class manages attaching manifolds to faces when a manual attachment is required (for...
Definition manifolds.h:25
MaterialInteractions - Class that defines physical properties due to interactions between two differe...
Definition parameters.h:757
Mesh - Parameters that control mesh reading and mesh generation.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
PhysicalProperties - Define the possible physical properties. All continuum equations share the same ...
Definition parameters.h:839
Postprocessing - Defines the parameters for the post-processing. In Lethe, post-processing implies th...
Implements a drift velocity function to account for simplified multiphase flows.
Class that manages the physical properties model which are required to calculate the various physical...
Parameters::Testing test
bool no_fluid_fluid_interaction_error(std::vector< Parameters::MaterialInteractions > &material_interactions)
SourceTerms::SourceTerm< dim > source_term
Parameters::Mortar< dim > mortar_parameters
std::shared_ptr< Parameters::MeshBoxRefinement< dim > > mesh_box_refinement
BoundaryConditions::TracerBoundaryConditions< dim > tracer_boundary_conditions
Parameters::Evaporation evaporation
std::shared_ptr< Parameters::Laser< dim > > laser_parameters
Parameters::Restart restart_parameters
BoundaryConditions::CLSBoundaryConditions< dim > cls_boundary_conditions
Parameters::Dimensionality dimensionality
Parameters::Stabilization stabilization
AnalyticalSolutions::AnalyticalSolution< dim > * analytical_solution
void parse(ParameterHandler &prm)
Parameters::ConstrainSolidDomain< dim > constrain_solid_domain
std::shared_ptr< Parameters::IBParticles< dim > > particlesParameters
bool is_constant_surface_tension_model(std::vector< Parameters::MaterialInteractions > &material_interactions)
PhysicalPropertiesManager physical_properties_manager
BoundaryConditions::HeatTransferBoundaryConditions< dim > boundary_conditions_ht
Parameters::DynamicFlowControl flow_control
Parameters::Multiphysics< dim > multiphysics
Parameters::MeshAdaptation mesh_adaptation
std::vector< std::string > nonlinear_physics_names
std::map< CLSSubequationsID, Parameters::NonLinearSolver > cls_subequations_non_linear_solvers
std::shared_ptr< Parameters::Nitsche< dim > > nitsche
std::map< CLSSubequationsID, Parameters::LinearSolver > cls_subequations_linear_solvers
Parameters::SimulationControl simulation_control
Parameters::Manifolds manifolds_parameters
Parameters::TracerDriftVelocity< dim > tracer_drift_velocity
Parameters::Mesh< dim > mesh
Parameters::PostProcessing< dim > post_processing
Parameters::ALE< dim > ale
Parameters::InitialConditions< dim > * initial_condition
Parameters::PhysicalProperties physical_properties
BoundaryConditions::FluidDynamicsBoundaryConditions< dim > boundary_conditions
std::map< PhysicsID, Parameters::LinearSolver > linear_solver
BoundaryConditions::QMOMBoundaryConditions< dim > qmom_boundary_conditions
BoundaryConditions::TimeHarmonicMaxwellBoundaryConditions< dim > boundary_conditions_time_harmonic_electromagnetics
std::vector< std::string > linear_physics_names
Parameters::Forces forces_parameters
Parameters::VelocitySource velocity_sources
std::map< PhysicsID, Parameters::NonLinearSolver > physics_solving_strategy
std::vector< std::string > cls_subequations_names
BoundaryConditions::CahnHilliardBoundaryConditions< dim > cahn_hilliard_boundary_conditions
void declare(ParameterHandler &prm, Parameters::SizeOfSubsections size_of_subsections)
CLSSubequationsID get_cls_subequation_id(const std::string &cls_subequation_name)
Get the CLSSubequationsID associated to a specific CLS subequation from a string.
CLSSubequationsID
IDs associated to the different subequations solved in Lethe.
@ phase
Phase indicator scalar field from CLS.
@ velocity
Velocity vector field from fluid dynamics.
@ pressure
Pressure scalar field from fluid dynamics.
@ temperature
Temperature scalar field from heat transfer.
PhysicsID get_physics_id(const std::string &physics_name)
Utility function used for parsing physics-based parameters.
PhysicsID
Unique identifiers for each physics module in Lethe.
Parameter classes for solid objects used in Nitsche immersed boundary and DEM simulations.
Set of parameters constraining a certain portion of a fluid domain to null velocity and pressure fiel...
Definition parameters.h:911
FlowControl - Set average velocity on a boundary (CFD) or the domain (CFD-DEM).
static void declare_parameters(ParameterHandler &prm)
Declare the default parameters.
Evaporation - Defines the subparameters for the evaporation cooling and recoil pressure at the free s...
static void declare_parameters(ParameterHandler &prm)
Declare the default parameters.
FEM - The finite element section controls the properties of the finite element method....
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
Forces - Defines the parameters for the force calculation on boundaries of the domain.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
static void declare_parameters(ParameterHandler &prm, const std::string &physics_name)
Declare the parameters.
MeshAdaption - Parameters that control dynamic mesh adaptation. Dynamic mesh adaptation in Lethe is v...
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
Mortar - Defines parameters used to construct mortar elements.
Multiphysics - the parameters for multiphysics simulations and handles sub-physics parameters.
static void declare_parameters(ParameterHandler &prm, const std::string &physics_name)
Declare the parameters.
Restart - Controls writing and reading simulation checkpoints.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
SimulationControl - Defines the parameter that control the flow of the simulation as well as the freq...
Definition parameters.h:87
static void declare_parameters(ParameterHandler &prm)
Declare the simulation control parameters.
Stabilization - Defines parameters for an advanced control over the stabilization strategy used by th...
Definition parameters.h:988
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
Testing - Some solvers have a specific testing mode that can be enabled to output more variables to t...
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
Timer - Defines the parameters that control the timing of the simulation. Lethe supports advanced tim...
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.
VelocitySource - Adds velocity-dependent source term to the Navier-Stokes equations with the appropri...
static void declare_parameters(ParameterHandler &prm)
Declare the parameters.