27 params.
addClassDescription(
"Creates all the objects necessary to solve a particular physics");
29 params.
addParam<std::vector<SubdomainName>>(
30 "block", {},
"Blocks (subdomains) that this Physics is active on.");
32 MooseEnum transient_options(
"true false same_as_problem",
"same_as_problem");
34 "transient", transient_options,
"Whether the physics is to be solved as a transient");
36 params.
addParam<
bool>(
"verbose",
false,
"Flag to facilitate debugging a Physics");
39 params.
addParam<std::vector<SolverSystemName>>(
42 "Name of the solver system(s) for the variables. If a single name is specified, " 43 "that system is used for all solver variables.");
44 MooseEnum pc_options(
"default defer",
"defer");
47 "Which preconditioning to use/add for this Physics, or whether to " 48 "defer to the Preconditioning block, or another Physics");
51 params.
addParam<
bool>(
"initialize_variables_from_mesh_file",
53 "Determines if the variables that are added by the action are initialized" 54 "from the mesh file (only for Exodus format)");
56 "initial_from_file_timestep",
58 "Gives the time step number (or \"LATEST\") for which to read the Exodus solution");
60 "Restart from Exodus");
64 "dont_create_solver_variables",
false,
"Whether to skip the 'add_variable' task");
65 params.
addParam<
bool>(
"dont_create_ics",
false,
"Whether to skip the 'add_ic' task");
67 "dont_create_kernels",
false,
"Whether to skip the 'add_kernel' task for each kernel type");
68 params.
addParam<
bool>(
"dont_create_bcs",
70 "Whether to skip the 'add_bc' task for each boundary condition type");
71 params.
addParam<
bool>(
"dont_create_functions",
false,
"Whether to skip the 'add_function' task");
73 "dont_create_aux_variables",
false,
"Whether to skip the 'add_aux_variable' task");
75 "dont_create_aux_kernels",
false,
"Whether to skip the 'add_aux_kernel' task");
76 params.
addParam<
bool>(
"dont_create_materials",
78 "Whether to skip the 'add_material' task for each material type");
80 "dont_create_user_objects",
82 "Whether to skip the 'add_user_object' task. This does not apply to UserObject derived " 83 "classes being created on a different task (for example: postprocessors, VPPs, correctors)");
85 "dont_create_correctors",
false,
"Whether to skip the 'add_correctors' task");
87 "dont_create_postprocessors",
false,
"Whether to skip the 'add_postprocessors' task");
88 params.
addParam<
bool>(
"dont_create_vectorpostprocessors",
90 "Whether to skip the 'add_vectorpostprocessors' task");
92 "dont_create_solver_variables dont_create_ics dont_create_kernels dont_create_bcs " 93 "dont_create_functions dont_create_aux_variables dont_create_aux_kernels " 94 "dont_create_materials dont_create_user_objects dont_create_correctors " 95 "dont_create_postprocessors dont_create_vectorpostprocessors",
96 "Reduce Physics object creation");
106 _system_names(getParam<
std::vector<SolverSystemName>>(
"system_names")),
107 _verbose(getParam<bool>(
"verbose")),
108 _preconditioning(getParam<
MooseEnum>(
"preconditioning")),
109 _blocks(getParam<
std::vector<SubdomainName>>(
"block")),
110 _is_transient(getParam<
MooseEnum>(
"transient"))
113 "initial_from_file_timestep");
131 else if (
_current_task ==
"add_variable" && !getParam<bool>(
"dont_create_solver_variables"))
133 else if (
_current_task ==
"add_ic" && !getParam<bool>(
"dont_create_ics"))
137 else if (
_current_task ==
"add_kernel" && !getParam<bool>(
"dont_create_kernels"))
139 else if (
_current_task ==
"add_nodal_kernel" && !getParam<bool>(
"dont_create_kernels"))
142 !getParam<bool>(
"dont_create_kernels"))
144 else if (
_current_task ==
"add_dirac_kernel" && !getParam<bool>(
"dont_create_kernels"))
146 else if (
_current_task ==
"add_dg_kernel" && !getParam<bool>(
"dont_create_kernels"))
148 else if (
_current_task ==
"add_scalar_kernel" && !getParam<bool>(
"dont_create_kernels"))
150 else if (
_current_task ==
"add_interface_kernel" && !getParam<bool>(
"dont_create_kernels"))
152 else if (
_current_task ==
"add_fv_ik" && !getParam<bool>(
"dont_create_kernels"))
156 else if (
_current_task ==
"add_bc" && !getParam<bool>(
"dont_create_bcs"))
158 else if (
_current_task ==
"add_nodal_bc" && !getParam<bool>(
"dont_create_bcs"))
161 !getParam<bool>(
"dont_create_bcs"))
163 else if (
_current_task ==
"add_periodic_bc" && !getParam<bool>(
"dont_create_bcs"))
167 else if (
_current_task ==
"add_function" && !getParam<bool>(
"dont_create_functions"))
169 else if (
_current_task ==
"add_aux_variable" && !getParam<bool>(
"dont_create_aux_variables"))
171 else if (
_current_task ==
"add_aux_kernel" && !getParam<bool>(
"dont_create_aux_kernels"))
173 else if (
_current_task ==
"add_material" && !getParam<bool>(
"dont_create_materials"))
175 else if (
_current_task ==
"add_functor_material" && !getParam<bool>(
"dont_create_materials"))
185 else if (
_current_task ==
"add_user_object" && !getParam<bool>(
"dont_create_user_objects"))
187 else if (
_current_task ==
"add_corrector" && !getParam<bool>(
"dont_create_correctors"))
189 else if (
_current_task ==
"add_postprocessor" && !getParam<bool>(
"dont_create_postprocessors"))
192 !getParam<bool>(
"dont_create_vectorpostprocessors"))
225 if (getParam<bool>(
"initialize_variables_from_mesh_file"))
229 "initial_from_file_timestep");
235 mooseAssert(
_problem,
"We don't have a problem yet");
247 mooseAssert(
_mesh,
"We dont have a mesh yet");
248 mooseAssert(
_dim < 4,
"Dimension has not been set yet");
252 std::set<SubdomainID>
255 const bool not_block_restricted =
258 mooseAssert(
_mesh,
"Should have a mesh");
262 std::set<SubdomainID> block_ids_set =
263 not_block_restricted ?
_mesh->meshSubdomains() :
_mesh->getSubdomainIDs(
blocks);
264 return block_ids_set;
267 std::vector<std::string>
270 mooseAssert(
_mesh,
"Should have a mesh");
271 std::vector<std::string> sub_names_ids;
272 sub_names_ids.reserve(
blocks.size());
273 for (
const auto bid :
blocks)
275 const auto bname =
_mesh->getSubdomainName(bid);
276 sub_names_ids.push_back((bname.empty() ?
"(unnamed)" : bname) +
" (" + std::to_string(bid) +
279 return sub_names_ids;
295 if (block_ids.size())
297 for (
const auto bid : block_ids)
306 for (
const auto & block : component.
blocks())
331 "Empty block restriction is not supported. Comment out the Physics if you are " 332 "trying to disable it.");
336 _blocks.push_back(
"ANY_BLOCK_ID");
338 mooseAssert(
_mesh,
"We should have a mesh to find the dimension");
358 if (std::find(problem_nl_systems.begin(), problem_nl_systems.end(), sys_name) ==
359 problem_nl_systems.end() &&
360 std::find(problem_lin_systems.begin(), problem_lin_systems.end(), sys_name) ==
361 problem_lin_systems.end() &&
363 mooseError(
"System '", sys_name,
"' is not found in the Problem");
374 paramError(
"transient",
"We cannot solve a physics as transient in a steady problem");
379 "There should be one system name per solver variable (potentially repeated), or a " 380 "single system name for all variables. Current you have '" +
381 std::to_string(
_system_names.size()) +
"' systems specified for '" +
385 unsigned int var_i = 0;
389 if (!
_problem->getSolverSystem(
_problem->solverSysNum(sys_name)).hasVariable(var_name) &&
390 !
_problem->getSolverSystem(
_problem->solverSysNum(sys_name)).hasScalarVariable(var_name))
392 "We expected system '" + sys_name +
"' to contain variable '" + var_name +
393 "' but it did not. Make sure the system names closely match the ordering of " 394 "the variables in the Physics.");
402 if (getParam<bool>(
"initialize_variables_from_mesh_file"))
404 mooseInfoRepeated(
"Adding Exodus restart for " + std::to_string(variables_to_copy.size()) +
407 for (
const auto i :
index_range(variables_to_copy))
413 const auto & var_name = variables_to_copy[i];
415 var_name, var_name, getParam<std::string>(
"initial_from_file_timestep"));
423 if (error_if_aux &&
_problem->getAuxiliarySystem().hasVariable(var_name))
426 "' is supposed to be nonlinear for physics '",
428 "' but it is already defined as auxiliary");
430 return _problem->hasVariable(var_name);
436 return _problem->hasSolverVariable(var_name);
439 const SolverSystemName &
442 mooseAssert(!
_system_names.empty(),
"We should have a solver system name");
451 const SolverSystemName &
454 mooseAssert(!
_system_names.empty(),
"We should have a solver system name");
464 mooseError(
"Variable '", var_name,
"' was not found within the Physics solver variables.");
474 if (!registered_tasks.count(required_task))
476 "' has been declared as required by a Physics parent class of derived class '" +
478 "' but this task is not registered to the derived class. Registered tasks for " 479 "this Physics are: " +
490 params.
set<std::vector<SubdomainName>>(
"block") =
blocks;
492 mooseInfoRepeated(
"Empty block restriction assigned to an object created by Physics '" +
493 name() +
"'.\n Did you mean to do this?");
498 const std::vector<SubdomainName> &
blocks,
499 bool error_if_not_identical)
const 513 auto copy_blocks_other =
blocks;
514 std::sort(copy_blocks.begin(), copy_blocks.end());
515 copy_blocks.erase(unique(copy_blocks.begin(), copy_blocks.end()), copy_blocks.end());
516 std::sort(copy_blocks_other.begin(), copy_blocks_other.end());
517 copy_blocks_other.erase(unique(copy_blocks_other.begin(), copy_blocks_other.end()),
518 copy_blocks_other.end());
520 if (copy_blocks == copy_blocks_other)
522 std::vector<SubdomainName> diff;
523 std::set_difference(copy_blocks.begin(),
525 copy_blocks_other.begin(),
526 copy_blocks_other.end(),
527 std::inserter(diff, diff.begin()));
528 if (error_if_not_identical)
533 "' have different block restrictions.\nPhysics: ",
546 mooseAssert(
_mesh,
"The mesh should exist already");
550 else if (
blocks.size() !=
_mesh->meshSubdomains().size())
553 for (
const auto mesh_block :
_mesh->meshSubdomains())
555 const auto & subdomain_name =
_mesh->getSubdomainName(mesh_block);
557 if (!subdomain_name.empty() &&
561 else if (std::find(
blocks.begin(),
blocks.end(), std::to_string(mesh_block)) ==
blocks.end())
570 std::vector<SubdomainName> blocks_vec(
blocks.begin(),
blocks.end());
576 const std::vector<std::pair<MooseEnumItem, std::string>> & petsc_pair_options)
583 _problem->getSolverSystem(solver_sys_num).prefix(),
591 const auto var = &
_problem->getVariable(0, var_name);
598 return _problem->hasScalarVariable(var_name);
603 const std::vector<SubdomainName> &
blocks,
604 const bool error_if_aux)
609 auto & var =
_problem->getVariable(0, var_name);
610 const bool not_block_restricted =
613 if (!var.blockRestricted() || (!not_block_restricted && var.hasBlocks(
blocks)))
620 mooseError(
"Variable '" + var_name +
"' already exists with subdomain restriction '" +
621 Moose::stringify(var.blocks()) +
"' which does not include the subdomains '" +
627 const std::vector<SubdomainName> &
blocks,
628 const bool ic_is_default_ic,
629 const bool error_if_already_defined)
const 635 if (getParam<bool>(
"initialize_variables_from_mesh_file"))
638 mooseAssert(!
isVariableScalar(var_name),
"shouldCreateIC not implemented for scalar variables");
641 std::set<SubdomainName> blocks_set(
blocks.begin(),
blocks.end());
645 std::set<SubdomainID> blocks_ids_covered;
648 has_all_blocks =
_problem->getFVInitialConditionWarehouse().hasObjectsForVariableAndBlocks(
649 var_name, blocks_ids_set, blocks_ids_covered, 0);
651 has_all_blocks =
_problem->getInitialConditionWarehouse().hasObjectsForVariableAndBlocks(
652 var_name, blocks_ids_set, blocks_ids_covered, 0);
654 const bool has_some_blocks = !blocks_ids_covered.empty();
655 if (!has_some_blocks)
660 if (error_if_already_defined)
661 mooseError(
"ICs for variable '" + var_name +
"' have already been defined for blocks '" +
668 mooseError(
"There is a partial overlap between the subdomains covered by pre-existing initial " 669 "conditions (ICs), defined on blocks (ids): " +
671 "\n and a newly created IC for variable " + var_name +
673 ".\nWe should be creating the Physics' IC only for non-covered blocks. This is not " 674 "implemented at this time.");
679 const std::vector<SubdomainName> &
blocks,
680 const bool error_if_already_defined)
const 690 "shouldCreateTimeDerivative not implemented for scalar variables");
691 mooseAssert(!
_problem->hasAuxiliaryVariable(var_name),
692 "Should not be called with auxiliary variables");
695 const auto var = &
_problem->getVariable(0, var_name);
696 const auto var_id = var->number();
697 const auto sys_num = var->sys().number();
698 const auto time_vector_tag =
699 (sys_num <
_problem->numNonlinearSystems())
700 ? var->sys().timeVectorTag()
702 :
dynamic_cast<LinearSystem *
>(&var->sys())->rightHandSideTimeVectorTag();
705 bool all_blocks_covered =
true;
706 std::set<SubdomainID> blocks_ids_covered;
709 for (
const auto & block :
blocks)
711 std::vector<MooseObject *> time_kernels;
712 if (block !=
"ANY_BLOCK_ID")
714 const auto bid =
_mesh->getSubdomainID(block);
717 .template condition<AttribSysNum>(sys_num)
718 .
template condition<AttribVar>(var_id)
719 .template condition<AttribSubdomains>(bid)
721 .
template condition<AttribVectorTags>(time_vector_tag)
722 .queryInto(time_kernels);
727 .template condition<AttribSysNum>(sys_num)
728 .
template condition<AttribVar>(var_id)
730 .template condition<AttribVectorTags>(time_vector_tag)
731 .queryInto(time_kernels);
733 if (time_kernels.size())
735 if (block ==
"ANY_BLOCK_ID")
737 for (
const auto & time_kernel : time_kernels)
738 if (
const auto blk = dynamic_cast<BlockRestrictable *>(time_kernel))
739 blocks_ids_covered.insert(blk->blockIDs().begin(), blk->blockIDs().end());
742 blocks_ids_covered.insert(
_mesh->getSubdomainID(block));
745 all_blocks_covered =
false;
749 if (all_blocks_covered)
751 std::set<SubdomainName> blocks_set(
blocks.begin(),
blocks.end());
753 if (blocks_ids != blocks_ids_covered)
754 all_blocks_covered =
false;
756 const bool has_some_blocks = !blocks_ids_covered.empty();
757 if (!has_some_blocks)
759 if (all_blocks_covered)
761 if (error_if_already_defined)
762 mooseError(
"A time kernel for variable '" + var_name +
769 mooseError(
"There is a partial overlap between the subdomains covered by pre-existing time " 770 "derivative kernel(s), defined on blocks (ids): " +
772 "\nand a newly created time derivative kernel for variable " + var_name +
774 ".\nWe should be creating the Physics' time derivative only for non-covered " 775 "blocks. This is not implemented at this time.");
780 const std::string & object_type)
const 782 std::vector<std::string> defaults_unused;
783 std::vector<std::string> user_values_unused;
784 for (
const auto & param : param_names)
787 user_values_unused.push_back(param);
789 defaults_unused.push_back(param);
791 if (defaults_unused.size() &&
_verbose)
793 "' for object of type '" + object_type +
794 "' were not used because the object was not created by this Physics.");
795 if (user_values_unused.size())
799 "User-specifed values for parameters '" +
Moose::stringify(user_values_unused) +
800 "' for object of type '" + object_type +
801 "' were not used because the corresponding object was not created by this Physics.");
804 "User-specified values for parameters '" +
Moose::stringify(user_values_unused) +
805 "' for object of type '" + object_type +
806 "' were not used because the corresponding object was not created by this Physics.");
const T & getAction(const std::string &name) const
Retrieve an action with its name and the desired type.
const std::vector< VariableName > & auxVariableNames() const
Return the list of aux variables in this physics.
const std::vector< NonlinearSystemName > & getNonlinearSystemNames() const
virtual void act() override final
Forwards from the action tasks to the implemented addXYZ() in the derived classes If you need more th...
virtual InputParameters getAdditionalRMParams() const
Provide additional parameters for the relationship managers.
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.
virtual void addInitialConditions()
bool shouldCreateVariable(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_aux)
Returns whether this Physics should create the variable.
std::vector< VariableName > _aux_var_names
Vector of the aux variables in the Physics.
virtual void addFVInterfaceKernels()
virtual void addPreconditioning()
MooseEnum _is_transient
Whether the physics is to be solved as a transient.
RelationshipManagerType
Main types of Relationship Managers.
ActionWarehouse & _awh
Reference to ActionWarehouse where we store object build by actions.
void initializePhysics()
Process some parameters that require the problem to be created. Executed on init_physics.
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.
virtual void checkIntegrity() const
Additional checks performed near the end of the setup phase.
Base class to help creating an entire physics.
virtual void checkIntegrityEarly() const
Additional checks performed once the executioner / executor has been created.
std::set< std::string > getTasksByAction(const std::string &action) const
virtual void addMultiApps()
virtual void addAuxiliaryKernels()
A struct for storing the various types of petsc options and values.
virtual void addPeriodicBCs()
const std::vector< SubdomainName > & blocks() const
Return the blocks this physics is defined on.
void mooseInfoRepeated(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
virtual void addVariableToCopy(const std::string &dest_name, const std::string &source_name, const std::string ×tep)
Add info about variable that will be copied.
bool solverVariableExists(const VariableName &var_name) const
Check whether a variable already exists and is a solver variable.
const bool _verbose
Whether to output additional information.
Base class for components that are defined using an action.
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.
bool shouldCreateTimeDerivative(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_already_defined) const
Returns whether this Physics should create the variable.
Base class for a system (of equations)
bool isRestarting() const
Whether or not this is a "restart" calculation.
bool allMeshBlocks(const std::vector< SubdomainName > &blocks) const
Check if a vector contains all the mesh blocks.
virtual const std::string & name() const
Get the name of the class.
std::vector< SubdomainName > _blocks
Keep track of the subdomains the Physics is defined on.
unsigned int dimension() const
Return the maximum dimension of the blocks the Physics is active on.
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
void addBlocks(const std::vector< SubdomainName > &blocks)
Add new blocks to the Physics.
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
virtual FEProblemBase & getProblem()
Get the problem for this physics Useful to add objects to the simulation.
static InputParameters validParams()
virtual void addNodalBCs()
const SolverSystemName & getSolverSystem(unsigned int variable_index) const
Get the solver system for this variable index.
virtual void addNodalKernels()
virtual void addDGKernels()
bool unusedFlagIsError() const
Returns whether the flag for unused parameters is set to throw an error.
virtual void addMaterials()
std::set< std::string > _required_tasks
Manually keeps track of the tasks required by each physics as tasks cannot be inherited.
void setExodusFileRestart(bool flag)
Set the flag to indicate whether or not we need to use a separate Exodus reader to read the mesh BEFO...
bool isVariableScalar(const VariableName &var_name) const
Whether the variable is a scalar variable (global single scalar, not a field)
PhysicsBase(const InputParameters ¶meters)
void copyVariablesFromMesh(const std::vector< VariableName > &variables_to_copy, bool are_nonlinear=true)
Copy nonlinear or aux variables from the mesh file.
unsigned int _dim
Dimension of the physics, which we expect for now to be the dimension of the mesh NOTE: this is not k...
virtual void addReporters()
bool isVariableFV(const VariableName &var_name) const
Whether the variable is a finite volume variable.
std::vector< std::string > getSubdomainNamesAndIDs(const std::set< SubdomainID > &blocks) const
Get the vector of subdomain names and ids for the incoming set of subdomain IDs.
const std::string & type() const
Get the type of this class.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
const std::string & _current_task
The current action (even though we have separate instances for each action)
virtual const SystemBase & systemBaseAuxiliary() const override
Return the auxiliary system object as a base class reference.
virtual void addPostprocessors()
virtual void addFunctions()
MooseApp & _app
The MOOSE application this is associated with.
void paramError(const std::string ¶m, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
ActionFactory & _action_factory
Builds Actions.
std::string stringify(const T &t)
conversion to string
virtual void addSolverVariables()
The default implementation of these routines will do nothing as we do not expect all Physics to be de...
virtual void addExecutioner()
const std::vector< LinearSystemName > & getLinearSystemNames() const
const std::vector< VariableName > & solverVariableNames() const
Return the list of solver (nonlinear + linear) variables in this physics.
bool variableExists(const VariableName &var_name, bool error_if_aux) const
Check whether a variable already exists.
bool checkBlockRestrictionIdentical(const std::string &object_name, const std::vector< SubdomainName > &blocks, const bool error_if_not_identical=true) const
Check if an external object has the same block restriction.
virtual void addFVKernels()
static InputParameters validParams()
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
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.
std::shared_ptr< MooseMesh > & _mesh
std::vector< VariableName > _solver_var_names
Vector of the solver variables (nonlinear and linear) in the Physics.
std::set< SubdomainID > getSubdomainIDs(const std::set< SubdomainName > &blocks) const
Get the set of subdomain ids for the incoming vector of subdomain names.
virtual void addComponent(const ActionComponent &component)
Most basic way of adding a component: simply adding the blocks to the block restriction of the Physic...
virtual void addFEKernels()
virtual void addUserObjects()
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override
Method to add a relationship manager for the objects being added to the system.
void addPetscPairsToPetscOptions(const std::vector< std::pair< MooseEnumItem, std::string >> &petsc_pair_options, const unsigned int mesh_dimension, const std::string &prefix, const ParallelParamObject ¶m_object, PetscOptions &petsc_options)
Populate name and value pairs in a given PetscOptions object using vectors of input arguments...
bool unusedFlagIsWarning() const
Returns whether the flag for unused parameters is set to throw a warning only.
virtual void actOnAdditionalTasks()
Routine to add additional setup work on additional registered tasks to a Physics. ...
void addBlocksById(const std::vector< SubdomainID > &block_ids)
void prepareCopyVariablesFromMesh() const
Tell the app if we want to use Exodus restart.
const std::vector< SubdomainName > & blocks() const
Returns the subdomains for the component mesh, if any.
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
virtual void addOutputs()
bool addRelationshipManagers(Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
Method to add a relationship manager for the objects being added to the system.
std::shared_ptr< FEProblemBase > & _problem
Convenience reference to a problem this action works on.
Linear system to be solved.
virtual void addDiracKernels()
virtual void addVectorPostprocessors()
virtual void addExecutors()
void reportPotentiallyMissedParameters(const std::vector< std::string > ¶m_names, const std::string &object_type) const
When this is called, we are knowingly not using the value of these parameters.
virtual bool isTransient() const override
virtual void addInterfaceKernels()
virtual void addFunctorMaterials()
const ActionComponent & getActionComponent(const ComponentName &comp_name) const
Get a component with the requested name.
std::vector< unsigned int > _system_numbers
System numbers for the system(s) owning the solver variables.
virtual void addTransfers()
bool isRecovering() const
Whether or not this is a "recover" calculation.
virtual void addCorrectors()
void setVerboseProblem(bool verbose)
Make the problem be verbose.
auto index_range(const T &sizable)
std::vector< SolverSystemName > _system_names
System names for the system(s) owning the solver variables.
bool isTransient() const
Return whether the Physics is solved using a transient.
virtual void addAuxiliaryVariables()
virtual void initializePhysicsAdditional()
Additional initialization work that should happen very early, as soon as the problem is created...
virtual void addScalarKernels()
void checkRequiredTasks() const
Check the list of required tasks for missing tasks.