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

#include <XFEMAction.h>

Inheritance diagram for XFEMAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 XFEMAction (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

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::vector< UserObjectName > _geom_cut_userobjects
 
std::string _xfem_qrule
 
std::string _order
 
std::string _family
 
bool _xfem_cut_plane
 
bool _xfem_use_crack_growth_increment
 
Real _xfem_crack_growth_increment
 
bool _use_crack_tip_enrichment
 
UserObjectName _crack_front_definition
 
std::vector< VariableName > _enrich_displacements
 
std::vector< VariableName > _displacements
 
std::vector< BoundaryName > _cut_off_bc
 
Real _cut_off_radius
 
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 15 of file XFEMAction.h.

Constructor & Destructor Documentation

◆ XFEMAction()

XFEMAction::XFEMAction ( const InputParameters &  params)

Definition at line 90 of file XFEMAction.C.

91 : Action(params),
92 _geom_cut_userobjects(getParam<std::vector<UserObjectName>>("geometric_cut_userobjects")),
93 _xfem_qrule(getParam<std::string>("qrule")),
94 _xfem_cut_plane(false),
95 _xfem_use_crack_growth_increment(getParam<bool>("use_crack_growth_increment")),
96 _xfem_crack_growth_increment(getParam<Real>("crack_growth_increment")),
97 _use_crack_tip_enrichment(getParam<bool>("use_crack_tip_enrichment"))
98{
99 _order = "CONSTANT";
100 _family = "MONOMIAL";
101 if (isParamValid("output_cut_plane"))
102 _xfem_cut_plane = getParam<bool>("output_cut_plane");
103
104 if (_use_crack_tip_enrichment)
105 {
106 if (isParamValid("crack_front_definition"))
107 _crack_front_definition = getParam<UserObjectName>("crack_front_definition");
108 else
109 mooseError("To add crack tip enrichment, crack_front_definition must be provided.");
110
111 if (isParamValid("displacements"))
112 _displacements = getParam<std::vector<VariableName>>("displacements");
113 else
114 mooseError("To add crack tip enrichment, displacements must be provided.");
115
116 if (isParamValid("enrichment_displacements"))
117 {
118 _enrich_displacements = getParam<std::vector<VariableName>>("enrichment_displacements");
119 if (_enrich_displacements.size() != 8 && _displacements.size() == 2)
120 mooseError("The number of enrichment displacements should be total 8 for 2D.");
121 else if (_enrich_displacements.size() != 12 && _displacements.size() == 3)
122 mooseError("The number of enrichment displacements should be total 12 for 3D.");
123 }
124 else
125 mooseError("To add crack tip enrichment, enrichment_displacements must be provided.");
126
127 if (isParamValid("cut_off_boundary"))
128 _cut_off_bc = getParam<std::vector<BoundaryName>>("cut_off_boundary");
129 else
130 mooseError("To add crack tip enrichment, cut_off_boundary must be provided.");
131
132 if (isParamValid("cut_off_radius"))
133 _cut_off_radius = getParam<Real>("cut_off_radius");
134 else
135 mooseError("To add crack tip enrichment, cut_off_radius must be provided.");
136 }
137}
Action::mooseError
void mooseError(Args &&... args) const
Action::getParam
const T & getParam(const std::string &name) const
Action::isParamValid
bool isParamValid(const std::string &name) const
XFEMAction::_use_crack_tip_enrichment
bool _use_crack_tip_enrichment
Definition XFEMAction.h:32
XFEMAction::_family
std::string _family
Definition XFEMAction.h:28
XFEMAction::_displacements
std::vector< VariableName > _displacements
Definition XFEMAction.h:35
XFEMAction::_geom_cut_userobjects
std::vector< UserObjectName > _geom_cut_userobjects
Definition XFEMAction.h:25
XFEMAction::_xfem_qrule
std::string _xfem_qrule
Definition XFEMAction.h:26
XFEMAction::_enrich_displacements
std::vector< VariableName > _enrich_displacements
Definition XFEMAction.h:34
XFEMAction::_crack_front_definition
UserObjectName _crack_front_definition
Definition XFEMAction.h:33
XFEMAction::_cut_off_bc
std::vector< BoundaryName > _cut_off_bc
Definition XFEMAction.h:36
XFEMAction::_order
std::string _order
Definition XFEMAction.h:27
XFEMAction::_xfem_cut_plane
bool _xfem_cut_plane
Definition XFEMAction.h:29
XFEMAction::_xfem_use_crack_growth_increment
bool _xfem_use_crack_growth_increment
Definition XFEMAction.h:30
XFEMAction::_xfem_crack_growth_increment
Real _xfem_crack_growth_increment
Definition XFEMAction.h:31
XFEMAction::_cut_off_radius
Real _cut_off_radius
Definition XFEMAction.h:37

Member Function Documentation

◆ act()

void XFEMAction::act ( )
virtual

Implements Action.

Definition at line 140 of file XFEMAction.C.

141{
142
143 std::shared_ptr<XFEMInterface> xfem_interface = _problem->getXFEM();
144 if (xfem_interface == nullptr)
145 {
146 const auto & params = _app.getInputParameterWarehouse().getInputParameters();
147 InputParameters & pars(*(params.find(uniqueActionName())->second.get()));
148 pars.set<FEProblemBase *>("_fe_problem_base") = &*_problem;
149 std::shared_ptr<XFEM> new_xfem(new XFEM(_pars));
150 _problem->initXFEM(new_xfem);
151 xfem_interface = _problem->getXFEM();
152 }
153
154 std::shared_ptr<XFEM> xfem = MooseSharedNamespace::dynamic_pointer_cast<XFEM>(xfem_interface);
155 if (xfem == nullptr)
156 mooseError("dynamic cast of xfem object failed");
157
158 if (_current_task == "setup_xfem")
159 {
160 xfem->setXFEMQRule(_xfem_qrule);
161
162 xfem->setCrackGrowthMethod(_xfem_use_crack_growth_increment, _xfem_crack_growth_increment);
163 xfem->setDebugOutputLevel(getParam<unsigned int>("debug_output_level"));
164 xfem->setMinWeightMultiplier(getParam<Real>("min_weight_multiplier"));
165 }
166 else if (_current_task == "add_variable" && _use_crack_tip_enrichment)
167 {
168 auto var_params = _factory.getValidParams("MooseVariable");
169 var_params.set<MooseEnum>("family") = "LAGRANGE";
170 var_params.set<MooseEnum>("order") = "FIRST";
171
172 for (const auto & enrich_disp : _enrich_displacements)
173 _problem->addVariable("MooseVariable", enrich_disp, var_params);
174 }
175 else if (_current_task == "add_kernel" && _use_crack_tip_enrichment)
176 {
177 for (unsigned int i = 0; i < _enrich_displacements.size(); ++i)
178 {
179 InputParameters params = _factory.getValidParams("CrackTipEnrichmentStressDivergenceTensors");
180 params.set<NonlinearVariableName>("variable") = _enrich_displacements[i];
181 params.set<unsigned int>("component") = i / 4;
182 params.set<unsigned int>("enrichment_component") = i % 4;
183 params.set<UserObjectName>("crack_front_definition") = _crack_front_definition;
184 params.set<std::vector<VariableName>>("enrichment_displacements") = _enrich_displacements;
185 params.set<std::vector<VariableName>>("displacements") = _displacements;
186 _problem->addKernel(
187 "CrackTipEnrichmentStressDivergenceTensors", _enrich_displacements[i], params);
188 }
189 }
190 else if (_current_task == "add_bc" && _use_crack_tip_enrichment)
191 {
192 for (unsigned int i = 0; i < _enrich_displacements.size(); ++i)
193 {
194 InputParameters params = _factory.getValidParams("CrackTipEnrichmentCutOffBC");
195 params.set<NonlinearVariableName>("variable") = _enrich_displacements[i];
196 params.set<Real>("value") = 0;
197 params.set<std::vector<BoundaryName>>("boundary") = _cut_off_bc;
198 params.set<Real>("cut_off_radius") = _cut_off_radius;
199 params.set<UserObjectName>("crack_front_definition") = _crack_front_definition;
200 _problem->addBoundaryCondition(
201 "CrackTipEnrichmentCutOffBC", _enrich_displacements[i], params);
202 }
203 }
204 else if (_current_task == "add_aux_variable" && _xfem_cut_plane)
205 {
206 auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
207
208 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_origin_x", var_params);
209 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_origin_y", var_params);
210 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_origin_z", var_params);
211 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_normal_x", var_params);
212 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_normal_y", var_params);
213 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_normal_z", var_params);
214 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_origin_x", var_params);
215 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_origin_y", var_params);
216 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_origin_z", var_params);
217 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_normal_x", var_params);
218 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_normal_y", var_params);
219 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_normal_z", var_params);
220 _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_volfrac", var_params);
221 }
222 else if (_current_task == "add_aux_kernel" && _xfem_cut_plane)
223 {
224 InputParameters params = _factory.getValidParams("XFEMVolFracAux");
225 params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_BEGIN;
226 params.set<AuxVariableName>("variable") = "xfem_volfrac";
227 _problem->addAuxKernel("XFEMVolFracAux", "xfem_volfrac", params);
228
229 params = _factory.getValidParams("XFEMCutPlaneAux");
230 params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
231
232 // first cut plane
233 params.set<unsigned int>("plane_id") = 0;
234
235 params.set<AuxVariableName>("variable") = "xfem_cut_origin_x";
236 params.set<MooseEnum>("quantity") = "origin_x";
237 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_origin_x", params);
238
239 params.set<AuxVariableName>("variable") = "xfem_cut_origin_y";
240 params.set<MooseEnum>("quantity") = "origin_y";
241 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_origin_y", params);
242
243 params.set<AuxVariableName>("variable") = "xfem_cut_origin_z";
244 params.set<MooseEnum>("quantity") = "origin_z";
245 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_origin_z", params);
246
247 params.set<AuxVariableName>("variable") = "xfem_cut_normal_x";
248 params.set<MooseEnum>("quantity") = "normal_x";
249 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_normal_x", params);
250
251 params.set<AuxVariableName>("variable") = "xfem_cut_normal_y";
252 params.set<MooseEnum>("quantity") = "normal_y";
253 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_normal_y", params);
254
255 params.set<AuxVariableName>("variable") = "xfem_cut_normal_z";
256 params.set<MooseEnum>("quantity") = "normal_z";
257 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_normal_z", params);
258
259 // second cut plane
260 params.set<unsigned int>("plane_id") = 1;
261
262 params.set<AuxVariableName>("variable") = "xfem_cut2_origin_x";
263 params.set<MooseEnum>("quantity") = "origin_x";
264 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_origin_x", params);
265
266 params.set<AuxVariableName>("variable") = "xfem_cut2_origin_y";
267 params.set<MooseEnum>("quantity") = "origin_y";
268 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_origin_y", params);
269
270 params.set<AuxVariableName>("variable") = "xfem_cut2_origin_z";
271 params.set<MooseEnum>("quantity") = "origin_z";
272 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_origin_z", params);
273
274 params.set<AuxVariableName>("variable") = "xfem_cut2_normal_x";
275 params.set<MooseEnum>("quantity") = "normal_x";
276 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_normal_x", params);
277
278 params.set<AuxVariableName>("variable") = "xfem_cut2_normal_y";
279 params.set<MooseEnum>("quantity") = "normal_y";
280 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_normal_y", params);
281
282 params.set<AuxVariableName>("variable") = "xfem_cut2_normal_z";
283 params.set<MooseEnum>("quantity") = "normal_z";
284 _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_normal_z", params);
285 }
286}
Action::uniqueActionName
MooseObjectName uniqueActionName() const
Action::_app
MooseApp & _app
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::_current_task
const std::string & _current_task
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameterWarehouse::getInputParameters
const std::multimap< MooseObjectName, std::shared_ptr< InputParameters > > & getInputParameters(THREAD_ID tid=0) const
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
MooseApp::getInputParameterWarehouse
InputParameterWarehouse & getInputParameterWarehouse()
Action::_pars
const InputParameters & _pars
Action::_factory
Factory & _factory
XFEM
This is the XFEM class.
Definition XFEM.h:108
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ validParams()

InputParameters XFEMAction::validParams ( )
static

Definition at line 45 of file XFEMAction.C.

46{
47 InputParameters params = Action::validParams();
48
49 params.addParam<std::vector<UserObjectName>>(
50 "geometric_cut_userobjects",
51 {},
52 "List of names of GeometricCutUserObjects with cut info and methods");
53 params.addParam<std::string>("qrule", "volfrac", "XFEM quadrature rule to use");
54 params.addRangeCheckedParam<unsigned int>(
55 "debug_output_level",
56 1,
57 "debug_output_level <= 3",
58 "Controls the amount of debug output from XFEM. 0: None, 1: Summary, 2: Details on "
59 "modifications to mesh, 3: Full dump of element fragment algorithm mesh");
60 params.addRangeCheckedParam<Real>("min_weight_multiplier",
61 1.e-3,
62 "min_weight_multiplier >= 0 & min_weight_multiplier<=1",
63 "Minimum average multiplier applied by XFEM to integration "
64 "point weights for partial elements");
65 params.addParam<bool>("output_cut_plane", false, "Output the XFEM cut plane and volume fraction");
66 params.addParam<bool>("use_crack_growth_increment", false, "Use fixed crack growth increment");
67 params.addParam<Real>("crack_growth_increment", 0.1, "Crack growth increment");
68 params.addParam<bool>("use_crack_tip_enrichment", false, "Use crack tip enrichment functions");
69 params.addParam<UserObjectName>("crack_front_definition",
70 "The CrackFrontDefinition user object name (only "
71 "needed if 'use_crack_tip_enrichment=true')");
72 params.addParam<std::vector<VariableName>>("displacements",
73 "Names of displacement variables (only "
74 "needed if 'use_crack_tip_enrichment=true')");
75 params.addParam<std::vector<VariableName>>("enrichment_displacements",
76 "Names of enrichment displacement variables (only "
77 "needed if 'use_crack_tip_enrichment=true')");
78 params.addParam<std::vector<BoundaryName>>("cut_off_boundary",
79 "Boundary that contains all nodes for which "
80 "enrichment DOFs should be fixed away from crack tip "
81 "(only needed if 'use_crack_tip_enrichment=true')");
82 params.addParam<Real>("cut_off_radius",
83 "The cut off radius of crack tip enrichment functions (only needed if "
84 "'use_crack_tip_enrichment=true')");
85 params.addClassDescription("Action to input general parameters and simulation options for use "
86 "in XFEM.");
87 return params;
88}
Action::validParams
static InputParameters validParams()
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::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)

Member Data Documentation

◆ _crack_front_definition

UserObjectName XFEMAction::_crack_front_definition
protected

Definition at line 33 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _cut_off_bc

std::vector<BoundaryName> XFEMAction::_cut_off_bc
protected

Definition at line 36 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _cut_off_radius

Real XFEMAction::_cut_off_radius
protected

Definition at line 37 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _displacements

std::vector<VariableName> XFEMAction::_displacements
protected

Definition at line 35 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _enrich_displacements

std::vector<VariableName> XFEMAction::_enrich_displacements
protected

Definition at line 34 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _family

std::string XFEMAction::_family
protected

Definition at line 28 of file XFEMAction.h.

Referenced by XFEMAction().

◆ _geom_cut_userobjects

std::vector<UserObjectName> XFEMAction::_geom_cut_userobjects
protected

Definition at line 25 of file XFEMAction.h.

◆ _order

std::string XFEMAction::_order
protected

Definition at line 27 of file XFEMAction.h.

Referenced by XFEMAction().

◆ _use_crack_tip_enrichment

bool XFEMAction::_use_crack_tip_enrichment
protected

Definition at line 32 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _xfem_crack_growth_increment

Real XFEMAction::_xfem_crack_growth_increment
protected

Definition at line 31 of file XFEMAction.h.

Referenced by act().

◆ _xfem_cut_plane

bool XFEMAction::_xfem_cut_plane
protected

Definition at line 29 of file XFEMAction.h.

Referenced by act(), and XFEMAction().

◆ _xfem_qrule

std::string XFEMAction::_xfem_qrule
protected

Definition at line 26 of file XFEMAction.h.

Referenced by act().

◆ _xfem_use_crack_growth_increment

bool XFEMAction::_xfem_use_crack_growth_increment
protected

Definition at line 30 of file XFEMAction.h.

Referenced by act().

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:44:06 for https://mooseframework.inl.gov by doxygen 1.9.8