AuxiliarySystem.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "ExecuteMooseObjectWarehouse.h"
#include "PerfGraphInterface.h"

#include "libmesh/explicit_system.h"
#include "libmesh/transient_system.h"

// Forward declarations
template <typename ComputeValueType>
class AuxKernelTempl;
typedef AuxKernelTempl<Real> AuxKernel;
typedef AuxKernelTempl<RealVectorValue> VectorAuxKernel;
class FEProblemBase;
class TimeIntegrator;
class AuxScalarKernel;

// libMesh forward declarations
namespace libMesh
{
template <typename T>
class NumericVector;
}

class AuxiliarySystem : public SystemBase, public PerfGraphInterface
{
public:
  AuxiliarySystem(FEProblemBase & subproblem, const std::string & name);
  virtual ~AuxiliarySystem();

  virtual void init() override;
  virtual void addExtraVectors() override;

  virtual void initialSetup();
  virtual void timestepSetup();
  virtual void subdomainSetup();
  virtual void residualSetup();
  virtual void jacobianSetup();
  virtual void updateActive(THREAD_ID tid);

  virtual void addVariable(const std::string & var_name,
                           const FEType & type,
                           Real scale_factor,
                           const std::set<SubdomainID> * const active_subdomains = NULL) override;

  void addTimeIntegrator(const std::string & type,
                         const std::string & name,
                         InputParameters parameters) override;
  using SystemBase::addTimeIntegrator;

  void addDotVectors();

  void
  addKernel(const std::string & kernel_name, const std::string & name, InputParameters parameters);

  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, BoundaryID bnd_id, THREAD_ID tid) override;

  const NumericVector<Number> * const & currentSolution() const override
  {
    _current_solution = _sys.current_local_solution.get();
    return _current_solution;
  }

  NumericVector<Number> * solutionUDot() override { return _u_dot; }
  NumericVector<Number> * solutionUDotDot() override { return _u_dotdot; }
  NumericVector<Number> * solutionUDotOld() override { return _u_dot_old; }
  NumericVector<Number> * solutionUDotDotOld() override { return _u_dotdot_old; }
  const NumericVector<Number> * solutionUDot() const override { return _u_dot; }
  const NumericVector<Number> * solutionUDotDot() const override { return _u_dotdot; }
  const NumericVector<Number> * solutionUDotOld() const override { return _u_dot_old; }
  const NumericVector<Number> * solutionUDotDotOld() const override { return _u_dotdot_old; }

  virtual void serializeSolution();
  virtual NumericVector<Number> & serializedSolution() override;

  // This is an empty function since the Aux system doesn't have a matrix!
  virtual void augmentSparsity(SparsityPattern::Graph & /*sparsity*/,
                               std::vector<dof_id_type> & /*n_nz*/,
                               std::vector<dof_id_type> & /*n_oz*/) override;

  virtual void compute(ExecFlagType type);

  std::set<std::string> getDependObjects(ExecFlagType type);
  std::set<std::string> getDependObjects();
  NumericVector<Number> &
  addVector(const std::string & vector_name, const bool project, const ParallelType type) override;

  virtual Order getMinQuadratureOrder() override;

  bool needMaterialOnSide(BoundaryID bnd_id);

  NumericVector<Number> & solution() override { return *_sys.solution; }
  NumericVector<Number> & solutionOld() override { return *_sys.old_local_solution; }
  NumericVector<Number> & solutionOlder() override { return *_sys.older_local_solution; }
  NumericVector<Number> * solutionPreviousNewton() override { return _solution_previous_nl; }

  const NumericVector<Number> & solution() const override { return *_sys.solution; }
  const NumericVector<Number> & solutionOld() const override { return *_sys.old_local_solution; }
  const NumericVector<Number> & solutionOlder() const override
  {
    return *_sys.older_local_solution;
  }
  const NumericVector<Number> * solutionPreviousNewton() const override
  {
    return _solution_previous_nl;
  }

  virtual TransientExplicitSystem & sys() { return _sys; }

  virtual System & system() override { return _sys; }
  virtual const System & system() const override { return _sys; }

  virtual void setPreviousNewtonSolution();

  void setScalarVariableCoupleableTags(ExecFlagType type);

  void clearScalarVariableCoupleableTags();

  // protected:
  void computeScalarVars(ExecFlagType type);
  void computeNodalVars(ExecFlagType type);
  void computeNodalVecVars(ExecFlagType type);
  void computeElementalVars(ExecFlagType type);
  void computeElementalVecVars(ExecFlagType type);

  template <typename AuxKernelType>
  void computeElementalVarsHelper(const MooseObjectWarehouse<AuxKernelType> & warehouse,
                                  const std::vector<std::vector<MooseVariableFEBase *>> & vars,
                                  const PerfID timer);

  template <typename AuxKernelType>
  void computeNodalVarsHelper(const MooseObjectWarehouse<AuxKernelType> & warehouse,
                              const std::vector<std::vector<MooseVariableFEBase *>> & vars,
                              const PerfID timer);

  FEProblemBase & _fe_problem;

  TransientExplicitSystem & _sys;

  mutable const NumericVector<Number> * _current_solution;
  NumericVector<Number> & _serialized_solution;
  NumericVector<Number> * _solution_previous_nl;
  std::shared_ptr<TimeIntegrator> _time_integrator;
  NumericVector<Number> * _u_dot;
  NumericVector<Number> * _u_dotdot;

  NumericVector<Number> * _u_dot_old;
  NumericVector<Number> * _u_dotdot_old;

  bool _need_serialized_solution;

  // Variables
  std::vector<std::vector<MooseVariableFEBase *>> _nodal_vars;
  std::vector<std::vector<MooseVariableFEBase *>> _nodal_std_vars;
  std::vector<std::vector<MooseVariableFEBase *>> _nodal_vec_vars;

  std::vector<std::vector<MooseVariableFEBase *>> _elem_vars;
  std::vector<std::vector<MooseVariableFEBase *>> _elem_std_vars;
  std::vector<std::vector<MooseVariableFEBase *>> _elem_vec_vars;

  // Storage for AuxScalarKernel objects
  ExecuteMooseObjectWarehouse<AuxScalarKernel> _aux_scalar_storage;

  // Storage for AuxKernel objects
  ExecuteMooseObjectWarehouse<AuxKernel> _nodal_aux_storage;
  ExecuteMooseObjectWarehouse<AuxKernel> _elemental_aux_storage;

  // Storage for VectorAuxKernel objects
  ExecuteMooseObjectWarehouse<VectorAuxKernel> _nodal_vec_aux_storage;
  ExecuteMooseObjectWarehouse<VectorAuxKernel> _elemental_vec_aux_storage;

  const PerfID _compute_scalar_vars_timer;
  const PerfID _compute_nodal_vars_timer;
  const PerfID _compute_nodal_vec_vars_timer;
  const PerfID _compute_elemental_vars_timer;
  const PerfID _compute_elemental_vec_vars_timer;

  friend class ComputeIndicatorThread;
  friend class ComputeMarkerThread;
  friend class FlagElementsThread;
  friend class ComputeNodalKernelsThread;
  friend class ComputeNodalKernelBcsThread;
  friend class ComputeNodalKernelJacobiansThread;
  friend class ComputeNodalKernelBCJacobiansThread;
};