Address comments idaholab#30655

Author: NamjaeChoi

framework/include/kokkos/base/KokkosParsedObjectBase.h

@@ -30,7 +30,7 @@ class ParsedObjectBase
    * @param param The parameter name containing symbols
    */
   template <typename T>
-  void checkDuplicateSymbols(const std::vector<T> symbols, const std::string param);
+  void checkDuplicateSymbols(const std::vector<T> & symbols, const std::string & param);
 
   /**
    * Add a constant
@@ -43,7 +43,7 @@ class ParsedObjectBase
    * @param name The variable name
    * @param scalar The pointer to the scalar variable
    */
-  void addScalar(const std::string & name, const Real * scalar);
+  void addScalar(const std::string & name, const Real & scalar);
   /**
    * Add a field variable
    * @param name The variable name
@@ -57,18 +57,14 @@ class ParsedObjectBase
    */
   void addProperty(const std::string & name, const MaterialProperty<Real> & property);
   /**
-   * Add a material property
+   * Add a function
    * @param name The variable name
    * @param function The function
    */
   void addFunction(const std::string & name, const Function & function);
-  /**
-   * Finalize parsed function
-   */
-  void finalize();
 
   /**
-   * Initialize symbols from parsed parameters. variable_names must be supplied by
+   * Initialize symbols from parsed parameters. \p variable_names must be supplied by
    * the caller because Coupleable::coupledNames() is protected.
    */
   template <typename T>
@@ -89,25 +85,30 @@ class ParsedObjectBase
   /**
    * Constants used in the parsed expression
    */
-  std::map<std::string, Real> _constants;
+  std::unordered_map<std::string, Real> _constants;
   /**
    * Scalar variables used in the parsed expression
    */
-  std::map<std::string, const Real *> _scalars;
+  std::unordered_map<std::string, std::reference_wrapper<const Real>> _scalars;
   /**
    * Field variables used in the parsed expression
    */
-  std::map<std::string, VariableValue> _fields;
+  std::unordered_map<std::string, VariableValue> _fields;
   /**
    * Material properties used in the parsed expression
    */
-  std::map<std::string, MaterialProperty<Real>> _properties;
+  std::unordered_map<std::string, MaterialProperty<Real>> _properties;
   /**
    * Functions used in the parsed expression
    */
-  std::map<std::string, Function> _functions;
+  std::unordered_map<std::string, Function> _functions;
 
 private:
+  /**
+   * Finalize parsed function
+   */
+  void finalize();
+
   /**
    * Parsed object
    */
@@ -120,7 +121,7 @@ class ParsedObjectBase
 
 template <typename T>
 void
-ParsedObjectBase::checkDuplicateSymbols(const std::vector<T> symbols, const std::string param)
+ParsedObjectBase::checkDuplicateSymbols(const std::vector<T> & symbols, const std::string & param)
 {
   for (const auto & symbol : symbols)
   {
@@ -148,7 +149,7 @@ ParsedObjectBase::initParsed(T * obj, const std::vector<VariableName> & variable
     addConstant(constant_names[i], constant_expressions[i]);
 
   for (const auto & pp : postprocessor_names)
-    addScalar(pp, &obj->getPostprocessorValueByName(pp));
+    addScalar(pp, obj->getPostprocessorValueByName(pp));
 
   for (const auto i : make_range(variable_names.size()))
     addField(variable_names[i], obj->kokkosCoupledValue("coupled_variables", i));

framework/src/functions/MooseParsedFunctionBase.C

@@ -30,11 +30,9 @@ MooseParsedFunctionBase::validParams()
       "Use 'symbol_values' instead.");
   params.addParam<std::vector<std::string>>(
       "symbol_names",
-      std::vector<std::string>(),
       "Symbols (excluding t,x,y,z) that are bound to the values provided by the corresponding "
       "items in the vals vector.");
   params.addParam<std::vector<std::string>>("symbol_values",
-                                            std::vector<std::string>(),
                                             "Constant numeric values, postprocessor names, "
                                             "function names, and scalar variables corresponding to"
                                             " the symbols in symbol_names.");

framework/src/kokkos/base/KokkosParsedObjectBase.K

@@ -9,6 +9,8 @@
 
 #include "KokkosParsedObjectBase.h"
 
+#include "FEProblemBase.h"
+
 namespace Moose::Kokkos
 {
 
@@ -21,6 +23,8 @@ ParsedObjectBase::validParams()
       "use_xyzt",
       false,
       "Make coordinate (x,y,z) and time (t) variables available in the function expression.");
+  params.addParam<bool>(
+      "use_dt", false, "Make time step (dt) variable available in the function expression.");
 
   // Constants and their values
   params.addParam<std::vector<std::string>>("constant_names",
@@ -34,24 +38,24 @@ ParsedObjectBase::validParams()
   params.addParam<std::vector<PostprocessorName>>(
       "postprocessor_names",
       std::vector<PostprocessorName>(),
-      "Vector of postprocessor names used in the parsed function");
+      "Vector of postprocessor names used in the parsed function.");
 
   // Field variables
-  params.addCoupledVar("coupled_variables", "Vector of variables used in the parsed function");
+  params.addCoupledVar("coupled_variables", "Vector of variables used in the parsed function.");
 
   // Material properties
   params.addParam<std::vector<MaterialPropertyName>>(
       "material_property_names",
       std::vector<MaterialPropertyName>(),
-      "Vector of material properties used in the parsed function");
+      "Vector of material properties used in the parsed function.");
 
   // Functions
   params.addParam<std::vector<FunctionName>>("function_names",
                                              std::vector<FunctionName>(),
-                                             "Vector of functions used in the parsed function");
+                                             "Vector of functions used in the parsed function.");
 
   // Function expression
-  params.addParam<std::string>("expression", "Parsed function expression for the parsed material");
+  params.addParam<std::string>("expression", "Parsed function expression.");
 
   return params;
 }
@@ -73,6 +77,13 @@ ParsedObjectBase::ParsedObjectBase(const MooseObject * object)
     _all_symbols.insert("t");
   }
 
+  if (parameters.get<bool>("use_dt"))
+  {
+    addScalar("dt", object->getMooseApp().feProblem().dt());
+
+    _all_symbols.insert("dt");
+  }
+
   const auto & constant_names = parameters.get<std::vector<std::string>>("constant_names");
   const auto & postprocessor_names =
       parameters.get<std::vector<PostprocessorName>>("postprocessor_names");
@@ -96,16 +107,14 @@ ParsedObjectBase::addConstant(const std::string & name, const Real constant)
   _builder->addVariable(name);
 
   _constants[name] = constant;
-  _builder->associateScalar(name, &_constants.at(name));
 }
 
 void
-ParsedObjectBase::addScalar(const std::string & name, const Real * scalar)
+ParsedObjectBase::addScalar(const std::string & name, const Real & scalar)
 {
   _builder->addVariable(name);
 
-  _scalars[name] = scalar;
-  _builder->associateScalar(name, _scalars.at(name));
+  _scalars.insert({name, scalar});
 }
 
 void
@@ -114,7 +123,6 @@ ParsedObjectBase::addField(const std::string & name, const VariableValue & field
   _builder->addVariable(name);
 
   _fields[name] = field;
-  _builder->associateField(name, &_fields.at(name));
 }
 
 void
@@ -123,7 +131,6 @@ ParsedObjectBase::addProperty(const std::string & name, const MaterialProperty<R
   _builder->addVariable(name);
 
   _properties[name] = property;
-  _builder->associateProperty(name, &_properties.at(name));
 }
 
 void
@@ -132,12 +139,26 @@ ParsedObjectBase::addFunction(const std::string & name, const Function & functio
   _builder->addVariable(name);
 
   _functions.insert({name, function});
-  _builder->associateFunction(name, &_functions.at(name));
 }
 
 void
 ParsedObjectBase::finalize()
 {
+  for (const auto & [name, constant] : _constants)
+    _builder->associateScalar(name, &constant);
+
+  for (const auto & [name, scalar] : _scalars)
+    _builder->associateScalar(name, &scalar.get());
+
+  for (const auto & [name, field] : _fields)
+    _builder->associateField(name, &field);
+
+  for (const auto & [name, property] : _properties)
+    _builder->associateProperty(name, &property);
+
+  for (const auto & [name, function] : _functions)
+    _builder->associateFunction(name, &function);
+
   _builder->build();
   _builder->finalize();
 

framework/src/kokkos/functions/KokkosParsedFunction.K

@@ -37,7 +37,10 @@ KokkosParsedFunction::KokkosParsedFunction(const InputParameters & parameters)
 {
   _builder->addDefaultVariables();
 
-  const auto & symbol_names = getParam<std::vector<std::string>>("symbol_names");
+  std::vector<std::string> symbol_names;
+
+  if (isParamValid("symbol_names"))
+    symbol_names = getParam<std::vector<std::string>>("symbol_names");
 
   for (const auto & name : symbol_names)
     _builder->addVariable(name);
@@ -65,8 +68,13 @@ KokkosParsedFunction::KokkosParsedFunction(const KokkosParsedFunction & function
 void
 KokkosParsedFunction::initialSetup()
 {
-  const auto & symbol_names = getParam<std::vector<std::string>>("symbol_names");
-  const auto & symbol_values = getParam<std::vector<std::string>>("symbol_values");
+  std::vector<std::string> symbol_names;
+  std::vector<std::string> symbol_values;
+
+  if (isParamValid("symbol_names"))
+    symbol_names = getParam<std::vector<std::string>>("symbol_names");
+  if (isParamValid("symbol_values"))
+    symbol_values = getParam<std::vector<std::string>>("symbol_values");
 
   _symbol_values.reserve(symbol_values.size());
   _symbol_functions.reserve(symbol_values.size());

framework/src/kokkos/materials/KokkosParsedMaterial.K

@@ -19,8 +19,6 @@ KokkosParsedMaterial::validParams()
 
   params.addRequiredParam<MaterialPropertyName>("property_name",
                                                 "Name of the parsed material property");
-  params.addParam<bool>(
-      "use_dt", false, "Make  time step (dt) variable available in the function expression.");
   params.addClassDescription("Evaluates a property with a parsed expression.");
 
   return params;
@@ -31,13 +29,5 @@ KokkosParsedMaterial::KokkosParsedMaterial(const InputParameters & parameters)
     ParsedObjectBase(this),
     _prop(declareKokkosProperty<Real>("property_name"))
 {
-  if (getParam<bool>("use_dt"))
-  {
-    checkDuplicateSymbols(std::vector<std::string>{"dt"}, "use_dt");
-
-    auto & dt = *_dt;
-    addScalar("dt", &dt);
-  }
-
   initParsed(this, coupledNames("coupled_variables"));
 }

test/tests/kokkos/auxkernels/parsed/kokkos_parsed_aux_mat_test.i

@@ -1,14 +1,10 @@
 [Mesh]
   type = GeneratedMesh
-
   dim = 2
-
   xmin = 0
   xmax = 1
-
   ymin = 0
   ymax = 1
-
   nx = 10
   ny = 10
 []
@@ -100,7 +96,6 @@
 
 [Executioner]
   type = Steady
-
   solve_type = 'PJFNK'
 []
 

test/tests/kokkos/auxkernels/parsed/kokkos_parsed_aux_test.i

@@ -1,14 +1,10 @@
 [Mesh]
   type = GeneratedMesh
-
   dim = 2
-
   xmin = 0
   xmax = 1
-
   ymin = 0
   ymax = 1
-
   nx = 10
   ny = 10
 []
@@ -85,7 +81,6 @@
 
 [Executioner]
   type = Steady
-
   solve_type = 'PJFNK'
 []
 

test/tests/kokkos/materials/parsed/kokkos_parsed_material.i

@@ -82,7 +82,6 @@
 
 [Executioner]
   type = Transient
-
   solve_type = 'PJFNK'
   end_time = 10
 []