MooseVariableBase.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 "MooseObject.h"
#include "BlockRestrictable.h"
#include "OutputInterface.h"
#include "SetupInterface.h"
#include "MooseTypes.h"
#include "MooseArray.h"
#include "MooseError.h"
#include "MooseFunctorArguments.h"
 
#include "libmesh/fe_type.h"
#include "libmesh/enum_fe_family.h"
 
// libMesh forward declarations
namespace libMesh
{
class DofMap;
class Variable;
}
 
class Assembly;
class SubProblem;
class SystemBase;
class MooseMesh;
 
class MooseVariableBase : public MooseObject,
                          public BlockRestrictable,
                          public OutputInterface,
                          public SetupInterface
{
public:
  static InputParameters validParams();
 
  MooseVariableBase(const InputParameters & parameters);
 
  const std::string & arrayVariableComponent(const unsigned int i) const;
 
  unsigned int number() const { return _var_num; }
 
  const libMesh::FEType & feType() const { return _fe_type; }
 
  SystemBase & sys() { return _sys; }
 
  const SystemBase & sys() const { return _sys; }
 
  const std::set<SubdomainID> & activeSubdomains() const;
 
  bool activeOnSubdomain(SubdomainID subdomain) const;
 
  bool activeOnSubdomains(const std::set<SubdomainID> & subdomains) const;
 
  bool useDual() const { return _use_dual; }
 
  const std::vector<dof_id_type> & allDofIndices() const;
  unsigned int totalVarDofs() { return allDofIndices().size(); }
 
  Moose::VarKindType kind() const { return _var_kind; }
 
  void scalingFactor(const std::vector<Real> & factor);
 
  Real scalingFactor() const { return _scaling_factor[0]; }
  const std::vector<Real> & arrayScalingFactor() const { return _scaling_factor; }
 
  libMesh::Order order() const;
 
  unsigned int count() const { return _count; }
 
  virtual bool isNodal() const { mooseError("Base class cannot determine this"); }
 
  virtual bool hasDoFsOnNodes() const { mooseError("Base class cannot determine this"); };
 
  virtual bool supportsQpBasedLoops() const;
 
  virtual bool supportsGeometricInfoBasedLoops() const;
 
  virtual libMesh::FEContinuity getContinuity() const
  {
    mooseError("Base class cannot determine this");
  };
 
  const libMesh::DofMap & dofMap() const { return _dof_map; }
 
  virtual void getDofIndices(const Elem * /*elem*/,
                             std::vector<dof_id_type> & /*dof_indices*/) const
  {
    mooseError("not implemented");
  };
 
  virtual const std::vector<dof_id_type> & dofIndices() const { return _dof_indices; }
 
  std::vector<dof_id_type> componentDofIndices(const std::vector<dof_id_type> & dof_indices,
                                               unsigned int component) const;
 
  virtual unsigned int numberOfDofs() const { return _dof_indices.size(); }
 
  bool eigen() const { return _is_eigen; }
 
  void eigen(bool eigen) { _is_eigen = eigen; }
 
  void initialSetup() override;
 
  virtual void clearAllDofIndices() { _dof_indices.clear(); }
 
  virtual void setActiveTags(const std::set<TagID> & vtags);
 
  virtual bool isArray() const { return !_array_var_component_names.empty(); }
 
  virtual void sizeMatrixTagData() { mooseError("Derived class must implement this method"); }
 
protected:
  const libMesh::NumericVector<libMesh::Number> & getSolution(const Moose::StateArg & state) const;
 
  bool doDerivatives() const;
 
  SystemBase & _sys;
 
  libMesh::FEType _fe_type;
 
  unsigned int _var_num;
 
  unsigned int _index;
 
  bool _is_eigen;
 
  Moose::VarKindType _var_kind;
 
  SubProblem & _subproblem;
 
  const libMesh::Variable & _variable;
 
  Assembly & _assembly;
 
  const libMesh::DofMap & _dof_map;
 
  std::vector<dof_id_type> _dof_indices;
 
  MooseMesh & _mesh;
 
  THREAD_ID _tid;
 
  const unsigned int _count;
 
  std::vector<Real> _scaling_factor;
 
  bool _use_dual;
 
  bool _is_lower_d;
 
  std::vector<std::string> _array_var_component_names;
};
 
inline void
MooseVariableBase::setActiveTags(const std::set<TagID> &)
{
  mooseError("setActiveTags must be overridden in derived classes.");
}
 
#define usingMooseVariableBaseMembers                                                              \
  using MooseVariableBase::_sys;                                                                   \
  using MooseVariableBase::_fe_type;                                                               \
  using MooseVariableBase::_var_num;                                                               \
  using MooseVariableBase::_index;                                                                 \
  using MooseVariableBase::_var_kind;                                                              \
  using MooseVariableBase::_subproblem;                                                            \
  using MooseVariableBase::_variable;                                                              \
  using MooseVariableBase::_assembly;                                                              \
  using MooseVariableBase::_dof_map;                                                               \
  using MooseVariableBase::_dof_indices;                                                           \
  using MooseVariableBase::_mesh;                                                                  \
  using MooseVariableBase::_tid;                                                                   \
  using MooseVariableBase::_count;                                                                 \
  using MooseVariableBase::_scaling_factor