PhysicsBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Action.h"
#include "ActionWarehouse.h"
#include "InputParametersChecksUtils.h"
#include "ActionComponent.h"

// We include these headers for all the derived classes that will be building objects
#include "FEProblemBase.h"
#include "Factory.h"
#include "MultiMooseEnum.h"

#define registerPhysicsBaseTasks(app_name, derived_name)                                           \
  registerMooseAction(app_name, derived_name, "init_physics");                                     \
  registerMooseAction(app_name, derived_name, "copy_vars_physics");                                \
  registerMooseAction(app_name, derived_name, "check_integrity_early_physics")

class PhysicsBase : public Action, public InputParametersChecksUtils<PhysicsBase>
{
public:
  static InputParameters validParams();

  PhysicsBase(const InputParameters & parameters);

  virtual InputParameters getAdditionalRMParams() const { return emptyInputParameters(); };

  // Responding to tasks //
  virtual void act() override final;

  virtual void actOnAdditionalTasks() {}

  // Block restriction //
  void addBlocks(const std::vector<SubdomainName> & blocks);
  void addBlocksById(const std::vector<SubdomainID> & block_ids);

  const std::vector<SubdomainName> & blocks() const { return _blocks; }

  bool checkBlockRestrictionIdentical(const std::string & object_name,
                                      const std::vector<SubdomainName> & blocks,
                                      const bool error_if_not_identical = true) const;

  bool hasBlocks(const std::vector<SubdomainName> & blocks) const;

  // Coupling with Physics //
  template <typename T>
  const T * getCoupledPhysics(const PhysicsName & phys_name, const bool allow_fail = false) const;
  template <typename T>
  const std::vector<T *> getCoupledPhysics(const bool allow_fail = false) const;

  unsigned int dimension() const;

  // Coupling with Components //
  const ActionComponent & getActionComponent(const ComponentName & comp_name) const;
  template <typename T>
  void checkComponentType(const ActionComponent & component) const;
  virtual void addComponent(const ActionComponent & component);

  const std::vector<VariableName> & solverVariableNames() const { return _solver_var_names; };
  const std::vector<VariableName> & auxVariableNames() const { return _aux_var_names; };

  virtual std::vector<UserObjectName> getSuppliedUserObjects() const { return {}; }

protected:
  bool isTransient() const;

  Factory & getFactory() { return _factory; }
  Factory & getFactory() const { return _factory; }
  virtual FEProblemBase & getProblem()
  {
    mooseAssert(_problem, "Requesting the problem too early");
    return *_problem;
  }
  virtual const FEProblemBase & getProblem() const
  {
    mooseAssert(_problem, "Requesting the problem too early");
    return *_problem;
  }

  void prepareCopyVariablesFromMesh() const;
  void copyVariablesFromMesh(const std::vector<VariableName> & variables_to_copy,
                             bool are_nonlinear = true);

  std::string prefix() const { return name() + "_"; }

  void
  addUserObject(const std::string & uo_type, const std::string & uo_name, InputParameters & params);

  void saveSolverVariableName(const VariableName & var_name)
  {
    _solver_var_names.push_back(var_name);
  }
  void saveAuxVariableName(const VariableName & var_name) { _aux_var_names.push_back(var_name); }

  bool variableExists(const VariableName & var_name, bool error_if_aux) const;
  bool solverVariableExists(const VariableName & var_name) const;

  const SolverSystemName & getSolverSystem(unsigned int variable_index) const;
  const SolverSystemName & getSolverSystem(const VariableName & variable_name) const;

  void addRequiredPhysicsTask(const std::string & task) { _required_tasks.insert(task); }

  void assignBlocks(InputParameters & params, const std::vector<SubdomainName> & blocks) const;
  bool allMeshBlocks(const std::vector<SubdomainName> & blocks) const;
  bool allMeshBlocks(const std::set<SubdomainName> & blocks) const;
  // These APIs can deal with ANY_BLOCK_ID or ids with no names. They will be slower than the
  // MooseMeshUtils' APIs, but are more convenient for setup purposes
  std::set<SubdomainID> getSubdomainIDs(const std::set<SubdomainName> & blocks) const;
  std::vector<std::string> getSubdomainNamesAndIDs(const std::set<SubdomainID> & blocks) const;

  void addPetscPairsToPetscOptions(
      const std::vector<std::pair<MooseEnumItem, std::string>> & petsc_pair_options);

  // Helpers to check on variable types
  bool isVariableFV(const VariableName & var_name) const;
  bool isVariableScalar(const VariableName & var_name) const;

  // Routines to help with deciding when to create objects
  bool shouldCreateVariable(const VariableName & var_name,
                            const std::vector<SubdomainName> & blocks,
                            const bool error_if_aux);

  bool shouldCreateIC(const VariableName & var_name,
                      const std::vector<SubdomainName> & blocks,
                      const bool ic_is_default_ic,
                      const bool error_if_already_defined) const;

  bool shouldCreateTimeDerivative(const VariableName & var_name,
                                  const std::vector<SubdomainName> & blocks,
                                  const bool error_if_already_defined) const;

  // Other conceivable "shouldCreate" routines for things that are unique to a variable
  // - shouldCreateTimeIntegrator
  // - shouldCreatePredictor/Corrector

  void reportPotentiallyMissedParameters(const std::vector<std::string> & param_names,
                                         const std::string & object_type,
                                         const std::string & object_name = "") const;

  virtual void checkIntegrity() const {}

  std::vector<SolverSystemName> _system_names;

  std::vector<unsigned int> _system_numbers;

  const bool _verbose;

  const MooseEnum & _preconditioning;

  std::vector<SubdomainName> _blocks;

private:
  using Action::addRelationshipManagers;
  virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override;

  void initializePhysics();
  virtual void initializePhysicsAdditional() {}
  virtual void checkIntegrityEarly() const;

  virtual void addSolverVariables() {}
  virtual void addAuxiliaryVariables() {}
  virtual void addInitialConditions() {}
  virtual void addFEKernels() {}
  virtual void addFVKernels() {}
  virtual void addFVInterpolationMethods() {}
  virtual void addNodalKernels() {}
  virtual void addDiracKernels() {}
  virtual void addDGKernels() {}
  virtual void addScalarKernels() {}
  virtual void addInterfaceKernels() {}
  virtual void addFVInterfaceKernels() {}
  virtual void addFEBCs() {}
  virtual void addFVBCs() {}
  virtual void addNodalBCs() {}
  virtual void addPeriodicBCs() {}
  virtual void addFunctions() {}
  virtual void addAuxiliaryKernels() {}
  virtual void addMaterials() {}
  virtual void addFunctorMaterials() {}
  virtual void addUserObjects() {}
  virtual void addCorrectors() {}
  virtual void addMultiApps() {}
  virtual void addTransfers() {}
  virtual void addPostprocessors() {}
  virtual void addVectorPostprocessors() {}
  virtual void addReporters() {}
  virtual void addOutputs() {}
  virtual void addPreconditioning() {}
  virtual void addExecutioner() {}
  virtual void addExecutors() {}

  void checkRequiredTasks() const;

  MooseEnum _is_transient;

  std::vector<VariableName> _solver_var_names;
  std::vector<VariableName> _aux_var_names;

  unsigned int _dim = libMesh::invalid_uint;

  std::set<std::string> _required_tasks;
};

template <typename T>
const T *
PhysicsBase::getCoupledPhysics(const PhysicsName & phys_name, const bool allow_fail) const
{
  constexpr bool is_physics = std::is_base_of<PhysicsBase, T>::value;
  libmesh_ignore(is_physics);
  mooseAssert(is_physics, "Must be a PhysicsBase to be retrieved by getCoupledPhysics");
  const auto all_T_physics = _awh.getActions<T>();
  for (const auto * const physics : all_T_physics)
  {
    if (physics->name() == phys_name)
      return physics;
  }
  if (!allow_fail)
    mooseError("Requested Physics '",
               phys_name,
               "' does not exist or is not of type '",
               MooseUtils::prettyCppType<T>(),
               "'");
  else
    return nullptr;
}

template <typename T>
const std::vector<T *>
PhysicsBase::getCoupledPhysics(const bool allow_fail) const
{
  constexpr bool is_physics = std::is_base_of<PhysicsBase, T>::value;
  libmesh_ignore(is_physics);
  mooseAssert(is_physics, "Must be a PhysicsBase to be retrieved by getCoupledPhysics");
  const auto all_T_physics = _awh.getActions<T>();
  if (!allow_fail && all_T_physics.empty())
    mooseError("No Physics of requested type '", MooseUtils::prettyCppType<T>(), "'");
  else
    return all_T_physics;
}

template <typename T>
void
PhysicsBase::checkComponentType(const ActionComponent & component) const
{
  if (!dynamic_cast<const T *>(&component))
    mooseError("Component '" + component.name() + "' must be of type '" +
               MooseUtils::prettyCppType<T>() + "'.\nIt is currently of type '" + component.type() +
               "'");
}