https://mooseframework.inl.gov
PhysicsBase.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #include "Action.h"
13 #include "ActionWarehouse.h"
15 #include "ActionComponent.h"
16 
17 // We include these headers for all the derived classes that will be building objects
18 #include "FEProblemBase.h"
19 #include "Factory.h"
20 #include "MultiMooseEnum.h"
21 
22 #define registerPhysicsBaseTasks(app_name, derived_name) \
23  registerMooseAction(app_name, derived_name, "init_physics"); \
24  registerMooseAction(app_name, derived_name, "copy_vars_physics"); \
25  registerMooseAction(app_name, derived_name, "check_integrity_early_physics")
26 
30 class PhysicsBase : public Action, public InputParametersChecksUtils<PhysicsBase>
31 {
32 public:
34 
36 
39 
40  // Responding to tasks //
46  virtual void act() override final;
47 
49  virtual void actOnAdditionalTasks() {}
50 
51  // Block restriction //
56  void addBlocks(const std::vector<SubdomainName> & blocks);
57  void addBlocksById(const std::vector<SubdomainID> & block_ids);
58 
60  const std::vector<SubdomainName> & blocks() const { return _blocks; }
61 
68  bool checkBlockRestrictionIdentical(const std::string & object_name,
69  const std::vector<SubdomainName> & blocks,
70  const bool error_if_not_identical = true) const;
71 
72  // Coupling with Physics //
78  template <typename T>
79  const T * getCoupledPhysics(const PhysicsName & phys_name, const bool allow_fail = false) const;
81  template <typename T>
82  const std::vector<T *> getCoupledPhysics(const bool allow_fail = false) const;
83 
85  unsigned int dimension() const;
86 
87  // Coupling with Components //
89  const ActionComponent & getActionComponent(const ComponentName & comp_name) const;
91  template <typename T>
92  void checkComponentType(const ActionComponent & component) const;
95  virtual void addComponent(const ActionComponent & component);
96 
98  const std::vector<VariableName> & solverVariableNames() const { return _solver_var_names; };
100  const std::vector<VariableName> & auxVariableNames() const { return _aux_var_names; };
101 
102 protected:
104  bool isTransient() const;
105 
108  Factory & getFactory() { return _factory; }
109  Factory & getFactory() const { return _factory; }
113  {
114  mooseAssert(_problem, "Requesting the problem too early");
115  return *_problem;
116  }
117  virtual const FEProblemBase & getProblem() const
118  {
119  mooseAssert(_problem, "Requesting the problem too early");
120  return *_problem;
121  }
122 
124  void prepareCopyVariablesFromMesh() const;
131  void copyVariablesFromMesh(const std::vector<VariableName> & variables_to_copy,
132  bool are_nonlinear = true);
133 
135  std::string prefix() const { return name() + "_"; }
136 
138  void saveSolverVariableName(const VariableName & var_name)
139  {
140  _solver_var_names.push_back(var_name);
141  }
143  void saveAuxVariableName(const VariableName & var_name) { _aux_var_names.push_back(var_name); }
144 
146  bool variableExists(const VariableName & var_name, bool error_if_aux) const;
148  bool solverVariableExists(const VariableName & var_name) const;
149 
152  const SolverSystemName & getSolverSystem(unsigned int variable_index) const;
154  const SolverSystemName & getSolverSystem(const VariableName & variable_name) const;
155 
158  void addRequiredPhysicsTask(const std::string & task) { _required_tasks.insert(task); }
159 
165  void assignBlocks(InputParameters & params, const std::vector<SubdomainName> & blocks) const;
170  bool allMeshBlocks(const std::vector<SubdomainName> & blocks) const;
171  bool allMeshBlocks(const std::set<SubdomainName> & blocks) const;
172  // These APIs can deal with ANY_BLOCK_ID or ids with no names. They will be slower than the
173  // MooseMeshUtils' APIs, but are more convenient for setup purposes
175  std::set<SubdomainID> getSubdomainIDs(const std::set<SubdomainName> & blocks) const;
177  std::vector<std::string> getSubdomainNamesAndIDs(const std::set<SubdomainID> & blocks) const;
178 
183  const std::vector<std::pair<MooseEnumItem, std::string>> & petsc_pair_options);
184 
185  // Helpers to check on variable types
187  bool isVariableFV(const VariableName & var_name) const;
189  bool isVariableScalar(const VariableName & var_name) const;
190 
191  // Routines to help with deciding when to create objects
199  bool shouldCreateVariable(const VariableName & var_name,
200  const std::vector<SubdomainName> & blocks,
201  const bool error_if_aux);
202 
216  bool shouldCreateIC(const VariableName & var_name,
217  const std::vector<SubdomainName> & blocks,
218  const bool ic_is_default_ic,
219  const bool error_if_already_defined) const;
220 
231  bool shouldCreateTimeDerivative(const VariableName & var_name,
232  const std::vector<SubdomainName> & blocks,
233  const bool error_if_already_defined) const;
234 
235  // Other conceivable "shouldCreate" routines for things that are unique to a variable
236  // - shouldCreateTimeIntegrator
237  // - shouldCreatePredictor/Corrector
238 
244  void reportPotentiallyMissedParameters(const std::vector<std::string> & param_names,
245  const std::string & object_type) const;
246 
248  std::vector<SolverSystemName> _system_names;
249 
251  std::vector<unsigned int> _system_numbers;
252 
254  const bool _verbose;
255 
259 
261  std::vector<SubdomainName> _blocks;
262 
263 private:
267  virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override;
268 
270  void initializePhysics();
272  virtual void initializePhysicsAdditional() {}
274  virtual void checkIntegrityEarly() const;
276  virtual void checkIntegrity() const {}
277 
280  virtual void addSolverVariables() {}
281  virtual void addAuxiliaryVariables() {}
282  virtual void addInitialConditions() {}
283  virtual void addFEKernels() {}
284  virtual void addFVKernels() {}
285  virtual void addNodalKernels() {}
286  virtual void addDiracKernels() {}
287  virtual void addDGKernels() {}
288  virtual void addScalarKernels() {}
289  virtual void addInterfaceKernels() {}
290  virtual void addFVInterfaceKernels() {}
291  virtual void addFEBCs() {}
292  virtual void addFVBCs() {}
293  virtual void addNodalBCs() {}
294  virtual void addPeriodicBCs() {}
295  virtual void addFunctions() {}
296  virtual void addAuxiliaryKernels() {}
297  virtual void addMaterials() {}
298  virtual void addFunctorMaterials() {}
299  virtual void addUserObjects() {}
300  virtual void addCorrectors() {}
301  virtual void addMultiApps() {}
302  virtual void addTransfers() {}
303  virtual void addPostprocessors() {}
304  virtual void addVectorPostprocessors() {}
305  virtual void addReporters() {}
306  virtual void addOutputs() {}
307  virtual void addPreconditioning() {}
308  virtual void addExecutioner() {}
309  virtual void addExecutors() {}
310 
312  void checkRequiredTasks() const;
313 
317 
319  std::vector<VariableName> _solver_var_names;
321  std::vector<VariableName> _aux_var_names;
322 
325  unsigned int _dim = libMesh::invalid_uint;
326 
328  std::set<std::string> _required_tasks;
329 };
330 
331 template <typename T>
332 const T *
333 PhysicsBase::getCoupledPhysics(const PhysicsName & phys_name, const bool allow_fail) const
334 {
335  constexpr bool is_physics = std::is_base_of<PhysicsBase, T>::value;
336  libmesh_ignore(is_physics);
337  mooseAssert(is_physics, "Must be a PhysicsBase to be retrieved by getCoupledPhysics");
338  const auto all_T_physics = _awh.getActions<T>();
339  for (const auto * const physics : all_T_physics)
340  {
341  if (physics->name() == phys_name)
342  return physics;
343  }
344  if (!allow_fail)
345  mooseError("Requested Physics '",
346  phys_name,
347  "' does not exist or is not of type '",
348  MooseUtils::prettyCppType<T>(),
349  "'");
350  else
351  return nullptr;
352 }
353 
354 template <typename T>
355 const std::vector<T *>
356 PhysicsBase::getCoupledPhysics(const bool allow_fail) const
357 {
358  constexpr bool is_physics = std::is_base_of<PhysicsBase, T>::value;
359  libmesh_ignore(is_physics);
360  mooseAssert(is_physics, "Must be a PhysicsBase to be retrieved by getCoupledPhysics");
361  const auto all_T_physics = _awh.getActions<T>();
362  if (!allow_fail && all_T_physics.empty())
363  mooseError("No Physics of requested type '", MooseUtils::prettyCppType<T>(), "'");
364  else
365  return all_T_physics;
366 }
367 
368 template <typename T>
369 void
371 {
372  if (!dynamic_cast<const T *>(&component))
373  mooseError("Component '" + component.name() + "' must be of type '" +
374  MooseUtils::prettyCppType<T>() + "'.\nIt is currently of type '" + component.type() +
375  "'");
376 }
std::string prefix() const
Use prefix() to disambiguate names.
Definition: PhysicsBase.h:135
const std::vector< VariableName > & auxVariableNames() const
Return the list of aux variables in this physics.
Definition: PhysicsBase.h:100
virtual void act() override final
Forwards from the action tasks to the implemented addXYZ() in the derived classes If you need more th...
Definition: PhysicsBase.C:121
virtual InputParameters getAdditionalRMParams() const
Provide additional parameters for the relationship managers.
Definition: PhysicsBase.h:38
virtual void addInitialConditions()
Definition: PhysicsBase.h:282
void assignBlocks(InputParameters &params, const std::vector< SubdomainName > &blocks) const
Set the blocks parameter to the input parameters of an object this Physics will create.
Definition: PhysicsBase.C:484
bool shouldCreateVariable(const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_aux)
Returns whether this Physics should create the variable.
Definition: PhysicsBase.C:602
std::vector< VariableName > _aux_var_names
Vector of the aux variables in the Physics.
Definition: PhysicsBase.h:321
Factory & getFactory()
Get the factory for this physics The factory lets you get the parameters for objects.
Definition: PhysicsBase.h:108
virtual void addFVInterfaceKernels()
Definition: PhysicsBase.h:290
virtual void addPreconditioning()
Definition: PhysicsBase.h:307
MooseEnum _is_transient
Whether the physics is to be solved as a transient.
Definition: PhysicsBase.h:316
const unsigned int invalid_uint
RelationshipManagerType
Main types of Relationship Managers.
Definition: MooseTypes.h:963
ActionWarehouse & _awh
Reference to ActionWarehouse where we store object build by actions.
Definition: Action.h:159
void initializePhysics()
Process some parameters that require the problem to be created. Executed on init_physics.
Definition: PhysicsBase.C:324
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...
Definition: PhysicsBase.h:158
void addPetscPairsToPetscOptions(const std::vector< std::pair< MooseEnumItem, std::string >> &petsc_pair_options)
Process the given petsc option pairs into the system solver settings.
Definition: PhysicsBase.C:575
Generic factory class for build all sorts of objects.
Definition: Factory.h:28
virtual void checkIntegrity() const
Additional checks performed near the end of the setup phase.
Definition: PhysicsBase.h:276
virtual const FEProblemBase & getProblem() const
Definition: PhysicsBase.h:117
Base class to help creating an entire physics.
Definition: PhysicsBase.h:30
virtual void checkIntegrityEarly() const
Additional checks performed once the executioner / executor has been created.
Definition: PhysicsBase.C:371
virtual void addMultiApps()
Definition: PhysicsBase.h:301
virtual void addAuxiliaryKernels()
Definition: PhysicsBase.h:296
const T * getCoupledPhysics(const PhysicsName &phys_name, const bool allow_fail=false) const
Get a Physics from the ActionWarehouse with the requested type and name.
Definition: PhysicsBase.h:333
virtual void addPeriodicBCs()
Definition: PhysicsBase.h:294
const std::vector< SubdomainName > & blocks() const
Return the blocks this physics is defined on.
Definition: PhysicsBase.h:60
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const MooseEnum & _preconditioning
Whether to add a default preconditioning.
Definition: PhysicsBase.h:258
bool solverVariableExists(const VariableName &var_name) const
Check whether a variable already exists and is a solver variable.
Definition: PhysicsBase.C:434
const bool _verbose
Whether to output additional information.
Definition: PhysicsBase.h:254
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.
Definition: PhysicsBase.C:626
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.
Definition: PhysicsBase.C:678
bool allMeshBlocks(const std::vector< SubdomainName > &blocks) const
Check if a vector contains all the mesh blocks.
Definition: PhysicsBase.C:544
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
std::vector< SubdomainName > _blocks
Keep track of the subdomains the Physics is defined on.
Definition: PhysicsBase.h:261
Base class for actions.
Definition: Action.h:33
unsigned int dimension() const
Return the maximum dimension of the blocks the Physics is active on.
Definition: PhysicsBase.C:245
InputParameters emptyInputParameters()
void checkComponentType(const ActionComponent &component) const
Check that the component is of the desired type.
Definition: PhysicsBase.h:370
virtual void addFVBCs()
Definition: PhysicsBase.h:292
void addBlocks(const std::vector< SubdomainName > &blocks)
Add new blocks to the Physics.
Definition: PhysicsBase.C:283
Factory & _factory
The Factory associated with the MooseApp.
Utility class to help check parameters.
void saveAuxVariableName(const VariableName &var_name)
Keep track of the name of an aux variable defined in the Physics.
Definition: PhysicsBase.h:143
virtual FEProblemBase & getProblem()
Get the problem for this physics Useful to add objects to the simulation.
Definition: PhysicsBase.h:112
void libmesh_ignore(const Args &...)
virtual void addNodalBCs()
Definition: PhysicsBase.h:293
const SolverSystemName & getSolverSystem(unsigned int variable_index) const
Get the solver system for this variable index.
Definition: PhysicsBase.C:440
virtual void addNodalKernels()
Definition: PhysicsBase.h:285
virtual void addDGKernels()
Definition: PhysicsBase.h:287
virtual void addMaterials()
Definition: PhysicsBase.h:297
std::set< std::string > _required_tasks
Manually keeps track of the tasks required by each physics as tasks cannot be inherited.
Definition: PhysicsBase.h:328
bool isVariableScalar(const VariableName &var_name) const
Whether the variable is a scalar variable (global single scalar, not a field)
Definition: PhysicsBase.C:596
PhysicsBase(const InputParameters &parameters)
Definition: PhysicsBase.C:103
void copyVariablesFromMesh(const std::vector< VariableName > &variables_to_copy, bool are_nonlinear=true)
Copy nonlinear or aux variables from the mesh file.
Definition: PhysicsBase.C:399
unsigned int _dim
Dimension of the physics, which we expect for now to be the dimension of the mesh NOTE: this is not k...
Definition: PhysicsBase.h:325
virtual void addReporters()
Definition: PhysicsBase.h:305
bool isVariableFV(const VariableName &var_name) const
Whether the variable is a finite volume variable.
Definition: PhysicsBase.C:589
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.
Definition: PhysicsBase.C:268
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
virtual void addPostprocessors()
Definition: PhysicsBase.h:303
Factory & getFactory() const
Definition: PhysicsBase.h:109
virtual void addFunctions()
Definition: PhysicsBase.h:295
virtual void addFEBCs()
Definition: PhysicsBase.h:291
virtual void addSolverVariables()
The default implementation of these routines will do nothing as we do not expect all Physics to be de...
Definition: PhysicsBase.h:280
virtual void addExecutioner()
Definition: PhysicsBase.h:308
const std::vector< VariableName > & solverVariableNames() const
Return the list of solver (nonlinear + linear) variables in this physics.
Definition: PhysicsBase.h:98
bool variableExists(const VariableName &var_name, bool error_if_aux) const
Check whether a variable already exists.
Definition: PhysicsBase.C:421
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.
Definition: PhysicsBase.C:497
virtual void addFVKernels()
Definition: PhysicsBase.h:284
static InputParameters validParams()
Definition: PhysicsBase.C:24
std::vector< VariableName > _solver_var_names
Vector of the solver variables (nonlinear and linear) in the Physics.
Definition: PhysicsBase.h:319
std::set< SubdomainID > getSubdomainIDs(const std::set< SubdomainName > &blocks) const
Get the set of subdomain ids for the incoming vector of subdomain names.
Definition: PhysicsBase.C:253
virtual void addComponent(const ActionComponent &component)
Most basic way of adding a component: simply adding the blocks to the block restriction of the Physic...
Definition: PhysicsBase.C:304
virtual void addFEKernels()
Definition: PhysicsBase.h:283
virtual void addUserObjects()
Definition: PhysicsBase.h:299
virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override
Method to add a relationship manager for the objects being added to the system.
Definition: PhysicsBase.C:311
virtual void actOnAdditionalTasks()
Routine to add additional setup work on additional registered tasks to a Physics. ...
Definition: PhysicsBase.h:49
void addBlocksById(const std::vector< SubdomainID > &block_ids)
Definition: PhysicsBase.C:293
void prepareCopyVariablesFromMesh() const
Tell the app if we want to use Exodus restart.
Definition: PhysicsBase.C:223
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
virtual void addOutputs()
Definition: PhysicsBase.h:306
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.
Definition: Action.C:136
std::shared_ptr< FEProblemBase > & _problem
Convenience reference to a problem this action works on.
Definition: Action.h:168
const InputParameters & parameters() const
Get the parameters of the object.
virtual void addDiracKernels()
Definition: PhysicsBase.h:286
virtual void addVectorPostprocessors()
Definition: PhysicsBase.h:304
virtual void addExecutors()
Definition: PhysicsBase.h:309
void reportPotentiallyMissedParameters(const std::vector< std::string > &param_names, const std::string &object_type) const
When this is called, we are knowingly not using the value of these parameters.
Definition: PhysicsBase.C:779
virtual void addInterfaceKernels()
Definition: PhysicsBase.h:289
virtual void addFunctorMaterials()
Definition: PhysicsBase.h:298
const ActionComponent & getActionComponent(const ComponentName &comp_name) const
Get a component with the requested name.
Definition: PhysicsBase.C:318
std::vector< const T * > getActions()
Retrieve all actions in a specific type ordered by their names.
std::vector< unsigned int > _system_numbers
System numbers for the system(s) owning the solver variables.
Definition: PhysicsBase.h:251
virtual void addTransfers()
Definition: PhysicsBase.h:302
virtual void addCorrectors()
Definition: PhysicsBase.h:300
void saveSolverVariableName(const VariableName &var_name)
Keep track of the name of the solver variable defined in the Physics.
Definition: PhysicsBase.h:138
std::vector< SolverSystemName > _system_names
System names for the system(s) owning the solver variables.
Definition: PhysicsBase.h:248
bool isTransient() const
Return whether the Physics is solved using a transient.
Definition: PhysicsBase.C:233
virtual void addAuxiliaryVariables()
Definition: PhysicsBase.h:281
virtual void initializePhysicsAdditional()
Additional initialization work that should happen very early, as soon as the problem is created...
Definition: PhysicsBase.h:272
virtual void addScalarKernels()
Definition: PhysicsBase.h:288
void checkRequiredTasks() const
Check the list of required tasks for missing tasks.
Definition: PhysicsBase.C:468