Eliminated code duplication in sanity checks

Issue #21422

Author: Kylee Swanson

framework/include/auxkernels/ParsedAux.h

@@ -25,6 +25,21 @@ class ParsedAux : public AuxKernel, public FunctionParserUtils<false>
 protected:
   virtual Real computeValue() override;
 
+  /// Function to validate the symbols in _functor_symbols
+  void validateFunctorSymbols();
+
+  /// Function to validate the names in _functor_names
+  void validateFunctorNames();
+
+  /**
+   * Function to ensure vector entries (names) do not overlap with xyzt or coupled variable names.
+   * @param names_vec Vector containing names to compare to xyzt and coupled variables names.
+   * @param param_name Name of the parameter corresponding to names_vec. This will be the paremeter
+   * errored on, if applicable.
+   */
+  template <typename T>
+  void validateGenericVectorNames(const std::vector<T> & names_vec, const std::string & param_name);
+
   /// function expression
   std::string _function;
 
@@ -35,6 +50,9 @@ class ParsedAux : public AuxKernel, public FunctionParserUtils<false>
   /// import coordinates and time
   const bool _use_xyzt;
 
+  /// coordinate and time variable names
+  const std::vector<std::string> _xyzt;
+
   /// function parser object for the resudual and on-diagonal Jacobian
   SymFunctionPtr _func_F;
 
@@ -51,4 +69,31 @@ class ParsedAux : public AuxKernel, public FunctionParserUtils<false>
 
   /// Vector of pointers to functors
   std::vector<const Moose::Functor<Real> *> _functors;
+
+  /// Vector of coupled variable names
+  std::vector<std::string> _coupled_variable_names;
 };
+
+template <typename T>
+void
+ParsedAux::validateGenericVectorNames(const std::vector<T> & names_vec,
+                                      const std::string & param_name)
+{
+  for (const auto & name : names_vec)
+  {
+    // Make sure symbol is not x, y, z, or t
+    if (_use_xyzt && (std::find(_xyzt.begin(), _xyzt.end(), name) != _xyzt.end()))
+      paramError(
+          param_name,
+          "x, y, z, and t cannot be used in '" + param_name + "' when use_xyzt=true." +
+              (param_name == "functor_names" ? " Use 'functor_symbols' to disambiguate." : ""));
+    // Make sure symbol is not a coupled variable name
+    if (_coupled_variable_names.size() &&
+        (std::find(_coupled_variable_names.begin(), _coupled_variable_names.end(), name) !=
+         _coupled_variable_names.end()))
+      paramError(
+          param_name,
+          "Values in '" + param_name + "' cannot overlap with coupled variable names." +
+              (param_name == "functor_names" ? " Use 'functor_symbols' to disambiguate." : ""));
+  }
+}

framework/src/auxkernels/ParsedAux.C

@@ -55,58 +55,28 @@ ParsedAux::ParsedAux(const InputParameters & parameters)
     _nargs(coupledComponents("coupled_variables")),
     _args(coupledValues("coupled_variables")),
     _use_xyzt(getParam<bool>("use_xyzt")),
+    _xyzt({"x", "y", "z", "t"}),
     _functor_names(getParam<std::vector<MooseFunctorName>>("functor_names")),
     _n_functors(_functor_names.size()),
     _functor_symbols(getParam<std::vector<std::string>>("functor_symbols"))
 {
+
+  for (const auto i : make_range(_nargs))
+    _coupled_variable_names.push_back(getFieldVar("coupled_variables", i)->name());
+
   // sanity checks
   if (!_functor_symbols.empty() && (_functor_symbols.size() != _n_functors))
     paramError("functor_symbols", "functor_symbols must be the same length as functor_names.");
 
-  const std::vector<std::string> xyzt = {"x", "y", "z", "t"};
-  std::vector<std::string> variable_names;
-  for (const auto i : make_range(_nargs))
-    variable_names.push_back(getFieldVar("coupled_variables", i)->name());
-
-  if (_functor_symbols.size())
-  {
-    for (const auto & symbol : _functor_symbols)
-    {
-      // Make sure symbol is not x, y, z, or t
-      if (_use_xyzt && (std::find(xyzt.begin(), xyzt.end(), symbol) != xyzt.end()))
-        paramError("functor_symbols",
-                   "x, y, z, and t cannot be used as a functor symbol when use_xyzt=true.");
-      // Make sure symbol is not a variable name
-      if (variable_names.size() &&
-          (std::find(variable_names.begin(), variable_names.end(), symbol) != variable_names.end()))
-        paramError("functor_symbols",
-                   "Functor symbols cannot overlap with coupled variable names.");
-    }
-  }
-  else
-    for (const auto & name : _functor_names)
-    {
-      // Make sure symbol is not x, y, z, or t
-      if (_use_xyzt && (std::find(xyzt.begin(), xyzt.end(), std::string(name)) != xyzt.end()))
-        paramError("functor_names",
-                   "x, y, z, and t cannot be used as a functor name when use_xyzt=true. Use "
-                   "'functor_symbols' to disambiguate.");
-      // Make sure symbol is not a variable name
-      if (variable_names.size() &&
-          (std::find(variable_names.begin(), variable_names.end(), std::string(name)) !=
-           variable_names.end()))
-        paramError(
-            "functor_names",
-            "Functor names cannot overlap with coupled variable names. Use 'functor_symbols' to "
-            "disambiguate.");
-    }
+  validateFunctorSymbols();
+  validateFunctorNames();
 
   // build variables argument
   std::string variables;
 
   // coupled field variables
-  for (const auto i : make_range(_nargs))
-    variables += (i == 0 ? "" : ",") + getFieldVar("coupled_variables", i)->name();
+  for (const auto i : index_range(_coupled_variable_names))
+    variables += (i == 0 ? "" : ",") + _coupled_variable_names[i];
 
   // adding functors to the expression
   if (_functor_symbols.size())
@@ -118,7 +88,7 @@ ParsedAux::ParsedAux(const InputParameters & parameters)
 
   // "system" variables
   if (_use_xyzt)
-    for (auto & v : xyzt)
+    for (auto & v : _xyzt)
       variables += (variables.empty() ? "" : ",") + v;
 
   // base function object
@@ -191,3 +161,15 @@ ParsedAux::computeValue()
 
   return evaluate(_func_F);
 }
+
+void
+ParsedAux::validateFunctorSymbols()
+{
+  validateGenericVectorNames(_functor_symbols, "functor_symbols");
+}
+
+void
+ParsedAux::validateFunctorNames()
+{
+  validateGenericVectorNames(_functor_names, "functor_names");
+}

test/tests/auxkernels/parsed_aux/tests

@@ -38,28 +38,28 @@
       type = RunException
       input = 'parsed_aux_functors_test.i'
       cli_args = "AuxKernels/set_parsed/functor_names='u v' AuxKernels/set_parsed/functor_symbols='x v' AuxKernels/set_parsed/use_xyzt=true"
-      expect_err = "x, y, z, and t cannot be used as a functor symbol when use_xyzt=true."
+      expect_err = "x, y, z, and t cannot be used in 'functor_symbols' when use_xyzt=true."
       detail = "functor symbols parameter contains 'x', 'y', 'z', or 't' when coordinates and time parameters are already in use"
     [../]
     [functor_symbol_variable_name_overlap]
       type = RunException
       input = 'parsed_aux_functors_test.i'
       cli_args = "AuxKernels/set_parsed/functor_symbols='u v' AuxKernels/set_parsed/coupled_variables='u v'"
-      expect_err = "Functor symbols cannot overlap with coupled variable names."
+      expect_err = "Values in 'functor_symbols' cannot overlap with coupled variable names."
       detail = "functor symbols cannot overlap with coupled variable names"
     [../]
     [invalid_functor_name]
       type = RunException
       input = 'parsed_aux_functors_test.i'
       cli_args = "AuxKernels/set_parsed/functor_names='x v' AuxKernels/set_parsed/functor_symbols='' AuxKernels/set_parsed/use_xyzt=true"
-      expect_err = "x, y, z, and t cannot be used as a functor name when use_xyzt=true. Use 'functor_symbols' to disambiguate."
+      expect_err = "x, y, z, and t cannot be used in 'functor_names' when use_xyzt=true. Use 'functor_symbols' to disambiguate."
       detail = "functor names parameter contains 'x', 'y', 'z', or 't' when coordinates and time parameters are already in use"
     [../]
     [functor_name_variable_name_overlap]
       type = RunException
       input = 'parsed_aux_functors_test.i'
       cli_args = "AuxKernels/set_parsed/functor_names='u v' AuxKernels/set_parsed/coupled_variables='u v' AuxKernels/set_parsed/functor_symbols=''"
-      expect_err = "Functor names cannot overlap with coupled variable names. Use 'functor_symbols' to disambiguate."
+      expect_err = "Values in 'functor_names' cannot overlap with coupled variable names. Use 'functor_symbols' to disambiguate."
       detail = "functor names cannot overlap with coupled variable names"
     [../]
     [expression]