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

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}
v
const double v
Definition GasLiquidMassTransferTest.C:23
EXEC_TIMESTEP_END
const ExecFlagType EXEC_TIMESTEP_END
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::_current_task
const std::string & _current_task
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
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::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::_factory
Factory & _factory
Moose::stringify
std::string stringify(const T &t)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ addBnds()

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

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}
Action::_pars
const InputParameters & _pars

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

◆ addVariables()

void GrainGrowthAction::addVariables ( )
protectedinherited

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)
GrainGrowthAction::_initial_from_file
const bool _initial_from_file
Take initial values from file?
Definition GrainGrowthAction.h:38
GrainGrowthAction::_fe_type
const libMesh::FEType _fe_type
FEType for the variable being created.
Definition GrainGrowthAction.h:35
MooseApp::setExodusFileRestart
void setExodusFileRestart(bool flag)
Action::type
const std::string & type() const

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

◆ 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}
GrainGrowthAction::validParams
static InputParameters validParams()
Definition GrainGrowthAction.C:33
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
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 Aug 21 2026 13:42:53 for https://mooseframework.inl.gov by doxygen 1.9.8