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 "LinearFVGradientInterface.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 LinearFVGradientInterface
{
public:
  AuxiliarySystem(FEProblemBase & subproblem, const std::string & name);
  virtual ~AuxiliarySystem();

  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 LinearFVGradientInterface::linearFVLimitedGradientContainer;
  using LinearFVGradientInterface::requestLinearFVLimitedGradients;

  virtual void copyCurrentIntoPreviousNL();

  void setScalarVariableCoupleableTags(ExecFlagType type);

  void clearScalarVariableCoupleableTags();

  const ExecuteMooseObjectWarehouse<AuxKernel> & nodalAuxWarehouse() 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:
  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<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