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 "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; }

  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 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(); }

  bool isLowerD() const { return _is_lower_d; }

  virtual void sizeMatrixTagData() { mooseError("Derived class must implement this method"); }

protected:
  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