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.
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
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.
Factory & _factory
The Factory associated with the MooseApp.
Base class to help creating an entire physics.
const InputParameters & parameters() const
Get the parameters of the object.
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.
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.
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
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.
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
const ActionComponent & getActionComponent(const ComponentName &comp_name) const
Get a component with the requested name.
virtual void addPreconditioning() override
bool isParamSetByUser(const std::string &name) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
void saveSolverVariableName(const VariableName &var_name)
Keep track of the name of the solver variable defined in the Physics.
const ExecFlagType EXEC_INITIAL