https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
GrandPotentialKernelAction Class Reference

Generates the necessary kernels for the Grand Potential Function for any number of order parameters and chemical potentials. More...

#include <GrandPotentialKernelAction.h>

Inheritance diagram for GrandPotentialKernelAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 GrandPotentialKernelAction (const InputParameters &parameters)
 
virtual void act ()
 
void timedAct ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
MooseObjectName uniqueActionName () const
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
const std::string & name () const
 
std::string typeAndName () const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T * queryParam (const std::string &name) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &name) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 
void mooseError (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecatedNoTrace (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &relative_path) const
 
std::string getDataFilePath (const std::string &relative_path) const
 
PerfGraph & perfGraph ()
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static InputParameters validParams ()
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
const ConsoleStream _console
 

Static Public Attributes

static const std::string unique_action_name_param
 
static const std::string type_param
 
static const std::string name_param
 
static const std::string unique_name_param
 
static const std::string app_param
 
static const std::string moose_base_param
 
static const std::string kokkos_object_param
 
static constexpr auto SYSTEM
 
static constexpr auto NAME
 

Protected Member Functions

bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 
void associateWithParameter (const std::string &param_name, InputParameters &params) const
 
void associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
 
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

std::string _registered_identifier
 
std::string _specific_task_name
 
std::set< std::string > _all_tasks
 
ActionWarehouse & _awh
 
const std::string & _current_task
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 
PerfID _act_timer
 
MooseApp & _app
 
Factory & _factory
 
ActionFactory & _action_factory
 
const std::string & _type
 
const std::string & _name
 
const InputParameters & _pars
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

Private Member Functions

bool addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
 
virtual std::string meshPropertyPrefix (const std::string &data_name) const
 
const RestartableDataValue & getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
 
void mooseErrorInternal (Args &&... args) const
 

Static Private Member Functions

static const hit::Node * getHitNode (const InputParameters &params)
 
static std::string messagePrefix (const InputParameters &params, const bool hit_prefix)
 

Private Attributes

const ParallelParamObject & _parent
 
MooseApp & _meta_data_app
 
const MooseObject *const _meta_data_object
 
const MooseBase & _si_moose_base
 
const FEProblemBase * _si_problem
 

Detailed Description

Generates the necessary kernels for the Grand Potential Function for any number of order parameters and chemical potentials.

Can do so with two sets of order parameters that use different material properties. Also able to use anisotropic diffusivities for the chemical potential variables.

KERNELS GENERATED BY THIS ACTION chemical_potentials -SusceptibilityTimeDerivative -MatDiffusion (or MatAnisonDiffusion if D is a tensor) -CoupledSwitchingTimeDerivative (one for each gr and op) grains -TimeDerivative -ACInterface -ACSwitching -ACGrGrMulti additional_order_parameters -TimeDerivative -ACInterface -ACSwitching -ACGrGrMulti

Definition at line 37 of file GrandPotentialKernelAction.h.

Constructor & Destructor Documentation

◆ GrandPotentialKernelAction()

GrandPotentialKernelAction::GrandPotentialKernelAction ( const InputParameters &  parameters)

Definition at line 89 of file GrandPotentialKernelAction.C.

90 : Action(parameters)
91{
92}
Action::parameters
const InputParameters & parameters() const

Member Function Documentation

◆ act()

void GrandPotentialKernelAction::act ( )
virtual

Implements Action.

Definition at line 95 of file GrandPotentialKernelAction.C.

96{
97 // Get Variables from parameters
98 const auto w_names = getParam<std::vector<NonlinearVariableName>>("chemical_potentials");
99 const auto chis = getParam<std::vector<MaterialPropertyName>>("susceptibilities");
100 const auto Fj_gr = getParam<std::vector<MaterialPropertyName>>("free_energies_gr");
101 const auto Fj_w = getParam<std::vector<MaterialPropertyName>>("free_energies_w");
102 const auto hj = getParam<std::vector<MaterialPropertyName>>("switching_function_names");
103 const auto M = getParam<std::vector<MaterialPropertyName>>("mobilities");
104 auto n_grs = getParam<unsigned int>("op_num");
105 const auto var_name_base = getParam<std::string>("var_name_base");
106 const auto Fj_op = getParam<std::vector<MaterialPropertyName>>("free_energies_op");
107 const auto kappa_gr = getParam<MaterialPropertyName>("kappa_gr");
108 const auto kappa_op = getParam<MaterialPropertyName>("kappa_op");
109 const auto gamma_gr = getParam<MaterialPropertyName>("gamma_gr");
110 const auto gamma_op = getParam<MaterialPropertyName>("gamma_op");
111 const auto gamma_xx = getParam<MaterialPropertyName>("gamma_grxop");
112 const auto gr_mob = getParam<MaterialPropertyName>("mobility_name_gr");
113 const auto op_mob = getParam<MaterialPropertyName>("mobility_name_op");
114 auto implicity = getParam<bool>("implicit");
115 auto displaced_mesh = getParam<bool>("use_displaced_mesh");
116 auto aniso = getParam<MultiMooseEnum>("anisotropic");
117 const auto hj_over_kVa = getParam<std::vector<MaterialPropertyName>>("hj_over_kVa");
118 const auto hj_c_min = getParam<std::vector<MaterialPropertyName>>("hj_c_min");
119 auto mass_conservation = getParam<bool>("mass_conservation");
120
121 // Size definitions and checks
122 unsigned int n_w = w_names.size();
123 unsigned int n_hj = hj.size();
124 std::vector<NonlinearVariableName> etas;
125 std::vector<NonlinearVariableName> c_names;
126 unsigned int n_etas = 0;
127 std::string kernel_name;
128 if (isParamValid("additional_ops"))
129 {
130 etas = getParam<std::vector<NonlinearVariableName>>("additional_ops");
131 n_etas = etas.size();
132 }
133
134 if (chis.size() != n_w)
135 mooseError("susceptibilities and chemical_potentials should be vectors of the same length.");
136 if (Fj_w.size() != n_w * n_hj)
137 mooseError("free_energies_w should be length of chemcial_potentials * length of "
138 "switching_function_names");
139 if (M.size() != n_w)
140 mooseError("M and chemical_potentials should be vectors of the same length.");
141 if (aniso.size() != n_w)
142 paramError("anisotropic", "Provide as many values as entries in 'chemical_potentials'.");
143
144 // Define additional vectors
145 std::vector<std::string> grs; // vector of all grain variable names
146 grs.resize(n_grs);
147 for (unsigned int i = 0; i < n_grs; ++i)
148 grs[i] = var_name_base + Moose::stringify(i);
149
150 std::vector<NonlinearVariableName> all_etas; // vector of all grain variables and order parameters
151 all_etas.reserve(n_etas + n_grs);
152 all_etas.insert(all_etas.end(), etas.begin(), etas.end());
153 all_etas.insert(all_etas.end(), grs.begin(), grs.end());
154
155 std::vector<std::string> all_vars; // vector of all variables
156 all_vars.reserve(n_etas + n_grs + n_w);
157 all_vars.insert(all_vars.end(), all_etas.begin(), all_etas.end());
158 all_vars.insert(all_vars.end(), w_names.begin(), w_names.end());
159
160 std::vector<MaterialPropertyName> fj_temp;
161 fj_temp.resize(n_hj);
162 std::vector<VariableName> notarealvector;
163 notarealvector.resize(1);
164 std::vector<VariableName> v0;
165 v0.resize(n_etas + n_grs + n_w);
166 for (unsigned int i = 0; i < n_etas + n_grs + n_w; ++i)
167 v0[i] = all_vars[i];
168 std::vector<VariableName> v1;
169 v1.resize(n_etas + n_grs);
170 for (unsigned int i = 0; i < n_etas + n_grs; ++i)
171 v1[i] = all_etas[i];
172 std::vector<VariableName> v2;
173 v2.resize(n_etas + n_grs - 1);
174
175 std::vector<VariableName> v_etas;
176 v_etas.resize(n_etas);
177 for (unsigned int i = 0; i < n_etas; ++i)
178 v_etas[i] = all_etas[i];
179
180 // Grains and order parameters
181 NonlinearVariableName var_name;
182 MaterialPropertyName kappa;
183 MaterialPropertyName mob_name;
184 std::vector<MaterialPropertyName> Fj_names;
185
186 for (unsigned int i = 0; i < n_etas + n_grs; ++i)
187 {
188 var_name = all_etas[i];
189 // Distinguish between grains and the additional order parameters
190 if (i < n_etas) // First part of list is grain variables
191 {
192 kappa = kappa_op;
193 mob_name = op_mob;
194 Fj_names.resize(Fj_op.size());
195 Fj_names = Fj_op;
196 }
197 else // Second part of list is additional order parameters
198 {
199 kappa = kappa_gr;
200 mob_name = gr_mob;
201 Fj_names.resize(Fj_gr.size());
202 Fj_names = Fj_gr;
203 }
204
205 // Remove var_name from coupled variables
206 std::vector<MaterialPropertyName> gam;
207 gam.resize(n_etas + n_grs - 1);
208 unsigned int op = 0;
209 for (unsigned int j = 0; j < n_etas + n_grs; ++j)
210 {
211 if (i != j)
212 {
213 v2[op] = all_etas[j];
214 if (j < n_etas)
215 gam[op] = gamma_op;
216 else
217 gam[op] = gamma_gr;
218 if (i < n_etas && j < n_etas)
219 gam[op] = gamma_op;
220 else if (i >= n_etas && j >= n_etas)
221 gam[op] = gamma_gr;
222 else
223 gam[op] = gamma_xx;
224 ++op;
225 }
226 }
227
228 // TimeDerivative Kernel
229 InputParameters params = _factory.getValidParams("TimeDerivative");
230 params.set<NonlinearVariableName>("variable") = var_name;
231 params.set<bool>("implicit") = implicity;
232 params.set<bool>("use_displaced_mesh") = displaced_mesh;
233 kernel_name = "DT_" + var_name;
234 _problem->addKernel("TimeDerivative", kernel_name, params);
235
236 // ACInterface Kernel
237 params = _factory.getValidParams("ACInterface");
238 params.set<NonlinearVariableName>("variable") = var_name;
239 params.set<bool>("implicit") = implicity;
240 params.set<bool>("use_displaced_mesh") = displaced_mesh;
241 params.set<MaterialPropertyName>("kappa_name") = kappa;
242 params.set<MaterialPropertyName>("mob_name") = mob_name;
243 params.set<std::vector<VariableName>>("coupled_variables") = v2;
244 kernel_name = "ACInt_" + var_name;
245 _problem->addKernel("ACInterface", kernel_name, params);
246
247 // ACSwitching Kernel
248 params = _factory.getValidParams("ACSwitching");
249 params.set<NonlinearVariableName>("variable") = var_name;
250 params.set<bool>("implicit") = implicity;
251 params.set<bool>("use_displaced_mesh") = displaced_mesh;
252 params.set<std::vector<MaterialPropertyName>>("Fj_names") = Fj_names;
253 params.set<std::vector<MaterialPropertyName>>("hj_names") = hj;
254 params.set<MaterialPropertyName>("mob_name") = mob_name;
255 params.set<std::vector<VariableName>>("coupled_variables") = v0;
256 kernel_name = "ACSwitch_" + var_name;
257 _problem->addKernel("ACSwitching", kernel_name, params);
258
259 // ACGrGrMulti Kernel
260 params = _factory.getValidParams("ACGrGrMulti");
261 params.set<NonlinearVariableName>("variable") = var_name;
262 params.set<bool>("implicit") = implicity;
263 params.set<bool>("use_displaced_mesh") = displaced_mesh;
264 params.set<MaterialPropertyName>("mob_name") = mob_name;
265 params.set<std::vector<VariableName>>("v") = v2;
266 params.set<std::vector<MaterialPropertyName>>("gamma_names") = gam;
267 kernel_name = "AcGrGr_" + var_name;
268 _problem->addKernel("ACGrGrMulti", kernel_name, params);
269 } // for (unsigned int i = 0; i < n_etas + n_grs; ++i)
270
271 if (mass_conservation) // mass conservation kernels with conc and chempot coupling
272 {
273 c_names = getParam<std::vector<NonlinearVariableName>>("concentrations");
274 std::vector<VariableName> v3;
275 v3.resize(n_w);
276 for (unsigned int i = 0; i < n_w; ++i)
277 v3[i] = w_names[i];
278
279 std::vector<VariableName> v4;
280 unsigned int n_c = c_names.size();
281 v4.resize(n_c);
282 for (unsigned int i = 0; i < n_c; ++i)
283 v4[i] = c_names[i];
284
285 for (unsigned int i = 0; i < n_c; ++i)
286 {
287 // TimeDerivative concentration Kernel
288 InputParameters params = _factory.getValidParams("TimeDerivative");
289 params.set<NonlinearVariableName>("variable") = c_names[i];
290 params.set<bool>("implicit") = implicity;
291 params.set<bool>("use_displaced_mesh") = displaced_mesh;
292 kernel_name = "DT_" + c_names[i];
293 _problem->addKernel("TimeDerivative", kernel_name, params);
294
295 // MatDiffusion concentration (coupled with chempot)
296 params = _factory.getValidParams("PolycrystalMatDiffusion");
297 params.set<NonlinearVariableName>("variable") = c_names[i];
298 params.set<std::vector<VariableName>>("v") = v3;
299 params.set<bool>("implicit") = implicity;
300 params.set<bool>("use_displaced_mesh") = displaced_mesh;
301 params.set<MaterialPropertyName>("diffusivity") = M[i];
302 kernel_name = "MatDif_" + w_names[i];
303 if (aniso.get(i))
304 {
305 params.set<std::vector<VariableName>>("args") = v1;
306 params.set<std::vector<VariableName>>("surface_op_var") = v_etas;
307 _problem->addKernel("PolycrystalMatAnisoDiffusion", kernel_name, params);
308 }
309 else
310 {
311 params.set<std::vector<VariableName>>("args") = v0;
312 _problem->addKernel("PolycrystalMatDiffusion", kernel_name, params);
313 }
314 }
315
316 // Chemical Potentials
317 for (unsigned int i = 0; i < n_w; ++i)
318 {
319 // coupling of c and w
320 InputParameters params = _factory.getValidParams("MatReaction");
321 params.set<NonlinearVariableName>("variable") = w_names[i];
322 params.set<std::vector<VariableName>>("v") = v4;
323 params.set<MaterialPropertyName>("reaction_rate") = "-1";
324 kernel_name = "MR_c" + w_names[i];
325 _problem->addKernel("MatReaction", kernel_name, params);
326
327 // contribution between chempot and each grains to concentration
328 // Summations of MatReaction and MaskedBodyForce
329
330 for (unsigned int j = 0; j < n_hj; ++j)
331 {
332 // MatReaction
333 params = _factory.getValidParams("MatReaction");
334 params.set<NonlinearVariableName>("variable") = w_names[i];
335 params.set<std::vector<VariableName>>("args") = v1;
336 params.set<MaterialPropertyName>("reaction_rate") = hj_over_kVa[j];
337 params.set<bool>("implicit") = implicity;
338 params.set<bool>("use_displaced_mesh") = displaced_mesh;
339 kernel_name = "MR_" + w_names[i] + "_" + all_etas[j];
340 _problem->addKernel("MatReaction", kernel_name, params);
341
342 // MaskedBodyForce
343 InputParameters params = _factory.getValidParams("MaskedBodyForce");
344 params.set<NonlinearVariableName>("variable") = w_names[i];
345 params.set<std::vector<VariableName>>("coupled_variables") = v1;
346 params.set<MaterialPropertyName>("mask") = hj_c_min[j];
347 params.set<bool>("implicit") = implicity;
348 params.set<bool>("use_displaced_mesh") = displaced_mesh;
349 kernel_name = "MBD_" + w_names[i] + "_" + all_etas[j];
350 _problem->addKernel("MaskedBodyForce", kernel_name, params);
351 }
352 }
353 }
354 else
355 {
356 // Chemical Potentials
357 for (unsigned int i = 0; i < n_w; ++i)
358 {
359 // SusceptibilityTimeDerivative
360 InputParameters params = _factory.getValidParams("SusceptibilityTimeDerivative");
361 params.set<NonlinearVariableName>("variable") = w_names[i];
362 params.set<MaterialPropertyName>("f_name") = chis[i];
363 params.set<std::vector<VariableName>>("coupled_variables") = v0;
364 params.set<bool>("implicit") = implicity;
365 params.set<bool>("use_displaced_mesh") = displaced_mesh;
366 kernel_name = "ChiDt_" + w_names[i];
367 _problem->addKernel("SusceptibilityTimeDerivative", kernel_name, params);
368
369 // MatDiffusion
370 params = _factory.getValidParams("PolycrystalMatDiffusion");
371 params.set<NonlinearVariableName>("variable") = w_names[i];
372 params.set<bool>("implicit") = implicity;
373 params.set<bool>("use_displaced_mesh") = displaced_mesh;
374 params.set<MaterialPropertyName>("diffusivity") = M[i];
375 kernel_name = "MatDif_" + w_names[i];
376 params.set<std::vector<VariableName>>("args") = v0;
377 if (aniso.get(i))
378 {
379 params.set<std::vector<VariableName>>("surface_op_var") = v_etas;
380 _problem->addKernel("PolycrystalMatAnisoDiffusion", kernel_name, params);
381 }
382 else
383 {
384 params.set<std::vector<VariableName>>("args") = v0;
385 _problem->addKernel("PolycrystalMatDiffusion", kernel_name, params);
386 }
387
388 // CoupledSwitchingTimeDerivative
389 for (unsigned int j = 0; j < n_hj; ++j)
390 fj_temp[j] = Fj_w[i * n_hj + j];
391 for (unsigned int j = 0; j < n_etas + n_grs; ++j)
392 {
393 notarealvector[0] = all_etas[j];
394 params = _factory.getValidParams("CoupledSwitchingTimeDerivative");
395 params.set<NonlinearVariableName>("variable") = w_names[i];
396 params.set<std::vector<VariableName>>("v") = notarealvector;
397 params.set<std::vector<VariableName>>("coupled_variables") = v0;
398 params.set<std::vector<MaterialPropertyName>>("Fj_names") = fj_temp;
399 params.set<std::vector<MaterialPropertyName>>("hj_names") = hj;
400 params.set<bool>("implicit") = implicity;
401 params.set<bool>("use_displaced_mesh") = displaced_mesh;
402 kernel_name = "Coupled_" + w_names[i] + "_" + all_etas[j];
403 _problem->addKernel("CoupledSwitchingTimeDerivative", kernel_name, params);
404 }
405 }
406 }
407} // GrandPotentialKernelAction::act()
M
const double M
Definition GasLiquidMassTransferTest.C:20
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Action::paramError
void paramError(const std::string &param, Args... args) const
Action::mooseError
void mooseError(Args &&... args) const
Action::isParamValid
bool isParamValid(const std::string &name) const
Action::_factory
Factory & _factory
Moose::stringify
std::string stringify(const T &t)

◆ validParams()

InputParameters GrandPotentialKernelAction::validParams ( )
static

Definition at line 19 of file GrandPotentialKernelAction.C.

20{
21 InputParameters parameters = Action::validParams();
22 parameters.addClassDescription(
23 "Automatically generate most or all of the kernels for the grand potential model");
24 parameters.addRequiredParam<std::vector<NonlinearVariableName>>(
25 "chemical_potentials", "List of chemical potential variables");
26 parameters.addRequiredParam<std::vector<MaterialPropertyName>>(
27 "susceptibilities", "List of susceptibilities that correspond to chemical_potentials");
28 parameters.addRequiredParam<std::vector<MaterialPropertyName>>(
29 "free_energies_gr",
30 "List of free energies for each phase. Place in same order as switching_function_names.");
31 parameters.addRequiredParam<std::vector<MaterialPropertyName>>(
32 "free_energies_w",
33 "List of functions for each phase. Length should be length of chemical_potentials * length "
34 "of switching_function_names.");
35 parameters.addRequiredParam<std::vector<MaterialPropertyName>>(
36 "switching_function_names",
37 "Switching function materials that provide switching function for free_energies_*.");
38 parameters.addRequiredParam<std::vector<MaterialPropertyName>>(
39 "mobilities", "Vector of mobilities that must match chemical_potentials");
40 parameters.addRequiredParam<unsigned int>("op_num", "specifies the number of grains to create");
41 parameters.addRequiredParam<std::string>("var_name_base",
42 "specifies the base name of the grain variables");
43 parameters.addParam<std::vector<NonlinearVariableName>>(
44 "additional_ops", "List of any additional order parameters which are not grains");
45 parameters.addParam<std::vector<MaterialPropertyName>>("free_energies_op",
46 "List of free energies used by additional "
47 "order parameters. Places in same order "
48 "as switching_function_names.");
49 parameters.addParam<MaterialPropertyName>("kappa_gr", "kappa", "The kappa used with the grains");
50 parameters.addParam<MaterialPropertyName>(
51 "kappa_op", "kappa", "The kappa used with additional_ops");
52 parameters.addParam<MaterialPropertyName>(
53 "gamma_gr", "gamma", "Name of the gamma used with grains");
54 parameters.addParam<MaterialPropertyName>(
55 "gamma_op", "gamma", "Name of the gamma used with additional order parameters");
56 parameters.addParam<MaterialPropertyName>(
57 "gamma_grxop",
58 "gamma",
59 "Name of the gamma used when grains interact with other order parameters");
60 parameters.addParam<MaterialPropertyName>(
61 "mobility_name_gr", "L", "Name of mobility to be used with grains");
62 parameters.addParam<MaterialPropertyName>(
63 "mobility_name_op", "L", "Name of mobility to be used with additional_ops");
64 parameters.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
65 parameters.addParam<bool>(
66 "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
67 MultiMooseEnum anisotropy("true=1 false=0", "false");
68 parameters.addParam<bool>(
69 "mass_conservation", false, "Whether strict mass conservation formulation is used or not");
70 parameters.addRequiredParam<MultiMooseEnum>(
71 "anisotropic", anisotropy, "Whether or not each mobility is anisotropic");
72 parameters.addParam<std::vector<NonlinearVariableName>>(
73 "concentrations", "List of concentration variables for strict mass conservation");
74 parameters.addParam<std::vector<MaterialPropertyName>>(
75 "hj_c_min",
76 {},
77 "List of body forces coefficients for strict mass conservation formulation that indicates "
78 "the minima in concentration free energy."
79 "Place in same order as switching_function_names.");
80 parameters.addParam<std::vector<MaterialPropertyName>>(
81 "hj_over_kVa",
82 {},
83 "List of MatReaction coefficients for strict mass conservation formulation that relates "
84 "chemical potential with switching functionj between phases"
85 "Place in same order as switching_function_names.");
86 return parameters;
87}
Action::validParams
static InputParameters validParams()
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:42:53 for https://mooseframework.inl.gov by doxygen 1.9.8