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 MooseVariableFEBase;
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<RealVectorValue> VectorMooseVariable;
typedef MooseVariableFE<RealEigenVector> ArrayMooseVariable;
class MooseVariableScalar;
 
class VariableWarehouse
{
public:
  VariableWarehouse();
 
  void add(const std::string & var_name, std::shared_ptr<MooseVariableBase> var);
 
  void addBoundaryVar(BoundaryID bnd, MooseVariableFEBase * var);
 
  void addBoundaryVar(const std::set<BoundaryID> & boundary_ids, MooseVariableFEBase * var);
 
  void
  addBoundaryVars(const std::set<BoundaryID> & boundary_ids,
                  const std::unordered_map<std::string, std::vector<MooseVariableFEBase *>> & vars);
 
  MooseVariableBase * getVariable(const std::string & var_name);
 
  MooseVariableBase * getVariable(unsigned int var_number);
 
  template <typename T>
  MooseVariableFE<T> * getFieldVariable(const std::string & var_name);
 
  template <typename T>
  MooseVariableFE<T> * getFieldVariable(unsigned int var_number);
 
  const std::vector<VariableName> & names() const;
 
  const std::vector<MooseVariableFEBase *> & fieldVariables() const;
 
  const std::set<MooseVariableFEBase *> & boundaryVars(BoundaryID bnd) const;
 
  const std::vector<MooseVariableScalar *> & scalars() const;
 
protected:
  std::vector<VariableName> _names;
 
  std::vector<MooseVariableFEBase *> _vars;
 
  HashMap<std::string, MooseVariable *> _regular_vars_by_name;
 
  HashMap<unsigned, MooseVariable *> _regular_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<MooseVariableFEBase *>> _boundary_vars;
 
  std::vector<MooseVariableScalar *> _scalar_vars;
 
  std::map<unsigned int, std::shared_ptr<MooseVariableBase>> _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);