Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "VariableWarehouse.h"
      11             : #include "MooseVariableFE.h"
      12             : #include "MooseVariableFV.h"
      13             : #include "MooseLinearVariableFV.h"
      14             : #include "MooseVariableScalar.h"
      15             : #include "MooseTypes.h"
      16             : 
      17      132936 : VariableWarehouse::VariableWarehouse() {}
      18             : 
      19             : void
      20      176150 : VariableWarehouse::add(const std::string & var_name, std::shared_ptr<MooseVariableBase> var)
      21             : {
      22      176150 :   _names.push_back(var_name);
      23      176150 :   auto * raw_var = var.get();
      24      176150 :   _all_objects[var->number()] = var;
      25      176150 :   _var_name[var_name] = raw_var;
      26             : 
      27      176150 :   if (auto * tmp_var = dynamic_cast<MooseVariableFieldBase *>(raw_var))
      28             :   {
      29      172860 :     _vars.push_back(tmp_var);
      30      172860 :     if (auto * tmp_var = dynamic_cast<MooseVariable *>(raw_var))
      31             :     {
      32      161132 :       _regular_vars_by_number[tmp_var->number()] = tmp_var;
      33      161132 :       _regular_vars_by_name[var_name] = tmp_var;
      34             :     }
      35       11728 :     else if (auto * tmp_var = dynamic_cast<MooseVariableFVReal *>(raw_var))
      36             :     {
      37        6374 :       _fv_vars_by_number[tmp_var->number()] = tmp_var;
      38        6374 :       _fv_vars_by_name[var_name] = tmp_var;
      39             :     }
      40        5354 :     else if (auto * tmp_var = dynamic_cast<MooseLinearVariableFVReal *>(raw_var))
      41             :     {
      42        1311 :       _linear_fv_vars_by_number[tmp_var->number()] = tmp_var;
      43        1311 :       _linear_fv_vars_by_name[var_name] = tmp_var;
      44             :     }
      45        4043 :     else if (auto * tmp_var = dynamic_cast<VectorMooseVariable *>(raw_var))
      46             :     {
      47        1571 :       _vector_vars_by_number[tmp_var->number()] = tmp_var;
      48        1571 :       _vector_vars_by_name[var_name] = tmp_var;
      49             :     }
      50        2472 :     else if (auto * tmp_var = dynamic_cast<ArrayMooseVariable *>(raw_var))
      51             :     {
      52        2472 :       _array_vars_by_number[tmp_var->number()] = tmp_var;
      53        2472 :       _array_vars_by_name[var_name] = tmp_var;
      54             :     }
      55             :     else
      56           0 :       mooseError("Unknown variable class passed into VariableWarehouse. Attempt to hack us?");
      57             :   }
      58        3290 :   else if (auto * tmp_var = dynamic_cast<MooseVariableScalar *>(raw_var))
      59        3290 :     _scalar_vars.push_back(tmp_var);
      60             :   else
      61           0 :     mooseError("Unknown variable class passed into VariableWarehouse. Attempt to hack us?");
      62      176150 : }
      63             : 
      64             : void
      65      105485 : VariableWarehouse::addBoundaryVar(BoundaryID bnd, const MooseVariableFEBase * var)
      66             : {
      67      105485 :   _boundary_vars[bnd].insert(var);
      68      105485 : }
      69             : 
      70             : void
      71       77129 : VariableWarehouse::addBoundaryVar(const std::set<BoundaryID> & boundary_ids,
      72             :                                   const MooseVariableFEBase * var)
      73             : {
      74      177219 :   for (const auto & bid : boundary_ids)
      75      100090 :     addBoundaryVar(bid, var);
      76       77129 : }
      77             : 
      78             : void
      79       77125 : VariableWarehouse::addBoundaryVars(
      80             :     const std::set<BoundaryID> & boundary_ids,
      81             :     const std::unordered_map<std::string, std::vector<MooseVariableFEBase *>> & vars)
      82             : {
      83      177207 :   for (const auto & bid : boundary_ids)
      84      104449 :     for (const auto & it : vars)
      85        9762 :       for (const auto & var : it.second)
      86        5395 :         addBoundaryVar(bid, var);
      87       77125 : }
      88             : 
      89             : MooseVariableBase *
      90     4595260 : VariableWarehouse::getVariable(const std::string & var_name) const
      91             : {
      92     4595260 :   auto it = _var_name.find(var_name);
      93     4595260 :   if (it != _var_name.end())
      94     4595252 :     return it->second;
      95             :   else
      96           8 :     return nullptr;
      97             : }
      98             : 
      99             : MooseVariableBase *
     100      185323 : VariableWarehouse::getVariable(unsigned int var_number) const
     101             : {
     102      185323 :   auto it = _all_objects.find(var_number);
     103      185323 :   if (it != _all_objects.end())
     104      185323 :     return it->second.get();
     105             :   else
     106           0 :     return nullptr;
     107             : }
     108             : 
     109             : const std::vector<VariableName> &
     110     6623597 : VariableWarehouse::names() const
     111             : {
     112     6623597 :   return _names;
     113             : }
     114             : 
     115             : const std::vector<MooseVariableFEBase *> &
     116  1940202821 : VariableWarehouse::fieldVariables() const
     117             : {
     118  1940202821 :   return _vars;
     119             : }
     120             : 
     121             : const std::vector<MooseVariableScalar *> &
     122   152580592 : VariableWarehouse::scalars() const
     123             : {
     124   152580592 :   return _scalar_vars;
     125             : }
     126             : 
     127             : const std::set<const MooseVariableFEBase *> &
     128           0 : VariableWarehouse::boundaryVars(BoundaryID bnd) const
     129             : {
     130           0 :   return _boundary_vars.find(bnd)->second;
     131             : }
     132             : 
     133             : namespace
     134             : {
     135             : template <typename T, typename Map, typename Key>
     136             : MooseVariableFE<T> *
     137     3130921 : getFieldVariableHelper(const Map & map, const Key & key, const std::string & container_name)
     138             : {
     139             :   // TODO: the requested variable might be an FV variable - how to we
     140             :   // reconcile this since this function returns an FE (not Field) pointer?
     141             :   // crap tons of objects depend on this.
     142             : 
     143     3130921 :   auto it = map.find(key);
     144     3130921 :   if (it == map.end())
     145           0 :     mooseError("Key '", key, "' not found in VariableWarehouse container '", container_name, "'");
     146             : 
     147     3130921 :   return it->second;
     148             : }
     149             : }
     150             : 
     151             : template <typename T>
     152             : MooseVariableFE<T> *
     153       53041 : VariableWarehouse::getFieldVariable(const std::string & var_name)
     154             : {
     155       53041 :   return getFieldVariableHelper<T>(_regular_vars_by_name, var_name, "_regular_vars_by_name");
     156             : }
     157             : 
     158             : template <typename T>
     159             : MooseVariableFE<T> *
     160           0 : VariableWarehouse::getFieldVariable(unsigned int var_number)
     161             : {
     162           0 :   return getFieldVariableHelper<T>(_regular_vars_by_number, var_number, "_regular_vars_by_number");
     163             : }
     164             : 
     165             : template <>
     166             : VectorMooseVariable *
     167        1330 : VariableWarehouse::getFieldVariable<RealVectorValue>(const std::string & var_name)
     168             : {
     169        2660 :   return getFieldVariableHelper<RealVectorValue>(
     170        2660 :       _vector_vars_by_name, var_name, "_vector_vars_by_name");
     171             : }
     172             : 
     173             : template <>
     174             : VectorMooseVariable *
     175     1950694 : VariableWarehouse::getFieldVariable<RealVectorValue>(unsigned int var_number)
     176             : {
     177     3901388 :   return getFieldVariableHelper<RealVectorValue>(
     178     3901388 :       _vector_vars_by_number, var_number, "_vector_vars_by_number");
     179             : }
     180             : 
     181             : template <>
     182             : ArrayMooseVariable *
     183        1770 : VariableWarehouse::getFieldVariable<RealEigenVector>(const std::string & var_name)
     184             : {
     185        3540 :   return getFieldVariableHelper<RealEigenVector>(
     186        3540 :       _array_vars_by_name, var_name, "_array_vars_by_name");
     187             : }
     188             : 
     189             : template <>
     190             : ArrayMooseVariable *
     191     1124086 : VariableWarehouse::getFieldVariable<RealEigenVector>(unsigned int var_number)
     192             : {
     193     2248172 :   return getFieldVariableHelper<RealEigenVector>(
     194     2248172 :       _array_vars_by_number, var_number, "_array_vars_by_number");
     195             : }
     196             : 
     197             : template MooseVariableFE<Real> *
     198             : VariableWarehouse::getFieldVariable<Real>(const std::string & var_name);
     199             : template MooseVariableFE<Real> * VariableWarehouse::getFieldVariable<Real>(unsigned int var_number);
     200             : 
     201             : template <typename T>
     202             : MooseVariableField<T> *
     203      100977 : VariableWarehouse::getActualFieldVariable(const std::string & var_name)
     204             : {
     205      100977 :   auto it = _regular_vars_by_name.find(var_name);
     206      100977 :   if (it != _regular_vars_by_name.end())
     207       96182 :     return it->second;
     208        4795 :   auto it_fv = _fv_vars_by_name.find(var_name);
     209        4795 :   if (it_fv != _fv_vars_by_name.end())
     210        3467 :     return it_fv->second;
     211        1328 :   return _linear_fv_vars_by_name.at(var_name);
     212             : }
     213             : 
     214             : template <typename T>
     215             : MooseVariableField<T> *
     216   128666116 : VariableWarehouse::getActualFieldVariable(unsigned int var_number)
     217             : {
     218   128666116 :   auto it = _regular_vars_by_number.find(var_number);
     219   128666116 :   if (it != _regular_vars_by_number.end())
     220   128619720 :     return it->second;
     221       46396 :   auto it_fv = _fv_vars_by_number.find(var_number);
     222       46396 :   if (it_fv != _fv_vars_by_number.end())
     223       46396 :     return it_fv->second;
     224           0 :   return _linear_fv_vars_by_number.at(var_number);
     225             : }
     226             : 
     227             : template <>
     228             : MooseVariableField<RealVectorValue> *
     229         826 : VariableWarehouse::getActualFieldVariable<RealVectorValue>(const std::string & var_name)
     230             : {
     231             :   // TODO: when necessary, add the if check to see if we have an FV vector var
     232             :   // before just returning nothing as found in FE vars list.
     233         826 :   return getFieldVariable<RealVectorValue>(var_name);
     234             : }
     235             : 
     236             : template <>
     237             : MooseVariableField<RealVectorValue> *
     238     1950694 : VariableWarehouse::getActualFieldVariable<RealVectorValue>(unsigned int var_number)
     239             : {
     240             :   // TODO: when necessary, add the if check to see if we have an FV vector var
     241             :   // before just returning nothing as found in FE vars list.
     242     1950694 :   return getFieldVariable<RealVectorValue>(var_number);
     243             : }
     244             : 
     245             : template <>
     246             : MooseVariableField<RealEigenVector> *
     247        1402 : VariableWarehouse::getActualFieldVariable<RealEigenVector>(const std::string & var_name)
     248             : {
     249        1402 :   return getFieldVariable<RealEigenVector>(var_name);
     250             : }
     251             : 
     252             : template <>
     253             : MooseVariableField<RealEigenVector> *
     254     1124086 : VariableWarehouse::getActualFieldVariable<RealEigenVector>(unsigned int var_number)
     255             : {
     256     1124086 :   return getFieldVariable<RealEigenVector>(var_number);
     257             : }
     258             : 
     259             : void
     260      126049 : VariableWarehouse::initialSetup()
     261             : {
     262      295586 :   for (auto & pair : _all_objects)
     263      169537 :     pair.second->initialSetup();
     264      126049 : }
     265             : 
     266             : void
     267      639166 : VariableWarehouse::timestepSetup()
     268             : {
     269     1804651 :   for (auto & pair : _all_objects)
     270     1165485 :     pair.second->timestepSetup();
     271      639166 : }
     272             : 
     273             : void
     274     4135877 : VariableWarehouse::customSetup(const ExecFlagType & exec_type)
     275             : {
     276    10480108 :   for (auto & pair : _all_objects)
     277     6344231 :     pair.second->customSetup(exec_type);
     278     4135877 : }
     279             : 
     280             : void
     281     6447797 : VariableWarehouse::subdomainSetup()
     282             : {
     283    14176318 :   for (auto & pair : _all_objects)
     284     7728521 :     pair.second->subdomainSetup();
     285     6447797 : }
     286             : 
     287             : void
     288     1117528 : VariableWarehouse::jacobianSetup()
     289             : {
     290     2413029 :   for (auto & pair : _all_objects)
     291     1295501 :     pair.second->jacobianSetup();
     292     1117528 : }
     293             : 
     294             : void
     295     7050427 : VariableWarehouse::residualSetup()
     296             : {
     297    14719640 :   for (auto & pair : _all_objects)
     298     7669213 :     pair.second->residualSetup();
     299     7050427 : }
     300             : 
     301             : void
     302      771546 : VariableWarehouse::clearAllDofIndices()
     303             : {
     304     2011975 :   for (auto * var : _vars)
     305     1240429 :     var->clearAllDofIndices();
     306      771546 : }
     307             : 
     308             : void
     309    13746547 : VariableWarehouse::setActiveVariableCoupleableVectorTags(const std::set<TagID> & vtags)
     310             : {
     311    31642085 :   for (auto * var : _vars)
     312    17895538 :     var->setActiveTags(vtags);
     313    13746547 : }
     314             : 
     315             : void
     316       99768 : VariableWarehouse::setActiveScalarVariableCoupleableVectorTags(const std::set<TagID> & vtags)
     317             : {
     318      209606 :   for (auto * var : _scalar_vars)
     319      109838 :     var->setActiveTags(vtags);
     320       99768 : }
     321             : 
     322             : template MooseVariableField<Real> *
     323             : VariableWarehouse::getActualFieldVariable<Real>(const std::string & var_name);
     324             : template MooseVariableField<Real> *
     325             : VariableWarehouse::getActualFieldVariable<Real>(unsigned int var_number);