22 params.
addParam<VariableName>(
"variable_name",
"u",
"Variable name for the equation");
23 params.
addParam<FunctionName>(
"initial_condition",
"Initial condition for the diffused variable");
26 params.
addParam<MaterialPropertyName>(
"diffusivity_matprop",
27 "Material property defining the diffusion coefficient");
28 params.
addParam<MooseFunctorName>(
"diffusivity_functor",
"Functor specifying the diffusivity");
31 params.
addParam<MooseFunctorName>(
"source_functor",
"Source term in the diffusion problem");
32 params.
addParam<
Real>(
"source_coef", 1,
"Coefficient multiplying the source");
35 params.
addParam<std::vector<BoundaryName>>(
36 "neumann_boundaries", {},
"Boundaries on which to apply a diffusive flux");
37 params.
addParam<std::vector<BoundaryName>>(
38 "dirichlet_boundaries", {},
"Boundaries on which to apply a fixed value");
39 params.
addParam<std::vector<MooseFunctorName>>(
40 "boundary_fluxes", {},
"Functors to compute the diffusive flux on each Neumann boundary'");
41 params.
addParam<std::vector<MooseFunctorName>>(
42 "boundary_values", {},
"Functors to compute the diffusive flux on each Dirichlet boundary'");
45 "Boundary conditions");
48 params.
addParam<std::vector<BoundaryName>>(
49 "compute_diffusive_fluxes_on", {},
"Surfaces to compute the diffusive flux on");
52 MooseEnum pc_options(
"default defer",
"default");
54 "preconditioning", pc_options,
"Which preconditioning to use for this Physics");
62 _var_name(getParam<VariableName>(
"variable_name")),
63 _neumann_boundaries(getParam<
std::vector<BoundaryName>>(
"neumann_boundaries")),
64 _dirichlet_boundaries(getParam<
std::vector<BoundaryName>>(
"dirichlet_boundaries"))
70 checkVectorParamsSameLength<BoundaryName, MooseFunctorName>(
"neumann_boundaries",
72 checkVectorParamsSameLength<BoundaryName, MooseFunctorName>(
"dirichlet_boundaries",
74 checkVectorParamsNoOverlap<BoundaryName>({
"neumann_boundaries",
"dirichlet_boundaries"});
89 const auto option_pair1 =
90 std::make_pair<MooseEnumItem, std::string>(
MooseEnumItem(
"-pc_type"),
"hypre");
91 const auto option_pair2 =
92 std::make_pair<MooseEnumItem, std::string>(
MooseEnumItem(
"-pc_hypre_type"),
"boomeramg");
100 for (
const auto & boundary_name :
101 getParam<std::vector<BoundaryName>>(
"compute_diffusive_fluxes_on"))
104 const bool use_ad =
isParamValid(
"use_automatic_differentiation")
105 ? getParam<bool>(
"use_automatic_differentiation")
107 const std::string pp_type =
108 use_ad ?
"ADSideDiffusiveFluxIntegral" :
"SideDiffusiveFluxIntegral";
110 params.
set<std::vector<VariableName>>(
"variable") = {
_var_name};
112 params.set<MaterialPropertyName>(
"diffusivity") =
113 getParam<MaterialPropertyName>(
"diffusivity_matprop");
115 params.set<MooseFunctorName>(
"functor_diffusivity") =
116 getParam<MooseFunctorName>(
"diffusivity_functor");
118 params.set<MooseFunctorName>(
"functor_diffusivity") =
"1";
119 params.set<std::vector<BoundaryName>>(
"boundary") = {boundary_name};
133 std::vector<SubdomainName> component_ic_blocks;
139 component_ic_blocks.insert(component_ic_blocks.end(), comp_blocks.begin(), comp_blocks.end());
143 std::vector<SubdomainName> remaining_blocks;
144 for (
const auto & block :
_blocks)
145 if (std::find(component_ic_blocks.begin(), component_ic_blocks.end(), block) ==
146 component_ic_blocks.end())
147 remaining_blocks.push_back(block);
150 if (remaining_blocks.empty())
159 !
parameters().hasDefault(
"initial_condition"),
160 "Should not have a default");
163 _var_name, remaining_blocks,
false,
true))
166 params.
set<FunctionName>(
"function") = getParam<FunctionName>(
"initial_condition");
185 params.
set<MooseFunctorName>(
"functor") = libmesh_map_find(component_bc_map,
_var_name);
std::string prefix() const
Use prefix() to disambiguate names.
A MultiMooseEnum object to hold "execute_on" flags.
void assignBlocks(InputParameters ¶ms, const std::vector< SubdomainName > &blocks) const
Set the blocks parameter to the input parameters of an object this Physics will create.
static InputParameters validParams()
Factory & getFactory()
Get the factory for this physics The factory lets you get the parameters for objects.
void addRequiredPhysicsTask(const std::string &task)
Add a new required task for all physics deriving from this class NOTE: This does not register the tas...
void addPetscPairsToPetscOptions(const std::vector< std::pair< MooseEnumItem, std::string >> &petsc_pair_options)
Process the given petsc option pairs into the system solver settings.
static InputParameters validParams()
virtual void addPostprocessors() override
Add postprocessing of the fluxes.
Base class to help creating an entire physics.
DiffusionPhysicsBase(const InputParameters ¶meters)
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
const std::vector< SubdomainName > & blocks() const
Return the blocks this physics is defined on.
const MooseEnum & _preconditioning
Whether to add a default preconditioning.
const ExecFlagType EXEC_TIMESTEP_END
bool shouldCreateIC(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool ic_is_default_ic, const bool error_if_already_defined) const
Returns whether this Physics should create the variable.
std::map< std::string, std::map< VariableName, MooseFunctorName > > _components_initial_conditions
Map of components to variables and initial conditions.
const VariableName & _var_name
Name of the diffused variable.
std::vector< SubdomainName > _blocks
Keep track of the subdomains the Physics is defined on.
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Factory & _factory
The Factory associated with the MooseApp.
virtual void addInitialCondition(const std::string &ic_name, const std::string &name, InputParameters ¶meters)
virtual FEProblemBase & getProblem()
Get the problem for this physics Useful to add objects to the simulation.
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters ¶meters)
virtual void addInitialConditionsFromComponents() override
Interface class to help components interact with Physics.
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
const ExecFlagType EXEC_LINEAR
static InputParameters validParams()
const ExecFlagType EXEC_NONLINEAR
virtual void addInitialConditions() override
bool isParamSetByUser(const std::string &nm) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Class for containing MooseEnum item information.
const std::vector< SubdomainName > & blocks() const
Returns the subdomains for the component mesh, if any.
const InputParameters & parameters() const
Get the parameters of the object.
const ActionComponent & getActionComponent(const ComponentName &comp_name) const
Get a component with the requested name.
virtual void addPreconditioning() override
void saveSolverVariableName(const VariableName &var_name)
Keep track of the name of the solver variable defined in the Physics.
const ExecFlagType EXEC_INITIAL