Line data Source code
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 :
14 : InputParameters
15 62107 : ParsedMaterialBase::validParams()
16 : {
17 62107 : InputParameters params = emptyInputParameters();
18 62107 : params.addCoupledVar("args", "Vector of variables used in the parsed function");
19 62107 : params.deprecateCoupledVar("args", "coupled_variables", "02/07/2024");
20 :
21 : // Constants and their values
22 186321 : params.addParam<std::vector<std::string>>(
23 : "constant_names",
24 124214 : std::vector<std::string>(),
25 : "Vector of constants used in the parsed function (use this for kB etc.)");
26 186321 : params.addParam<std::vector<std::string>>(
27 : "constant_expressions",
28 124214 : 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 186321 : params.addParam<std::vector<std::string>>("tol_names",
33 124214 : 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 186321 : params.addParam<std::vector<Real>>("tol_values",
38 124214 : std::vector<Real>(),
39 : "Vector of tolerance values for the variables in tol_names");
40 :
41 : // Functors and their symbols
42 62107 : params.addParam<std::vector<MooseFunctorName>>(
43 : "functor_names", {}, "Functors to use in the parsed expression");
44 62107 : 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 186321 : params.addParam<std::vector<std::string>>(
52 : "material_property_names",
53 124214 : std::vector<std::string>(),
54 : "Vector of material properties used in the parsed function");
55 :
56 : // Postprocessors
57 186321 : params.addParam<std::vector<PostprocessorName>>(
58 : "postprocessor_names",
59 124214 : std::vector<PostprocessorName>(),
60 : "Vector of postprocessor names used in the parsed function");
61 :
62 : // Function expression
63 62107 : 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 62107 : params.addCustomTypeParam<std::string>(
70 : "expression",
71 : "FunctionExpression",
72 : "Parsed function (see FParser) expression for the parsed material");
73 :
74 62107 : return params;
75 0 : }
76 :
77 3873 : ParsedMaterialBase::ParsedMaterialBase(const InputParameters & parameters, const MooseObject * obj)
78 3873 : : _derived_object(obj)
79 : {
80 : // get function expression
81 7800 : _function = parameters.isParamValid("function") ? parameters.get<std::string>("function")
82 3927 : : parameters.get<std::string>("expression");
83 :
84 : // get constant vectors
85 3873 : _constant_names = parameters.get<std::vector<std::string>>("constant_names");
86 3873 : _constant_expressions = parameters.get<std::vector<std::string>>("constant_expressions");
87 :
88 : // get tolerance vectors
89 3873 : _tol_names = parameters.get<std::vector<std::string>>("tol_names");
90 3873 : _tol_values = parameters.get<std::vector<Real>>("tol_values");
91 :
92 : // get functor vectors
93 3873 : _functor_names = parameters.get<std::vector<MooseFunctorName>>("functor_names");
94 3873 : _functor_symbols = parameters.get<std::vector<std::string>>("functor_symbols");
95 :
96 : // validate all vector names (constants, tolerances, and functors)
97 3873 : validateVectorNames();
98 3873 : }
99 :
100 : void
101 5304 : ParsedMaterialBase::validateVectorNames(const std::set<std::string> & reserved_names)
102 : {
103 : // helper method to raise an paramError
104 0 : auto raiseErr = [this](std::string param_name, std::string msg)
105 : {
106 0 : if (_derived_object != nullptr)
107 0 : _derived_object->paramError(param_name, msg);
108 : else
109 0 : mooseException(msg);
110 5304 : };
111 :
112 10686 : auto hasDuplicates = [](const std::vector<std::string> & values)
113 : {
114 10686 : std::set<std::string> s(values.begin(), values.end());
115 21372 : return values.size() != s.size();
116 10686 : };
117 :
118 : // helper function to check if the name given is one of the constants
119 78 : auto isKnownConstantName = [this](const std::string & name)
120 : {
121 : return (
122 78 : _constant_names.size() &&
123 78 : (std::find(_constant_names.begin(), _constant_names.end(), name) != _constant_names.end()));
124 5304 : };
125 :
126 : // helper function to check if the name given is one of the reserved_names
127 78 : auto isReservedName = [reserved_names](const std::string & name)
128 5382 : { return reserved_names.find(name) != reserved_names.end(); };
129 :
130 : // check constants
131 5304 : if (hasDuplicates(_constant_names))
132 0 : raiseErr("constant_names", "In the constants duplicate names are not permitted.");
133 5304 : for (const auto & name : _constant_names)
134 : {
135 0 : if (isReservedName(name))
136 0 : raiseErr("constant_names", "In constants, the name '" + name + "' is not permitted.");
137 : }
138 :
139 : // check tolerance vectors
140 5304 : if (hasDuplicates(_tol_names))
141 0 : raiseErr("tol_names", "In the tolerances duplicate names are not permitted.");
142 :
143 : // check functor vectors
144 5304 : if (_functor_symbols.empty())
145 : {
146 5226 : if (!_functor_names.empty())
147 0 : raiseErr("functor_names", "functor_symbols must be the same length as functor_names.");
148 : }
149 : else
150 : {
151 78 : if (_functor_symbols.size() != _functor_names.size())
152 0 : raiseErr("functor_names", "functor_symbols must be the same length as functor_names.");
153 78 : std::vector<std::string> names;
154 78 : if (_functor_symbols.empty())
155 0 : std::copy(_functor_names.begin(), _functor_names.end(), std::back_inserter(names));
156 : else
157 78 : std::copy(_functor_symbols.begin(), _functor_symbols.end(), std::back_inserter(names));
158 78 : if (hasDuplicates(names))
159 0 : raiseErr(_functor_symbols.empty() ? "functor_names" : "functor_symbols",
160 : "In functors, duplicate names are not permitted.");
161 156 : for (const auto & name : names)
162 : {
163 78 : if (isKnownConstantName(name))
164 0 : raiseErr(_functor_symbols.empty() ? "functor_names" : "functor_symbols",
165 0 : "In functors, the name '" + name + "' is already in use as a constant.");
166 78 : if (isReservedName(name))
167 0 : raiseErr(_functor_symbols.empty() ? "functor_names" : "functor_symbols",
168 0 : "In functors, the name '" + name + "' is not permitted.");
169 : }
170 78 : }
171 5304 : }
|
