VariableWarehouse.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 "MooseTypes.h"
#include "HashMap.h"
#include "MooseError.h"
 
#include <vector>
#include <map>
#include <set>
 
namespace libMesh
{
template <typename>
class VectorValue;
typedef VectorValue<Real> RealVectorValue;
}
 
class MooseVariableBase;
class MooseVariableFieldBase;
template <typename>
class MooseVariableFE;
template <typename>
class MooseVariableField;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<RealVectorValue> VectorMooseVariable;
typedef MooseVariableFE<RealEigenVector> ArrayMooseVariable;
 
template <typename>
class MooseVariableFV;
typedef MooseVariableFV<Real> MooseVariableFVReal;
 
template <typename>
class MooseLinearVariableFV;
typedef MooseLinearVariableFV<Real> MooseLinearVariableFVReal;
 
class MooseVariableScalar;
 
class VariableWarehouse
{
public:
  VariableWarehouse();
 
  void add(const std::string & var_name, std::shared_ptr<MooseVariableBase> var);
 
  void addBoundaryVar(BoundaryID bnd, const MooseVariableFieldBase * var);
 
  void addBoundaryVar(const std::set<BoundaryID> & boundary_ids,
                      const MooseVariableFieldBase * var);
 
  void addBoundaryVars(
      const std::set<BoundaryID> & boundary_ids,
      const std::unordered_map<std::string, std::vector<MooseVariableFieldBase *>> & vars);
 
  MooseVariableBase * getVariable(const std::string & var_name) const;
 
  MooseVariableBase * getVariable(unsigned int var_number) const;
 
  template <typename T>
  MooseVariableFE<T> * getFieldVariable(const std::string & var_name);
 
  template <typename T>
  MooseVariableFE<T> * getFieldVariable(unsigned int var_number);
 
  template <typename T>
  MooseVariableField<T> * getActualFieldVariable(const std::string & var_name);
 
  template <typename T>
  MooseVariableFV<T> * getFVVariable(const std::string & var_name);
 
  template <typename T>
  MooseVariableField<T> * getActualFieldVariable(unsigned int var_number);
 
  const std::vector<VariableName> & names() const;
 
  const std::vector<MooseVariableFieldBase *> & fieldVariables() const;
 
  const std::set<const MooseVariableFieldBase *> & boundaryVars(BoundaryID bnd) const;
 
  const std::vector<MooseVariableScalar *> & scalars() const;
 
  void initialSetup();
 
  void timestepSetup();
 
  void customSetup(const ExecFlagType & exec_type);
 
  void subdomainSetup();
 
  void residualSetup();
 
  void jacobianSetup();
 
  void clearAllDofIndices();
 
  void setActiveVariableCoupleableVectorTags(const std::set<TagID> & vtags);
 
  void setActiveScalarVariableCoupleableVectorTags(const std::set<TagID> & vtags);
 
  const std::map<unsigned int, std::shared_ptr<MooseVariableBase>> & numberToVariableMap() const;
 
protected:
  std::vector<VariableName> _names;
 
  std::vector<MooseVariableFieldBase *> _vars;
 
  HashMap<unsigned, MooseVariable *> _regular_vars_by_number;
 
  HashMap<std::string, MooseVariableFVReal *> _fv_vars_by_name;
 
  HashMap<std::string, MooseLinearVariableFVReal *> _linear_fv_vars_by_name;
 
  HashMap<std::string, MooseVariable *> _regular_vars_by_name;
 
  HashMap<unsigned, MooseVariableFVReal *> _fv_vars_by_number;
 
  HashMap<unsigned, MooseLinearVariableFVReal *> _linear_fv_vars_by_number;
 
  HashMap<std::string, VectorMooseVariable *> _vector_vars_by_name;
 
  HashMap<unsigned, VectorMooseVariable *> _vector_vars_by_number;
 
  HashMap<std::string, ArrayMooseVariable *> _array_vars_by_name;
 
  HashMap<unsigned, ArrayMooseVariable *> _array_vars_by_number;
 
  std::map<std::string, MooseVariableBase *> _var_name;
 
  std::map<BoundaryID, std::set<const MooseVariableFieldBase *>> _boundary_vars;
 
  std::vector<MooseVariableScalar *> _scalar_vars;
 
  std::map<unsigned int, std::shared_ptr<MooseVariableBase>> _all_objects;
};
 
template <typename T>
MooseVariableFV<T> *
VariableWarehouse::getFVVariable(const std::string & var_name)
{
  auto it = _fv_vars_by_name.find(var_name);
  if (it == _fv_vars_by_name.end())
    mooseError("Requested variable ",
               var_name,
               " doesn't exist as a finite volume variable in the warehouse.");
 
  return it->second;
}
 
inline const std::map<unsigned int, std::shared_ptr<MooseVariableBase>> &
VariableWarehouse::numberToVariableMap() const
{
  return _all_objects;
}
 
template <>
MooseVariableFE<RealVectorValue> *
VariableWarehouse::getFieldVariable<RealVectorValue>(const std::string & var_name);
 
template <>
MooseVariableFE<RealVectorValue> *
VariableWarehouse::getFieldVariable<RealVectorValue>(unsigned int var_number);
 
template <>
MooseVariableFE<RealEigenVector> *
VariableWarehouse::getFieldVariable<RealEigenVector>(const std::string & var_name);
 
template <>
MooseVariableFE<RealEigenVector> *
VariableWarehouse::getFieldVariable<RealEigenVector>(unsigned int var_number);
 
template <>
MooseVariableField<RealVectorValue> *
VariableWarehouse::getActualFieldVariable<RealVectorValue>(const std::string & var_name);
 
template <>
MooseVariableField<RealVectorValue> *
VariableWarehouse::getActualFieldVariable<RealVectorValue>(unsigned int var_number);
 
template <>
MooseVariableField<RealEigenVector> *
VariableWarehouse::getActualFieldVariable<RealEigenVector>(const std::string & var_name);
 
template <>
MooseVariableField<RealEigenVector> *
VariableWarehouse::getActualFieldVariable<RealEigenVector>(unsigned int var_number);