XFEMAction Class Reference

#include <XFEMAction.h>

Inheritance diagram for XFEMAction:

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	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	mooseWarningNonPrefixed (Args &&... args) const
void	mooseDeprecated (Args &&... args) const
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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)

Public Attributes
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

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

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.

  : Action(params),
    _geom_cut_userobjects(getParam<std::vector<UserObjectName>>("geometric_cut_userobjects")),
    _xfem_qrule(getParam<std::string>("qrule")),
    _xfem_cut_plane(false),
    _xfem_use_crack_growth_increment(getParam<bool>("use_crack_growth_increment")),
    _xfem_crack_growth_increment(getParam<Real>("crack_growth_increment")),
    _use_crack_tip_enrichment(getParam<bool>("use_crack_tip_enrichment"))
{
  _order = "CONSTANT";
  _family = "MONOMIAL";
  if (isParamValid("output_cut_plane"))
    _xfem_cut_plane = getParam<bool>("output_cut_plane");

  if (_use_crack_tip_enrichment)
  {
    if (isParamValid("crack_front_definition"))
      _crack_front_definition = getParam<UserObjectName>("crack_front_definition");
    else
      mooseError("To add crack tip enrichment, crack_front_definition must be provided.");

    if (isParamValid("displacements"))
      _displacements = getParam<std::vector<VariableName>>("displacements");
    else
      mooseError("To add crack tip enrichment, displacements must be provided.");

    if (isParamValid("enrichment_displacements"))
    {
      _enrich_displacements = getParam<std::vector<VariableName>>("enrichment_displacements");
      if (_enrich_displacements.size() != 8 && _displacements.size() == 2)
        mooseError("The number of enrichment displacements should be total 8 for 2D.");
      else if (_enrich_displacements.size() != 12 && _displacements.size() == 3)
        mooseError("The number of enrichment displacements should be total 12 for 3D.");
    }
    else
      mooseError("To add crack tip enrichment, enrichment_displacements must be provided.");

    if (isParamValid("cut_off_boundary"))
      _cut_off_bc = getParam<std::vector<BoundaryName>>("cut_off_boundary");
    else
      mooseError("To add crack tip enrichment, cut_off_boundary must be provided.");

    if (isParamValid("cut_off_radius"))
      _cut_off_radius = getParam<Real>("cut_off_radius");
    else
      mooseError("To add crack tip enrichment, cut_off_radius must be provided.");
  }
}

Member Function Documentation

act()

void XFEMAction::act ( )

virtual

Implements Action.

Definition at line 140 of file XFEMAction.C.

{

  std::shared_ptr<XFEMInterface> xfem_interface = _problem->getXFEM();
  if (xfem_interface == nullptr)
  {
    const auto & params = _app.getInputParameterWarehouse().getInputParameters();
    InputParameters & pars(*(params.find(uniqueActionName())->second.get()));
    pars.set<FEProblemBase *>("_fe_problem_base") = &*_problem;
    std::shared_ptr<XFEM> new_xfem(new XFEM(_pars));
    _problem->initXFEM(new_xfem);
    xfem_interface = _problem->getXFEM();
  }

  std::shared_ptr<XFEM> xfem = MooseSharedNamespace::dynamic_pointer_cast<XFEM>(xfem_interface);
  if (xfem == nullptr)
    mooseError("dynamic cast of xfem object failed");

  if (_current_task == "setup_xfem")
  {
    xfem->setXFEMQRule(_xfem_qrule);

    xfem->setCrackGrowthMethod(_xfem_use_crack_growth_increment, _xfem_crack_growth_increment);
    xfem->setDebugOutputLevel(getParam<unsigned int>("debug_output_level"));
    xfem->setMinWeightMultiplier(getParam<Real>("min_weight_multiplier"));
  }
  else if (_current_task == "add_variable" && _use_crack_tip_enrichment)
  {
    auto var_params = _factory.getValidParams("MooseVariable");
    var_params.set<MooseEnum>("family") = "LAGRANGE";
    var_params.set<MooseEnum>("order") = "FIRST";

    for (const auto & enrich_disp : _enrich_displacements)
      _problem->addVariable("MooseVariable", enrich_disp, var_params);
  }
  else if (_current_task == "add_kernel" && _use_crack_tip_enrichment)
  {
    for (unsigned int i = 0; i < _enrich_displacements.size(); ++i)
    {
      InputParameters params = _factory.getValidParams("CrackTipEnrichmentStressDivergenceTensors");
      params.set<NonlinearVariableName>("variable") = _enrich_displacements[i];
      params.set<unsigned int>("component") = i / 4;
      params.set<unsigned int>("enrichment_component") = i % 4;
      params.set<UserObjectName>("crack_front_definition") = _crack_front_definition;
      params.set<std::vector<VariableName>>("enrichment_displacements") = _enrich_displacements;
      params.set<std::vector<VariableName>>("displacements") = _displacements;
      _problem->addKernel(
          "CrackTipEnrichmentStressDivergenceTensors", _enrich_displacements[i], params);
    }
  }
  else if (_current_task == "add_bc" && _use_crack_tip_enrichment)
  {
    for (unsigned int i = 0; i < _enrich_displacements.size(); ++i)
    {
      InputParameters params = _factory.getValidParams("CrackTipEnrichmentCutOffBC");
      params.set<NonlinearVariableName>("variable") = _enrich_displacements[i];
      params.set<Real>("value") = 0;
      params.set<std::vector<BoundaryName>>("boundary") = _cut_off_bc;
      params.set<Real>("cut_off_radius") = _cut_off_radius;
      params.set<UserObjectName>("crack_front_definition") = _crack_front_definition;
      _problem->addBoundaryCondition(
          "CrackTipEnrichmentCutOffBC", _enrich_displacements[i], params);
    }
  }
  else if (_current_task == "add_aux_variable" && _xfem_cut_plane)
  {
    auto var_params = _factory.getValidParams("MooseVariableConstMonomial");

    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_origin_x", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_origin_y", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_origin_z", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_normal_x", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_normal_y", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut_normal_z", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_origin_x", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_origin_y", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_origin_z", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_normal_x", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_normal_y", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_cut2_normal_z", var_params);
    _problem->addAuxVariable("MooseVariableConstMonomial", "xfem_volfrac", var_params);
  }
  else if (_current_task == "add_aux_kernel" && _xfem_cut_plane)
  {
    InputParameters params = _factory.getValidParams("XFEMVolFracAux");
    params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_BEGIN;
    params.set<AuxVariableName>("variable") = "xfem_volfrac";
    _problem->addAuxKernel("XFEMVolFracAux", "xfem_volfrac", params);

    params = _factory.getValidParams("XFEMCutPlaneAux");
    params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;

    // first cut plane
    params.set<unsigned int>("plane_id") = 0;

    params.set<AuxVariableName>("variable") = "xfem_cut_origin_x";
    params.set<MooseEnum>("quantity") = "origin_x";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_origin_x", params);

    params.set<AuxVariableName>("variable") = "xfem_cut_origin_y";
    params.set<MooseEnum>("quantity") = "origin_y";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_origin_y", params);

    params.set<AuxVariableName>("variable") = "xfem_cut_origin_z";
    params.set<MooseEnum>("quantity") = "origin_z";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_origin_z", params);

    params.set<AuxVariableName>("variable") = "xfem_cut_normal_x";
    params.set<MooseEnum>("quantity") = "normal_x";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_normal_x", params);

    params.set<AuxVariableName>("variable") = "xfem_cut_normal_y";
    params.set<MooseEnum>("quantity") = "normal_y";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_normal_y", params);

    params.set<AuxVariableName>("variable") = "xfem_cut_normal_z";
    params.set<MooseEnum>("quantity") = "normal_z";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut_normal_z", params);

    // second cut plane
    params.set<unsigned int>("plane_id") = 1;

    params.set<AuxVariableName>("variable") = "xfem_cut2_origin_x";
    params.set<MooseEnum>("quantity") = "origin_x";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_origin_x", params);

    params.set<AuxVariableName>("variable") = "xfem_cut2_origin_y";
    params.set<MooseEnum>("quantity") = "origin_y";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_origin_y", params);

    params.set<AuxVariableName>("variable") = "xfem_cut2_origin_z";
    params.set<MooseEnum>("quantity") = "origin_z";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_origin_z", params);

    params.set<AuxVariableName>("variable") = "xfem_cut2_normal_x";
    params.set<MooseEnum>("quantity") = "normal_x";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_normal_x", params);

    params.set<AuxVariableName>("variable") = "xfem_cut2_normal_y";
    params.set<MooseEnum>("quantity") = "normal_y";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_normal_y", params);

    params.set<AuxVariableName>("variable") = "xfem_cut2_normal_z";
    params.set<MooseEnum>("quantity") = "normal_z";
    _problem->addAuxKernel("XFEMCutPlaneAux", "xfem_cut2_normal_z", params);
  }
}

validParams()

InputParameters XFEMAction::validParams ( )

static

Definition at line 45 of file XFEMAction.C.

{
  InputParameters params = Action::validParams();

  params.addParam<std::vector<UserObjectName>>(
      "geometric_cut_userobjects",
      {},
      "List of names of GeometricCutUserObjects with cut info and methods");
  params.addParam<std::string>("qrule", "volfrac", "XFEM quadrature rule to use");
  params.addRangeCheckedParam<unsigned int>(
      "debug_output_level",
      1,
      "debug_output_level <= 3",
      "Controls the amount of debug output from XFEM.  0: None, 1: Summary, 2: Details on "
      "modifications to mesh, 3: Full dump of element fragment algorithm mesh");
  params.addRangeCheckedParam<Real>("min_weight_multiplier",
                                    1.e-3,
                                    "min_weight_multiplier >= 0 & min_weight_multiplier<=1",
                                    "Minimum average multiplier applied by XFEM to integration "
                                    "point weights for partial elements");
  params.addParam<bool>("output_cut_plane", false, "Output the XFEM cut plane and volume fraction");
  params.addParam<bool>("use_crack_growth_increment", false, "Use fixed crack growth increment");
  params.addParam<Real>("crack_growth_increment", 0.1, "Crack growth increment");
  params.addParam<bool>("use_crack_tip_enrichment", false, "Use crack tip enrichment functions");
  params.addParam<UserObjectName>("crack_front_definition",
                                  "The CrackFrontDefinition user object name (only "
                                  "needed if 'use_crack_tip_enrichment=true')");
  params.addParam<std::vector<VariableName>>("displacements",
                                             "Names of displacement variables (only "
                                             "needed if 'use_crack_tip_enrichment=true')");
  params.addParam<std::vector<VariableName>>("enrichment_displacements",
                                             "Names of enrichment displacement variables (only "
                                             "needed if 'use_crack_tip_enrichment=true')");
  params.addParam<std::vector<BoundaryName>>("cut_off_boundary",
                                             "Boundary that contains all nodes for which "
                                             "enrichment DOFs should be fixed away from crack tip "
                                             "(only needed if 'use_crack_tip_enrichment=true')");
  params.addParam<Real>("cut_off_radius",
                        "The cut off radius of crack tip enrichment functions (only needed if "
                        "'use_crack_tip_enrichment=true')");
  params.addClassDescription("Action to input general parameters and simulation options for use "
                             "in XFEM.");
  return params;
}

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:

• xfem/include/actions/XFEMAction.h
• xfem/src/actions/XFEMAction.C