https://mooseframework.inl.gov
ParsedMaterialBase.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "ParsedMaterialBase.h"
11 #include "ParsedAux.h"
12 #include "MooseObject.h"
13 
16 {
18  params.addCoupledVar("args", "Vector of variables used in the parsed function");
19  params.deprecateCoupledVar("args", "coupled_variables", "02/07/2024");
20 
21  // Constants and their values
22  params.addParam<std::vector<std::string>>(
23  "constant_names",
24  std::vector<std::string>(),
25  "Vector of constants used in the parsed function (use this for kB etc.)");
26  params.addParam<std::vector<std::string>>(
27  "constant_expressions",
28  std::vector<std::string>(),
29  "Vector of values for the constants in constant_names (can be an FParser expression)");
30 
31  // Variables with applied tolerances and their tolerance values
32  params.addParam<std::vector<std::string>>("tol_names",
33  std::vector<std::string>(),
34  "Vector of variable names to be protected from "
35  "being 0 or 1 within a tolerance (needed for log(c) "
36  "and log(1-c) terms)");
37  params.addParam<std::vector<Real>>("tol_values",
38  std::vector<Real>(),
39  "Vector of tolerance values for the variables in tol_names");
40 
41  // Functors and their symbols
42  params.addParam<std::vector<MooseFunctorName>>(
43  "functor_names", {}, "Functors to use in the parsed expression");
44  params.addParam<std::vector<std::string>>(
45  "functor_symbols",
46  {},
47  "Symbolic name to use for each functor in 'functor_names' in the parsed expression. If not "
48  "provided, then the actual functor names will be used in the parsed expression.");
49 
50  // Material properties
51  params.addParam<std::vector<std::string>>(
52  "material_property_names",
53  std::vector<std::string>(),
54  "Vector of material properties used in the parsed function");
55 
56  // Postprocessors
57  params.addParam<std::vector<PostprocessorName>>(
58  "postprocessor_names",
59  std::vector<PostprocessorName>(),
60  "Vector of postprocessor names used in the parsed function");
61 
62  // Function expression
63  params.addDeprecatedCustomTypeParam<std::string>(
64  "function",
65  "FunctionExpression",
66  "Parsed function (see FParser) expression for the parsed material",
67  "'function' is deprecated, use 'expression' instead");
68  // TODO Make required once deprecation is handled, see #19119
69  params.addCustomTypeParam<std::string>(
70  "expression",
71  "FunctionExpression",
72  "Parsed function (see FParser) expression for the parsed material");
73 
74  return params;
75 }
76 
78  : _derived_object(obj),
79  _function_param(parameters.isParamValid("function") ? "function" : "expression"),
80  _function(parameters.get<std::string>(_function_param))
81 {
82  // get constant vectors
83  _constant_names = parameters.get<std::vector<std::string>>("constant_names");
84  _constant_expressions = parameters.get<std::vector<std::string>>("constant_expressions");
85 
86  // get tolerance vectors
87  _tol_names = parameters.get<std::vector<std::string>>("tol_names");
88  _tol_values = parameters.get<std::vector<Real>>("tol_values");
89 
90  // get functor vectors
91  _functor_names = parameters.get<std::vector<MooseFunctorName>>("functor_names");
92  _functor_symbols = parameters.get<std::vector<std::string>>("functor_symbols");
93 
94  // validate all vector names (constants, tolerances, and functors)
96 }
97 
98 void
99 ParsedMaterialBase::validateVectorNames(const std::set<std::string> & reserved_names)
100 {
101  // helper method to raise an paramError
102  auto raiseErr = [this](std::string param_name, std::string msg)
103  {
104  if (_derived_object != nullptr)
105  _derived_object->paramError(param_name, msg);
106  else
107  mooseException(msg);
108  };
109 
110  auto hasDuplicates = [](const std::vector<std::string> & values)
111  {
112  std::set<std::string> s(values.begin(), values.end());
113  return values.size() != s.size();
114  };
115 
116  // helper function to check if the name given is one of the constants
117  auto isKnownConstantName = [this](const std::string & name)
118  {
119  return (
120  _constant_names.size() &&
121  (std::find(_constant_names.begin(), _constant_names.end(), name) != _constant_names.end()));
122  };
123 
124  // helper function to check if the name given is one of the reserved_names
125  auto isReservedName = [reserved_names](const std::string & name)
126  { return reserved_names.find(name) != reserved_names.end(); };
127 
128  // check constants
129  if (hasDuplicates(_constant_names))
130  raiseErr("constant_names", "In the constants duplicate names are not permitted.");
131  for (const auto & name : _constant_names)
132  {
133  if (isReservedName(name))
134  raiseErr("constant_names", "In constants, the name '" + name + "' is not permitted.");
135  }
136 
137  // check tolerance vectors
138  if (hasDuplicates(_tol_names))
139  raiseErr("tol_names", "In the tolerances duplicate names are not permitted.");
140 
141  // check functor vectors
142  if (_functor_symbols.empty())
143  {
144  if (!_functor_names.empty())
145  raiseErr("functor_names", "functor_symbols must be the same length as functor_names.");
146  }
147  else
148  {
149  if (_functor_symbols.size() != _functor_names.size())
150  raiseErr("functor_names", "functor_symbols must be the same length as functor_names.");
151  std::vector<std::string> names;
152  if (_functor_symbols.empty())
153  std::copy(_functor_names.begin(), _functor_names.end(), std::back_inserter(names));
154  else
155  std::copy(_functor_symbols.begin(), _functor_symbols.end(), std::back_inserter(names));
156  if (hasDuplicates(names))
157  raiseErr(_functor_symbols.empty() ? "functor_names" : "functor_symbols",
158  "In functors, duplicate names are not permitted.");
159  for (const auto & name : names)
160  {
161  if (isKnownConstantName(name))
162  raiseErr(_functor_symbols.empty() ? "functor_names" : "functor_symbols",
163  "In functors, the name '" + name + "' is already in use as a constant.");
164  if (isReservedName(name))
165  raiseErr(_functor_symbols.empty() ? "functor_names" : "functor_symbols",
166  "In functors, the name '" + name + "' is not permitted.");
167  }
168  }
169 }
std::vector< std::string > _constant_expressions
std::string name(const ElemQuality q)
std::vector< std::string > _constant_names
constant vectors
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition: MooseBase.h:435
static InputParameters validParams()
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1155
void addCustomTypeParam(const std::string &name, const T &value, const std::string &custom_type, const std::string &doc_string)
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
InputParameters emptyInputParameters()
ParsedMaterialBase(const InputParameters &parameters, const MooseObject *obj)
std::vector< std::string > _tol_names
tolerance vectors
void validateVectorNames(const std::set< std::string > &reserved_names={})
Function to ensure that the names of constants, tolerances, and functors do not overlap with each oth...
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:27
std::vector< std::string > _functor_symbols
void deprecateCoupledVar(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
void addCoupledVar(const std::string &name, const std::string &doc_string)
This method adds a coupled variable name pair.
void addDeprecatedCustomTypeParam(const std::string &name, const std::string &custom_type, const std::string &doc_string, const std::string &deprecation_msg)
const MooseObject *const _derived_object
Pointer to the MooseObject (to call paramError)
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
std::vector< MooseFunctorName > _functor_names
Functor vectors (names, count, and symbols)
std::vector< Real > _tol_values