Fix combo marker block restriction issues

framework/include/markers/ComboMarker.h

@@ -12,7 +12,7 @@
 #include "Marker.h"
 
 /**
- * Combines multiple marker fields.  The most conservative wins.
+ * Combines multiple marker fields.  The most conservative (requesting additional refinement) wins.
  */
 class ComboMarker : public Marker
 {
@@ -24,7 +24,15 @@ class ComboMarker : public Marker
 protected:
   virtual MarkerValue computeElementMarker() override;
 
-  std::vector<MarkerName> _names;
+  /// Names of the markers contributing to the combo
+  const std::vector<MarkerName> & _names;
 
+  /// Pointers to the markers contributing to the Combo marker
   std::vector<const VariableValue *> _markers;
+
+  /// Boolean to keep track of whether any marker does not have the same block restriction
+  bool _block_restriction_mismatch;
+
+  /// Pointers to the variables for the markers
+  std::vector<const MooseVariableFieldBase *> _marker_variables;
 };

framework/include/markers/Marker.h

@@ -71,6 +71,7 @@ class Marker : public MooseObject,
    */
   static MooseEnum markerStates();
 
+  /// Computes and sets the value of the refinement flag
   virtual void computeMarker();
 
   bool isActive() const;
@@ -115,9 +116,12 @@ class Marker : public MooseObject,
 
   Assembly & _assembly;
 
+  /// Reference to this marker as a variable
   MooseVariable & _field_var;
+  /// Pointer to the current element being considered in the marker element-based loop
   const Elem * const & _current_elem;
 
+  /// Reference to the mesh, obtained from the subproblem
   MooseMesh & _mesh;
 
   /// Depend Markers

framework/src/markers/ComboMarker.C

@@ -8,6 +8,7 @@
 //* https://www.gnu.org/licenses/lgpl-2.1.html
 
 #include "ComboMarker.h"
+#include "FEProblemBase.h"
 
 registerMooseObject("MooseApp", ComboMarker);
 
@@ -24,10 +25,33 @@ ComboMarker::validParams()
 }
 
 ComboMarker::ComboMarker(const InputParameters & parameters)
-  : Marker(parameters), _names(parameters.get<std::vector<MarkerName>>("markers"))
+  : Marker(parameters),
+    _names(getParam<std::vector<MarkerName>>("markers")),
+    _block_restriction_mismatch(false)
 {
   for (const auto & marker_name : _names)
     _markers.push_back(&getMarkerValue(marker_name));
+
+  std::string other_block_restricted = "";
+  for (const auto & marker_name : _names)
+  {
+    const auto var_ptr = &_subproblem.getVariable(_tid, marker_name);
+    _marker_variables.push_back(var_ptr);
+
+    // Check block restrictions
+    if (blockIDs() != var_ptr->blockIDs())
+      other_block_restricted += (other_block_restricted == "" ? "" : ", ") + marker_name;
+  }
+
+  if (other_block_restricted != "")
+  {
+    _block_restriction_mismatch = true;
+    paramInfo(
+        "markers",
+        "Combo marker and markers '" + other_block_restricted +
+            "' do not share the same block restrictions. Markers outside their block restriction "
+            "will not mark.");
+  }
 }
 
 Marker::MarkerValue
@@ -36,8 +60,14 @@ ComboMarker::computeElementMarker()
   // We start with DONT_MARK because it's -1
   MarkerValue marker_value = DONT_MARK;
 
-  for (const auto & var : _markers)
-    marker_value = std::max(marker_value, static_cast<MarkerValue>((*var)[0]));
+  // No need to check block restrictions if they all match
+  if (!_block_restriction_mismatch)
+    for (const auto & var : _markers)
+      marker_value = std::max(marker_value, static_cast<MarkerValue>((*var)[0]));
+  else
+    for (const auto i : index_range(_markers))
+      if (_marker_variables[i]->hasBlocks(_current_elem->subdomain_id()))
+        marker_value = std::max(marker_value, static_cast<MarkerValue>((*_markers[i])[0]));
 
   return marker_value;
 }

test/tests/markers/combo_marker/combo_marker_block_restricted.i

@@ -0,0 +1,90 @@
+[Mesh]
+  [base]
+    type = GeneratedMeshGenerator
+    dim = 2
+    nx = 10
+    ny = 10
+    elem_type = QUAD4
+  []
+  [subdomain_1]
+    type = SubdomainBoundingBoxGenerator
+    input = base
+    bottom_left = '0.1 0.1 0'
+    block_id = 1
+    top_right = '0.4 0.9 0'
+  []
+  [subdomain_2]
+    type = SubdomainBoundingBoxGenerator
+    input = subdomain_1
+    bottom_left = '0.1 0.1 0'
+    block_id = 2
+    top_right = '0.4 0.9 0'
+    location = OUTSIDE
+  []
+[]
+
+[Variables]
+  [u]
+    order = FIRST
+    family = LAGRANGE
+  []
+[]
+
+[Kernels]
+  [diff]
+    type = Diffusion
+    variable = u
+  []
+[]
+
+[BCs]
+  [left]
+    type = DirichletBC
+    variable = u
+    boundary = 1
+    value = 0
+  []
+  [right]
+    type = DirichletBC
+    variable = u
+    boundary = 2
+    value = 1
+  []
+[]
+
+[Executioner]
+  type = Steady
+
+  solve_type = 'PJFNK'
+[]
+
+[Adaptivity]
+  initial_marker = combo
+  initial_steps = 1
+  [Markers]
+    [box]
+      type = BoxMarker
+      bottom_left = '0.0 0. 0'
+      top_right = '1 0.5 0'
+      inside = refine
+      outside = do_nothing
+      block = '1'
+    []
+    [box2]
+      type = BoxMarker
+      bottom_left = '0.5 0.5 0'
+      top_right = '0.8 0.8 0'
+      inside = refine
+      outside = coarsen
+      block = '2'
+    []
+    [combo]
+      type = ComboMarker
+      markers = 'box box2'
+    []
+  []
+[]
+
+[Outputs]
+  exodus = true
+[]

test/tests/markers/combo_marker/tests

@@ -1,13 +1,19 @@
 [Tests]
-  issues = '#1303'
   design = 'ComboMarker.md'
 
-  [./test]
+  [test]
     type = 'Exodiff'
     input = 'combo_marker_test.i'
     exodiff = 'combo_marker_test_out.e'
     scale_refine = 2
-
     requirement = "The system shall include the ability to combine multiple mesh refinement markers into a single value."
-  [../]
+    issues = '#1303'
+  []
+  [test_block_restriction]
+    type = 'Exodiff'
+    input = 'combo_marker_block_restricted.i'
+    exodiff = 'combo_marker_block_restricted_out.e'
+    requirement = "The system shall include the ability to combine multiple mesh refinement markers into a single value even if the block restrictions of each marker do not match."
+    issues = '#30103'
+  []
 []