https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected 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
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParameters & parameters () const
 
MooseObjectName uniqueName () 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 &nm) const
 
void paramError (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
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) 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 ()
 

Public Attributes

const ConsoleStream _console
 

Static Public Attributes

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
 

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 More...
 
const std::string _var_name_base
 
const libMesh::FEType _fe_type
 FEType for the variable being created. More...
 
const bool _initial_from_file
 Take initial values from file? More...
 
const bool _use_ad
 use AD objects where possible More...
 
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
 
const std::string _type
 
const std::string _name
 
const InputParameters & _pars
 
Factory & _factory
 
ActionFactory & _action_factory
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

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::_use_ad
const bool _use_ad
use AD objects where possible
Definition: GrainGrowthAction.h:41
GrainGrowthAction::_fe_type
const libMesh::FEType _fe_type
FEType for the variable being created.
Definition: GrainGrowthAction.h:35
Action::Action
Action(const InputParameters &parameters)
GrainGrowthAction::_op_num
const unsigned int _op_num
number of variables and variable name base for variable creation
Definition: GrainGrowthAction.h:31
GrainGrowthAction::_var_name_base
const std::string _var_name_base
Definition: GrainGrowthAction.h:32
GrainGrowthAction::_initial_from_file
const bool _initial_from_file
Take initial values from file?
Definition: GrainGrowthAction.h:38

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 }
GrainGrowthAction::_use_ad
const bool _use_ad
use AD objects where possible
Definition: GrainGrowthAction.h:41
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)
GrainGrowthAction::_op_num
const unsigned int _op_num
number of variables and variable name base for variable creation
Definition: GrainGrowthAction.h:31
Action::isParamValid
bool isParamValid(const std::string &name) const
Action::_factory
Factory & _factory
GrainGrowthAction::_var_name_base
const std::string _var_name_base
Definition: GrainGrowthAction.h:32
Action::_current_task
const std::string & _current_task
Moose::stringify
std::string stringify(const T &t)
NS::v
static const std::string v
Definition: NS.h:84
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const
EM::j
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")

◆ addBnds()

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

Definition at line 239 of file GrainGrowthAction.C.

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

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 }
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)
EXEC_TIMESTEP_END
const ExecFlagType EXEC_TIMESTEP_END
GrainGrowthAction::_op_num
const unsigned int _op_num
number of variables and variable name base for variable creation
Definition: GrainGrowthAction.h:31
Action::_factory
Factory & _factory
Action::_current_task
const std::string & _current_task
Moose::stringify
std::string stringify(const T &t)
NS::v
static const std::string v
Definition: NS.h:84
Action::_pars
const InputParameters & _pars
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const
EM::j
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL

◆ addVariables()

void GrainGrowthAction::addVariables ( )
protected

Definition at line 203 of file GrainGrowthAction.C.

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

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 }
GrainGrowthAction::_fe_type
const libMesh::FEType _fe_type
FEType for the variable being created.
Definition: GrainGrowthAction.h:35
Action::_app
MooseApp & _app
GrainGrowthAction::_op_num
const unsigned int _op_num
number of variables and variable name base for variable creation
Definition: GrainGrowthAction.h:31
Action::_factory
Factory & _factory
GrainGrowthAction::_var_name_base
const std::string _var_name_base
Definition: GrainGrowthAction.h:32
MooseApp::setExodusFileRestart
void setExodusFileRestart(bool flag)
Action::type
const std::string & type() const
Action::_current_task
const std::string & _current_task
AddVariableAction::variableType
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
Moose::stringify
std::string stringify(const T &t)
Action::_pars
const InputParameters & _pars
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
GrainGrowthAction::_initial_from_file
const bool _initial_from_file
Take initial values from file?
Definition: GrainGrowthAction.h:38

◆ validParams()

InputParameters GrainGrowthAction::validParams ( )
static

Definition at line 33 of file GrainGrowthAction.C.

Referenced by GrainGrowthLinearizedInterfaceAction::validParams().

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("args", "Vector of nonlinear variable arguments that L depends on");
74  params.deprecateCoupledVar("args", "coupled_variables", "02/09/2024");
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 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
AddVariableAction::getNonlinearVariableFamilies
static MooseEnum getNonlinearVariableFamilies()
Action::validParams
static InputParameters validParams()
AddVariableAction::getNonlinearVariableOrders
static MooseEnum getNonlinearVariableOrders()
InputParameters::deprecateCoupledVar
void deprecateCoupledVar(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
InputParameters::addCoupledVar
void addCoupledVar(const std::string &name, const std::string &doc_string)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)

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 Jul 18 2025 12:01:33 for https://mooseframework.inl.gov by   doxygen 1.8.14