SystemBase.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
 
#include <vector>
 
#include "DataIO.h"
#include "MooseTypes.h"
#include "VariableWarehouse.h"
#include "InputParameters.h"
#include "MooseObjectWarehouseBase.h"
#include "MooseVariableBase.h"
 
// libMesh
#include "libmesh/exodusII_io.h"
#include "libmesh/parallel_object.h"
#include "libmesh/numeric_vector.h"
#include "libmesh/sparse_matrix.h"
 
// Forward declarations
class Factory;
class MooseApp;
class MooseVariableFEBase;
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<VectorValue<Real>> VectorMooseVariable;
class MooseMesh;
class SubProblem;
class SystemBase;
class TimeIntegrator;
class InputParameters;
 
// libMesh forward declarations
namespace libMesh
{
class System;
class DofMap;
class FEType;
}
 
void extraSendList(std::vector<dof_id_type> & send_list, void * context);
 
void extraSparsity(SparsityPattern::Graph & sparsity,
                   std::vector<dof_id_type> & n_nz,
                   std::vector<dof_id_type> & n_oz,
                   void * context);
 
template <>
void dataStore(std::ostream & stream, SystemBase & system_base, void * context);
 
template <>
void dataLoad(std::istream & stream, SystemBase & system_base, void * context);
 
struct VarCopyInfo
{
  VarCopyInfo(const std::string & dest_name,
              const std::string & source_name,
              const std::string & timestep)
    : _dest_name(dest_name), _source_name(source_name), _timestep(timestep)
  {
  }
 
  std::string _dest_name;
  std::string _source_name;
  std::string _timestep;
};
 
class SystemBase : public libMesh::ParallelObject
{
public:
  SystemBase(SubProblem & subproblem, const std::string & name, Moose::VarKindType var_kind);
  virtual ~SystemBase() {}
 
  virtual unsigned int number() const;
  virtual MooseMesh & mesh() { return _mesh; }
  virtual const MooseMesh & mesh() const { return _mesh; }
  virtual SubProblem & subproblem() { return _subproblem; }
  virtual const SubProblem & subproblem() const { return _subproblem; }
 
  void applyScalingFactors(const std::vector<Real> & inverse_scaling_factors);
 
  bool computingScalingJacobian() const { return _computing_scaling_jacobian; }
 
  void computingScalingJacobian(bool computing_scaling_jacobian)
  {
    _computing_scaling_jacobian = computing_scaling_jacobian;
  }
 
  bool computingScalingResidual() const { return _computing_scaling_residual; }
 
  void computingScalingResidual(bool computing_scaling_residual)
  {
    _computing_scaling_residual = computing_scaling_residual;
  }
 
  virtual DofMap & dofMap();
 
  virtual const DofMap & dofMap() const;
 
  virtual System & system() = 0;
  virtual const System & system() const = 0;
 
  virtual void init(){};
 
  virtual void initializeObjects(){};
 
  virtual void addExtraVectors();
 
  virtual void update();
 
  virtual void solve();
 
  virtual void copyOldSolutions();
  virtual void restoreSolutions();
 
  virtual const NumericVector<Number> * const & currentSolution() const = 0;
 
  virtual NumericVector<Number> & solution() = 0;
  virtual NumericVector<Number> & solutionOld() = 0;
  virtual NumericVector<Number> & solutionOlder() = 0;
  virtual NumericVector<Number> * solutionPreviousNewton() = 0;
  virtual const NumericVector<Number> & solution() const = 0;
  virtual const NumericVector<Number> & solutionOld() const = 0;
  virtual const NumericVector<Number> & solutionOlder() const = 0;
  virtual const NumericVector<Number> * solutionPreviousNewton() const = 0;
 
  virtual Number & duDotDu() { return _du_dot_du; }
  virtual Number & duDotDotDu() { return _du_dotdot_du; }
  virtual const Number & duDotDu() const { return _du_dot_du; }
  virtual const Number & duDotDotDu() const { return _du_dotdot_du; }
 
  // non-const getters
  virtual NumericVector<Number> * solutionUDot() = 0;
  virtual NumericVector<Number> * solutionUDotOld() = 0;
  virtual NumericVector<Number> * solutionUDotDot() = 0;
  virtual NumericVector<Number> * solutionUDotDotOld() = 0;
  // const getters
  virtual const NumericVector<Number> * solutionUDot() const = 0;
  virtual const NumericVector<Number> * solutionUDotOld() const = 0;
  virtual const NumericVector<Number> * solutionUDotDot() const = 0;
  virtual const NumericVector<Number> * solutionUDotDotOld() const = 0;
 
  virtual void saveOldSolutions();
  virtual void restoreOldSolutions();
 
  bool hasVector(const std::string & tag_name) const;
 
  virtual bool hasVector(TagID tag_id) const;
 
  virtual TagID timeVectorTag();
 
  virtual TagID timeMatrixTag();
 
  virtual TagID systemMatrixTag();
 
  /*
   * Return TagID for nontime
   */
  virtual TagID nonTimeVectorTag();
 
  /*
   * Return TagID for nontime
   */
  virtual TagID residualVectorTag();
 
  virtual NumericVector<Number> & getVector(const std::string & name);
 
  virtual NumericVector<Number> & getVector(TagID tag);
 
  virtual const NumericVector<Number> & getVector(TagID tag) const;
 
  virtual void associateVectorToTag(NumericVector<Number> & vec, TagID tag);
 
  virtual void disassociateVectorFromTag(NumericVector<Number> & vec, TagID tag);
 
  virtual void disassociateAllTaggedVectors();
 
  virtual bool hasMatrix(TagID tag) const;
 
  virtual SparseMatrix<Number> & getMatrix(TagID tag);
 
  virtual const SparseMatrix<Number> & getMatrix(TagID tag) const;
 
  virtual void activeAllMatrixTags();
 
  virtual void activeMatrixTag(TagID tag);
 
  virtual bool matrixTagActive(TagID tag) const;
 
  virtual void deactiveMatrixTag(TagID tag);
 
  virtual void deactiveAllMatrixTags();
 
  void closeTaggedMatrices(const std::set<TagID> & tags);
 
  virtual void associateMatrixToTag(SparseMatrix<Number> & matrix, TagID tag);
 
  virtual void disassociateMatrixFromTag(SparseMatrix<Number> & matrix, TagID tag);
 
  virtual void disassociateAllTaggedMatrices();
 
  virtual NumericVector<Number> & serializedSolution() = 0;
 
  virtual NumericVector<Number> & residualCopy()
  {
    mooseError("This system does not support getting a copy of the residual");
  }
  virtual NumericVector<Number> & residualGhosted()
  {
    mooseError("This system does not support getting a ghosted copy of the residual");
  }
 
  virtual void augmentSendList(std::vector<dof_id_type> & send_list);
 
  virtual void augmentSparsity(SparsityPattern::Graph & sparsity,
                               std::vector<dof_id_type> & n_nz,
                               std::vector<dof_id_type> & n_oz) = 0;
 
  virtual void addVariable(const std::string & var_type,
                           const std::string & var_name,
                           InputParameters & parameters);
 
  virtual bool isArrayVariable(const std::string & var_name) const;
 
 
  virtual bool hasVariable(const std::string & var_name) const;
  virtual bool hasScalarVariable(const std::string & var_name) const;
 
  virtual bool isScalarVariable(unsigned int var_name) const;
 
  MooseVariableFEBase & getVariable(THREAD_ID tid, const std::string & var_name);
 
  MooseVariableFEBase & getVariable(THREAD_ID tid, unsigned int var_number);
 
  template <typename T>
  MooseVariableFE<T> & getFieldVariable(THREAD_ID tid, const std::string & var_name);
 
  template <typename T>
  MooseVariableFE<T> & getFieldVariable(THREAD_ID tid, unsigned int var_number);
 
  virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, const std::string & var_name);
 
  virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, unsigned int var_number);
 
  virtual const std::set<SubdomainID> * getVariableBlocks(unsigned int var_number);
 
  virtual unsigned int nVariables() const;
 
  std::size_t getMaxVarNDofsPerElem() const { return _max_var_n_dofs_per_elem; }
 
  std::size_t getMaxVarNDofsPerNode() const { return _max_var_n_dofs_per_node; }
 
  void assignMaxVarNDofsPerElem(std::size_t max_dofs) { _max_var_n_dofs_per_elem = max_dofs; }
 
  void assignMaxVarNDofsPerNode(std::size_t max_dofs) { _max_var_n_dofs_per_node = max_dofs; }
 
  virtual void addVariableToZeroOnResidual(std::string var_name);
 
  virtual void addVariableToZeroOnJacobian(std::string var_name);
 
  virtual void zeroVariables(std::vector<std::string> & vars_to_be_zeroed);
 
  virtual void zeroVariablesForResidual();
 
  virtual void zeroVariablesForJacobian();
 
  virtual Order getMinQuadratureOrder();
 
  virtual void prepare(THREAD_ID tid);
 
  virtual void prepareFace(THREAD_ID tid, bool resize_data);
 
  virtual void prepareNeighbor(THREAD_ID tid);
 
  virtual void prepareLowerD(THREAD_ID tid);
 
  virtual void reinitElem(const Elem * elem, THREAD_ID tid);
 
  virtual void
  reinitElemFace(const Elem * elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid);
 
  virtual void
  reinitNeighborFace(const Elem * elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid);
 
  virtual void reinitNeighbor(const Elem * elem, THREAD_ID tid);
 
  virtual void reinitLowerD(THREAD_ID tid);
 
  virtual void reinitNode(const Node * node, THREAD_ID tid);
 
  virtual void reinitNodeFace(const Node * node, BoundaryID bnd_id, THREAD_ID tid);
 
  virtual void reinitNodes(const std::vector<dof_id_type> & nodes, THREAD_ID tid);
 
  virtual void reinitNodesNeighbor(const std::vector<dof_id_type> & nodes, THREAD_ID tid);
 
  virtual void reinitScalars(THREAD_ID tid, bool reinit_for_derivative_reordering = false);
 
  virtual void addVariableToCopy(const std::string & dest_name,
                                 const std::string & source_name,
                                 const std::string & timestep);
 
  const std::vector<MooseVariableFEBase *> & getVariables(THREAD_ID tid)
  {
    return _vars[tid].fieldVariables();
  }
 
  const std::vector<MooseVariableScalar *> & getScalarVariables(THREAD_ID tid)
  {
    return _vars[tid].scalars();
  }
 
  const std::set<SubdomainID> & getSubdomainsForVar(unsigned int var_number) const
  {
    return _var_map.at(var_number);
  }
 
  virtual void removeVector(const std::string & name);
 
  virtual NumericVector<Number> &
  addVector(const std::string & vector_name, const bool project, const ParallelType type);
 
  NumericVector<Number> & addVector(TagID tag, const bool project, const ParallelType type);
 
  virtual void closeTaggedVectors(const std::set<TagID> & tags);
 
  virtual void zeroTaggedVectors(const std::set<TagID> & tags);
 
  virtual void removeVector(TagID tag_id);
 
  virtual SparseMatrix<Number> & addMatrix(TagID /* tag */)
  {
    mooseError("Adding a matrix is not supported for this type of system!");
  }
 
  virtual void removeMatrix(TagID /* tag */)
  {
    mooseError("Removing a matrix is not supported for this type of system!");
  }
 
  virtual const std::string & name() const;
 
  const std::vector<VariableName> & getVariableNames() const { return _vars[0].names(); }
 
  unsigned int getMaxVariableNumber() const { return _max_var_number; }
 
  virtual void computeVariables(const NumericVector<Number> & /*soln*/) {}
 
  void copyVars(ExodusII_IO & io);
 
  virtual void copySolutionsBackwards();
 
  virtual void addTimeIntegrator(const std::string & /*type*/,
                                 const std::string & /*name*/,
                                 InputParameters & /*parameters*/)
  {
  }
 
  virtual void addTimeIntegrator(std::shared_ptr<TimeIntegrator> /*ti*/) {}
 
  TimeIntegrator * getTimeIntegrator() { return _time_integrator.get(); }
  const TimeIntegrator * getTimeIntegrator() const { return _time_integrator.get(); }
 
  std::shared_ptr<TimeIntegrator> getSharedTimeIntegrator() { return _time_integrator; }
 
protected:
  SubProblem & _subproblem;
 
  MooseApp & _app;
  Factory & _factory;
 
  MooseMesh & _mesh;
  std::string _name;
 
  std::vector<VariableWarehouse> _vars;
  std::map<unsigned int, std::set<SubdomainID>> _var_map;
  unsigned int _max_var_number;
 
  std::vector<std::string> _vars_to_be_zeroed_on_residual;
  std::vector<std::string> _vars_to_be_zeroed_on_jacobian;
 
  Real _du_dot_du;
  Real _du_dotdot_du;
 
  std::vector<NumericVector<Number> *> _tagged_vectors;
  std::vector<SparseMatrix<Number> *> _tagged_matrices;
  std::vector<bool> _matrix_tag_active_flags;
 
  // Used for saving old solutions so that they wont be accidentally changed
  NumericVector<Real> * _saved_old;
  NumericVector<Real> * _saved_older;
 
  // Used for saving old u_dot and u_dotdot so that they wont be accidentally changed
  NumericVector<Real> * _saved_dot_old;
  NumericVector<Real> * _saved_dotdot_old;
 
  Moose::VarKindType _var_kind;
 
  std::vector<VarCopyInfo> _var_to_copy;
 
  size_t _max_var_n_dofs_per_elem;
 
  size_t _max_var_n_dofs_per_node;
 
  std::shared_ptr<TimeIntegrator> _time_integrator;
 
  std::vector<std::vector<MooseVariableFEBase *>> _numbered_vars;
 
  MooseObjectWarehouseBase<MooseVariableBase> _variable_warehouse;
 
  bool _computing_scaling_jacobian;
 
  bool _computing_scaling_residual;
};
 
#define PARALLEL_TRY
 
#define PARALLEL_CATCH _fe_problem.checkExceptionAndStopSolve();