add missing pieces for coupling tagged solution vectors idaholab#17586

framework/include/interfaces/Coupleable.h

@@ -96,6 +96,16 @@ class Coupleable
 
   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;
+  }
+
 protected:
   /**
    * A call-back function provided by the derived object for actions before coupling a variable

framework/include/loops/ComputeJacobianThread.h

@@ -68,6 +68,8 @@ class ComputeJacobianThread : public ThreadedElementLoop<ConstElemRange>
   // Reference to Kernel storage structure
   MooseObjectTagWarehouse<KernelBase> & _kernels;
 
+  const MaterialWarehouse & _materials;
+
   // A pointer to different warehouse
   MooseObjectWarehouse<KernelBase> * _warehouse;
 

framework/include/loops/ComputeResidualThread.h

@@ -71,6 +71,8 @@ class ComputeResidualThread : public ThreadedElementLoop<ConstElemRange>
   /// Reference to Kernel storage structures
   MooseObjectTagWarehouse<KernelBase> & _kernels;
 
+  const MaterialWarehouse & _materials;
+
   MooseObjectWarehouse<KernelBase> * _tag_kernels;
   ///@}
 };

framework/include/variables/MooseVariableData.h

@@ -467,21 +467,9 @@ class MooseVariableData
 
   /////////////////////////////// Tags ///////////////////////////////////////////////////
 
-  const FieldVariableValue & vectorTagValue(TagID tag) const
-  {
-    _need_vector_tag_u[tag] = true;
-    return _vector_tag_u[tag];
-  }
-  const FieldVariableGradient & vectorTagGradient(TagID tag) const
-  {
-    _need_vector_tag_grad[tag] = true;
-    return _vector_tag_grad[tag];
-  }
-  const FieldVariableValue & matrixTagValue(TagID tag) const
-  {
-    _need_matrix_tag_u[tag] = true;
-    return _matrix_tag_u[tag];
-  }
+  const FieldVariableValue & vectorTagValue(TagID tag) const;
+  const FieldVariableGradient & vectorTagGradient(TagID tag) const;
+  const FieldVariableValue & matrixTagValue(TagID tag) const;
 
   /**
    * The oldest solution state that is requested for this variable

framework/include/warehouses/MooseObjectWarehouseBase.h

@@ -15,6 +15,8 @@
 #include "BlockRestrictable.h"
 #include "TransientInterface.h"
 #include "Coupleable.h"
+#include "MaterialPropertyInterface.h"
+#include "MooseVariableDependencyInterface.h"
 #include "SubProblem.h"
 
 // Forward declarations
@@ -618,8 +620,12 @@ MooseObjectWarehouseBase<T>::updateVariableDependencyHelper(
 {
   for (const auto & object : objects)
   {
-    const auto & mv_deps = object->getMooseVariableDependencies();
-    needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
+    auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
+    if (c)
+    {
+      const auto & mv_deps = c->getMooseVariableDependencies();
+      needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
+    }
   }
 }
 
@@ -650,8 +656,12 @@ MooseObjectWarehouseBase<T>::updateFEVariableCoupledVectorTagDependencyHelper(
 {
   for (const auto & object : objects)
   {
-    const auto & tag_deps = object->getFEVariableCoupleableVectorTags();
-    needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
+    auto c = dynamic_cast<const Coupleable *>(object.get());
+    if (c)
+    {
+      const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
+      needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
+    }
   }
 }
 
@@ -700,8 +710,12 @@ MooseObjectWarehouseBase<T>::updateMatPropDependencyHelper(
 {
   for (auto & object : objects)
   {
-    auto & mp_deps = object->getMatPropDependencies();
-    needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
+    auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
+    if (c)
+    {
+      auto & mp_deps = c->getMatPropDependencies();
+      needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
+    }
   }
 }
 

framework/src/loops/ComputeElemAuxVarsThread.C

@@ -63,6 +63,8 @@ ComputeElemAuxVarsThread<AuxKernelType>::subdomainChanged()
   std::set<TagID> needed_fe_var_matrix_tags;
   std::set<TagID> needed_fe_var_vector_tags;
 
+  _fe_problem.getMaterialWarehouse().updateBlockFEVariableCoupledVectorTagDependency(
+      _subdomain, needed_fe_var_vector_tags, _tid);
   if (_aux_kernels.hasActiveBlockObjects(_subdomain, _tid))
   {
     const std::vector<std::shared_ptr<AuxKernelType>> & kernels =

framework/src/loops/ComputeJacobianThread.C

@@ -32,6 +32,7 @@ ComputeJacobianThread::ComputeJacobianThread(FEProblemBase & fe_problem,
     _dg_kernels(_nl.getDGKernelWarehouse()),
     _interface_kernels(_nl.getInterfaceKernelWarehouse()),
     _kernels(_nl.getKernelWarehouse()),
+    _materials(fe_problem.getMaterialWarehouse()),
     _tags(tags)
 {
 }
@@ -45,6 +46,7 @@ ComputeJacobianThread::ComputeJacobianThread(ComputeJacobianThread & x, Threads:
     _dg_kernels(x._dg_kernels),
     _interface_kernels(x._interface_kernels),
     _kernels(x._kernels),
+    _materials(x._materials),
     _warehouse(x._warehouse),
     _tags(x._tags)
 {
@@ -152,6 +154,13 @@ ComputeJacobianThread::subdomainChanged()
   _dg_kernels.updateBlockVariableDependency(_subdomain, needed_moose_vars, _tid);
   _interface_kernels.updateBoundaryVariableDependency(needed_moose_vars, _tid);
 
+  // Update FE variable coupleable vector tags
+  std::set<TagID> needed_fe_var_vector_tags;
+  _kernels.updateBlockFEVariableCoupledVectorTagDependency(
+      _subdomain, needed_fe_var_vector_tags, _tid);
+  _materials.updateBlockFEVariableCoupledVectorTagDependency(
+      _subdomain, needed_fe_var_vector_tags, _tid);
+
   // Update material dependencies
   std::set<unsigned int> needed_mat_props;
   _kernels.updateBlockMatPropDependency(_subdomain, needed_mat_props, _tid);
@@ -180,6 +189,7 @@ ComputeJacobianThread::subdomainChanged()
 
   _fe_problem.setActiveElementalMooseVariables(needed_moose_vars, _tid);
   _fe_problem.setActiveMaterialProperties(needed_mat_props, _tid);
+  _fe_problem.setActiveFEVariableCoupleableVectorTags(needed_fe_var_vector_tags, _tid);
   _fe_problem.prepareMaterials(_subdomain, _tid);
 
   // If users pass a empty vector or a full size of vector,

framework/src/loops/ComputeResidualThread.C

@@ -31,7 +31,8 @@ ComputeResidualThread::ComputeResidualThread(FEProblemBase & fe_problem,
     _integrated_bcs(_nl.getIntegratedBCWarehouse()),
     _dg_kernels(_nl.getDGKernelWarehouse()),
     _interface_kernels(_nl.getInterfaceKernelWarehouse()),
-    _kernels(_nl.getKernelWarehouse())
+    _kernels(_nl.getKernelWarehouse()),
+    _materials(fe_problem.getMaterialWarehouse())
 {
 }
 
@@ -45,6 +46,7 @@ ComputeResidualThread::ComputeResidualThread(ComputeResidualThread & x, Threads:
     _dg_kernels(x._dg_kernels),
     _interface_kernels(x._interface_kernels),
     _kernels(x._kernels),
+    _materials(x._materials),
     _tag_kernels(x._tag_kernels)
 {
 }
@@ -67,6 +69,10 @@ ComputeResidualThread::subdomainChanged()
   std::set<TagID> needed_fe_var_vector_tags;
   _kernels.updateBlockFEVariableCoupledVectorTagDependency(
       _subdomain, needed_fe_var_vector_tags, _tid);
+  _integrated_bcs.updateBlockFEVariableCoupledVectorTagDependency(
+      _subdomain, needed_fe_var_vector_tags, _tid);
+  _materials.updateBlockFEVariableCoupledVectorTagDependency(
+      _subdomain, needed_fe_var_vector_tags, _tid);
 
   // Update material dependencies
   std::set<unsigned int> needed_mat_props;

framework/src/loops/ComputeUserObjectsThread.C

@@ -67,25 +67,38 @@ ComputeUserObjectsThread::subdomainChanged()
 
   std::set<MooseVariableFEBase *> needed_moose_vars;
   std::set<unsigned int> needed_mat_props;
+  std::set<TagID> needed_fe_var_vector_tags;
   for (const auto obj : objs)
   {
     auto v_obj = dynamic_cast<MooseVariableDependencyInterface *>(obj);
-    if (!v_obj)
-      mooseError("robert wrote broken code");
-    const auto & v_deps = v_obj->getMooseVariableDependencies();
-    needed_moose_vars.insert(v_deps.begin(), v_deps.end());
+    if (v_obj)
+    {
+      const auto & v_deps = v_obj->getMooseVariableDependencies();
+      needed_moose_vars.insert(v_deps.begin(), v_deps.end());
+    }
 
     auto m_obj = dynamic_cast<MaterialPropertyInterface *>(obj);
-    if (!m_obj)
-      mooseError("robert wrote broken code again");
-    auto & m_deps = m_obj->getMatPropDependencies();
-    needed_mat_props.insert(m_deps.begin(), m_deps.end());
+    if (m_obj)
+    {
+      auto & m_deps = m_obj->getMatPropDependencies();
+      needed_mat_props.insert(m_deps.begin(), m_deps.end());
+    }
+
+    auto c_obj = dynamic_cast<Coupleable *>(obj);
+    if (c_obj)
+    {
+      const auto & tag_deps = c_obj->getFEVariableCoupleableVectorTags();
+      needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
+    }
 
     obj->subdomainSetup();
   }
+  _fe_problem.getMaterialWarehouse().updateBlockFEVariableCoupledVectorTagDependency(
+      _subdomain, needed_fe_var_vector_tags, _tid);
 
   _fe_problem.setActiveElementalMooseVariables(needed_moose_vars, _tid);
   _fe_problem.setActiveMaterialProperties(needed_mat_props, _tid);
+  _fe_problem.setActiveFEVariableCoupleableVectorTags(needed_fe_var_vector_tags, _tid);
   _fe_problem.prepareMaterials(_subdomain, _tid);
 
   querySubdomain(Interfaces::InternalSideUserObject, _internal_side_objs);

framework/src/variables/MooseVariableData.C

@@ -761,10 +761,13 @@ MooseVariableData<OutputType>::computeValues()
 
       for (auto tag : active_coupleable_vector_tags)
       {
-        if (_need_vector_tag_u[tag])
-          _vector_tag_u[tag][qp] += phi_local * _vector_tags_dof_u[tag][i];
-        if (_need_vector_tag_grad[tag])
-          _vector_tag_grad[tag][qp].add_scaled(dphi_qp, _vector_tags_dof_u[tag][i]);
+        if (_sys.hasVector(tag) && _sys.getVector(tag).closed())
+        {
+          if (_need_vector_tag_u[tag])
+            _vector_tag_u[tag][qp] += phi_local * _vector_tags_dof_u[tag][i];
+          if (_need_vector_tag_grad[tag])
+            _vector_tag_grad[tag][qp].add_scaled(dphi_qp, _vector_tags_dof_u[tag][i]);
+        }
       }
 
       for (auto tag : active_coupleable_matrix_tags)
@@ -2180,6 +2183,51 @@ MooseVariableData<OutputType>::nodalMatrixTagValue(TagID tag) const
                "' is not nodal.");
 }
 
+template <typename OutputType>
+const typename MooseVariableData<OutputType>::FieldVariableValue &
+MooseVariableData<OutputType>::vectorTagValue(TagID tag) const
+{
+  _need_vector_tag_u[tag] = true;
+
+  if (_sys.hasVector(tag) && tag < _vector_tag_u.size())
+    return _vector_tag_u[tag];
+  else
+    mooseError("Tag is not associated with any vector or there is no any data for tag ",
+               tag,
+               " for variable ",
+               _var.name());
+}
+
+template <typename OutputType>
+const typename MooseVariableData<OutputType>::FieldVariableGradient &
+MooseVariableData<OutputType>::vectorTagGradient(TagID tag) const
+{
+  _need_vector_tag_grad[tag] = true;
+
+  if (_sys.hasVector(tag) && tag < _vector_tag_grad.size())
+    return _vector_tag_grad[tag];
+  else
+    mooseError("Tag is not associated with any vector or there is no any data for tag ",
+               tag,
+               " for variable ",
+               _var.name());
+}
+
+template <typename OutputType>
+const typename MooseVariableData<OutputType>::FieldVariableValue &
+MooseVariableData<OutputType>::matrixTagValue(TagID tag) const
+{
+  _need_matrix_tag_u[tag] = true;
+
+  if (_sys.hasMatrix(tag) && tag < _matrix_tag_u.size())
+    return _matrix_tag_u[tag];
+  else
+    mooseError("Tag is not associated with any matrix or there is no any data for tag ",
+               tag,
+               " for variable ",
+               _var.name());
+}
+
 template <typename OutputType>
 void
 MooseVariableData<OutputType>::fetchDoFValues()
@@ -2244,6 +2292,7 @@ MooseVariableData<OutputType>::fetchDoFValues()
       if ((_sys.subproblem().vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
            _sys.subproblem().safeAccessTaggedVectors()) ||
           _sys.subproblem().vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
+        // tag is defined on problem but may not be used by a system
         if (_sys.hasVector(tag) && _sys.getVector(tag).closed())
         {
           auto & vec = _sys.getVector(tag);
@@ -2339,6 +2388,7 @@ MooseVariableData<RealEigenVector>::fetchDoFValues()
     if ((_sys.subproblem().vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
          _sys.subproblem().safeAccessTaggedVectors()) ||
         _sys.subproblem().vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
+      // tag is defined on problem but may not be used by a system
       if (_sys.hasVector(tag) && _sys.getVector(tag).closed())
         getArrayDoFValues(_sys.getVector(tag), n, _vector_tags_dof_u[tag]);