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
GrainGrowthAction Class Reference

#include <GrainGrowthAction.h>

Inheritance diagram for GrainGrowthAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 GrainGrowthAction (const InputParameters &params)
 
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

void addVariables ()
 
void addBnds (const std::string &name_base)
 
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

const unsigned int _op_num
 number of variables and variable name base for variable creation
 
const std::string _var_name_base
 
const libMesh::FEType _fe_type
 FEType for the variable being created.
 
const bool _initial_from_file
 Take initial values from file?
 
const bool _use_ad
 use AD objects where possible
 
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

Definition at line 17 of file GrainGrowthAction.h.

Constructor & Destructor Documentation

◆ GrainGrowthAction()

GrainGrowthAction::GrainGrowthAction ( const InputParameters &  params)

Definition at line 91 of file GrainGrowthAction.C.

92 : Action(params),
93 _op_num(getParam<unsigned int>("op_num")),
94 _var_name_base(getParam<std::string>("var_name_base")),
95 _fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
96 Utility::string_to_enum<FEFamily>(getParam<MooseEnum>("family"))),
97 _initial_from_file(getParam<bool>("initial_from_file")),
98 _use_ad(getParam<bool>("use_automatic_differentiation"))
99{
100}
GrainGrowthAction::_initial_from_file
const bool _initial_from_file
Take initial values from file?
Definition GrainGrowthAction.h:38
GrainGrowthAction::_use_ad
const bool _use_ad
use AD objects where possible
Definition GrainGrowthAction.h:41
GrainGrowthAction::_var_name_base
const std::string _var_name_base
Definition GrainGrowthAction.h:32
GrainGrowthAction::_op_num
const unsigned int _op_num
number of variables and variable name base for variable creation
Definition GrainGrowthAction.h:31
GrainGrowthAction::_fe_type
const libMesh::FEType _fe_type
FEType for the variable being created.
Definition GrainGrowthAction.h:35

Member Function Documentation

◆ act()

void GrainGrowthAction::act ( )
virtual

Implements Action.

Reimplemented in GrainGrowthLinearizedInterfaceAction.

Definition at line 103 of file GrainGrowthAction.C.

104{
105 // Add Variables
106 addVariables();
107
108 // Add Kernels
109 for (unsigned int op = 0; op < _op_num; op++)
110 {
111 // Create variable name
112 std::string var_name = _var_name_base + Moose::stringify(op);
113
114 // Add the kernels for each grain growth variable
115 if (_current_task == "add_kernel")
116 {
117 //
118 // Add time derivative kernel
119 //
120
121 {
122 std::string kernel_type = _use_ad ? "ADTimeDerivative" : "TimeDerivative";
123
124 std::string kernel_name = var_name + "_" + kernel_type;
125 InputParameters params = _factory.getValidParams(kernel_type);
126 params.set<NonlinearVariableName>("variable") = var_name;
127 params.applyParameters(parameters());
128
129 _problem->addKernel(kernel_type, kernel_name, params);
130 }
131
132 //
133 // Add ACGrGrPoly kernel
134 //
135
136 {
137 std::string kernel_type = _use_ad ? "ADGrainGrowth" : "ACGrGrPoly";
138
139 // Make vector of order parameter names, excluding this one
140 std::vector<VariableName> v;
141 v.resize(_op_num - 1);
142
143 unsigned int ind = 0;
144 for (unsigned int j = 0; j < _op_num; ++j)
145 if (j != op)
146 v[ind++] = _var_name_base + Moose::stringify(j);
147
148 std::string kernel_name = var_name + "_" + kernel_type;
149 InputParameters params = _factory.getValidParams(kernel_type);
150 params.set<NonlinearVariableName>("variable") = var_name;
151 params.set<std::vector<VariableName>>("v") = v;
152 params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
153 params.applyParameters(parameters());
154
155 _problem->addKernel(kernel_type, kernel_name, params);
156 }
157
158 //
159 // Add ACInterface kernel
160 //
161
162 {
163 std::string kernel_type = _use_ad ? "ADACInterface" : "ACInterface";
164
165 std::string kernel_name = var_name + "_" + kernel_type;
166 InputParameters params = _factory.getValidParams(kernel_type);
167 params.set<NonlinearVariableName>("variable") = var_name;
168 params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
169 params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
170 params.set<bool>("variable_L") = getParam<bool>("variable_mobility");
171 params.applyParameters(parameters());
172
173 _problem->addKernel(kernel_type, kernel_name, params);
174 }
175
176 //
177 // Set up optional ACGBPoly bubble interaction kernels
178 //
179
180 if (isParamValid("c"))
181 {
182 if (_use_ad)
183 mooseError("AD version of ACGBPoly is not implemented");
184
185 std::string kernel_type = "ACGBPoly";
186
187 std::string kernel_name = var_name + "_" + kernel_type;
188 InputParameters params = _factory.getValidParams(kernel_type);
189 params.set<NonlinearVariableName>("variable") = var_name;
190 params.set<std::vector<VariableName>>("c") = {getParam<VariableName>("c")};
191 params.applyParameters(parameters());
192
193 _problem->addKernel(kernel_type, kernel_name, params);
194 }
195 }
196 }
197
198 // Add AuxVriable and AuxKernel for Bnds variable
199 addBnds(_var_name_base);
200}
v
const double v
Definition GasLiquidMassTransferTest.C:23
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::_current_task
const std::string & _current_task
GrainGrowthAction::addBnds
void addBnds(const std::string &name_base)
Definition GrainGrowthAction.C:239
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Action::parameters
const InputParameters & parameters() 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)

◆ addBnds()

void GrainGrowthAction::addBnds ( const std::string &  name_base)
protected

Definition at line 239 of file GrainGrowthAction.C.

240{
241 // Create auxvariable
242 if (_current_task == "add_aux_variable")
243 {
244 auto var_params = _factory.getValidParams("MooseVariable");
245 var_params.set<MooseEnum>("family") = "LAGRANGE";
246 var_params.set<MooseEnum>("order") = "FIRST";
247 var_params.applySpecificParameters(_pars, {"block"});
248 _problem->addAuxVariable("MooseVariable", "bnds", var_params);
249 }
250 // Create auxkernel
251 else if (_current_task == "add_aux_kernel")
252 {
253 // Make vector of order parameter names, excluding this one std::vector<VariableName> v;
254 std::vector<VariableName> v;
255 v.resize(_op_num);
256
257 for (unsigned int j = 0; j < _op_num; ++j)
258 v[j] = name_base + Moose::stringify(j);
259
260 std::string aux_kernel_type = "BndsCalcAux";
261
262 std::string aux_kernel_name = "bnds_" + aux_kernel_type;
263 InputParameters params = _factory.getValidParams(aux_kernel_type);
264 params.set<AuxVariableName>("variable") = "bnds";
265 params.set<std::vector<VariableName>>("v") = v;
266 params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
267 params.applyParameters(parameters());
268
269 _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
270 }
271}
EXEC_TIMESTEP_END
const ExecFlagType EXEC_TIMESTEP_END
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL
Action::_pars
const InputParameters & _pars

Referenced by act(), and GrainGrowthLinearizedInterfaceAction::act().

◆ addVariables()

void GrainGrowthAction::addVariables ( )
protected

Definition at line 203 of file GrainGrowthAction.C.

204{
205 for (unsigned int op = 0; op < _op_num; op++)
206 {
207 // Create variable name
208 std::string var_name = _var_name_base + Moose::stringify(op);
209
210 // Setup initial from file if requested
211 if (_initial_from_file)
212 {
213 if (_current_task == "check_copy_nodal_vars")
214 _app.setExodusFileRestart(true);
215
216 if (_current_task == "copy_nodal_vars")
217 {
218 auto * system = &_problem->getNonlinearSystemBase(/*nl_sys_num=*/0);
219 system->addVariableToCopy(var_name, var_name, "LATEST");
220 }
221 }
222
223 // Add each grain growth variable
224 if (_current_task == "add_variable")
225 {
226 auto type = AddVariableAction::variableType(_fe_type);
227 auto var_params = _factory.getValidParams(type);
228
229 var_params.applySpecificParameters(_pars, {"family", "order", "block"});
230 var_params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
231
232 // Add variable
233 _problem->addVariable(type, var_name, var_params);
234 }
235 }
236}
Action::_app
MooseApp & _app
AddVariableAction::variableType
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
MooseApp::setExodusFileRestart
void setExodusFileRestart(bool flag)
Action::type
const std::string & type() const

Referenced by act(), and GrainGrowthLinearizedInterfaceAction::act().

◆ validParams()

InputParameters GrainGrowthAction::validParams ( )
static

Definition at line 33 of file GrainGrowthAction.C.

34{
35 InputParameters params = Action::validParams();
36 params.addClassDescription(
37 "Set up the variable and the kernels needed for a grain growth simulation");
38 params.addRequiredParam<unsigned int>("op_num",
39 "specifies the number of order parameters to create");
40 params.addRequiredParam<std::string>("var_name_base", "specifies the base name of the variables");
41 params.addParam<Real>(
42 "scaling", 1.0, "Specifies a scaling factor to apply to the order parameters");
43 params.addParam<bool>(
44 "initial_from_file",
45 false,
46 "Take the initial condition of all polycrystal variables from the mesh file");
47
48 // Get MooseEnums for the possible order/family options for this variable
49 MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
50 MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
51 params.addParam<MooseEnum>("family",
52 families,
53 "Specifies the family of FE "
54 "shape function to use for the order parameters");
55 params.addParam<MooseEnum>("order",
56 orders,
57 "Specifies the order of the FE "
58 "shape function to use for the order parameters");
59
60 params.addParam<MaterialPropertyName>(
61 "mobility", "L", "The isotropic mobility used with the kernels");
62 params.addParam<MaterialPropertyName>("kappa", "kappa_op", "The kappa used with the kernels");
63
64 params.addParam<VariableName>("c", "Name of coupled concentration variable");
65
66 params.addParam<Real>("en_ratio", 1.0, "Ratio of surface to GB energy");
67 params.addParam<unsigned int>("ndef", 0, "Specifies the number of deformed grains to create");
68 params.addParam<bool>("variable_mobility",
69 true,
70 "The mobility is a function of any MOOSE variable (if "
71 "this is set to false, L must be constant over the "
72 "entire domain!)");
73 params.addCoupledVar("coupled_variables",
74 "Vector of nonlinear variable arguments that L depends on");
75
76 params.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
77 params.addParam<bool>(
78 "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
79 params.addParam<bool>("use_automatic_differentiation",
80 false,
81 "Flag to use automatic differentiation (AD) objects when possible");
82 params.addParam<std::vector<SubdomainName>>(
83 "block", {}, "Block restriction for the variables and kernels");
84
85 params.addParamNamesToGroup("scaling implicit use_displaced_mesh", "Advanced");
86 params.addParamNamesToGroup("c en_ratio ndef", "Multiphysics");
87
88 return params;
89}
Action::validParams
static InputParameters validParams()
AddVariableAction::getNonlinearVariableFamilies
static MooseEnum getNonlinearVariableFamilies()
AddVariableAction::getNonlinearVariableOrders
static MooseEnum getNonlinearVariableOrders()
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
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)
InputParameters::addCoupledVar
void addCoupledVar(const std::string &name, const std::string &doc_string)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

Referenced by GrainGrowthLinearizedInterfaceAction::validParams().

Member Data Documentation

◆ _fe_type

const libMesh::FEType GrainGrowthAction::_fe_type
protected

FEType for the variable being created.

Definition at line 35 of file GrainGrowthAction.h.

Referenced by addVariables().

◆ _initial_from_file

const bool GrainGrowthAction::_initial_from_file
protected

Take initial values from file?

Definition at line 38 of file GrainGrowthAction.h.

Referenced by addVariables().

◆ _op_num

const unsigned int GrainGrowthAction::_op_num
protected

number of variables and variable name base for variable creation

Definition at line 31 of file GrainGrowthAction.h.

Referenced by act(), GrainGrowthLinearizedInterfaceAction::act(), addBnds(), and addVariables().

◆ _use_ad

const bool GrainGrowthAction::_use_ad
protected

use AD objects where possible

Definition at line 41 of file GrainGrowthAction.h.

Referenced by act().

◆ _var_name_base

const std::string GrainGrowthAction::_var_name_base
protected

Definition at line 32 of file GrainGrowthAction.h.

Referenced by act(), GrainGrowthLinearizedInterfaceAction::act(), and addVariables().

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