doxygen/moose/Coupleable_8h_source.html

 //* 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 <unordered_map>
 #include "MooseTypes.h"
 #include "MooseArray.h"
 #include "MooseVariableFE.h"
 #include "MooseVariableFV.h"
 #include "MooseLinearVariableFV.h"
 #include "InputParameters.h"
 #include "HasMembers.h"

 #define usingCoupleableMembers                                                                     \
   using Coupleable::_zero;                                                                         \
   using Coupleable::_grad_zero;                                                                    \
   using Coupleable::_ad_zero;                                                                      \
   using Coupleable::_ad_grad_zero

 // Forward declarations
 class MooseVariableScalar;
 class MooseObject;

 namespace libMesh
 {
 template <typename T>
 class DenseVector;
 }

 template <typename>
 class MooseVariableField;
 typedef MooseVariableField<Real> MooseWritableVariable;

 class Coupleable
 {
 public:
   Coupleable(const MooseObject * moose_object, bool nodal, bool is_fv = false);

   const std::unordered_map<std::string, std::vector<MooseVariableFieldBase *>> &
   getCoupledVars() const
   {
     return _coupled_vars;
   }

   const std::vector<MooseVariableFieldBase *> & getCoupledMooseVars() const
   {
     return _coupled_moose_vars;
   }

   const std::vector<MooseVariable *> & getCoupledStandardMooseVars() const
   {
     return _coupled_standard_moose_vars;
   }

   const std::vector<VectorMooseVariable *> & getCoupledVectorMooseVars() const
   {
     return _coupled_vector_moose_vars;
   }

   const std::vector<ArrayMooseVariable *> & getCoupledArrayMooseVars() const
   {
     return _coupled_array_moose_vars;
   }

   void addFEVariableCoupleableVectorTag(TagID tag) { _fe_coupleable_vector_tags.insert(tag); }

   void addFEVariableCoupleableMatrixTag(TagID tag) { _fe_coupleable_matrix_tags.insert(tag); }

   std::set<TagID> & getFEVariableCoupleableVectorTags() { return _fe_coupleable_vector_tags; }

   std::set<TagID> & getFEVariableCoupleableMatrixTags() { return _fe_coupleable_matrix_tags; }

   const std::set<TagID> & getFEVariableCoupleableVectorTags() const
   {
     return _fe_coupleable_vector_tags;
   }

   const std::set<TagID> & getFEVariableCoupleableMatrixTags() const
   {
     return _fe_coupleable_matrix_tags;
   }

   auto & getWritableCoupledVariables() const { return _writable_coupled_variables[_c_tid]; }

   bool hasWritableCoupledVariables() const { return !getWritableCoupledVariables().empty(); }

 protected:
   virtual void coupledCallback(const std::string & /*var_name*/, bool /*is_old*/) const {}

   virtual bool isCoupled(const std::string & var_name, unsigned int i = 0) const;

   virtual bool isCoupledConstant(const std::string & var_name) const;

   unsigned int coupledComponents(const std::string & var_name) const;

   VariableName coupledName(const std::string & var_name, unsigned int comp = 0) const;

   std::vector<VariableName> coupledNames(const std::string & var_name) const;

   virtual unsigned int coupled(const std::string & var_name, unsigned int comp = 0) const;

   std::vector<unsigned int> coupledIndices(const std::string & var_name) const;

   virtual const VariableValue & coupledValue(const std::string & var_name,
                                              unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledValues(const std::string & var_name) const;

   std::vector<const VectorVariableValue *> coupledVectorValues(const std::string & var_name) const;

   template <bool is_ad>
   const GenericVariableValue<is_ad> & coupledGenericValue(const std::string & var_name,
                                                           unsigned int comp = 0) const;

   template <bool is_ad>
   std::vector<const GenericVariableValue<is_ad> *>
   coupledGenericValues(const std::string & var_name) const;

   template <bool is_ad>
   const GenericVariableValue<is_ad> & coupledGenericDofValue(const std::string & var_name,
                                                              unsigned int comp = 0) const;

   virtual const VariableValue & coupledValueLower(const std::string & var_name,
                                                   unsigned int comp = 0) const;

   const ADVariableValue & adCoupledValue(const std::string & var_name, unsigned int comp = 0) const;

   std::vector<const ADVariableValue *> adCoupledValues(const std::string & var_name) const;

   const ADVariableValue & adCoupledLowerValue(const std::string & var_name,
                                               unsigned int comp = 0) const;

   const ADVectorVariableValue & adCoupledVectorValue(const std::string & var_name,
                                                      unsigned int comp = 0) const;

   std::vector<const ADVectorVariableValue *>
   adCoupledVectorValues(const std::string & var_name) const;

   virtual const VariableValue &
   coupledVectorTagValue(const std::string & var_names, TagID tag, unsigned int index = 0) const;

   virtual const VariableValue & coupledVectorTagValue(const std::string & var_names,
                                                       const std::string & tag_name,
                                                       unsigned int index = 0) const;

   std::vector<const VariableValue *> coupledVectorTagValues(const std::string & var_names,
                                                             TagID tag) const;

   std::vector<const VariableValue *> coupledVectorTagValues(const std::string & var_names,
                                                             const std::string & tag_name) const;

   virtual const ArrayVariableValue & coupledVectorTagArrayValue(const std::string & var_names,
                                                                 TagID tag,
                                                                 unsigned int index = 0) const;

   virtual const ArrayVariableValue & coupledVectorTagArrayValue(const std::string & var_names,
                                                                 const std::string & tag_name,
                                                                 unsigned int index = 0) const;

   std::vector<const ArrayVariableValue *> coupledVectorTagArrayValues(const std::string & var_names,
                                                                       TagID tag) const;

   std::vector<const ArrayVariableValue *>
   coupledVectorTagArrayValues(const std::string & var_names, const std::string & tag_name) const;

   virtual const VariableGradient &
   coupledVectorTagGradient(const std::string & var_names, TagID tag, unsigned int index = 0) const;

   virtual const VariableGradient & coupledVectorTagGradient(const std::string & var_names,
                                                             const std::string & tag_name,
                                                             unsigned int index = 0) const;

   std::vector<const VariableGradient *> coupledVectorTagGradients(const std::string & var_names,
                                                                   TagID tag) const;

   std::vector<const VariableGradient *>
   coupledVectorTagGradients(const std::string & var_names, const std::string & tag_name) const;

   virtual const ArrayVariableGradient & coupledVectorTagArrayGradient(const std::string & var_names,
                                                                       TagID tag,
                                                                       unsigned int index = 0) const;

   virtual const ArrayVariableGradient & coupledVectorTagArrayGradient(const std::string & var_names,
                                                                       const std::string & tag_name,
                                                                       unsigned int index = 0) const;

   std::vector<const ArrayVariableGradient *>
   coupledVectorTagArrayGradients(const std::string & var_names, TagID tag) const;

   std::vector<const ArrayVariableGradient *>
   coupledVectorTagArrayGradients(const std::string & var_names, const std::string & tag_name) const;

   virtual const VariableValue &
   coupledVectorTagDofValue(const std::string & var_name, TagID tag, unsigned int index = 0) const;

   virtual const VariableValue & coupledVectorTagDofValue(const std::string & var_names,
                                                          const std::string & tag_name,
                                                          unsigned int index = 0) const;

   const ArrayVariableValue & coupledVectorTagArrayDofValue(const std::string & var_name,
                                                            const std::string & tag_name,
                                                            unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledVectorTagDofValues(const std::string & var_names,
                                                                TagID tag) const;

   std::vector<const VariableValue *> coupledVectorTagDofValues(const std::string & var_names,
                                                                const std::string & tag_name) const;

   virtual const VariableValue &
   coupledMatrixTagValue(const std::string & var_names, TagID tag, unsigned int index = 0) const;

   virtual const VariableValue & coupledMatrixTagValue(const std::string & var_names,
                                                       const std::string & tag_name,
                                                       unsigned int index = 0) const;

   std::vector<const VariableValue *> coupledMatrixTagValues(const std::string & var_names,
                                                             TagID tag) const;

   std::vector<const VariableValue *> coupledMatrixTagValues(const std::string & var_names,
                                                             const std::string & tag_name) const;

   virtual const VectorVariableValue & coupledVectorValue(const std::string & var_name,
                                                          unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayValue(const std::string & var_name,
                                                        unsigned int comp = 0) const;

   std::vector<const ArrayVariableValue *> coupledArrayValues(const std::string & var_name) const;

   MooseWritableVariable & writableVariable(const std::string & var_name, unsigned int comp = 0);

   virtual VariableValue & writableCoupledValue(const std::string & var_name, unsigned int comp = 0);

   void checkWritableVar(MooseWritableVariable * var);

   virtual const VariableValue & coupledValueOld(const std::string & var_name,
                                                 unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledValuesOld(const std::string & var_name) const;

   virtual const VariableValue & coupledValueOlder(const std::string & var_name,
                                                   unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledValuesOlder(const std::string & var_name) const;

   virtual const VariableValue & coupledValuePreviousNL(const std::string & var_name,
                                                        unsigned int comp = 0) const;

   virtual const VectorVariableValue & coupledVectorValueOld(const std::string & var_name,
                                                             unsigned int comp = 0) const;

   virtual const VectorVariableValue & coupledVectorValueOlder(const std::string & var_name,
                                                               unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayValueOld(const std::string & var_name,
                                                           unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayValueOlder(const std::string & var_name,
                                                             unsigned int comp = 0) const;

   virtual const VariableGradient & coupledGradient(const std::string & var_name,
                                                    unsigned int comp = 0) const;

   std::vector<const VariableGradient *> coupledGradients(const std::string & var_name) const;

   const ADVariableGradient & adCoupledGradient(const std::string & var_name,
                                                unsigned int comp = 0) const;

   const ADVariableGradient & adCoupledGradientDot(const std::string & var_name,
                                                   unsigned int comp = 0) const;

   std::vector<const ADVariableGradient *> adCoupledGradients(const std::string & var_name) const;

   template <bool is_ad>
   const GenericVariableGradient<is_ad> & coupledGenericGradient(const std::string & var_name,
                                                                 unsigned int comp = 0) const;

   template <bool is_ad>
   std::vector<const GenericVariableGradient<is_ad> *>
   coupledGenericGradients(const std::string & var_name) const;

   const ADVectorVariableGradient & adCoupledVectorGradient(const std::string & var_name,
                                                            unsigned int comp = 0) const;

   const ADVariableSecond & adCoupledSecond(const std::string & var_name,
                                            unsigned int comp = 0) const;

   const ADVectorVariableSecond & adCoupledVectorSecond(const std::string & var_name,
                                                        unsigned int comp = 0) const;

   virtual const VariableGradient & coupledGradientOld(const std::string & var_name,
                                                       unsigned int comp = 0) const;

   std::vector<const VariableGradient *> coupledGradientsOld(const std::string & var_name) const;

   virtual const VariableGradient & coupledGradientOlder(const std::string & var_name,
                                                         unsigned int comp = 0) const;

   virtual const VariableGradient & coupledGradientPreviousNL(const std::string & var_name,
                                                              unsigned int comp = 0) const;

   virtual const VariableGradient & coupledGradientDot(const std::string & var_name,
                                                       unsigned int comp = 0) const;

   virtual const VariableGradient & coupledGradientDotDot(const std::string & var_name,
                                                          unsigned int comp = 0) const;

   virtual const VectorVariableGradient & coupledVectorGradient(const std::string & var_name,
                                                                unsigned int comp = 0) const;

   virtual const VectorVariableGradient & coupledVectorGradientOld(const std::string & var_name,
                                                                   unsigned int comp = 0) const;

   virtual const VectorVariableGradient & coupledVectorGradientOlder(const std::string & var_name,
                                                                     unsigned int comp = 0) const;

   virtual const ArrayVariableGradient & coupledArrayGradient(const std::string & var_name,
                                                              unsigned int comp = 0) const;

   virtual const ArrayVariableGradient & coupledArrayGradientOld(const std::string & var_name,
                                                                 unsigned int comp = 0) const;

   virtual const ArrayVariableGradient & coupledArrayGradientOlder(const std::string & var_name,
                                                                   unsigned int comp = 0) const;

   virtual const ArrayVariableGradient & coupledArrayGradientDot(const std::string & var_name,
                                                                 unsigned int comp = 0) const;

   virtual const VectorVariableCurl & coupledCurl(const std::string & var_name,
                                                  unsigned int comp = 0) const;

   virtual const VectorVariableCurl & coupledCurlOld(const std::string & var_name,
                                                     unsigned int comp = 0) const;

   virtual const VectorVariableCurl & coupledCurlOlder(const std::string & var_name,
                                                       unsigned int comp = 0) const;

   virtual const VectorVariableDivergence & coupledDiv(const std::string & var_name,
                                                       unsigned int comp = 0) const;

   virtual const VectorVariableDivergence & coupledDivOld(const std::string & var_name,
                                                          unsigned int comp = 0) const;

   virtual const VectorVariableDivergence & coupledDivOlder(const std::string & var_name,
                                                            unsigned int comp = 0) const;

   virtual const VariableSecond & coupledSecond(const std::string & var_name,
                                                unsigned int comp = 0) const;

   virtual const VariableSecond & coupledSecondOld(const std::string & var_name,
                                                   unsigned int comp = 0) const;

   virtual const VariableSecond & coupledSecondOlder(const std::string & var_name,
                                                     unsigned int comp = 0) const;

   virtual const VariableSecond & coupledSecondPreviousNL(const std::string & var_name,
                                                          unsigned int comp = 0) const;

   virtual const VariableValue & coupledDot(const std::string & var_name,
                                            unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledDots(const std::string & var_name) const;

   virtual const VariableValue & coupledDotDot(const std::string & var_name,
                                               unsigned int comp = 0) const;

   virtual const VariableValue & coupledDotOld(const std::string & var_name,
                                               unsigned int comp = 0) const;

   virtual const VariableValue & coupledDotDotOld(const std::string & var_name,
                                                  unsigned int comp = 0) const;

   const ADVariableValue & adCoupledDot(const std::string & var_name, unsigned int comp = 0) const;

   std::vector<const ADVariableValue *> adCoupledDots(const std::string & var_name) const;

   const ADVariableValue & adCoupledDotDot(const std::string & var_name,
                                           unsigned int comp = 0) const;

   const ADVectorVariableValue & adCoupledVectorDot(const std::string & var_name,
                                                    unsigned int comp = 0) const;

   virtual const VectorVariableValue & coupledVectorDot(const std::string & var_name,
                                                        unsigned int comp = 0) const;

   virtual const VectorVariableValue & coupledVectorDotDot(const std::string & var_name,
                                                           unsigned int comp = 0) const;

   virtual const VectorVariableValue & coupledVectorDotOld(const std::string & var_name,
                                                           unsigned int comp = 0) const;

   virtual const VectorVariableValue & coupledVectorDotDotOld(const std::string & var_name,
                                                              unsigned int comp = 0) const;

   virtual const VariableValue & coupledVectorDotDu(const std::string & var_name,
                                                    unsigned int comp = 0) const;

   virtual const VariableValue & coupledVectorDotDotDu(const std::string & var_name,
                                                       unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayDot(const std::string & var_name,
                                                      unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayDotDot(const std::string & var_name,
                                                         unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayDotOld(const std::string & var_name,
                                                         unsigned int comp = 0) const;

   virtual const ArrayVariableValue & coupledArrayDotDotOld(const std::string & var_name,
                                                            unsigned int comp = 0) const;

   virtual const VariableValue & coupledDotDu(const std::string & var_name,
                                              unsigned int comp = 0) const;

   virtual const VariableValue & coupledDotDotDu(const std::string & var_name,
                                                 unsigned int comp = 0) const;

   const VariableValue & coupledArrayDotDu(const std::string & var_name,
                                           unsigned int comp = 0) const;

   template <typename T>
   const T & coupledNodalValue(const std::string & var_name, unsigned int comp = 0) const;

   template <typename T>
   const typename Moose::ADType<T>::type & adCoupledNodalValue(const std::string & var_name,
                                                               unsigned int comp = 0) const;

   template <typename T>
   const T & coupledNodalValueOld(const std::string & var_name, unsigned int comp = 0) const;

   template <typename T>
   const T & coupledNodalValueOlder(const std::string & var_name, unsigned int comp = 0) const;

   template <typename T>
   const T & coupledNodalValuePreviousNL(const std::string & var_name, unsigned int comp = 0) const;

   template <typename T>
   const T & coupledNodalDot(const std::string & var_name, unsigned int comp = 0) const;

   virtual const VariableValue & coupledNodalDotDot(const std::string & var_name,
                                                    unsigned int comp = 0) const;

   virtual const VariableValue & coupledNodalDotOld(const std::string & var_name,
                                                    unsigned int comp = 0) const;

   virtual const VariableValue & coupledNodalDotDotOld(const std::string & var_name,
                                                       unsigned int comp = 0) const;
   // coupled-dof-values-begin
   virtual const VariableValue & coupledDofValues(const std::string & var_name,
                                                  unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledAllDofValues(const std::string & var_name) const;

   virtual const VariableValue & coupledDofValuesOld(const std::string & var_name,
                                                     unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledAllDofValuesOld(const std::string & var_name) const;

   virtual const VariableValue & coupledDofValuesOlder(const std::string & var_name,
                                                       unsigned int comp = 0) const;

   std::vector<const VariableValue *> coupledAllDofValuesOlder(const std::string & var_name) const;

   virtual const ArrayVariableValue & coupledArrayDofValues(const std::string & var_name,
                                                            unsigned int comp = 0) const;
   // coupled-dof-values-end

   virtual const ADVariableValue & adCoupledDofValues(const std::string & var_name,
                                                      unsigned int comp = 0) const;

   const ADVariableValue & adZeroValue() const;

   const ADVariableGradient & adZeroGradient() const;

   const ADVariableSecond & adZeroSecond() const;

   template <bool is_ad>
   const GenericVariableValue<is_ad> & genericZeroValue();

   template <bool is_ad>
   const GenericVariableGradient<is_ad> & genericZeroGradient();

   template <bool is_ad>
   const GenericVariableSecond<is_ad> & genericZeroSecond();

 protected:
   // Reference to the interface's input parameters
   const InputParameters & _c_parameters;

   const std::string & _c_name;
   const std::string & _c_type;

   // Reference to FEProblemBase
   FEProblemBase & _c_fe_problem;

   const SystemBase * const _c_sys;

   std::unordered_map<std::string, std::vector<MooseVariableFieldBase *>> _coupled_vars;

   std::vector<MooseVariableFieldBase *> _coupled_moose_vars;

   std::vector<MooseVariable *> _coupled_standard_moose_vars;

   std::vector<VectorMooseVariable *> _coupled_vector_moose_vars;

   std::vector<ArrayMooseVariable *> _coupled_array_moose_vars;

   std::vector<MooseVariableFV<Real> *> _coupled_standard_fv_moose_vars;

   std::vector<MooseLinearVariableFV<Real> *> _coupled_standard_linear_fv_moose_vars;

   const std::unordered_map<std::string, std::string> & _new_to_deprecated_coupled_vars;

   bool _c_nodal;

   bool _c_is_implicit;

   // Argument to allow element-to-nodal coupling
   const bool _c_allow_element_to_nodal_coupling;

   THREAD_ID _c_tid;

   mutable std::unordered_map<std::string, std::vector<std::unique_ptr<VariableValue>>>
       _default_value;

   mutable std::unordered_map<std::string, std::unique_ptr<MooseArray<DualReal>>> _ad_default_value;

   mutable std::unordered_map<std::string, std::unique_ptr<VectorVariableValue>>
       _default_vector_value;

   mutable std::unordered_map<std::string, std::unique_ptr<ArrayVariableValue>> _default_array_value;

   mutable std::unordered_map<std::string, std::unique_ptr<MooseArray<ADRealVectorValue>>>
       _ad_default_vector_value;

   mutable VariableValue _default_value_zero;

   mutable VariableGradient _default_gradient;

   mutable MooseArray<ADRealVectorValue> _ad_default_gradient;

   mutable MooseArray<ADRealTensorValue> _ad_default_vector_gradient;

   mutable VariableSecond _default_second;

   mutable MooseArray<ADRealTensorValue> _ad_default_second;

   const VariableValue & _zero;
   const VariablePhiValue & _phi_zero;
   const MooseArray<DualReal> & _ad_zero;

   const VariableGradient & _grad_zero;
   const MooseArray<ADRealVectorValue> & _ad_grad_zero;

   const VariablePhiGradient & _grad_phi_zero;

   const VariableSecond & _second_zero;
   const MooseArray<ADRealTensorValue> & _ad_second_zero;
   const VariablePhiSecond & _second_phi_zero;
   const VectorVariableValue & _vector_zero;
   const VectorVariableCurl & _vector_curl_zero;

   mutable VectorVariableValue _default_vector_value_zero;

   mutable VectorVariableGradient _default_vector_gradient;

   mutable VectorVariableCurl _default_vector_curl;

   mutable VectorVariableDivergence _default_div;

   ArrayVariableValue _default_array_value_zero;

   ArrayVariableGradient _default_array_gradient;

   bool
   checkVar(const std::string & var_name, unsigned int comp = 0, unsigned int comp_bound = 0) const;

 private:
   template <typename T>
   const typename OutputTools<T>::VariableValue &
   vectorTagValueHelper(const std::string & var_names, TagID tag, unsigned int index = 0) const;

   template <typename T>
   const typename OutputTools<T>::VariableValue & vectorTagValueHelper(const std::string & var_names,
                                                                       const std::string & tag_name,
                                                                       unsigned int index = 0) const;

   template <typename T>
   const typename OutputTools<T>::VariableValue &
   vectorTagDofValueHelper(const std::string & var_name, TagID tag, unsigned int comp = 0) const;

   template <typename T>
   const typename OutputTools<T>::VariableValue & vectorTagDofValueHelper(
       const std::string & var_name, const std::string & tag_name, unsigned int comp = 0) const;

   template <typename T>
   void
   requestStates(const std::string & var_name, const TagName & tag_name, const unsigned int comp);

   enum class FuncAge
   {
     Curr,
     Old,
     Older,
   };

   enum class VarType
   {
     Ignore,
     Gradient,
     Second,
     GradientDot,
     Dot,
   };

   void checkFuncType(const std::string var_name, VarType t, FuncAge age) const;

 protected:
   const MooseVariableFieldBase * getFEVar(const std::string & var_name, unsigned int comp) const;

   /*
    * Extract pointer to a base coupled field variable. Could be either a finite volume or finite
    * element variable
    * @param var_name Name of parameter desired
    * @param comp Component number of multiple coupled variables
    * @return Pointer to the desired variable
    */
   const MooseVariableFieldBase * getFieldVar(const std::string & var_name, unsigned int comp) const;

   /*
    * Extract pointer to a base coupled field variable. Could be either a finite volume or finite
    * element variable
    * @param var_name Name of variable desired
    * @param comp Component number of multiple coupled variables
    * @return Pointer to the desired variable
    */
   MooseVariableFieldBase * getFieldVar(const std::string & var_name, unsigned int comp);

   template <typename T>
   const T * getVarHelper(const std::string & var_name, unsigned int comp) const;

   template <typename T>
   T * getVarHelper(const std::string & var_name, unsigned int comp);

   MooseVariable * getVar(const std::string & var_name, unsigned int comp);

   VectorMooseVariable * getVectorVar(const std::string & var_name, unsigned int comp);

   ArrayMooseVariable * getArrayVar(const std::string & var_name, unsigned int comp);

   const MooseVariable * getVar(const std::string & var_name, unsigned int comp) const;

   const VectorMooseVariable * getVectorVar(const std::string & var_name, unsigned int comp) const;

   const ArrayMooseVariable * getArrayVar(const std::string & var_name, unsigned int comp) const;

   void validateExecutionerType(const std::string & name, const std::string & fn_name) const;

   template <typename T, typename Func>
   std::vector<T> coupledVectorHelper(const std::string & var_name, const Func & func) const
   {
     const auto components = coupledComponents(var_name);
     std::vector<T> vals(components);
     for (MooseIndex(components) comp = 0; comp < components; ++comp)
       vals[comp] = func(comp);
     return vals;
   }

   bool _coupleable_neighbor;

 public:
   const ADVariableValue * getADDefaultValue(const std::string & var_name) const;

   const ADVectorVariableValue * getADDefaultVectorValue(const std::string & var_name) const;

   const ADVariableGradient & getADDefaultGradient() const;

   const ADVectorVariableGradient & getADDefaultVectorGradient() const;

   const ADVariableSecond & getADDefaultSecond() const;

 private:
   const VariableValue * getDefaultValue(const std::string & var_name, unsigned int comp) const;

   const VectorVariableValue * getDefaultVectorValue(const std::string & var_name) const;

   const ArrayVariableValue * getDefaultArrayValue(const std::string & var_name) const;

   template <typename T>
   const T & getDefaultNodalValue(const std::string & var_name, unsigned int comp = 0) const;

   template <typename T>
   const Moose::Functor<T> & getDefaultFunctor(const std::string & var_name) const;

   unsigned int _coupleable_max_qps;

   std::unordered_map<std::string, std::vector<unsigned int>> _optional_var_index;

   std::unordered_map<std::string, std::vector<MooseVariableScalar *>> _c_coupled_scalar_vars;

   std::set<TagID> _fe_coupleable_vector_tags;

   std::set<TagID> _fe_coupleable_matrix_tags;

   const bool _is_fv;

   const MooseObject * const _obj;

   const std::set<std::string> _older_state_tags = {Moose::OLD_SOLUTION_TAG,
                                                    Moose::OLDER_SOLUTION_TAG};

   std::vector<std::set<MooseWritableVariable *>> _writable_coupled_variables;
 };

 template <typename T>
 T *
 Coupleable::getVarHelper(const std::string & var_name_in, unsigned int comp)
 {
   const auto var_name = _c_parameters.checkForRename(var_name_in);
   auto name_to_use = var_name;

   // First check for supplied name
   if (!checkVar(var_name, comp, 0))
   {
     // See if there is an associated deprecated name that the user may have used instead
     auto it = _new_to_deprecated_coupled_vars.find(var_name);
     if (it == _new_to_deprecated_coupled_vars.end())
       return nullptr;
     else
     {
       auto deprecated_name = it->second;
       if (checkVar(deprecated_name, comp, 0))
         name_to_use = deprecated_name;
       else
         return nullptr;
     }
   }

   auto coupled_vars_it = _coupled_vars.find(name_to_use);

   mooseAssert(coupled_vars_it != _coupled_vars.end(),
               "Trying to get a coupled var " << name_to_use << " that doesn't exist");

   if (auto coupled_var = dynamic_cast<T *>(coupled_vars_it->second[comp]))
     return coupled_var;
   else
   {
     for (auto & var : _coupled_standard_moose_vars)
       if (var->name() == name_to_use)
         mooseError("The named variable is a standard variable, try a "
                    "'coupled[Value/Gradient/Dot/etc]...' function instead");
     for (auto & var : _coupled_vector_moose_vars)
       if (var->name() == name_to_use)
         mooseError("The named variable is a vector variable, try a "
                    "'coupledVector[Value/Gradient/Dot/etc]...' function instead");
     for (auto & var : _coupled_array_moose_vars)
       if (var->name() == name_to_use)
         mooseError("The named variable is an array variable, try a "
                    "'coupledArray[Value/Gradient/Dot/etc]...' function instead");
     for (auto & var : _coupled_standard_fv_moose_vars)
       if (var->name() == name_to_use)
         mooseError("The named variable is a finite volume variable, which the coupled[...] routine "
                    "used does not support. Try using the functor system routines instead.");
     mooseError(
         "Variable '", name_to_use, "' is of a different C++ type than you tried to fetch it as.");
   }
 }

 template <typename T>
 const T *
 Coupleable::getVarHelper(const std::string & var_name, unsigned int comp) const
 {
   return const_cast<Coupleable *>(this)->getVarHelper<T>(var_name, comp);
 }
Coupleable::coupledArrayDotDotOld
virtual const ArrayVariableValue & coupledArrayDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled array variable.
Definition: Coupleable.C:1384

Coupleable::coupledDofValues
virtual const VariableValue & coupledDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the current solution vector of a coupled variable for the local element.
Definition: Coupleable.C:1978

Coupleable::coupledVectorTagValue
virtual const VariableValue & coupledVectorTagValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled variable for a given tag.
Definition: Coupleable.C:604

Coupleable::coupledVectorTagGradient
virtual const VariableGradient & coupledVectorTagGradient(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns gradient of a coupled variable for a given tag.
Definition: Coupleable.C:636

Coupleable::coupledArrayValueOlder
virtual const ArrayVariableValue & coupledArrayValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old value from two time steps previous of a coupled array variable.
Definition: Coupleable.C:1100

VariableGradient
OutputTools< Real >::VariableGradient VariableGradient
Definition: MooseTypes.h:303

Coupleable::coupledNodalDot
const T & coupledNodalDot(const std::string &var_name, unsigned int comp=0) const
Nodal values of time derivative of a coupled variable.
Definition: Coupleable.C:1916

VectorVariableDivergence
OutputTools< RealVectorValue >::VariableDivergence VectorVariableDivergence
Definition: MooseTypes.h:323

Coupleable::validateExecutionerType
void validateExecutionerType(const std::string &name, const std::string &fn_name) const
Checks to make sure that the current Executioner has set "_is_transient" when old/older values are co...
Definition: Coupleable.C:2069

Coupleable::isCoupled
virtual bool isCoupled(const std::string &var_name, unsigned int i=0) const
Returns true if a variables has been coupled as name.
Definition: Coupleable.C:128

Coupleable::coupledVectorGradient
virtual const VectorVariableGradient & coupledVectorGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled vector variable.
Definition: Coupleable.C:1578

Coupleable::getCoupledArrayMooseVars
const std::vector< ArrayMooseVariable * > & getCoupledArrayMooseVars() const
Get the list of array coupled variables.
Definition: Coupleable.h:97

Coupleable::_c_nodal
bool _c_nodal
True if we provide coupling to nodal values.
Definition: Coupleable.h:1382

Coupleable::checkFuncType
void checkFuncType(const std::string var_name, VarType t, FuncAge age) const
Definition: Coupleable.C:191

Coupleable::getCoupledVectorMooseVars
const std::vector< VectorMooseVariable * > & getCoupledVectorMooseVars() const
Get the list of vector coupled variables.
Definition: Coupleable.h:88

Coupleable::_default_vector_curl
VectorVariableCurl _default_vector_curl
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1464

Coupleable::getVectorVar
VectorMooseVariable * getVectorVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled vector variable.
Definition: Coupleable.C:293

InputParameters.h

Coupleable::_zero
const VariableValue & _zero
Zero value of a variable.
Definition: Coupleable.h:1433

Coupleable::_grad_phi_zero
const VariablePhiGradient & _grad_phi_zero
Zero gradient of trial function.
Definition: Coupleable.h:1442

Coupleable::coupled
virtual unsigned int coupled(const std::string &var_name, unsigned int comp=0) const
Returns the index for a coupled variable by name.
Definition: Coupleable.C:441

Coupleable::coupledVectorDotDot
virtual const VectorVariableValue & coupledVectorDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled vector variable.
Definition: Coupleable.C:1238

Coupleable::_second_phi_zero
const VariablePhiSecond & _second_phi_zero
Zero second derivative of a test function.
Definition: Coupleable.h:1448

Coupleable::coupledSecondPreviousNL
virtual const VariableSecond & coupledSecondPreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns second derivative of a coupled variable for the previous Newton iterate.
Definition: Coupleable.C:1822

Coupleable::_ad_default_vector_value
std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > > _ad_default_vector_value
Will hold the default value for optional vector coupled variables for automatic differentiation.
Definition: Coupleable.h:1409

Coupleable::getDefaultArrayValue
const ArrayVariableValue * getDefaultArrayValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for an uncoupled array variable...
Definition: Coupleable.C:396

Coupleable::coupledGenericGradient
const GenericVariableGradient< is_ad > & coupledGenericGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for use in templated automatic differentiation.

Coupleable::coupledValuesOlder
std::vector< const VariableValue * > coupledValuesOlder(const std::string &var_name) const
Returns the older values for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2634

Coupleable::adZeroSecond
const ADVariableSecond & adZeroSecond() const
Retrieve a zero second for automatic differentiation.
Definition: Coupleable.C:2352

Coupleable::getADDefaultVectorValue
const ADVectorVariableValue * getADDefaultVectorValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default vector value for Automatic Differentiat...
Definition: Coupleable.C:2300

Coupleable::coupledSecond
virtual const VariableSecond & coupledSecond(const std::string &var_name, unsigned int comp=0) const
Returns second spatial derivatives of a coupled variable.
Definition: Coupleable.C:1774

Coupleable::isCoupledConstant
virtual bool isCoupledConstant(const std::string &var_name) const
Returns true if a variable passed as a coupled value is really a constant.
Definition: Coupleable.C:151

Coupleable::coupledDotOld
virtual const VariableValue & coupledDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled variable.
Definition: Coupleable.C:1172

GenericVariableValue
typename Moose::GenericType< VariableValue, is_ad > GenericVariableValue
Definition: MooseTypes.h:573

GenericVariableSecond
typename Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
Definition: MooseTypes.h:577

Coupleable::coupledVectorValueOld
virtual const VectorVariableValue & coupledVectorValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old value from previous time step of a coupled vector variable.
Definition: Coupleable.C:1052

MooseVariableFE
Class for stuff related to variables.
Definition: Adaptivity.h:31

Coupleable::coupledArrayValues
std::vector< const ArrayVariableValue * > coupledArrayValues(const std::string &var_name) const
Returns the values for all of a coupled array variable&#39;s components.
Definition: Coupleable.C:856

Coupleable::coupledDots
std::vector< const VariableValue * > coupledDots(const std::string &var_name) const
Returns the time derivatives for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2677

Coupleable::coupledArrayValueOld
virtual const ArrayVariableValue & coupledArrayValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old value from previous time step of a coupled array variable.
Definition: Coupleable.C:1078

TagID
unsigned int TagID
Definition: MooseTypes.h:199

Coupleable::coupledName
VariableName coupledName(const std::string &var_name, unsigned int comp=0) const
Names of the variable in the Coupleable interface.
Definition: Coupleable.C:2422

Coupleable::coupledVectorGradientOld
virtual const VectorVariableGradient & coupledVectorGradientOld(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from previous time step of a coupled vector variable.
Definition: Coupleable.C:1594

Coupleable::FuncAge::Older

MooseWritableVariable
MooseVariableField< Real > MooseWritableVariable
Definition: Coupleable.h:38

Coupleable::VarType::Ignore

MooseVariableField
Class for stuff related to variables.
Definition: Coupleable.h:38

Coupleable::_vector_zero
const VectorVariableValue & _vector_zero
Zero value of a vector variable.
Definition: Coupleable.h:1450

Coupleable::_grad_zero
const VariableGradient & _grad_zero
Zero gradient of a variable.
Definition: Coupleable.h:1438

OutputTools
Definition: MooseTypes.h:266

Coupleable::_coupled_vars
std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > > _coupled_vars
Coupled vars whose values we provide.
Definition: Coupleable.h:1358

Coupleable::_fe_coupleable_matrix_tags
std::set< TagID > _fe_coupleable_matrix_tags
Definition: Coupleable.h:1739

Coupleable::_coupled_standard_fv_moose_vars
std::vector< MooseVariableFV< Real > * > _coupled_standard_fv_moose_vars
Vector of standard finite volume coupled variables.
Definition: Coupleable.h:1373

Coupleable::_ad_grad_zero
const MooseArray< ADRealVectorValue > & _ad_grad_zero
Definition: Coupleable.h:1439

Coupleable::coupledVectorDot
virtual const VectorVariableValue & coupledVectorDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled vector variable.
Definition: Coupleable.C:1222

Coupleable::coupledDotDotDu
virtual const VariableValue & coupledDotDotDu(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable with respect to the coefficients.
Definition: Coupleable.C:1431

Coupleable::checkWritableVar
void checkWritableVar(MooseWritableVariable *var)
Checks that the passed in variable is only accessed writable by one object in a given subdomain...
Definition: Coupleable.C:936

mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:299

Coupleable::_is_fv
const bool _is_fv
Whether the MooseObject is a finite volume object.
Definition: Coupleable.h:1742

Coupleable::coupledDofValuesOld
virtual const VariableValue & coupledDofValuesOld(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the old solution vector of a coupled variable for the local element.
Definition: Coupleable.C:1998

Moose::OLDER_SOLUTION_TAG
const TagName OLDER_SOLUTION_TAG
Definition: MooseTypes.C:29

Coupleable::coupledGenericValues
std::vector< const GenericVariableValue< is_ad > * > coupledGenericValues(const std::string &var_name) const
Returns the values for all of a coupled variable&#39;s components for use in templated automatic differen...

Coupleable::_coupled_array_moose_vars
std::vector< ArrayMooseVariable * > _coupled_array_moose_vars
Vector of array coupled variables.
Definition: Coupleable.h:1370

Coupleable::coupledVectorTagArrayDofValue
const ArrayVariableValue & coupledVectorTagArrayDofValue(const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const
Returns evaluations of a tagged vector at the requested variable&#39;s degree of freedom indices...
Definition: Coupleable.C:768

Coupleable::_second_zero
const VariableSecond & _second_zero
Zero second derivative of a variable.
Definition: Coupleable.h:1445

Coupleable::FuncAge
FuncAge
Definition: Coupleable.h:1525

Coupleable::coupledNodalValue
const T & coupledNodalValue(const std::string &var_name, unsigned int comp=0) const
Returns nodal values of a coupled variable.
Definition: Coupleable.C:1840

Coupleable::coupledVectorHelper
std::vector< T > coupledVectorHelper(const std::string &var_name, const Func &func) const
Definition: Coupleable.h:1641

Coupleable::coupledVectorTagDofValue
virtual const VariableValue & coupledVectorTagDofValue(const std::string &var_name, TagID tag, unsigned int index=0) const
Returns dof value of a coupled variable for a given tag.
Definition: Coupleable.C:752

VectorVariableValue
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
Definition: MooseTypes.h:319

Coupleable::adCoupledGradient
const ADVariableGradient & adCoupledGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2143

Coupleable::_default_div
VectorVariableDivergence _default_div
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1467

Coupleable::_c_allow_element_to_nodal_coupling
const bool _c_allow_element_to_nodal_coupling
Definition: Coupleable.h:1388

Coupleable::coupledVectorTagArrayValues
std::vector< const ArrayVariableValue * > coupledVectorTagArrayValues(const std::string &var_names, TagID tag) const
Returns the values for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2512

Coupleable::coupledArrayDofValues
virtual const ArrayVariableValue & coupledArrayDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the current solution vector of a coupled array variable for the local element...
Definition: Coupleable.C:2039

Coupleable::coupledVectorTagGradients
std::vector< const VariableGradient * > coupledVectorTagGradients(const std::string &var_names, TagID tag) const
Returns gradients for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2535

Coupleable::_fe_coupleable_vector_tags
std::set< TagID > _fe_coupleable_vector_tags
Definition: Coupleable.h:1737

Moose::FunctorEnvelope
This is a wrapper that forwards calls to the implementation, which can be switched out at any time wi...
Definition: MooseFunctor.h:1030

Coupleable::FuncAge::Curr

Coupleable::coupledDot
virtual const VariableValue & coupledDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable.
Definition: Coupleable.C:1122

Coupleable::_c_tid
THREAD_ID _c_tid
Thread ID of the thread using this object.
Definition: Coupleable.h:1391

Coupleable::adCoupledValue
const ADVariableValue & adCoupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2105

InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Definition: InputParameters.h:63

Coupleable::coupledNodalDotDot
virtual const VariableValue & coupledNodalDotDot(const std::string &var_name, unsigned int comp=0) const
Nodal values of second time derivative of a coupled variable.
Definition: Coupleable.C:1930

Coupleable::getADDefaultGradient
const ADVariableGradient & getADDefaultGradient() const
Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation ...
Definition: Coupleable.C:2317

Coupleable::getDefaultVectorValue
const VectorVariableValue * getDefaultVectorValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for an uncoupled vector variable...
Definition: Coupleable.C:361

Coupleable::_writable_coupled_variables
std::vector< std::set< MooseWritableVariable * > > _writable_coupled_variables
keep a set of allocated writable variable references to make sure only one object can obtain them per...
Definition: Coupleable.h:1751

Coupleable::coupledGradientDotDot
virtual const VariableGradient & coupledGradientDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of the gradient of a coupled variable.
Definition: Coupleable.C:1562

VariablePhiValue
OutputTools< Real >::VariablePhiValue VariablePhiValue
Definition: MooseTypes.h:307

Coupleable::_c_coupled_scalar_vars
std::unordered_map< std::string, std::vector< MooseVariableScalar * > > _c_coupled_scalar_vars
Scalar variables coupled into this object (for error checking)
Definition: Coupleable.h:1735

Coupleable::_default_value_zero
VariableValue _default_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1415

Coupleable::getVar
MooseVariable * getVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled variable.
Definition: Coupleable.C:287

Coupleable::genericZeroGradient
const GenericVariableGradient< is_ad > & genericZeroGradient()
Returns zero gradient templated with automatic differentiation boolean.

VectorVariableCurl
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
Definition: MooseTypes.h:322

Coupleable::coupledArrayDotOld
virtual const ArrayVariableValue & coupledArrayDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled array variable.
Definition: Coupleable.C:1362

Coupleable::coupledValueOld
virtual const VariableValue & coupledValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old value from previous time step of a coupled variable.
Definition: Coupleable.C:985

MooseVariableFieldBase
This class provides an interface for common operations on field variables of both FE and FV types wit...
Definition: MooseVariableFieldBase.h:29

Coupleable::coupledArrayDot
virtual const ArrayVariableValue & coupledArrayDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled array variable.
Definition: Coupleable.C:1318

libMesh
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...

Coupleable::coupledMatrixTagValue
virtual const VariableValue & coupledMatrixTagValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled variable for a given tag.
Definition: Coupleable.C:776

Coupleable::coupledCallback
virtual void coupledCallback(const std::string &, bool) const
A call-back function provided by the derived object for actions before coupling a variable with funct...
Definition: Coupleable.h:135

Coupleable::adZeroGradient
const ADVariableGradient & adZeroGradient() const
method that returns _grad_zero to RESIDUAL computing objects and _ad_grad_zero to JACOBIAN computing ...
Definition: Coupleable.C:2345

Coupleable::writableVariable
MooseWritableVariable & writableVariable(const std::string &var_name, unsigned int comp=0)
Returns a writable MooseVariable object for a nodal or elemental variable.
Definition: Coupleable.C:863

SystemBase
Base class for a system (of equations)
Definition: SystemBase.h:85

Coupleable::coupledDivOlder
virtual const VectorVariableDivergence & coupledDivOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old divergence from two time steps previous of a coupled variable.
Definition: Coupleable.C:1758

Coupleable::_default_vector_value
std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > > _default_vector_value
Will hold the default value for optional vector coupled variables.
Definition: Coupleable.h:1402

Coupleable::writableCoupledValue
virtual VariableValue & writableCoupledValue(const std::string &var_name, unsigned int comp=0)
Returns a writable reference to a coupled variable for writing to multiple AuxVariables from a single...
Definition: Coupleable.C:898

Coupleable::coupledNames
std::vector< VariableName > coupledNames(const std::string &var_name) const
Names of the variables in the Coupleable interface.
Definition: Coupleable.C:2439

FEProblemBase
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition: FEProblemBase.h:148

Coupleable::coupledGradient
virtual const VariableGradient & coupledGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable.
Definition: Coupleable.C:1481

Coupleable::getVarHelper
const T * getVarHelper(const std::string &var_name, unsigned int comp) const
Helper that that be used to retrieve a variable of arbitrary type T.
Definition: Coupleable.h:1810

Coupleable::VarType::GradientDot

VariablePhiSecond
OutputTools< Real >::VariablePhiSecond VariablePhiSecond
Definition: MooseTypes.h:309

Coupleable::coupledNodalValuePreviousNL
const T & coupledNodalValuePreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns nodal values of a coupled variable for previous Newton iterate.
Definition: Coupleable.C:1900

Coupleable::adCoupledValues
std::vector< const ADVariableValue * > adCoupledValues(const std::string &var_name) const
Returns the values for all of a coupled variable&#39;s components for use in Automatic Differentiation...
Definition: Coupleable.C:2474

Coupleable::coupledValueOlder
virtual const VariableValue & coupledValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old value from two time steps previous of a coupled variable.
Definition: Coupleable.C:1007

Coupleable::_coupled_standard_moose_vars
std::vector< MooseVariable * > _coupled_standard_moose_vars
Vector of standard coupled variables.
Definition: Coupleable.h:1364

Coupleable::getCoupledStandardMooseVars
const std::vector< MooseVariable * > & getCoupledStandardMooseVars() const
Get the list of standard coupled variables.
Definition: Coupleable.h:79

Coupleable::adCoupledDotDot
const ADVariableValue & adCoupledDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable for ad simulations.
Definition: Coupleable.C:2219

Coupleable::_c_sys
const SystemBase *const _c_sys
Pointer to the system object if the moose object this is an interface for has one.
Definition: Coupleable.h:1355

Coupleable::_c_fe_problem
FEProblemBase & _c_fe_problem
Definition: Coupleable.h:1352

Coupleable::coupledVectorTagArrayValue
virtual const ArrayVariableValue & coupledVectorTagArrayValue(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns value of a coupled array variable for a given tag.
Definition: Coupleable.C:620

Coupleable::_ad_zero
const MooseArray< DualReal > & _ad_zero
Definition: Coupleable.h:1435

Coupleable::coupledSecondOlder
virtual const VariableSecond & coupledSecondOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old second derivative from two time steps previous of a coupled variable.
Definition: Coupleable.C:1806

Coupleable::vectorTagDofValueHelper
const OutputTools< T >::VariableValue & vectorTagDofValueHelper(const std::string &var_name, TagID tag, unsigned int comp=0) const
Generic helper method to get vector tag degree of freedom values based on tag ID. ...
Definition: Coupleable.C:713

Coupleable::_c_is_implicit
bool _c_is_implicit
True if implicit value is required.
Definition: Coupleable.h:1385

Coupleable::coupledValue
virtual const VariableValue & coupledValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable.
Definition: Coupleable.C:482

Coupleable::adCoupledLowerValue
const ADVariableValue & adCoupledLowerValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled lower-dimensional variable for use in Automatic Differentiation.
Definition: Coupleable.C:2125

Coupleable::coupledVectorValueOlder
virtual const VectorVariableValue & coupledVectorValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old value from two time steps previous of a coupled vector variable.
Definition: Coupleable.C:1065

MooseTypes.h

Coupleable::adCoupledVectorSecond
const ADVectorVariableSecond & adCoupledVectorSecond(const std::string &var_name, unsigned int comp=0) const
Returns second derivatives of a coupled vector variable for use in Automatic Differentiation.

Coupleable::_coupled_vector_moose_vars
std::vector< VectorMooseVariable * > _coupled_vector_moose_vars
Vector of vector coupled variables.
Definition: Coupleable.h:1367

Coupleable::requestStates
void requestStates(const std::string &var_name, const TagName &tag_name, const unsigned int comp)
Method that may request additional solution states from the variable&#39;s system depending on the value ...
Definition: Coupleable.C:533

Coupleable::coupledValueLower
virtual const VariableValue & coupledValueLower(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled lower-dimensional variable.
Definition: Coupleable.C:587

Coupleable::Coupleable
Coupleable(const MooseObject *moose_object, bool nodal, bool is_fv=false)
Constructing the object.
Definition: Coupleable.C:26

Coupleable::coupledGradientOld
virtual const VariableGradient & coupledGradientOld(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from previous time step of a coupled variable.
Definition: Coupleable.C:1497

Coupleable::coupledVectorTagDofValues
std::vector< const VariableValue * > coupledVectorTagDofValues(const std::string &var_names, TagID tag) const
Returns the dof values for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2581

ArrayVariableValue
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Definition: MooseTypes.h:336

MooseLinearVariableFV.h

Coupleable::FuncAge::Old

Coupleable::coupledVectorDotDu
virtual const VariableValue & coupledVectorDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled vector variable with respect to the coefficients.
Definition: Coupleable.C:1286

Coupleable::addFEVariableCoupleableVectorTag
void addFEVariableCoupleableVectorTag(TagID tag)
Definition: Coupleable.h:102

Coupleable::VarType::Second

Coupleable::coupledSecondOld
virtual const VariableSecond & coupledSecondOld(const std::string &var_name, unsigned int comp=0) const
Returns an old second spatial derivatives from previous time step of a coupled variable.
Definition: Coupleable.C:1790

Coupleable::getWritableCoupledVariables
auto & getWritableCoupledVariables() const
returns a reference to the set of writable coupled variables
Definition: Coupleable.h:123

Moose::OLD_SOLUTION_TAG
const TagName OLD_SOLUTION_TAG
Definition: MooseTypes.C:28

MooseObject
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:33

Coupleable::coupledArrayValue
virtual const ArrayVariableValue & coupledArrayValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled array variable.
Definition: Coupleable.C:834

Coupleable::vectorTagValueHelper
const OutputTools< T >::VariableValue & vectorTagValueHelper(const std::string &var_names, TagID tag, unsigned int index=0) const
Generic helper method to get vector tag values based on tag ID.
Definition: Coupleable.C:507

Coupleable::coupledGradientsOld
std::vector< const VariableGradient * > coupledGradientsOld(const std::string &var_name) const
Returns the old gradients for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2670

Coupleable::coupledVectorTagArrayGradient
virtual const ArrayVariableGradient & coupledVectorTagArrayGradient(const std::string &var_names, TagID tag, unsigned int index=0) const
Returns gradient of a coupled array variable for a given tag.
Definition: Coupleable.C:674

Coupleable::_default_gradient
VariableGradient _default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1418

Coupleable::_default_second
VariableSecond _default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1427

Coupleable::getDefaultValue
const VariableValue * getDefaultValue(const std::string &var_name, unsigned int comp) const
Helper method to return (and insert if necessary) the default value for an uncoupled variable...
Definition: Coupleable.C:334

Coupleable::VarType
VarType
Definition: Coupleable.h:1532

MooseVariableFE.h

Coupleable::adCoupledDots
std::vector< const ADVariableValue * > adCoupledDots(const std::string &var_name) const
Returns the time derivatives for all of a coupled variable&#39;s components for ad simulations.
Definition: Coupleable.C:2684

Coupleable::coupledGenericValue
const GenericVariableValue< is_ad > & coupledGenericValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled variable for use in templated automatic differentiation classes...

Coupleable::coupledGradientDot
virtual const VariableGradient & coupledGradientDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of the gradient of a coupled variable.
Definition: Coupleable.C:1546

Coupleable::getADDefaultValue
const ADVariableValue * getADDefaultValue(const std::string &var_name) const
Helper method to return (and insert if necessary) the default value for Automatic Differentiation for...
Definition: Coupleable.C:2286

Coupleable::adCoupledDot
const ADVariableValue & adCoupledDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable for ad simulations.
Definition: Coupleable.C:2202

Coupleable::_c_name
const std::string & _c_name
The name of the object this interface is part of.
Definition: Coupleable.h:1347

Coupleable::coupledGenericDofValue
const GenericVariableValue< is_ad > & coupledGenericDofValue(const std::string &var_name, unsigned int comp=0) const
Returns DOF value of a coupled variable for use in templated automatic differentiation classes...

Coupleable::coupledCurlOld
virtual const VectorVariableCurl & coupledCurlOld(const std::string &var_name, unsigned int comp=0) const
Returns an old curl from previous time step of a coupled variable.
Definition: Coupleable.C:1694

Coupleable::adCoupledDofValues
virtual const ADVariableValue & adCoupledDofValues(const std::string &var_name, unsigned int comp=0) const
Returns DOF value of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2052

Coupleable::coupledNodalDotDotOld
virtual const VariableValue & coupledNodalDotDotOld(const std::string &var_name, unsigned int comp=0) const
Nodal values of old second time derivative of a coupled variable.
Definition: Coupleable.C:1962

Coupleable::VarType::Dot

Coupleable::coupledAllDofValuesOld
std::vector< const VariableValue * > coupledAllDofValuesOld(const std::string &var_name) const
Returns DoFs in the old solution vector of all of a coupled variable&#39;s components for the local eleme...
Definition: Coupleable.C:2011

Moose::ADType
Definition: MooseTypes.h:374

Coupleable::coupledGradients
std::vector< const VariableGradient * > coupledGradients(const std::string &var_name) const
Returns the gradients for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2641

Coupleable::VarType::Gradient

Coupleable::coupledAllDofValuesOlder
std::vector< const VariableValue * > coupledAllDofValuesOlder(const std::string &var_name) const
Returns DoFs in the older solution vector of all of a coupled variable&#39;s components for the local ele...
Definition: Coupleable.C:2031

Coupleable::getFEVariableCoupleableMatrixTags
const std::set< TagID > & getFEVariableCoupleableMatrixTags() const
Definition: Coupleable.h:115

Coupleable::adCoupledVectorDot
const ADVectorVariableValue & adCoupledVectorDot(const std::string &var_name, unsigned int comp=0) const
Time derivative of a vector coupled variable for ad simulations.
Definition: Coupleable.C:2236

Coupleable::getDefaultFunctor
const Moose::Functor< T > & getDefaultFunctor(const std::string &var_name) const

Coupleable::coupledDofValuesOlder
virtual const VariableValue & coupledDofValuesOlder(const std::string &var_name, unsigned int comp=0) const
Returns DoFs in the older solution vector of a coupled variable for the local element.
Definition: Coupleable.C:2018

Coupleable::_vector_curl_zero
const VectorVariableCurl & _vector_curl_zero
Zero value of the curl of a vector variable.
Definition: Coupleable.h:1452

Coupleable::getADDefaultVectorGradient
const ADVectorVariableGradient & getADDefaultVectorGradient() const
Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation ...
Definition: Coupleable.C:2324

Coupleable::adZeroValue
const ADVariableValue & adZeroValue() const
method that returns _zero to RESIDUAL computing objects and _ad_zero to JACOBIAN computing objects ...
Definition: Coupleable.C:2338

Coupleable::coupledIndices
std::vector< unsigned int > coupledIndices(const std::string &var_name) const
Returns the indices for a coupled variable&#39;s components.
Definition: Coupleable.C:2415

Coupleable::coupledNodalValueOlder
const T & coupledNodalValueOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old nodal value from two time steps previous of a coupled variable.
Definition: Coupleable.C:1880

Coupleable::getCoupledMooseVars
const std::vector< MooseVariableFieldBase * > & getCoupledMooseVars() const
Get the list of all coupled variables.
Definition: Coupleable.h:70

Coupleable::_obj
const MooseObject *const _obj
Definition: Coupleable.h:1744

Coupleable::_default_vector_gradient
VectorVariableGradient _default_vector_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1461

Coupleable::_coupled_moose_vars
std::vector< MooseVariableFieldBase * > _coupled_moose_vars
Vector of all coupled variables.
Definition: Coupleable.h:1361

Coupleable::coupledCurl
virtual const VectorVariableCurl & coupledCurl(const std::string &var_name, unsigned int comp=0) const
Returns curl of a coupled variable.
Definition: Coupleable.C:1678

VariableValue
OutputTools< Real >::VariableValue VariableValue
Definition: MooseTypes.h:302

Coupleable::getFEVariableCoupleableMatrixTags
std::set< TagID > & getFEVariableCoupleableMatrixTags()
Definition: Coupleable.h:108

Coupleable::coupledArrayGradient
virtual const ArrayVariableGradient & coupledArrayGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled array variable.
Definition: Coupleable.C:1626

Coupleable::coupledDotDu
virtual const VariableValue & coupledDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled variable with respect to the coefficients.
Definition: Coupleable.C:1406

VariablePhiGradient
OutputTools< Real >::VariablePhiGradient VariablePhiGradient
Definition: MooseTypes.h:308

Coupleable::coupledComponents
unsigned int coupledComponents(const std::string &var_name) const
Number of coupled components.
Definition: Coupleable.C:157

Coupleable::_coupleable_neighbor
bool _coupleable_neighbor
Whether or not this object is a "neighbor" object: ie all of it&#39;s coupled values should be neighbor v...
Definition: Coupleable.h:1651

Coupleable::coupledArrayGradientOlder
virtual const ArrayVariableGradient & coupledArrayGradientOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from two time steps previous of a coupled array variable. ...
Definition: Coupleable.C:1652

Coupleable::coupledVectorDotDotDu
virtual const VariableValue & coupledVectorDotDotDu(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled vector variable with respect to the coefficients.
Definition: Coupleable.C:1302

Coupleable::adCoupledGradients
std::vector< const ADVariableGradient * > adCoupledGradients(const std::string &var_name) const
Returns the gradients for all of a coupled variable&#39;s components for use in Automatic Differentiation...
Definition: Coupleable.C:2663

Coupleable
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:45

MooseArray< ADReal >

Coupleable::genericZeroSecond
const GenericVariableSecond< is_ad > & genericZeroSecond()
Returns zero second derivative templated with automatic differentiation boolean.

Coupleable::coupledValues
std::vector< const VariableValue * > coupledValues(const std::string &var_name) const
Returns the values for all of a coupled variable components.
Definition: Coupleable.C:2446

Coupleable::coupledVectorTagArrayGradients
std::vector< const ArrayVariableGradient * > coupledVectorTagArrayGradients(const std::string &var_names, TagID tag) const
Returns gradients for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2558

Coupleable::getDefaultNodalValue
const T & getDefaultNodalValue(const std::string &var_name, unsigned int comp=0) const
Get nodal default value.
Definition: Coupleable.C:418

Coupleable::_c_type
const std::string & _c_type
The type of the object this interface is part of.
Definition: Coupleable.h:1349

Coupleable::coupledVectorGradientOlder
virtual const VectorVariableGradient & coupledVectorGradientOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from two time steps previous of a coupled vector variable.
Definition: Coupleable.C:1610

Coupleable::_ad_second_zero
const MooseArray< ADRealTensorValue > & _ad_second_zero
Definition: Coupleable.h:1446

Coupleable::_default_vector_value_zero
VectorVariableValue _default_vector_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1458

Coupleable::checkVar
bool checkVar(const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const
Check that the right kind of variable is being coupled in.
Definition: Coupleable.C:208

Coupleable::coupledValuePreviousNL
virtual const VariableValue & coupledValuePreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns value of previous Newton iterate of a coupled variable.
Definition: Coupleable.C:1029

Coupleable::_ad_default_value
std::unordered_map< std::string, std::unique_ptr< MooseArray< DualReal > > > _ad_default_value
Will hold the default value for optional coupled variables for automatic differentiation.
Definition: Coupleable.h:1398

Coupleable::_ad_default_vector_gradient
MooseArray< ADRealTensorValue > _ad_default_vector_gradient
This will always be zero because the default values for optionally coupled vector variables is always...
Definition: Coupleable.h:1424

Coupleable::coupledVectorValue
virtual const VectorVariableValue & coupledVectorValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled vector variable.
Definition: Coupleable.C:809

Coupleable::getFEVariableCoupleableVectorTags
const std::set< TagID > & getFEVariableCoupleableVectorTags() const
Definition: Coupleable.h:110

InputParameters::checkForRename
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
Definition: InputParameters.C:1590

Coupleable::coupledDotDotOld
virtual const VariableValue & coupledDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled variable.
Definition: Coupleable.C:1197

Coupleable::_ad_default_second
MooseArray< ADRealTensorValue > _ad_default_second
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1430

Coupleable::coupledArrayDotDu
const VariableValue & coupledArrayDotDu(const std::string &var_name, unsigned int comp=0) const
Time derivative of a coupled array variable with respect to the coefficients.
Definition: Coupleable.C:1456

Coupleable::coupledVectorTagValues
std::vector< const VariableValue * > coupledVectorTagValues(const std::string &var_names, TagID tag) const
Returns the values for all the coupled variables desired for a given tag.
Definition: Coupleable.C:2489

Coupleable::_phi_zero
const VariablePhiValue & _phi_zero
Definition: Coupleable.h:1434

Coupleable::getArrayVar
ArrayMooseVariable * getArrayVar(const std::string &var_name, unsigned int comp)
Extract pointer to a coupled array variable.
Definition: Coupleable.C:305

Coupleable::coupledArrayDotDot
virtual const ArrayVariableValue & coupledArrayDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled array variable.
Definition: Coupleable.C:1340

Coupleable::_coupled_standard_linear_fv_moose_vars
std::vector< MooseLinearVariableFV< Real > * > _coupled_standard_linear_fv_moose_vars
Vector of standard linear finite volume coupled variables.
Definition: Coupleable.h:1376

MooseVariableScalar
Class for scalar variables (they are different).
Definition: MooseVariableScalar.h:28

Coupleable::adCoupledVectorGradient
const ADVectorVariableGradient & adCoupledVectorGradient(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled vector variable for use in Automatic Differentiation.
Definition: Coupleable.C:2270

Coupleable::_optional_var_index
std::unordered_map< std::string, std::vector< unsigned int > > _optional_var_index
Unique indices for optionally coupled vars that weren&#39;t provided.
Definition: Coupleable.h:1732

Coupleable::getFEVar
const MooseVariableFieldBase * getFEVar(const std::string &var_name, unsigned int comp) const
Deprecated method.
Definition: Coupleable.C:267

Coupleable::_default_value
std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > > _default_value
Will hold the default value for optional coupled variables.
Definition: Coupleable.h:1395

HasMembers.h

Coupleable::coupledMatrixTagValues
std::vector< const VariableValue * > coupledMatrixTagValues(const std::string &var_names, TagID tag) const
Returns the diagonal matrix values for all the coupled variables desired for a given tag...
Definition: Coupleable.C:2604

Coupleable::_c_parameters
const InputParameters & _c_parameters
Definition: Coupleable.h:1344

VariableSecond
OutputTools< Real >::VariableSecond VariableSecond
Definition: MooseTypes.h:304

Coupleable::coupledArrayGradientOld
virtual const ArrayVariableGradient & coupledArrayGradientOld(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from previous time step of a coupled array variable.
Definition: Coupleable.C:1639

Coupleable::adCoupledNodalValue
const Moose::ADType< T >::type & adCoupledNodalValue(const std::string &var_name, unsigned int comp=0) const
Returns AD nodal values of a coupled variable.
Definition: Coupleable.C:2083

Coupleable::coupledNodalDotOld
virtual const VariableValue & coupledNodalDotOld(const std::string &var_name, unsigned int comp=0) const
Nodal values of old time derivative of a coupled variable.
Definition: Coupleable.C:1946

Coupleable::genericZeroValue
const GenericVariableValue< is_ad > & genericZeroValue()
Returns zero value templated with automatic differentiation boolean.

Coupleable::_default_array_value
std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > > _default_array_value
Will hold the default value for optional array coupled variables.
Definition: Coupleable.h:1405

VectorVariableGradient
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
Definition: MooseTypes.h:320

Coupleable::_default_array_gradient
ArrayVariableGradient _default_array_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1476

Coupleable::getADDefaultSecond
const ADVariableSecond & getADDefaultSecond() const
Helper method to return (and insert if necessary) the default second derivatives for Automatic Differ...
Definition: Coupleable.C:2331

Coupleable::_older_state_tags
const std::set< std::string > _older_state_tags
vector tag names for which we need to request older solution states from the system ...
Definition: Coupleable.h:1747

Coupleable::coupledCurlOlder
virtual const VectorVariableCurl & coupledCurlOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old curl from two time steps previous of a coupled variable.
Definition: Coupleable.C:1710

Coupleable::coupledDiv
virtual const VectorVariableDivergence & coupledDiv(const std::string &var_name, unsigned int comp=0) const
Returns divergence of a coupled variable.
Definition: Coupleable.C:1726

Coupleable::coupledGradientPreviousNL
virtual const VariableGradient & coupledGradientPreviousNL(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable for previous Newton iterate.
Definition: Coupleable.C:1529

Coupleable::_default_array_value_zero
ArrayVariableValue _default_array_value_zero
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1473

Coupleable::_coupleable_max_qps
unsigned int _coupleable_max_qps
Maximum qps for any element in this system.
Definition: Coupleable.h:1729

ArrayVariableGradient
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
Definition: MooseTypes.h:337

Coupleable::addFEVariableCoupleableMatrixTag
void addFEVariableCoupleableMatrixTag(TagID tag)
Definition: Coupleable.h:104

GenericVariableGradient
typename Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
Definition: MooseTypes.h:575

Coupleable::adCoupledVectorValues
std::vector< const ADVectorVariableValue * > adCoupledVectorValues(const std::string &var_name) const
Returns the values for all of a coupled vector variable&#39;s components for use in Automatic Differentia...
Definition: Coupleable.C:2481

Coupleable::coupledVectorValues
std::vector< const VectorVariableValue * > coupledVectorValues(const std::string &var_name) const
Returns the values for all of a coupled vector variable&#39;s components.
Definition: Coupleable.C:2453

Coupleable::coupledDotDot
virtual const VariableValue & coupledDotDot(const std::string &var_name, unsigned int comp=0) const
Second time derivative of a coupled variable.
Definition: Coupleable.C:1147

Coupleable::coupledArrayGradientDot
virtual const ArrayVariableGradient & coupledArrayGradientDot(const std::string &var_name, unsigned int comp=0) const
Retun a gradient of a coupled array variable&#39;s time derivative.
Definition: Coupleable.C:1665

Coupleable::coupledGenericGradients
std::vector< const GenericVariableGradient< is_ad > * > coupledGenericGradients(const std::string &var_name) const
Returns the gradients for all of a coupled variable&#39;s components for use in templated automatic diffe...

Coupleable::getCoupledVars
const std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > > & getCoupledVars() const
Get the list of coupled variables.
Definition: Coupleable.h:61

Coupleable::getFEVariableCoupleableVectorTags
std::set< TagID > & getFEVariableCoupleableVectorTags()
Definition: Coupleable.h:106

Coupleable::coupledVectorDotOld
virtual const VectorVariableValue & coupledVectorDotOld(const std::string &var_name, unsigned int comp=0) const
Old time derivative of a coupled vector variable.
Definition: Coupleable.C:1254

Coupleable::adCoupledGradientDot
const ADVariableGradient & adCoupledGradientDot(const std::string &var_name, unsigned int comp=0) const
Returns gradient of a coupled variable&#39;s time derivative for use in Automatic Differentiation.
Definition: Coupleable.C:2160

Coupleable::adCoupledSecond
const ADVariableSecond & adCoupledSecond(const std::string &var_name, unsigned int comp=0) const
Returns second derivatives of a coupled variable for use in Automatic Differentiation.
Definition: Coupleable.C:2177

Coupleable::hasWritableCoupledVariables
bool hasWritableCoupledVariables() const
Checks whether the object has any writable coupled variables.
Definition: Coupleable.h:128

Coupleable::coupledVectorDotDotOld
virtual const VectorVariableValue & coupledVectorDotDotOld(const std::string &var_name, unsigned int comp=0) const
Old second time derivative of a coupled vector variable.
Definition: Coupleable.C:1270

Coupleable::adCoupledVectorValue
const ADVectorVariableValue & adCoupledVectorValue(const std::string &var_name, unsigned int comp=0) const
Returns value of a coupled vector variable for use in Automatic Differentiation.
Definition: Coupleable.C:2252

MooseArray.h

Coupleable::coupledNodalValueOld
const T & coupledNodalValueOld(const std::string &var_name, unsigned int comp=0) const
Returns an old nodal value from previous time step of a coupled variable.
Definition: Coupleable.C:1860

Coupleable::_ad_default_gradient
MooseArray< ADRealVectorValue > _ad_default_gradient
This will always be zero because the default values for optionally coupled variables is always consta...
Definition: Coupleable.h:1421

Coupleable::coupledValuesOld
std::vector< const VariableValue * > coupledValuesOld(const std::string &var_name) const
Returns the old values for all of a coupled variable&#39;s components.
Definition: Coupleable.C:2627

Coupleable::coupledGradientOlder
virtual const VariableGradient & coupledGradientOlder(const std::string &var_name, unsigned int comp=0) const
Returns an old gradient from two time steps previous of a coupled variable.
Definition: Coupleable.C:1513

THREAD_ID
unsigned int THREAD_ID
Definition: MooseTypes.h:198

Coupleable::_new_to_deprecated_coupled_vars
const std::unordered_map< std::string, std::string > & _new_to_deprecated_coupled_vars
map from new to deprecated variable names
Definition: Coupleable.h:1379

Coupleable::coupledAllDofValues
std::vector< const VariableValue * > coupledAllDofValues(const std::string &var_name) const
Returns DoFs in the current solution vector of all of a coupled variable&#39;s components for the local e...
Definition: Coupleable.C:1991

Coupleable::getFieldVar
const MooseVariableFieldBase * getFieldVar(const std::string &var_name, unsigned int comp) const
Definition: Coupleable.C:281

MooseVariableFV.h

Coupleable::coupledDivOld
virtual const VectorVariableDivergence & coupledDivOld(const std::string &var_name, unsigned int comp=0) const
Returns an old divergence from previous time step of a coupled variable.
Definition: Coupleable.C:1742