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

#include <ConservedAction.h>

Inheritance diagram for ConservedAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 ConservedAction (const InputParameters &params)
 
virtual void act () override
 
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 Types

enum class  SolveType { DIRECT , REVERSE_SPLIT , FORWARD_SPLIT }
 Type of solve. More...
 

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 _chempot_name
 Name of chemical potential variable for split solves.
 
const SolveType _solve_type
 Type of solve to use used in the action.
 
const NonlinearVariableName _var_name
 Name of the variable being created.
 
libMesh::FEType _fe_type
 FEType for the variable being created.
 
const Real _scaling
 Scaling parameter.
 
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 16 of file ConservedAction.h.

Member Enumeration Documentation

◆ SolveType

enum class ConservedAction::SolveType
strongprotected

Type of solve.

Enumerator
DIRECT 
REVERSE_SPLIT 
FORWARD_SPLIT 

Definition at line 27 of file ConservedAction.h.

28 {
29 DIRECT,
30 REVERSE_SPLIT,
31 FORWARD_SPLIT
32 };

Constructor & Destructor Documentation

◆ ConservedAction()

ConservedAction::ConservedAction ( const InputParameters &  params)

Definition at line 63 of file ConservedAction.C.

64 : Action(params),
65 _solve_type(getParam<MooseEnum>("solve_type").getEnum<SolveType>()),
66 _var_name(name()),
67 _scaling(getParam<Real>("scaling"))
68{
69 switch (_solve_type)
70 {
71 case SolveType::DIRECT:
72 _fe_type = FEType(Utility::string_to_enum<Order>("THIRD"),
73 Utility::string_to_enum<FEFamily>("HERMITE"));
74 if (!parameters().isParamSetByAddParam("order") &&
75 !parameters().isParamSetByAddParam("family"))
76 mooseWarning("Order and family autoset to third and hermite in ConservedAction");
77 break;
78 case SolveType::REVERSE_SPLIT:
79 case SolveType::FORWARD_SPLIT:
80 _fe_type = FEType(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
81 Utility::string_to_enum<FEFamily>(getParam<MooseEnum>("family")));
82 // Set name of chemical potential variable
83 _chempot_name = "chem_pot_" + _var_name;
84 break;
85 default:
86 paramError("solve_type", "Incorrect solve_type in ConservedAction");
87 }
88}
ConservedAction::_chempot_name
std::string _chempot_name
Name of chemical potential variable for split solves.
Definition ConservedAction.h:34
ConservedAction::_var_name
const NonlinearVariableName _var_name
Name of the variable being created.
Definition ConservedAction.h:38
ConservedAction::_scaling
const Real _scaling
Scaling parameter.
Definition ConservedAction.h:42
ConservedAction::_solve_type
const SolveType _solve_type
Type of solve to use used in the action.
Definition ConservedAction.h:36
ConservedAction::_fe_type
libMesh::FEType _fe_type
FEType for the variable being created.
Definition ConservedAction.h:40
Action::parameters
const InputParameters & parameters() const
Action::name
const std::string & name() const
Action::paramError
void paramError(const std::string &param, Args... args) const
Action::mooseWarning
void mooseWarning(Args &&... args) const

Member Function Documentation

◆ act()

void ConservedAction::act ( )
overridevirtual

Implements Action.

Definition at line 91 of file ConservedAction.C.

92{
93 //
94 // Add variable(s)
95 //
96 if (_current_task == "add_variable")
97 {
98 auto type = AddVariableAction::variableType(_fe_type);
99 auto var_params = _factory.getValidParams(type);
100 var_params.set<MooseEnum>("family") = Moose::stringify(_fe_type.family);
101 var_params.set<MooseEnum>("order") = _fe_type.order.get_order();
102 var_params.set<std::vector<Real>>("scaling") = {_scaling};
103 var_params.applySpecificParameters(parameters(), {"block"});
104
105 // Create conserved variable _var_name
106 _problem->addVariable(type, _var_name, var_params);
107
108 // Create chemical potential variable for split form
109 switch (_solve_type)
110 {
111 case SolveType::DIRECT:
112 break;
113 case SolveType::REVERSE_SPLIT:
114 case SolveType::FORWARD_SPLIT:
115 _problem->addVariable(type, _chempot_name, var_params);
116 }
117 }
118
119 //
120 // Add Kernels
121 //
122 else if (_current_task == "add_kernel")
123 {
124 switch (_solve_type)
125 {
126 case SolveType::DIRECT:
127 // Add time derivative kernel
128 {
129 std::string kernel_type = "TimeDerivative";
130
131 std::string kernel_name = _var_name + "_" + kernel_type;
132 InputParameters params = _factory.getValidParams(kernel_type);
133 params.set<NonlinearVariableName>("variable") = _var_name;
134 params.applyParameters(parameters());
135
136 _problem->addKernel(kernel_type, kernel_name, params);
137 }
138
139 // Add CahnHilliard kernel
140 {
141 std::string kernel_type = "CahnHilliard";
142
143 std::string kernel_name = _var_name + "_" + kernel_type;
144 InputParameters params = _factory.getValidParams(kernel_type);
145 params.set<NonlinearVariableName>("variable") = _var_name;
146 params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
147 params.set<MaterialPropertyName>("f_name") =
148 getParam<MaterialPropertyName>("free_energy");
149 params.applyParameters(parameters());
150
151 _problem->addKernel(kernel_type, kernel_name, params);
152 }
153
154 // Add ACInterface kernel
155 {
156 std::string kernel_type = "CHInterface";
157
158 std::string kernel_name = _var_name + "_" + kernel_type;
159 InputParameters params = _factory.getValidParams(kernel_type);
160 params.set<NonlinearVariableName>("variable") = _var_name;
161 params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
162 params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
163 params.applyParameters(parameters());
164
165 _problem->addKernel(kernel_type, kernel_name, params);
166 }
167 break;
168
169 case SolveType::REVERSE_SPLIT:
170 // Add time derivative kernel
171 {
172 std::string kernel_type = "CoupledTimeDerivative";
173
174 std::string kernel_name = _var_name + "_" + kernel_type;
175 InputParameters params = _factory.getValidParams(kernel_type);
176 params.set<NonlinearVariableName>("variable") = _chempot_name;
177 params.set<std::vector<VariableName>>("v") = {_var_name};
178 params.applyParameters(parameters());
179
180 _problem->addKernel(kernel_type, kernel_name, params);
181 }
182
183 // Add SplitCHWRes kernel
184 {
185 std::string kernel_type = "SplitCHWRes";
186
187 std::string kernel_name = _var_name + "_" + kernel_type;
188 InputParameters params = _factory.getValidParams(kernel_type);
189 params.set<NonlinearVariableName>("variable") = _chempot_name;
190 params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
191 params.applyParameters(parameters());
192
193 _problem->addKernel(kernel_type, kernel_name, params);
194 }
195
196 // Add SplitCHParsed kernel
197 {
198 std::string kernel_type = "SplitCHParsed";
199
200 std::string kernel_name = _var_name + "_" + kernel_type;
201 InputParameters params = _factory.getValidParams(kernel_type);
202 params.set<NonlinearVariableName>("variable") = _var_name;
203 params.set<std::vector<VariableName>>("w") = {_chempot_name};
204 params.set<MaterialPropertyName>("f_name") =
205 getParam<MaterialPropertyName>("free_energy");
206 params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
207 params.applyParameters(parameters());
208
209 _problem->addKernel(kernel_type, kernel_name, params);
210 }
211 break;
212
213 case SolveType::FORWARD_SPLIT:
214 // Add time derivative kernel
215 {
216 std::string kernel_type = "TimeDerivative";
217
218 std::string kernel_name = _var_name + "_" + kernel_type;
219 InputParameters params = _factory.getValidParams(kernel_type);
220 params.set<NonlinearVariableName>("variable") = _var_name;
221 params.applyParameters(parameters());
222
223 _problem->addKernel(kernel_type, kernel_name, params);
224 }
225
226 // Add MatDiffusion kernel for c residual
227 {
228 std::string kernel_type = "MatDiffusion";
229
230 std::string kernel_name = _var_name + "_" + kernel_type;
231 InputParameters params = _factory.getValidParams(kernel_type);
232 params.set<NonlinearVariableName>("variable") = _var_name;
233 params.set<std::vector<VariableName>>("v") = {_chempot_name};
234 params.set<MaterialPropertyName>("diffusivity") =
235 getParam<MaterialPropertyName>("mobility");
236 params.applyParameters(parameters());
237
238 _problem->addKernel(kernel_type, kernel_name, params);
239 }
240 // Add MatDiffusion kernel for chemical potential residual
241 {
242 std::string kernel_type = "MatDiffusion";
243
244 std::string kernel_name = _chempot_name + "_" + kernel_type;
245 InputParameters params = _factory.getValidParams(kernel_type);
246 params.set<NonlinearVariableName>("variable") = _chempot_name;
247 params.set<std::vector<VariableName>>("v") = {_var_name};
248 params.set<MaterialPropertyName>("diffusivity") = getParam<MaterialPropertyName>("kappa");
249 params.applyParameters(parameters());
250
251 _problem->addKernel(kernel_type, kernel_name, params);
252 }
253
254 // Add CoupledMaterialDerivative kernel
255 {
256 std::string kernel_type = "CoupledMaterialDerivative";
257
258 std::string kernel_name = _chempot_name + "_" + kernel_type;
259 InputParameters params = _factory.getValidParams(kernel_type);
260 params.set<NonlinearVariableName>("variable") = _chempot_name;
261 params.set<std::vector<VariableName>>("v") = {_var_name};
262 params.set<MaterialPropertyName>("f_name") =
263 getParam<MaterialPropertyName>("free_energy");
264 params.applyParameters(parameters());
265
266 _problem->addKernel(kernel_type, kernel_name, params);
267 }
268
269 // Add CoefReaction kernel
270 {
271 std::string kernel_type = "CoefReaction";
272
273 std::string kernel_name = _chempot_name + "_" + kernel_type;
274 InputParameters params = _factory.getValidParams(kernel_type);
275 params.set<NonlinearVariableName>("variable") = _chempot_name;
276 params.set<Real>("coefficient") = -1.0;
277 params.applyParameters(parameters());
278
279 _problem->addKernel(kernel_type, kernel_name, params);
280 }
281 }
282 }
283}
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
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)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
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::type
const std::string & type() const
Action::_factory
Factory & _factory
libMesh::FEType::order
OrderWrapper order
Moose::stringify
std::string stringify(const T &t)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ validParams()

InputParameters ConservedAction::validParams ( )
static

Definition at line 26 of file ConservedAction.C.

27{
28 InputParameters params = Action::validParams();
29 params.addClassDescription(
30 "Set up the variable(s) and the kernels needed for a conserved phase field variable."
31 " Note that for a direct solve, the element family and order are overwritten with hermite "
32 "and third.");
33 MooseEnum solves("DIRECT REVERSE_SPLIT FORWARD_SPLIT");
34 params.addRequiredParam<MooseEnum>("solve_type", solves, "Split or direct solve?");
35 // Get MooseEnums for the possible order/family options for this variable
36 MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
37 MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
38 params.addParam<MooseEnum>("family",
39 families,
40 "Specifies the family of FE "
41 "shape functions to use for this variable");
42 params.addParam<MooseEnum>("order",
43 orders,
44 "Specifies the order of the FE "
45 "shape function to use for this variable");
46 params.addParam<Real>("scaling", 1.0, "Specifies a scaling factor to apply to this variable");
47 params.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
48 params.addParam<bool>(
49 "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
50 params.addParamNamesToGroup("scaling implicit use_displaced_mesh", "Advanced");
51 params.addRequiredParam<MaterialPropertyName>("mobility", "The mobility used with the kernel");
52 params.addCoupledVar("coupled_variables",
53 "Vector of nonlinear variable arguments this kernel depends on");
54
55 params.addRequiredParam<MaterialPropertyName>(
56 "free_energy", "Base name of the free energy function F defined in a free energy material");
57 params.addRequiredParam<MaterialPropertyName>("kappa", "The kappa used with the kernel");
58 params.addParam<std::vector<SubdomainName>>(
59 "block", {}, "Block restriction for the variables and kernels");
60 return params;
61}
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)

Member Data Documentation

◆ _chempot_name

std::string ConservedAction::_chempot_name
protected

Name of chemical potential variable for split solves.

Definition at line 34 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

◆ _fe_type

libMesh::FEType ConservedAction::_fe_type
protected

FEType for the variable being created.

Definition at line 40 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

◆ _scaling

const Real ConservedAction::_scaling
protected

Scaling parameter.

Definition at line 42 of file ConservedAction.h.

Referenced by act().

◆ _solve_type

const SolveType ConservedAction::_solve_type
protected

Type of solve to use used in the action.

Definition at line 36 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

◆ _var_name

const NonlinearVariableName ConservedAction::_var_name
protected

Name of the variable being created.

Definition at line 38 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

The documentation for this class was generated from the following files:
Generated on Fri Sep 11 2026 20:37:50 for https://mooseframework.inl.gov by doxygen 1.9.8