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

#include <GrainGrowthLinearizedInterfaceAction.h>

Inheritance diagram for GrainGrowthLinearizedInterfaceAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 GrainGrowthLinearizedInterfaceAction (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 std::string _op_name_base
 number of variables and variable name base for variable creation More...
 
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 GrainGrowthLinearizedInterfaceAction.h.

Constructor & Destructor Documentation

◆ GrainGrowthLinearizedInterfaceAction()

GrainGrowthLinearizedInterfaceAction::GrainGrowthLinearizedInterfaceAction ( const InputParameters &  params)

Definition at line 46 of file GrainGrowthLinearizedInterfaceAction.C.

48  : GrainGrowthAction(params), _op_name_base(getParam<std::string>("op_name_base"))
49 {
50 }
GrainGrowthLinearizedInterfaceAction::_op_name_base
const std::string _op_name_base
number of variables and variable name base for variable creation
Definition: GrainGrowthLinearizedInterfaceAction.h:28
GrainGrowthAction::GrainGrowthAction
GrainGrowthAction(const InputParameters &params)
Definition: GrainGrowthAction.C:91

Member Function Documentation

◆ act()

void GrainGrowthLinearizedInterfaceAction::act ( )
virtual

Reimplemented from GrainGrowthAction.

Definition at line 53 of file GrainGrowthLinearizedInterfaceAction.C.

54 {
55  // Create Variables
56  addVariables();
57 
58  // Loop over order parameters
59  for (unsigned int op = 0; op < _op_num; op++)
60  {
61  // Create transformed variable name
62  std::string var_name = _var_name_base + Moose::stringify(op);
63 
64  // Create dependent order parameter name
65  std::string op_name = _op_name_base + Moose::stringify(op);
66 
67  // Add aux-variables
68  if (_current_task == "add_aux_variable")
69  {
70  // Add aux-variable defining dependent order parameter
71  auto var_params = _factory.getValidParams("MooseVariable");
72  var_params.set<MooseEnum>("family") = "LAGRANGE";
73  var_params.set<MooseEnum>("order") = "FIRST";
74  _problem->addAuxVariable("MooseVariable", op_name, var_params);
75 
76  // Add bounds_dummy used for constrained solve
77  var_params = _factory.getValidParams("MooseVariable");
78  var_params.set<MooseEnum>("family") = "LAGRANGE";
79  var_params.set<MooseEnum>("order") = "FIRST";
80  _problem->addAuxVariable("MooseVariable", "bounds_dummy", var_params);
81  }
82  // Add the kernels for each grain growth variable
83  else if (_current_task == "add_kernel")
84  {
85  //
86  // Add time derivative kernel
87  //
88 
89  {
90  std::string kernel_type = "ChangedVariableTimeDerivative";
91 
92  std::string kernel_name = var_name + "_" + kernel_type;
93  InputParameters params = _factory.getValidParams(kernel_type);
94  params.set<NonlinearVariableName>("variable") = var_name;
95  params.set<MaterialPropertyName>("order_parameter") = op_name;
96  params.applyParameters(parameters());
97 
98  _problem->addKernel(kernel_type, kernel_name, params);
99  }
100 
101  //
102  // Add ACGrGrPolyLinearizedInterface kernel
103  //
104 
105  {
106  std::string kernel_type = "ACGrGrPolyLinearizedInterface";
107 
108  // Make vector of variable names and order parameter names, excluding this one
109  std::vector<VariableName> v;
110  v.resize(_op_num - 1);
111  std::vector<MaterialPropertyName> other_ops;
112  other_ops.resize(_op_num - 1);
113 
114  unsigned int ind = 0;
115  for (unsigned int j = 0; j < _op_num; ++j)
116  if (j != op)
117  {
118  v[ind] = _var_name_base + Moose::stringify(j);
119  other_ops[ind] = _op_name_base + Moose::stringify(j);
120  ind++;
121  }
122 
123  std::string kernel_name = var_name + "_" + kernel_type;
124  InputParameters params2 = _factory.getValidParams(kernel_type);
125  params2.set<NonlinearVariableName>("variable") = var_name;
126  params2.set<std::vector<VariableName>>("v") = v;
127  params2.set<MaterialPropertyName>("this_op") = op_name;
128  params2.set<std::vector<MaterialPropertyName>>("other_ops") = other_ops;
129  params2.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
130  params2.applyParameters(parameters());
131 
132  _problem->addKernel(kernel_type, kernel_name, params2);
133  }
134 
135  //
136  // Add ACInterface kernel
137  //
138 
139  {
140  std::string kernel_type = "ACInterfaceChangedVariable";
141 
142  std::string kernel_name = var_name + "_" + kernel_type;
143  InputParameters params = _factory.getValidParams(kernel_type);
144  params.set<NonlinearVariableName>("variable") = var_name;
145  params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
146  params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
147  params.set<MaterialPropertyName>("order_parameter") = op_name;
148  params.set<bool>("variable_L") = getParam<bool>("variable_mobility");
149  params.applyParameters(parameters());
150 
151  _problem->addKernel(kernel_type, kernel_name, params);
152  }
153  }
154 
155  // Add derivative-parsed material defining order parameter expressions
156  if (_current_task == "add_material")
157  {
158  std::string material_name = "LinearizedInterfaceFunction";
159  auto params = _factory.getValidParams(material_name);
160  params.set<std::string>("property_name") = op_name;
161  params.set<std::vector<VariableName>>("phi") = {var_name};
162 
163  _problem->addMaterial(material_name, op_name, params);
164  }
165 
166  if (_current_task == "add_aux_kernel")
167  {
168  {
169  // Add auxkernel for the order parameter auxvariable
170  std::string aux_kernel_type = "LinearizedInterfaceAux";
171 
172  std::string aux_kernel_name = op_name + aux_kernel_type;
173  InputParameters params = _factory.getValidParams(aux_kernel_type);
174  params.set<AuxVariableName>("variable") = op_name;
175  params.set<std::vector<VariableName>>("nonlinear_variable") = {var_name};
176  params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
177  params.applyParameters(parameters());
178 
179  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
180  }
181  // Add upper and lower bound for each variable
182  // Upper bound
183  {
184  std::string bound_type = "ConstantBounds";
185  std::string bound_name = var_name + "_upper_bound";
186  auto params = _factory.getValidParams(bound_type);
187  params.set<AuxVariableName>("variable") = "bounds_dummy";
188  params.set<NonlinearVariableName>("bounded_variable") = var_name;
189  params.set<MooseEnum>("bound_type") = "upper";
190  params.set<Real>("bound_value") = getParam<Real>("bound_value");
191  _problem->addAuxKernel(bound_type, bound_name, params);
192  }
193  // Lower bound
194  {
195  std::string bound_type = "ConstantBounds";
196  std::string bound_name = var_name + "_lower_bound";
197  auto params = _factory.getValidParams(bound_type);
198  params.set<AuxVariableName>("variable") = "bounds_dummy";
199  params.set<NonlinearVariableName>("bounded_variable") = var_name;
200  params.set<MooseEnum>("bound_type") = "lower";
201  params.set<Real>("bound_value") = -1.0 * getParam<Real>("bound_value");
202  _problem->addAuxKernel(bound_type, bound_name, params);
203  }
204  }
205  }
206 
207  if (_current_task == "add_bounds_vectors")
208  {
209  _problem->getNonlinearSystemBase(/*nl_sys_num=*/0)
210  .addVector("lower_bound", false, libMesh::GHOSTED);
211  _problem->getNonlinearSystemBase(/*nl_sys_num=*/0)
212  .addVector("upper_bound", false, libMesh::GHOSTED);
213  }
214 
215  // Add AuxVriable and AuxKernel for Bnds variable
216  addBnds(_op_name_base);
217 }
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)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
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
GrainGrowthAction::_var_name_base
const std::string _var_name_base
Definition: GrainGrowthAction.h:32
GrainGrowthLinearizedInterfaceAction::_op_name_base
const std::string _op_name_base
number of variables and variable name base for variable creation
Definition: GrainGrowthLinearizedInterfaceAction.h:28
Action::_current_task
const std::string & _current_task
Moose::stringify
std::string stringify(const T &t)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
NS::v
static const std::string v
Definition: NS.h:84
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

◆ addBnds()

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

Definition at line 239 of file GrainGrowthAction.C.

Referenced by GrainGrowthAction::act(), and 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 ( )
protectedinherited

Definition at line 203 of file GrainGrowthAction.C.

Referenced by GrainGrowthAction::act(), and 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 GrainGrowthLinearizedInterfaceAction::validParams ( )
static

Definition at line 32 of file GrainGrowthLinearizedInterfaceAction.C.

33 {
34  InputParameters params = GrainGrowthAction::validParams();
35  params.addClassDescription("Set up the variable and the kernels needed for a grain growth "
36  "simulation with a linearized interface");
37  params.addRequiredParam<std::string>("op_name_base",
38  "specifies the base name of the dependent order parameters");
39  params.addRequiredParam<Real>(
40  "bound_value",
41  "Bounds value used in the constrained solve, where limits are +/- bound_value");
42 
43  return params;
44 }
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
GrainGrowthAction::validParams
static InputParameters validParams()
Definition: GrainGrowthAction.C:33
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)

Member Data Documentation

◆ _fe_type

const libMesh::FEType GrainGrowthAction::_fe_type
protectedinherited

FEType for the variable being created.

Definition at line 35 of file GrainGrowthAction.h.

Referenced by GrainGrowthAction::addVariables().

◆ _initial_from_file

const bool GrainGrowthAction::_initial_from_file
protectedinherited

Take initial values from file?

Definition at line 38 of file GrainGrowthAction.h.

Referenced by GrainGrowthAction::addVariables().

◆ _op_name_base

const std::string GrainGrowthLinearizedInterfaceAction::_op_name_base
protected

number of variables and variable name base for variable creation

Definition at line 28 of file GrainGrowthLinearizedInterfaceAction.h.

Referenced by act().

◆ _op_num

const unsigned int GrainGrowthAction::_op_num
protectedinherited

number of variables and variable name base for variable creation

Definition at line 31 of file GrainGrowthAction.h.

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

◆ _use_ad

const bool GrainGrowthAction::_use_ad
protectedinherited

use AD objects where possible

Definition at line 41 of file GrainGrowthAction.h.

Referenced by GrainGrowthAction::act().

◆ _var_name_base

const std::string GrainGrowthAction::_var_name_base
protectedinherited

Definition at line 32 of file GrainGrowthAction.h.

Referenced by GrainGrowthAction::act(), act(), and GrainGrowthAction::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