VariableWarehouse.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 "MooseTypes.h"
#include "HashMap.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);