AuxiliarySystem.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
 
// MOOSE includes
#include "SystemBase.h"
#include "LinearFVGradientManager.h"
#include "ExecuteMooseObjectWarehouse.h"
#include "PerfGraphInterface.h"
 
#include "libmesh/system.h"
#include "libmesh/transient_system.h"
 
// Forward declarations
class AuxKernelBase;
template <typename ComputeValueType>
class AuxKernelTempl;
typedef AuxKernelTempl<Real> AuxKernel;
typedef AuxKernelTempl<RealVectorValue> VectorAuxKernel;
typedef AuxKernelTempl<RealEigenVector> ArrayAuxKernel;
class FEProblemBase;
class TimeIntegrator;
class AuxScalarKernel;
 
// libMesh forward declarations
namespace libMesh
{
template <typename T>
class NumericVector;
}
 
class AuxiliarySystem : public SystemBase, public PerfGraphInterface, public LinearFVGradientManager
{
public:
  AuxiliarySystem(FEProblemBase & subproblem, const std::string & name);
  virtual ~AuxiliarySystem();
 
  virtual void initSolutionState() override;
  virtual void initialSetup() override;
  virtual void reinit() override;
  virtual void timestepSetup() override;
  virtual void customSetup(const ExecFlagType & exec_type) override;
  virtual void subdomainSetup() override;
  virtual void residualSetup() override;
  virtual void jacobianSetup() override;
  virtual void updateActive(THREAD_ID tid);
 
  virtual void addVariable(const std::string & var_type,
                           const std::string & name,
                           InputParameters & parameters) override;
 
  void addKernel(const std::string & kernel_name,
                 const std::string & name,
                 InputParameters & parameters);
 
#ifdef MOOSE_KOKKOS_ENABLED
  void addKokkosKernel(const std::string & kernel_name,
                       const std::string & name,
                       InputParameters & parameters);
#endif
 
  void addScalarKernel(const std::string & kernel_name,
                       const std::string & name,
                       InputParameters & parameters);
 
  virtual void reinitElem(const Elem * elem, THREAD_ID tid) override;
  virtual void reinitElemFace(const Elem * elem, unsigned int side, THREAD_ID tid) override;
 
  const NumericVector<Number> * const & currentSolution() const override
  {
    return _current_solution;
  }
 
  virtual void serializeSolution();
 
  // This is an empty function since the Aux system doesn't have a matrix!
  virtual void augmentSparsity(libMesh::SparsityPattern::Graph & /*sparsity*/,
                               std::vector<dof_id_type> & /*n_nz*/,
                               std::vector<dof_id_type> & /*n_oz*/) override;
 
  virtual void compute(ExecFlagType type) override;
 
#ifdef MOOSE_KOKKOS_ENABLED
  void kokkosCompute(ExecFlagType type);
#endif
 
  std::set<std::string> getDependObjects(ExecFlagType type);
  std::set<std::string> getDependObjects();
 
  virtual libMesh::Order getMinQuadratureOrder() override;
 
  bool needMaterialOnSide(BoundaryID bnd_id);
 
  virtual libMesh::System & sys() { return _sys; }
 
  virtual libMesh::System & system() override { return _sys; }
  virtual const libMesh::System & system() const override { return _sys; }
 
  using LinearFVGradientManager::registerFVGradient;
  using LinearFVGradientManager::updateFVGradient;
 
  virtual void copyCurrentIntoPreviousNL();
 
  void setScalarVariableCoupleableTags(ExecFlagType type);
 
  void clearScalarVariableCoupleableTags();
 
  const ExecuteMooseObjectWarehouse<AuxKernel> & nodalAuxWarehouse() const;
  const ExecuteMooseObjectWarehouse<AuxKernel> & mortarNodalAuxWarehouse() const;
  const ExecuteMooseObjectWarehouse<VectorAuxKernel> & nodalVectorAuxWarehouse() const;
  const ExecuteMooseObjectWarehouse<ArrayAuxKernel> & nodalArrayAuxWarehouse() const;
 
  const ExecuteMooseObjectWarehouse<AuxKernel> & elemAuxWarehouse() const;
  const ExecuteMooseObjectWarehouse<VectorAuxKernel> & elemVectorAuxWarehouse() const;
  const ExecuteMooseObjectWarehouse<ArrayAuxKernel> & elemArrayAuxWarehouse() const;
 
#ifdef MOOSE_KOKKOS_ENABLED
  const ExecuteMooseObjectWarehouse<AuxKernelBase> & kokkosNodalAuxWarehouse() const;
  const ExecuteMooseObjectWarehouse<AuxKernelBase> & kokkosElemAuxWarehouse() const;
#endif
 
  void variableWiseRelativeSolutionDifferenceNorm(std::vector<Number> & var_diffs) const;
 
protected:
  virtual void copyAdditionalStateBackwards(Moose::SolutionIterationType iteration_type,
                                            bool skip_current_to_old) override;
  virtual void restoreAdditionalStates() override;
 
  void computeScalarVars(ExecFlagType type);
  void computeNodalVars(ExecFlagType type);
  void computeMortarNodalVars(ExecFlagType type);
  void computeNodalVecVars(ExecFlagType type);
  void computeNodalArrayVars(ExecFlagType type);
  void computeElementalVars(ExecFlagType type);
  void computeElementalVecVars(ExecFlagType type);
  void computeElementalArrayVars(ExecFlagType type);
 
  template <typename AuxKernelType>
  void computeElementalVarsHelper(const MooseObjectWarehouse<AuxKernelType> & warehouse);
 
  template <typename AuxKernelType>
  void computeNodalVarsHelper(const MooseObjectWarehouse<AuxKernelType> & warehouse);
 
  libMesh::System & _sys;
 
  const NumericVector<Number> * _current_solution;
 
  std::vector<NumericVector<Number> *> _solution_state;
 
  // Variables
  std::vector<std::vector<MooseVariableFEBase *>> _nodal_vars;
 
 
  std::vector<std::vector<MooseVariableFieldBase *>> _elem_vars;
 
  // Storage for AuxScalarKernel objects
  ExecuteMooseObjectWarehouse<AuxScalarKernel> _aux_scalar_storage;
 
  // Storage for AuxKernel objects
  ExecuteMooseObjectWarehouse<AuxKernel> _nodal_aux_storage;
  ExecuteMooseObjectWarehouse<AuxKernel> _mortar_nodal_aux_storage;
  ExecuteMooseObjectWarehouse<AuxKernel> _elemental_aux_storage;
 
  // Storage for VectorAuxKernel objects
  ExecuteMooseObjectWarehouse<VectorAuxKernel> _nodal_vec_aux_storage;
  ExecuteMooseObjectWarehouse<VectorAuxKernel> _elemental_vec_aux_storage;
 
  // Storage for ArrayAuxKernel objects
  ExecuteMooseObjectWarehouse<ArrayAuxKernel> _nodal_array_aux_storage;
  ExecuteMooseObjectWarehouse<ArrayAuxKernel> _elemental_array_aux_storage;
 
#ifdef MOOSE_KOKKOS_ENABLED
  // Storage for KokkosAuxKernel objects
  ExecuteMooseObjectWarehouse<AuxKernelBase> _kokkos_nodal_aux_storage;
  ExecuteMooseObjectWarehouse<AuxKernelBase> _kokkos_elemental_aux_storage;
#endif
 
  friend class ComputeIndicatorThread;
  friend class ComputeMarkerThread;
  friend class FlagElementsThread;
  friend class ComputeNodalKernelsThread;
  friend class ComputeNodalKernelBcsThread;
  friend class ComputeNodalKernelJacobiansThread;
  friend class ComputeNodalKernelBCJacobiansThread;
 
  NumericVector<Number> & solutionInternal() const override { return *_sys.solution; }
};
 
inline const ExecuteMooseObjectWarehouse<AuxKernel> &
AuxiliarySystem::nodalAuxWarehouse() const
{
  return _nodal_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<AuxKernel> &
AuxiliarySystem::mortarNodalAuxWarehouse() const
{
  return _mortar_nodal_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<VectorAuxKernel> &
AuxiliarySystem::nodalVectorAuxWarehouse() const
{
  return _nodal_vec_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<ArrayAuxKernel> &
AuxiliarySystem::nodalArrayAuxWarehouse() const
{
  return _nodal_array_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<AuxKernel> &
AuxiliarySystem::elemAuxWarehouse() const
{
  return _elemental_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<VectorAuxKernel> &
AuxiliarySystem::elemVectorAuxWarehouse() const
{
  return _elemental_vec_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<ArrayAuxKernel> &
AuxiliarySystem::elemArrayAuxWarehouse() const
{
  return _elemental_array_aux_storage;
}
 
#ifdef MOOSE_KOKKOS_ENABLED
inline const ExecuteMooseObjectWarehouse<AuxKernelBase> &
AuxiliarySystem::kokkosNodalAuxWarehouse() const
{
  return _kokkos_nodal_aux_storage;
}
 
inline const ExecuteMooseObjectWarehouse<AuxKernelBase> &
AuxiliarySystem::kokkosElemAuxWarehouse() const
{
  return _kokkos_elemental_aux_storage;
}
#endif