Class used in fracture integrals to define geometric characteristics of the crack front. More...

#include <CrackFrontDefinition.h>

Inheritance diagram for CrackFrontDefinition:

Public Types
typedef DataFileName	DataFileParameterType

enum	TEST_TYPE

Public Member Functions
	CrackFrontDefinition (const InputParameters &parameters)

virtual void	initialSetup () override

virtual void	initialize () override

virtual void	finalize () override

virtual void	execute () override

void	updateNumberOfCrackFrontPoints (const std::size_t num_points)
	Change the number of crack front nodes.

const Node *	getCrackFrontNodePtr (const std::size_t node_index) const
	Get the node pointer for a specified node on the crack front.

const Point *	getCrackFrontPoint (const std::size_t point_index) const
	Get a Point object for a specified point on the crack front.

const RealVectorValue &	getCrackFrontTangent (const std::size_t point_index) const
	Get the vector tangent to the crack front at a specified position.

const RealVectorValue &	getCrackFrontNormal (const std::size_t point_index) const
	Get the vector normal to the crack front at a specified position.

Real	getCrackFrontForwardSegmentLength (const std::size_t point_index) const
	Get the length of the line segment on the crack front ahead of the specified position.

Real	getCrackFrontBackwardSegmentLength (const std::size_t point_index) const
	Get the length of the line segment on the crack front behind the specified position.

const RealVectorValue &	getCrackDirection (const std::size_t point_index) const
	Get the unit vector of the crack extension direction at the specified position.

Real	getDistanceAlongFront (const std::size_t point_index) const
	Get the distance along the crack front from the beginning of the crack to the specified position.

bool	hasAngleAlongFront () const
	Whether the distance along the crack front is available as an angle.

Real	getAngleAlongFront (const std::size_t point_index) const
	Get the angle along the crack front from the beginning of the crack to the specified position.

std::size_t	getNumCrackFrontPoints () const
	Get the number of points defining the crack front as a set of line segments.

bool	treatAs2D () const
	Whether the fracture computations are treated as 2D for the model.

bool	usingMeshCutter () const
	Is the crack defined by a mesh cutter object.

RealVectorValue	rotateToCrackFrontCoords (const RealVectorValue vector, const std::size_t point_index) const
	Rotate a vector in the global coordinate coordinate system to the crack front local coordinate system at a specified point on the crack.

RankTwoTensor	rotateToCrackFrontCoords (const RankTwoTensor tensor, const std::size_t point_index) const
	Rotate a RankTwoTensor in the global coordinate coordinate system to the crack front local coordinate system at a specified point on the crack.

RealVectorValue	rotateFromCrackFrontCoordsToGlobal (const RealVectorValue vector, const std::size_t point_index) const
	Rotate a vector from crack front cartesian coordinate to global cartesian coordinate.

void	calculateRThetaToCrackFront (const Point qp, const std::size_t point_index, Real &r, Real &theta) const
	Calculate r and theta of a point in the crack front polar coordinates for a given crack point index.

std::size_t	calculateRThetaToCrackFront (const Point qp, Real &r, Real &theta) const
	Calculate r and theta of a point in the crack front polar coordinate relative to the closest crack front point.

bool	isNodeOnIntersectingBoundary (const Node *const node) const
	Determine whether a given node is on one of the boundaries that intersects an end of the crack front.

bool	isPointWithIndexOnIntersectingBoundary (const std::size_t point_index) const
	Determine whether a given crack front point is on one of the boundaries that intersects an end of the crack front.

Real	getCrackFrontTangentialStrain (const std::size_t node_index) const
	Get the strain in the direction tangent to the crack front at a given point.

bool	hasCrackFrontNodes () const
	Determine whether the crack front was defined using nodes.

bool	isNodeInRing (const std::size_t ring_index, const dof_id_type connected_node_id, const std::size_t node_index) const
	Determine whether a node is contained within a specified volume integral element ring for a given node on the crack front.

Real	DomainIntegralQFunction (std::size_t crack_front_point_index, std::size_t ring_index, const Node *const current_node) const
	Compute the q function for the case where it is defined geometrically.

Real	DomainIntegralTopologicalQFunction (std::size_t crack_front_point_index, std::size_t ring_index, const Node *const current_node) const
	Compute the q function for the case where it is defined through element connectivity.

void	isCutterModified (const bool is_cutter_modified)
	Set the value of _is_cutter_modified.

virtual Real	spatialValue (const Point &) const

virtual const std::vector< Point >	spatialPoints () const

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

void	gatherSum (T &value)

void	gatherMax (T &value)

void	gatherMin (T &value)

void	gatherProxyValueMax (T1 &proxy, T2 &value)

void	gatherProxyValueMin (T1 &proxy, T2 &value)

std::set< UserObjectName >	getDependObjects () const

const std::set< std::string > &	getRequestedItems () override

const std::set< std::string > &	getSuppliedItems () override

unsigned int	systemNumber () const

virtual bool	needThreadedCopy () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

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

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyByName (const std::string &prop_name_in)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOldByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlderByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialProperty (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOld (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlder (const std::string &name)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (const MaterialPropertyName &name)

std::pair< Moose::Kokkos::MaterialProperty< T, dimension >, std::set< SubdomainID > >	getKokkosBlockMaterialProperty (const MaterialPropertyName &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)

std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &name)

std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &name)

std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &name)

std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &name)

void	checkBlockAndBoundaryCompatibility (std::shared_ptr< MaterialBase > discrete)

std::unordered_map< SubdomainID, std::vector< MaterialBase * > >	buildRequiredMaterials (bool allow_stateful=true)

void	statefulPropertiesAllowed (bool)

virtual bool	getMaterialPropertyCalled () const

virtual const std::unordered_set< unsigned int > &	getMatPropDependencies () const

virtual void	resolveOptionalProperties ()

const GenericMaterialProperty< T, is_ad > &	getPossiblyConstantGenericMaterialPropertyByName (const MaterialPropertyName &prop_name, MaterialData &material_data, const unsigned int state)

bool	isImplicit ()

Moose::StateArg	determineState () const

virtual void	threadJoin (const UserObject &) override

virtual void	threadJoin (const UserObject &) override

virtual void	subdomainSetup () override

virtual void	subdomainSetup () override

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)

const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

bool	hasMaterialProperty (const std::string &name)

bool	hasMaterialProperty (const std::string &name)

bool	hasMaterialPropertyByName (const std::string &name)

bool	hasMaterialPropertyByName (const std::string &name)

bool	hasADMaterialProperty (const std::string &name)

bool	hasADMaterialProperty (const std::string &name)

bool	hasADMaterialPropertyByName (const std::string &name)

bool	hasADMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

const Function &	getFunction (const std::string &name) const

const Function &	getFunctionByName (const FunctionName &name) const

bool	hasFunction (const std::string &param_name) const

bool	hasFunctionByName (const FunctionName &name) const

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const

const T &	getKokkosFunction (const std::string &name) const

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const

const T &	getKokkosFunctionByName (const FunctionName &name) const

bool	hasKokkosFunction (const std::string &param_name) const

bool	hasKokkosFunctionByName (const FunctionName &name) const

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const

const VectorPostprocessorName &	getVectorPostprocessorName (const std::string &param_name) const

T &	getSampler (const std::string &name)

Sampler &	getSampler (const std::string &name)

T &	getSamplerByName (const SamplerName &name)

Sampler &	getSamplerByName (const SamplerName &name)

virtual void	meshChanged ()

virtual void	meshDisplaced ()

PerfGraph &	perfGraph ()

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

const Distribution &	getDistribution (const std::string &name) const

const T &	getDistribution (const std::string &name) const

const Distribution &	getDistribution (const std::string &name) const

const T &	getDistribution (const std::string &name) const

const Distribution &	getDistributionByName (const DistributionName &name) const

const T &	getDistributionByName (const std::string &name) const

const Distribution &	getDistributionByName (const DistributionName &name) const

const T &	getDistributionByName (const std::string &name) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

virtual const std::set< BoundaryID > &	boundaryIDs () const

const std::vector< BoundaryName > &	boundaryNames () const

unsigned int	numBoundaryIDs () const

bool	hasBoundary (const BoundaryName &name) const

bool	hasBoundary (const std::vector< BoundaryName > &names) const

bool	hasBoundary (const BoundaryID &id) const

bool	hasBoundary (const std::vector< BoundaryID > &ids, TEST_TYPE type=ALL) const

bool	hasBoundary (const std::set< BoundaryID > &ids, TEST_TYPE type=ALL) const

bool	isBoundarySubset (const std::set< BoundaryID > &ids) const

bool	isBoundarySubset (const std::vector< BoundaryID > &ids) const

bool	hasBoundaryMaterialProperty (const std::string &prop_name) const

virtual bool	boundaryRestricted () const

const std::set< BoundaryID > &	meshBoundaryIDs () const

virtual bool	checkVariableBoundaryIntegrity () const

Static Public Member Functions
static InputParameters	validParams ()

static void	includeCrackFrontDefinitionParams (InputParameters &params)
	used by Actions to add CrackFrontDefinitionParams

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)

static void	sort (typename std::vector< T > &vector)

static void	sortDFS (typename std::vector< T > &vector)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header, NameFunc &&name_func)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header)

static bool	restricted (const std::set< BoundaryID > &ids)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

	ALL

	ANY

Static Public Attributes
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 PropertyValue::id_type	default_property_id

static constexpr PropertyValue::id_type	zero_property_id

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Types
enum class	DIRECTION_METHOD { CRACK_DIRECTION_VECTOR , CRACK_MOUTH , CURVED_CRACK_FRONT }
	Enum used to define the method for computing the crack extension direction. More...

enum class	END_DIRECTION_METHOD { NO_SPECIAL_TREATMENT , END_CRACK_DIRECTION_VECTOR , END_CRACK_TANGENT_VECTOR }
	Enum used to define the method for computing the crack extension direction at the ends of the crack. More...

enum	CRACK_NODE_TYPE { MIDDLE_NODE , END_1_NODE , END_2_NODE }
	Enum used to define the type of the nodes on the crack front (end or middle) More...

enum class	CRACK_GEOM_DEFINITION { CRACK_FRONT_NODES , CRACK_FRONT_POINTS }
	Enum used to define whether the crack front is defined using nodes or points. More...

Protected Member Functions
void	getCrackFrontNodes (std::set< dof_id_type > &nodes)
	Get the set of all crack front nodes.

void	orderCrackFrontNodes (std::set< dof_id_type > &nodes)
	Arrange the crack front nodes by their position along the crack front, and put them in the _ordered_crack_front_nodes member variable.

void	orderEndNodes (std::vector< dof_id_type > &end_nodes)
	Determine which of the end nodes should be the starting point of the crack front.

void	pickLoopCrackEndNodes (std::vector< dof_id_type > &end_nodes, std::set< dof_id_type > &nodes, std::map< dof_id_type, std::vector< dof_id_type > > &node_to_line_elem_map, std::vector< std::vector< dof_id_type > > &line_elems)
	For the case of a crack that is a complete loop, determine which of the nodes should be the start and end nodes in a repeatable way.

dof_id_type	maxNodeCoor (std::vector< Node * > &nodes, unsigned int dir0=0)
	Find the node with the maximum value of its coordinate.

void	updateCrackFrontGeometry ()
	Update the data structures defining the crack front geometry such as the ordered crack front nodes/points and other auxiliary data.

void	computeCrackMouthNodes ()
	compute node and coordinate data for crack fronts defined by crack_mouth_boundary_ids sidesets

void	computeCurvedCrackFrontCrackPlaneNormals ()
	Compute crack plane face normals for cracks that have a curved crack front but do not use a mesh cutter.

RealVectorValue	calculateCrackFrontDirection (const Point &crack_front_point, const RealVectorValue &tangent_direction, const CRACK_NODE_TYPE ntype, const std::size_t crack_front_point_index=0) const
	Compute the direction of crack extension for a given point on the crack front.

void	calculateTangentialStrainAlongFront ()
	Compute the strain in the direction tangent to the crack at all points on the crack front.

void	createQFunctionRings ()
	Create the data defining the rings used to define the q function when the topological option is used to define the q function.

void	addNodesToQFunctionRing (std::set< dof_id_type > &nodes_new_ring, const std::set< dof_id_type > &nodes_old_ring, const std::set< dof_id_type > &nodes_all_rings, const std::set< dof_id_type > &nodes_neighbor1, const std::set< dof_id_type > &nodes_neighbor2, std::vector< std::vector< const Elem * > > &nodes_to_elem_map)
	Find nodes that are connected through elements to the nodes in the previous node ring.

void	projectToFrontAtPoint (Real &dist_to_front, Real &dist_along_tangent, std::size_t crack_front_point_index, const Node *const current_node) const
	Project a point to a specified point along the crack front and compute the projected normal and tangential distance to the front.

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override

virtual void	addUserObjectDependencyHelper (const UserObjectBase &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

const ReporterContextBase &	getReporterContextBaseByName (const ReporterName &reporter_name) const

const ReporterName &	getReporterName (const std::string &param_name) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) 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

bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const

unsigned int	coupledScalarComponents (const std::string &var_name) const

unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual void	checkMaterialProperty (const std::string &name, const unsigned int state)

virtual void	getKokkosMaterialPropertyHook (const std::string &, const unsigned int)

void	markMatPropRequested (const std::string &)

MaterialPropertyName	getMaterialPropertyName (const std::string &name) const

void	checkExecutionStage ()

const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)

const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)

const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)

const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)

bool	hasBoundaryMaterialPropertyHelper (const std::string &prop_name) const

KOKKOS_FUNCTION dof_id_type	numKokkosBoundaryNodes () const

KOKKOS_FUNCTION dof_id_type	numKokkosBoundarySides () const

KOKKOS_FUNCTION ContiguousNodeID	kokkosBoundaryNodeID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION auto	kokkosBoundaryElementSideID (Moose::Kokkos::ThreadID tid) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
enum CrackFrontDefinition::DIRECTION_METHOD	_direction_method

enum CrackFrontDefinition::END_DIRECTION_METHOD	_end_direction_method

enum CrackFrontDefinition::CRACK_GEOM_DEFINITION	_geom_definition_method

AuxiliarySystem &	_aux
	Reference to the auxiliary system.

MooseMesh &	_mesh
	Reference to the mesh.

std::vector< dof_id_type >	_ordered_crack_front_nodes
	Crack front nodes ordered from the start to end of the crack front.

std::vector< Point >	_crack_front_points
	Vector of points along the crack front.

std::vector< RealVectorValue >	_tangent_directions
	Vector of tangent directions along the crack front.

std::vector< RealVectorValue >	_crack_directions
	Vector of crack extension directions along the crack front.

std::vector< std::pair< Real, Real > >	_segment_lengths
	Vector of segment lengths along the crack front.

std::vector< Real >	_distances_along_front
	Vector of distances along the crack front.

std::vector< Real >	_angles_along_front
	Vector of angles along the crack front.

std::vector< Real >	_strain_along_front
	Vector of tangential strain along the crack front.

std::vector< RankTwoTensor >	_rot_matrix
	Vector of rotation matrices along the crack front.

Real	_overall_length
	Overall length of the crack.

RealVectorValue	_crack_direction_vector
	Fixed vector optionally used to define crack extension direction.

RealVectorValue	_crack_direction_vector_end_1
	Fixed vector optionally used to define crack extension direction at end 1 of crack front.

RealVectorValue	_crack_direction_vector_end_2
	Fixed vector optionally used to define crack extension direction at end 2 of crack front.

RealVectorValue	_crack_tangent_vector_end_1
	Fixed vector optionally used to define crack tangent direction at end 1 of crack front.

RealVectorValue	_crack_tangent_vector_end_2
	Fixed vector optionally used to define crack tangent direction at end 2 of crack front.

std::vector< BoundaryName >	_crack_mouth_boundary_names
	Names of boundaries used to define location of crack mouth.

std::vector< BoundaryID >	_crack_mouth_boundary_ids
	IDs of boundaries used to define location of crack mouth.

std::vector< BoundaryName >	_intersecting_boundary_names
	Names of boundaries that intersect crack at its ends.

std::vector< BoundaryID >	_intersecting_boundary_ids
	IDs of boundaries that intersect crack at its ends.

RealVectorValue	_crack_mouth_coordinates
	Coordinates of crack mouth.

std::vector< RealVectorValue >	_crack_plane_normals
	Vector normals to a nonplanar crack.

bool	_treat_as_2d
	Whether to treat the model as 2D for computation of fracture integrals.

bool	_use_mesh_cutter
	Whether to describe the crack as a mesh cutter.

bool	_is_cutter_modified
	Indicator that shows if the cutter mesh is modified or not in the calculation step.

bool	_closed_loop
	Whether the crack forms a closed loop.

unsigned int	_axis_2d
	Out of plane axis when crack is treated as 2D.

bool	_has_symmetry_plane
	Whether the crack plane is also a symmetry plane in the model.

unsigned int	_symmetry_plane
	Which plane is the symmetry plane.

bool	_t_stress
	Whether the T-stress is being computed.

bool	_q_function_rings
	Whether topological rings are used to define the q functions.

std::size_t	_last_ring
	Numer of elements from crack tip to last topological ring.

std::size_t	_first_ring
	Numer of elements from crack tip to first topological ring.

std::map< std::pair< dof_id_type, std::size_t >, std::set< dof_id_type > >	_crack_front_node_to_node_map
	Data structure used to store information about topological rings Key is a pair of the crack front node index and ring id Data is a set of the IDs of the nodes in the ring for that crack front node.

MooseEnum	_q_function_type
	Method used to define the q function.

std::vector< bool >	_is_point_on_intersecting_boundary
	Vector of bools indicating whether individual crack front points are on an intersecting boundary.

std::vector< Real >	_j_integral_radius_inner
	Vector of inner radii of the rings used for geometric q functions.

std::vector< Real >	_j_integral_radius_outer
	Vector of outer radii of the rings used for geometric q functions.

const CrackFrontPointsProvider *	_crack_front_points_provider
	Pointer to a CrackFrontPointsProvider object optionally used to define the crack front points.

std::size_t	_num_points_from_provider
	Number of points coming from the CrackFrontPointsProvider.

const Real	_tol
	tolerance for matching nodes at crack front

const Moose::CoordinateSystemType &	_coord_sys

const THREAD_ID	_tid

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

Assembly &	_assembly

const bool	_duplicate_initial_execution

std::set< std::string >	_depend_uo

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

FEProblemBase &	_mdi_feproblem

MooseApp &	_pg_moose_app

const std::string	_prefix

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

const InputParameters &	_mi_params

const std::string	_mi_name

const MooseObjectName	_mi_moose_object_name

FEProblemBase &	_mi_feproblem

SubProblem &	_mi_subproblem

const THREAD_ID	_mi_tid

const bool	_is_kokkos_object

const Moose::MaterialDataType	_material_data_type

MaterialData &	_material_data

bool	_stateful_allowed

bool	_get_material_property_called

std::vector< std::unique_ptr< PropertyValue > >	_default_properties

std::unordered_set< unsigned int >	_material_property_dependencies

const MaterialPropertyName	_get_suffix

const bool	_use_interpolated_state

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

const Parallel::Communicator &	_communicator


std::string	_disp_x_var_name
	Names of the x, y, and z displacement variables.

std::string	_disp_y_var_name

std::string	_disp_z_var_name

Static Protected Attributes
static const std::string	_interpolated_old

static const std::string	_interpolated_older

Private Member Functions
const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const

const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const

const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const

void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const

const std::string &	userObjectType (const UserObjectBase &uo) const

const std::string &	userObjectName (const UserObjectBase &uo) const

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const VectorPostprocessorValue &	getVectorPostprocessorByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name, bool broadcast, std::size_t t_index) const

const VectorPostprocessorContext< VectorPostprocessorValue > &	getVectorPostprocessorContextByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	vectorPostprocessorsAdded () const

bool	reportersAdded () const

void	possiblyCheckHasReporter (const ReporterName &reporter_name, const std::string &param_name="") const

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const

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

const VariableValue *	getDefaultValue (const std::string &var_name) const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

void	checkVar (const std::string &var_name) const

void	validateExecutionerType (const std::string &name, const std::string &fn_name) const

Moose::MaterialDataType	getMaterialDataType (const std::set< BoundaryID > &boundary_ids) const

unsigned int	getMaxQps () const

void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

void	initializeBoundaryRestrictable ()

void	initializeKokkosBoundaryRestrictable ()

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
UserObject *	_primary_thread_copy

std::set< std::string >	_supplied_uo

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

const bool	_broadcast_by_default

const MooseObject &	_vpi_moose_object

const FEProblemBase &	_vpi_feproblem

const THREAD_ID	_vpi_tid

const InputParameters &	_ri_params

FEProblemBase &	_ri_fe_problem_base

const ReporterData &	_ri_reporter_data

const MooseObject &	_ri_moose_object

const InputParameters &	_dni_params

FEProblemBase &	_dni_feproblem

const MooseObject *const	_dni_moose_object_ptr

const InputParameters &	_si_params

FEProblemBase &	_si_feproblem

THREAD_ID	_si_tid

const RestartableDataMapName	_metaname

std::string	_restartable_name

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const InputParameters &	_sc_parameters

const std::string &	_sc_name

const bool	_sc_is_implicit

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars

std::unordered_map< std::string, std::unique_ptr< VariableValue > >	_default_value

std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value

std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars

std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_sc_coupled_vars

std::set< TagID >	_sc_coupleable_vector_tags

std::set< TagID >	_sc_coupleable_matrix_tags

const MooseObject &	_mi_moose_object

const bool	_mi_boundary_restricted

const std::set< SubdomainID > &	_mi_block_ids

const std::set< BoundaryID > &	_mi_boundary_ids

std::vector< std::unique_ptr< OptionalMaterialPropertyProxyBase< MaterialPropertyInterface > > >	_optional_property_proxies

const std::string	_ti_name

FEProblemBase *	_bnd_feproblem

MooseMesh *	_bnd_mesh

std::set< BoundaryID >	_bnd_ids

std::vector< BoundaryID >	_vec_ids

std::vector< BoundaryName >	_boundary_names

const bool	_bnd_dual_restrictable

const std::set< SubdomainID >	_empty_block_ids

const std::set< SubdomainID > &	_block_ids

THREAD_ID	_bnd_tid

const MaterialData &	_bnd_material_data

bool	_bnd_nodal

const MooseObject &	_moose_object

Moose::Kokkos::Array< ContiguousNodeID >	_kokkos_node_ids

Moose::Kokkos::Array< Moose::Kokkos::Pair< ContiguousElementID, unsigned int > >	_kokkos_element_side_ids

Detailed Description

Class used in fracture integrals to define geometric characteristics of the crack front.

Definition at line 29 of file CrackFrontDefinition.h.

Member Enumeration Documentation

◆ CRACK_GEOM_DEFINITION

enum class CrackFrontDefinition::CRACK_GEOM_DEFINITION

strongprotected

Enum used to define whether the crack front is defined using nodes or points.

Enumerator
CRACK_FRONT_NODES
CRACK_FRONT_POINTS

Definition at line 287 of file CrackFrontDefinition.h.

  {
    CRACK_FRONT_NODES,
    CRACK_FRONT_POINTS
  } _geom_definition_method;

◆ CRACK_NODE_TYPE

enum CrackFrontDefinition::CRACK_NODE_TYPE

protected

Enum used to define the type of the nodes on the crack front (end or middle)

Enumerator
MIDDLE_NODE
END_1_NODE
END_2_NODE

Definition at line 279 of file CrackFrontDefinition.h.

  {
    MIDDLE_NODE,
    END_1_NODE,
    END_2_NODE
  };

◆ DIRECTION_METHOD

enum class CrackFrontDefinition::DIRECTION_METHOD

strongprotected

Enum used to define the method for computing the crack extension direction.

Enumerator
CRACK_DIRECTION_VECTOR
CRACK_MOUTH
CURVED_CRACK_FRONT

Definition at line 264 of file CrackFrontDefinition.h.

                                    {
    CRACK_DIRECTION_VECTOR,
    CRACK_MOUTH,
    CURVED_CRACK_FRONT
  } _direction_method;

◆ END_DIRECTION_METHOD

enum class CrackFrontDefinition::END_DIRECTION_METHOD

strongprotected

Enum used to define the method for computing the crack extension direction at the ends of the crack.

Enumerator
NO_SPECIAL_TREATMENT
END_CRACK_DIRECTION_VECTOR
END_CRACK_TANGENT_VECTOR

Definition at line 272 of file CrackFrontDefinition.h.

                                        {
    NO_SPECIAL_TREATMENT,
    END_CRACK_DIRECTION_VECTOR,
    END_CRACK_TANGENT_VECTOR
  } _end_direction_method;

Constructor & Destructor Documentation

◆ CrackFrontDefinition()

CrackFrontDefinition::CrackFrontDefinition ( const InputParameters & parameters )

Definition at line 114 of file CrackFrontDefinition.C.

  : GeneralUserObject(parameters),
    BoundaryRestrictable(this, true), // false means nodesets
    _direction_method(getParam<MooseEnum>("crack_direction_method").getEnum<DIRECTION_METHOD>()),
    _end_direction_method(
        getParam<MooseEnum>("crack_end_direction_method").getEnum<END_DIRECTION_METHOD>()),
    _aux(_fe_problem.getAuxiliarySystem()),
    _mesh(_subproblem.mesh()),
    _treat_as_2d(getParam<bool>("2d")),
    _use_mesh_cutter(false),
    _is_cutter_modified(false),
    _closed_loop(getParam<bool>("closed_loop")),
    _axis_2d(getParam<unsigned int>("axis_2d")),
    _has_symmetry_plane(isParamValid("symmetry_plane")),
    _symmetry_plane(_has_symmetry_plane ? getParam<unsigned int>("symmetry_plane")
                                        : std::numeric_limits<unsigned int>::max()),
    _t_stress(getParam<bool>("t_stress")),
    _q_function_rings(getParam<bool>("q_function_rings")),
    _q_function_type(getParam<MooseEnum>("q_function_type")),
    _crack_front_points_provider(nullptr),
    _tol(getParam<Real>("crack_front_node_tolerance"))
{
  auto boundary = isParamValid("boundary") ? getParam<std::vector<BoundaryName>>("boundary")
                                           : std::vector<BoundaryName>{};
  if (isParamValid("crack_front_points"))
  {
    if (boundary.size())
      paramError("crack_front_points",
                 "CrackFrontDefinition error: since boundary is defined, crack_front_points should "
                 "not be added.");
    if (isParamValid("crack_front_points_provider"))
      paramError("crack_front_points_provider",
                 "As crack_front_points have been provided, the crack_front_points_provider will "
                 "not be used and needs to be removed.");
    _crack_front_points = getParam<std::vector<Point>>("crack_front_points");
    _geom_definition_method = CRACK_GEOM_DEFINITION::CRACK_FRONT_POINTS;
    if (_t_stress)
      paramError("t_stress", "t_stress not yet supported with crack_front_points");
    if (_q_function_rings)
      paramError("q_function_rings", "q_function_rings not supported with crack_front_points");
  }
  else if (isParamValid("crack_front_points_provider"))
  {
    if (boundary.size())
      paramError("crack_front_points_provider",
                 "CrackFrontDefinition error: since boundary is defined, "
                 "crack_front_points_provider should not be added.");
 
    _geom_definition_method = CRACK_GEOM_DEFINITION::CRACK_FRONT_POINTS;
  }
  else if (isParamValid("number_points_from_provider"))
    paramError("number_points_from_provider",
               "CrackFrontDefinition error: number_points_from_provider is provided but "
               "crack_front_points_provider cannot be found.");
  else if (boundary.size())
  {
    _geom_definition_method = CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES;
    if (parameters.isParamSetByUser("closed_loop"))
      paramError("closed_loop",
                 "In CrackFrontDefinition, if 'boundary' is defined, 'closed_loop' should not be "
                 "set by user because closed loops are detected automatically");
  }
  else
    mooseError("In CrackFrontDefinition, must define one of 'boundary', 'crack_front_points' "
               "and 'crack_front_points_provider'");
 
  if (isParamValid("crack_mouth_boundary"))
    _crack_mouth_boundary_names = getParam<std::vector<BoundaryName>>("crack_mouth_boundary");
 
  if (_has_symmetry_plane)
    if (_symmetry_plane > 2)
      paramError("symmetry_plane",
                 "symmetry_plane out of bounds: ",
                 _symmetry_plane,
                 " Must be >=0 and <=2.");
 
  switch (_direction_method)
  {
    case DIRECTION_METHOD::CRACK_DIRECTION_VECTOR:
      if (!isParamValid("crack_direction_vector"))
        paramError("crack_direction_vector",
                   "crack_direction_vector must be specified if crack_direction_method = "
                   "CrackDirectionVector");
      _crack_direction_vector = getParam<RealVectorValue>("crack_direction_vector");
      break;
    case DIRECTION_METHOD::CRACK_MOUTH:
      if (isParamValid("crack_direction_vector"))
        paramError("crack_direction_vector",
                   "crack_direction_vector must not be specified if crack_direction_method = "
                   "CrackMouthNodes");
      if (_crack_mouth_boundary_names.size() == 0)
        paramError(
            "crack_mouth_boundary",
            "crack_mouth_boundary must be specified if crack_direction_method = CrackMouthNodes");
      break;
    case DIRECTION_METHOD::CURVED_CRACK_FRONT:
      if (isParamValid("crack_direction_vector"))
        paramError("crack_direction_vector",
                   "crack_direction_vector must not be specified if crack_direction_method = "
                   "CurvedCrackFront");
      break;
    default:
      paramError("crack_direction_method", "Invalid direction_method");
  }
 
  if (isParamValid("intersecting_boundary"))
    _intersecting_boundary_names = getParam<std::vector<BoundaryName>>("intersecting_boundary");
 
  if (_end_direction_method == END_DIRECTION_METHOD::END_CRACK_DIRECTION_VECTOR)
  {
    if (!isParamValid("crack_direction_vector_end_1"))
      paramError("crack_direction_vector_end_1",
                 "crack_direction_vector_end_1 must be specified if crack_end_direction_method = "
                 "CrackDirectionVector");
    if (!isParamValid("crack_direction_vector_end_2"))
      paramError("crack_direction_vector_end_2",
                 "crack_direction_vector_end_2 must be specified if crack_end_direction_method = "
                 "CrackDirectionVector");
    _crack_direction_vector_end_1 = getParam<RealVectorValue>("crack_direction_vector_end_1");
    _crack_direction_vector_end_2 = getParam<RealVectorValue>("crack_direction_vector_end_2");
  }
 
  if (_end_direction_method == END_DIRECTION_METHOD::END_CRACK_TANGENT_VECTOR)
  {
    if (!isParamValid("crack_tangent_vector_end_1"))
      paramError("crack_tangent_vector_end_1",
                 "crack_tangent_vector_end_1 must be specified if crack_end_tangent_method = "
                 "CrackTangentVector");
    if (!isParamValid("crack_tangent_vector_end_2"))
      paramError("crack_tangent_vector_end_2",
                 "crack_tangent_vector_end_2 must be specified if crack_end_tangent_method = "
                 "CrackTangentVector");
    _crack_tangent_vector_end_1 = getParam<RealVectorValue>("crack_tangent_vector_end_1");
    _crack_tangent_vector_end_2 = getParam<RealVectorValue>("crack_tangent_vector_end_2");
  }
 
  if (isParamValid("disp_x") && isParamValid("disp_y") && isParamValid("disp_z"))
  {
    _disp_x_var_name = getParam<VariableName>("disp_x");
    _disp_y_var_name = getParam<VariableName>("disp_y");
    _disp_z_var_name = getParam<VariableName>("disp_z");
  }
  else if (_t_stress == true && _treat_as_2d == false)
    paramError("displacements", "Displacement variables must be provided for T-stress calculation");
 
  if (_q_function_rings)
  {
    if (!isParamValid("last_ring"))
      paramError("last_ring",
                 "The max number of rings of nodes to generate must be provided if "
                 "q_function_rings = true");
    _last_ring = getParam<unsigned int>("last_ring");
    _first_ring = getParam<unsigned int>("first_ring");
  }
  else
  {
    _j_integral_radius_inner = getParam<std::vector<Real>>("j_integral_radius_inner");
    _j_integral_radius_outer = getParam<std::vector<Real>>("j_integral_radius_outer");
  }
}

Member Function Documentation

◆ addNodesToQFunctionRing()

void CrackFrontDefinition::addNodesToQFunctionRing	(	std::set< dof_id_type > &	nodes_new_ring,
		const std::set< dof_id_type > &	nodes_old_ring,
		const std::set< dof_id_type > &	nodes_all_rings,
		const std::set< dof_id_type > &	nodes_neighbor1,
		const std::set< dof_id_type > &	nodes_neighbor2,
		std::vector< std::vector< const Elem * > > &	nodes_to_elem_map
	)

protected

Find nodes that are connected through elements to the nodes in the previous node ring.

Parameters

nodes_new_ring	Nodes in the new ring – populated by this method
nodes_old_ring	Nodes in the previous ring
nodes_all_rings	Nodes in all other rings to be excluded from the new ring
nodes_neighbor1	Nodes in the neighboring ring to one side to be excluded from the new ring
nodes_neighbor2	Nodes in the neighboring ring to the other side to be excluded from the new ring
nodes_to_elem_map	Map of nodes to connected elements

Definition at line 1783 of file CrackFrontDefinition.C.

{
  for (auto nit = nodes_old_ring.begin(); nit != nodes_old_ring.end(); ++nit)
  {
    std::vector<const Node *> neighbors;
    MeshTools::find_nodal_neighbors(
        _mesh.getMesh(), _mesh.nodeRef(*nit), nodes_to_elem_map, neighbors);
    for (std::size_t inei = 0; inei < neighbors.size(); ++inei)
    {
      auto previt = nodes_all_rings.find(neighbors[inei]->id());
      auto thisit = nodes_neighbor1.find(neighbors[inei]->id());
      auto nextit = nodes_neighbor2.find(neighbors[inei]->id());
 
      // Add only nodes that are not already present in any of the three sets of nodes
      if (previt == nodes_all_rings.end() && thisit == nodes_neighbor1.end() &&
          nextit == nodes_neighbor2.end())
        nodes_new_ring.insert(neighbors[inei]->id());
    }
  }
}

Referenced by createQFunctionRings().

◆ calculateCrackFrontDirection()

RealVectorValue CrackFrontDefinition::calculateCrackFrontDirection	(	const Point &	crack_front_point,
		const RealVectorValue &	tangent_direction,
		const CRACK_NODE_TYPE	ntype,
		const std::size_t	crack_front_point_index = `0`
	)		const

protected

Compute the direction of crack extension for a given point on the crack front.

Parameters

crack_front_point	Point on the crack front
tangent_direction	Tangent direction vector for the crack front point
ntype	Node type such as MIDDLE_NODE, END_1_NODE, END_2_NODE
crack_front_point_index	Index of the point on the crack front

Definition at line 1130 of file CrackFrontDefinition.C.

{
  RealVectorValue crack_dir;
  RealVectorValue zero_vec(0.0);
 
  bool calc_dir = true;
  if (_end_direction_method == END_DIRECTION_METHOD::END_CRACK_DIRECTION_VECTOR)
  {
    if (ntype == END_1_NODE)
    {
      crack_dir = _crack_direction_vector_end_1;
      calc_dir = false;
    }
    else if (ntype == END_2_NODE)
    {
      crack_dir = _crack_direction_vector_end_2;
      calc_dir = false;
    }
  }
 
  if (calc_dir)
  {
    if (_direction_method == DIRECTION_METHOD::CRACK_DIRECTION_VECTOR)
    {
      crack_dir = _crack_direction_vector;
    }
    else if (_direction_method == DIRECTION_METHOD::CRACK_MOUTH)
    {
      if (_crack_mouth_coordinates.absolute_fuzzy_equals(crack_front_point, _tol))
      {
        mooseError("Crack mouth too close to crack front node");
      }
      RealVectorValue mouth_to_front = crack_front_point - _crack_mouth_coordinates;
 
      RealVectorValue crack_plane_normal = mouth_to_front.cross(tangent_direction);
      if (crack_plane_normal.absolute_fuzzy_equals(zero_vec, _tol))
      {
        mooseError(
            "Vector from crack mouth to crack front node is collinear with crack front segment");
      }
 
      crack_dir = tangent_direction.cross(crack_plane_normal);
      Real dotprod = crack_dir * mouth_to_front;
      if (dotprod < 0)
      {
        crack_dir = -crack_dir;
      }
    }
    else if (_direction_method == DIRECTION_METHOD::CURVED_CRACK_FRONT)
    {
      crack_dir = tangent_direction.cross(_crack_plane_normals[crack_front_point_index]);
    }
  }
  crack_dir = crack_dir.unit();
 
  return crack_dir;
}

Referenced by updateCrackFrontGeometry().

◆ calculateRThetaToCrackFront() [1/2]

void CrackFrontDefinition::calculateRThetaToCrackFront	(	const Point	qp,
		const std::size_t	point_index,
		Real &	r,
		Real &	theta
	)		const

Calculate r and theta of a point in the crack front polar coordinates for a given crack point index.

Parameters

qp	The Point for which coordinates are evaluated
point_index	the crack front point index
r	Value of the radial coordinate computed in this function
theta	Value of the theta coordinate computed in this function

Definition at line 1309 of file CrackFrontDefinition.C.

{
  std::size_t num_points = getNumCrackFrontPoints();
  Point closest_point(0.0);
  RealVectorValue closest_point_to_p;
 
  const Point * crack_front_point = getCrackFrontPoint(point_index);
  RealVectorValue crack_front_point_rot = rotateToCrackFrontCoords(*crack_front_point, point_index);
 
  RealVectorValue crack_front_edge =
      rotateToCrackFrontCoords(_tangent_directions[point_index], point_index);
 
  Point p_rot = rotateToCrackFrontCoords(qp, point_index);
  p_rot = p_rot - crack_front_point_rot;
 
  if (_treat_as_2d)
  {
    // In 2D, the closest node is the crack tip node and the position of the crack tip node is
    // (0,0,0) in the crack front coordinate system
    // In case this is a 3D mesh treated as 2D, project point onto same plane as crack front node.
    // Note: In the crack front coordinate system, z is always in the tangent direction to the crack
    // front
    p_rot(2) = closest_point(2);
    closest_point_to_p = p_rot;
 
    // Find r, the distance between the qp and the crack front
    RealVectorValue r_vec = p_rot;
    r = r_vec.norm();
  }
  else
  {
    // Loop over crack front points to find the one closest to the point qp
    Real min_dist = std::numeric_limits<Real>::max();
    for (std::size_t pit = 0; pit != num_points; ++pit)
    {
      const Point * crack_front_point = getCrackFrontPoint(pit);
      RealVectorValue crack_point_to_current_point = qp - *crack_front_point;
      Real dist = crack_point_to_current_point.norm();
 
      if (dist < min_dist)
      {
        min_dist = dist;
        closest_point = *crack_front_point;
      }
    }
 
    // Rotate coordinates to crack front coordinate system
    closest_point = rotateToCrackFrontCoords(closest_point, point_index);
    closest_point = closest_point - crack_front_point_rot;
 
    // Find r, the distance between the qp and the crack front
    Real edge_length_sq = crack_front_edge.norm_sq();
    closest_point_to_p = p_rot - closest_point;
    Real perp = crack_front_edge * closest_point_to_p;
    Real dist_along_edge = perp / edge_length_sq;
    RealVectorValue point_on_edge = closest_point + crack_front_edge * dist_along_edge;
    RealVectorValue r_vec = p_rot - point_on_edge;
    r = r_vec.norm();
  }
 
  // Find theta, the angle between r and the crack front plane
  RealVectorValue crack_plane_normal =
      rotateToCrackFrontCoords(_crack_plane_normals[point_index], point_index);
  Real p_to_plane_dist = std::abs(closest_point_to_p * crack_plane_normal);
 
  // Determine if qp is above or below the crack plane
  Real y_local = p_rot(1) - closest_point(1);
 
  // Determine if qp is in front of or behind the crack front
  RealVectorValue p2(p_rot);
  p2(1) = 0;
  RealVectorValue p2_vec = p2 - closest_point;
  Real ahead = crack_front_edge(2) * p2_vec(0) - crack_front_edge(0) * p2_vec(2);
 
  Real x_local(0);
  if (ahead >= 0)
    x_local = 1;
  else
    x_local = -1;
 
  // Calculate theta based on in which quadrant in the crack front coordinate
  // system the qp is located
  if (r > 0)
  {
    Real theta_quadrant1(0.0);
    if (MooseUtils::absoluteFuzzyEqual(r, p_to_plane_dist, _tol))
      theta_quadrant1 = 0.5 * libMesh::pi;
    else if (p_to_plane_dist > r)
      mooseError(
          "Invalid distance p_to_plane_dist in CrackFrontDefinition::calculateRThetaToCrackFront");
    else
      theta_quadrant1 = std::asin(p_to_plane_dist / r);
 
    if (x_local >= 0 && y_local >= 0)
      theta = theta_quadrant1;
 
    else if (x_local < 0 && y_local >= 0)
      theta = libMesh::pi - theta_quadrant1;
 
    else if (x_local < 0 && y_local < 0)
      theta = -(libMesh::pi - theta_quadrant1);
 
    else if (x_local >= 0 && y_local < 0)
      theta = -theta_quadrant1;
  }
  else if (r == 0)
    theta = 0;
  else
    mooseError("Invalid distance r in CrackFrontDefinition::calculateRThetaToCrackFront");
}

Referenced by calculateRThetaToCrackFront(), InteractionIntegralBenchmarkBC::computeQpValue(), EnrichmentFunctionCalculation::crackTipEnrichementFunctionAtPoint(), EnrichmentFunctionCalculation::crackTipEnrichementFunctionDerivativeAtPoint(), and CrackTipEnrichmentCutOffBC::shouldApply().

◆ calculateRThetaToCrackFront() [2/2]

std::size_t CrackFrontDefinition::calculateRThetaToCrackFront	(	const Point	qp,
		Real &	r,
		Real &	theta
	)		const

Calculate r and theta of a point in the crack front polar coordinate relative to the closest crack front point.

This function loops over all crack front points to find the one closest to the specified point

Parameters

qp	The Point for which coordinates are evaluated
r	Value of the radial coordinate computed in this function
theta	Value of the theta coordinate computed in this function

Returns: Index of the closest crack front point

Definition at line 1424 of file CrackFrontDefinition.C.

{
  std::size_t num_points = getNumCrackFrontPoints();
 
  // Loop over crack front points to find the one closest to the point qp
  Real min_dist = std::numeric_limits<Real>::max();
  std::size_t point_index = 0;
  for (std::size_t pit = 0; pit != num_points; ++pit)
  {
    const Point * crack_front_point = getCrackFrontPoint(pit);
    RealVectorValue crack_point_to_current_point = qp - *crack_front_point;
    Real dist = crack_point_to_current_point.norm();
 
    if (dist < min_dist)
    {
      min_dist = dist;
      point_index = pit;
    }
  }
 
  calculateRThetaToCrackFront(qp, point_index, r, theta);
 
  return point_index;
}

◆ calculateTangentialStrainAlongFront()

void CrackFrontDefinition::calculateTangentialStrainAlongFront ( )

protected

Compute the strain in the direction tangent to the crack at all points on the crack front.

Definition at line 1487 of file CrackFrontDefinition.C.

{
  RealVectorValue disp_current_node;
  RealVectorValue disp_previous_node;
  RealVectorValue disp_next_node;
 
  RealVectorValue forward_segment0;
  RealVectorValue forward_segment1;
  Real forward_segment0_len;
  Real forward_segment1_len;
  RealVectorValue back_segment0;
  RealVectorValue back_segment1;
  Real back_segment0_len;
  Real back_segment1_len;
 
  std::size_t num_crack_front_nodes = _ordered_crack_front_nodes.size();
  const Node * current_node;
  const Node * previous_node;
  const Node * next_node;
 
  _strain_along_front.reserve(num_crack_front_nodes);
 
  // In finalize(), gatherMax builds and distributes the complete strain vector on all processors
  // -> reset the vector every time
  for (std::size_t i = 0; i < num_crack_front_nodes; ++i)
    _strain_along_front[i] = -std::numeric_limits<Real>::max();
 
  MooseVariable & disp_x_var = _subproblem.getStandardVariable(_tid, _disp_x_var_name);
  MooseVariable & disp_y_var = _subproblem.getStandardVariable(_tid, _disp_y_var_name);
  MooseVariable & disp_z_var = _subproblem.getStandardVariable(_tid, _disp_z_var_name);
 
  current_node = getCrackFrontNodePtr(0);
  if (current_node->processor_id() == processor_id())
  {
    disp_current_node(0) = disp_x_var.getNodalValue(*current_node);
    disp_current_node(1) = disp_y_var.getNodalValue(*current_node);
    disp_current_node(2) = disp_z_var.getNodalValue(*current_node);
 
    next_node = getCrackFrontNodePtr(1);
    disp_next_node(0) = disp_x_var.getNodalValue(*next_node);
    disp_next_node(1) = disp_y_var.getNodalValue(*next_node);
    disp_next_node(2) = disp_z_var.getNodalValue(*next_node);
 
    forward_segment0 = *next_node - *current_node;
    forward_segment0 = (forward_segment0 * _tangent_directions[0]) * _tangent_directions[0];
    forward_segment0_len = forward_segment0.norm();
 
    forward_segment1 = (*next_node + disp_next_node) - (*current_node + disp_current_node);
    forward_segment1 = (forward_segment1 * _tangent_directions[0]) * _tangent_directions[0];
    forward_segment1_len = forward_segment1.norm();
 
    _strain_along_front[0] = (forward_segment1_len - forward_segment0_len) / forward_segment0_len;
  }
 
  for (std::size_t i = 1; i < num_crack_front_nodes - 1; ++i)
  {
    current_node = getCrackFrontNodePtr(i);
    if (current_node->processor_id() == processor_id())
    {
      disp_current_node(0) = disp_x_var.getNodalValue(*current_node);
      disp_current_node(1) = disp_y_var.getNodalValue(*current_node);
      disp_current_node(2) = disp_z_var.getNodalValue(*current_node);
 
      previous_node = getCrackFrontNodePtr(i - 1);
      disp_previous_node(0) = disp_x_var.getNodalValue(*previous_node);
      disp_previous_node(1) = disp_y_var.getNodalValue(*previous_node);
      disp_previous_node(2) = disp_z_var.getNodalValue(*previous_node);
 
      next_node = getCrackFrontNodePtr(i + 1);
      disp_next_node(0) = disp_x_var.getNodalValue(*next_node);
      disp_next_node(1) = disp_y_var.getNodalValue(*next_node);
      disp_next_node(2) = disp_z_var.getNodalValue(*next_node);
 
      back_segment0 = *current_node - *previous_node;
      back_segment0 = (back_segment0 * _tangent_directions[i]) * _tangent_directions[i];
      back_segment0_len = back_segment0.norm();
 
      back_segment1 = (*current_node + disp_current_node) - (*previous_node + disp_previous_node);
      back_segment1 = (back_segment1 * _tangent_directions[i]) * _tangent_directions[i];
      back_segment1_len = back_segment1.norm();
 
      forward_segment0 = *next_node - *current_node;
      forward_segment0 = (forward_segment0 * _tangent_directions[i]) * _tangent_directions[i];
      forward_segment0_len = forward_segment0.norm();
 
      forward_segment1 = (*next_node + disp_next_node) - (*current_node + disp_current_node);
      forward_segment1 = (forward_segment1 * _tangent_directions[i]) * _tangent_directions[i];
      forward_segment1_len = forward_segment1.norm();
 
      _strain_along_front[i] =
          0.5 * ((back_segment1_len - back_segment0_len) / back_segment0_len +
                 (forward_segment1_len - forward_segment0_len) / forward_segment0_len);
    }
  }
 
  current_node = getCrackFrontNodePtr(num_crack_front_nodes - 1);
  if (current_node->processor_id() == processor_id())
  {
    disp_current_node(0) = disp_x_var.getNodalValue(*current_node);
    disp_current_node(1) = disp_y_var.getNodalValue(*current_node);
    disp_current_node(2) = disp_z_var.getNodalValue(*current_node);
 
    previous_node = getCrackFrontNodePtr(num_crack_front_nodes - 2);
    disp_previous_node(0) = disp_x_var.getNodalValue(*previous_node);
    disp_previous_node(1) = disp_y_var.getNodalValue(*previous_node);
    disp_previous_node(2) = disp_z_var.getNodalValue(*previous_node);
 
    back_segment0 = *current_node - *previous_node;
    back_segment0 = (back_segment0 * _tangent_directions[num_crack_front_nodes - 1]) *
                    _tangent_directions[num_crack_front_nodes - 1];
    back_segment0_len = back_segment0.norm();
 
    back_segment1 = (*current_node + disp_current_node) - (*previous_node + disp_previous_node);
    back_segment1 = (back_segment1 * _tangent_directions[num_crack_front_nodes - 1]) *
                    _tangent_directions[num_crack_front_nodes - 1];
    back_segment1_len = back_segment1.norm();
 
    _strain_along_front[num_crack_front_nodes - 1] =
        (back_segment1_len - back_segment0_len) / back_segment0_len;
  }
}

Referenced by execute().

◆ computeCrackMouthNodes()

void CrackFrontDefinition::computeCrackMouthNodes ( )

protected

compute node and coordinate data for crack fronts defined by crack_mouth_boundary_ids sidesets

Definition at line 1044 of file CrackFrontDefinition.C.

{
  if (_crack_mouth_boundary_ids.size() > 0)
  {
    _crack_mouth_coordinates.zero();
 
    std::set<Node *> crack_mouth_nodes;
    ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
    for (auto nd = bnd_nodes.begin(); nd != bnd_nodes.end(); ++nd)
    {
      const BndNode * bnode = *nd;
      BoundaryID boundary_id = bnode->_bnd_id;
 
      for (std::size_t ibid = 0; ibid < _crack_mouth_boundary_ids.size(); ++ibid)
      {
        if (boundary_id == _crack_mouth_boundary_ids[ibid])
        {
          crack_mouth_nodes.insert(bnode->_node);
          break;
        }
      }
    }
 
    for (auto nit = crack_mouth_nodes.begin(); nit != crack_mouth_nodes.end(); ++nit)
    {
      _crack_mouth_coordinates += **nit;
    }
    _crack_mouth_coordinates /= static_cast<Real>(crack_mouth_nodes.size());
 
    if (_has_symmetry_plane)
      _crack_mouth_coordinates(_symmetry_plane) = 0.0;
  }
}

Referenced by updateCrackFrontGeometry().

◆ computeCurvedCrackFrontCrackPlaneNormals()

void CrackFrontDefinition::computeCurvedCrackFrontCrackPlaneNormals ( )

protected

Compute crack plane face normals for cracks that have a curved crack front but do not use a mesh cutter.

Definition at line 1079 of file CrackFrontDefinition.C.

{
  if (_direction_method == DIRECTION_METHOD::CURVED_CRACK_FRONT && !_use_mesh_cutter)
  {
    _crack_plane_normals.clear();
 
    // Get 3 nodes on crack front
    std::size_t num_points = getNumCrackFrontPoints();
    if (num_points < 3)
    {
      mooseError("Crack front must contain at least 3 nodes to use CurvedCrackFront option");
    }
    std::size_t start_id;
    std::size_t mid_id;
    std::size_t end_id;
 
    if (_closed_loop)
    {
      start_id = 0;
      mid_id = (num_points - 1) / 3;
      end_id = 2 * mid_id;
    }
    else
    {
      start_id = 0;
      mid_id = (num_points - 1) / 2;
      end_id = num_points - 1;
    }
    const Point * start = getCrackFrontPoint(start_id);
    const Point * mid = getCrackFrontPoint(mid_id);
    const Point * end = getCrackFrontPoint(end_id);
 
    // Create two vectors connecting them
    RealVectorValue v1 = *mid - *start;
    RealVectorValue v2 = *end - *mid;
 
    // Take cross product to get normal
    Point crack_plane_normal = v1.cross(v2);
    crack_plane_normal = crack_plane_normal.unit();
    _crack_plane_normals.assign(num_points, crack_plane_normal);
 
    // Make sure they're not collinear
    RealVectorValue zero_vec(0.0);
    if (_crack_plane_normals.front().absolute_fuzzy_equals(zero_vec, _tol))
    {
      mooseError("Nodes on crack front are too close to being collinear");
    }
  }
}

Referenced by updateCrackFrontGeometry().

◆ createQFunctionRings()

void CrackFrontDefinition::createQFunctionRings ( )

protected

Create the data defining the rings used to define the q function when the topological option is used to define the q function.

Definition at line 1626 of file CrackFrontDefinition.C.

{
  // In the variable names, "cfn" = crack front node
  if (_treat_as_2d && _use_mesh_cutter == false) // 2D: the q-function defines an integral domain
                                                 // that is constant along the crack front
  {
    std::vector<std::vector<const Elem *>> nodes_to_elem_map;
    MeshTools::build_nodes_to_elem_map(_mesh.getMesh(), nodes_to_elem_map);
 
    std::set<dof_id_type> nodes_prev_ring;
    nodes_prev_ring.insert(_ordered_crack_front_nodes.begin(), _ordered_crack_front_nodes.end());
 
    std::set<dof_id_type> connected_nodes_this_cfn;
    connected_nodes_this_cfn.insert(_ordered_crack_front_nodes.begin(),
                                    _ordered_crack_front_nodes.end());
 
    std::set<dof_id_type> old_ring_nodes_this_cfn = connected_nodes_this_cfn;
 
    // The first ring contains only the crack front node(s)
    std::pair<dof_id_type, std::size_t> node_ring_index =
        std::make_pair(_ordered_crack_front_nodes[0], 1);
    _crack_front_node_to_node_map[node_ring_index].insert(connected_nodes_this_cfn.begin(),
                                                          connected_nodes_this_cfn.end());
 
    // Build rings of nodes around the crack front node
    for (std::size_t ring = 2; ring <= _last_ring; ++ring)
    {
 
      // Find nodes connected to the nodes of the previous ring
      std::set<dof_id_type> new_ring_nodes_this_cfn;
      for (auto nit = old_ring_nodes_this_cfn.begin(); nit != old_ring_nodes_this_cfn.end(); ++nit)
      {
        std::vector<const Node *> neighbors;
        MeshTools::find_nodal_neighbors(
            _mesh.getMesh(), _mesh.nodeRef(*nit), nodes_to_elem_map, neighbors);
        for (std::size_t inei = 0; inei < neighbors.size(); ++inei)
        {
          auto thisit = connected_nodes_this_cfn.find(neighbors[inei]->id());
 
          // Add only nodes that are not already present in any of the rings
          if (thisit == connected_nodes_this_cfn.end())
            new_ring_nodes_this_cfn.insert(neighbors[inei]->id());
        }
      }
 
      // Add new nodes to rings
      connected_nodes_this_cfn.insert(new_ring_nodes_this_cfn.begin(),
                                      new_ring_nodes_this_cfn.end());
      old_ring_nodes_this_cfn = new_ring_nodes_this_cfn;
 
      std::pair<dof_id_type, std::size_t> node_ring_index =
          std::make_pair(_ordered_crack_front_nodes[0], ring);
      _crack_front_node_to_node_map[node_ring_index].insert(connected_nodes_this_cfn.begin(),
                                                            connected_nodes_this_cfn.end());
    }
  }
  else // The q-function defines one integral domain around each crack front node
  {
    std::size_t num_crack_front_points = _ordered_crack_front_nodes.size();
    std::vector<std::vector<const Elem *>> nodes_to_elem_map;
    MeshTools::build_nodes_to_elem_map(_mesh.getMesh(), nodes_to_elem_map);
    for (std::size_t icfn = 0; icfn < num_crack_front_points; ++icfn)
    {
      std::set<dof_id_type> nodes_prev_ring;
      nodes_prev_ring.insert(_ordered_crack_front_nodes[icfn]);
 
      std::set<dof_id_type> connected_nodes_prev_cfn;
      std::set<dof_id_type> connected_nodes_this_cfn;
      std::set<dof_id_type> connected_nodes_next_cfn;
 
      connected_nodes_this_cfn.insert(_ordered_crack_front_nodes[icfn]);
 
      if (_closed_loop && icfn == 0)
      {
        connected_nodes_prev_cfn.insert(_ordered_crack_front_nodes[num_crack_front_points - 1]);
        connected_nodes_next_cfn.insert(_ordered_crack_front_nodes[icfn + 1]);
      }
      else if (_closed_loop && icfn == num_crack_front_points - 1)
      {
        connected_nodes_prev_cfn.insert(_ordered_crack_front_nodes[icfn - 1]);
        connected_nodes_next_cfn.insert(_ordered_crack_front_nodes[0]);
      }
      else if (icfn == 0)
      {
        connected_nodes_next_cfn.insert(_ordered_crack_front_nodes[icfn + 1]);
      }
      else if (icfn == num_crack_front_points - 1)
      {
        connected_nodes_prev_cfn.insert(_ordered_crack_front_nodes[icfn - 1]);
      }
      else
      {
        connected_nodes_prev_cfn.insert(_ordered_crack_front_nodes[icfn - 1]);
        connected_nodes_next_cfn.insert(_ordered_crack_front_nodes[icfn + 1]);
      }
 
      std::set<dof_id_type> old_ring_nodes_prev_cfn = connected_nodes_prev_cfn;
      std::set<dof_id_type> old_ring_nodes_this_cfn = connected_nodes_this_cfn;
      std::set<dof_id_type> old_ring_nodes_next_cfn = connected_nodes_next_cfn;
 
      // The first ring contains only the crack front node
      std::pair<dof_id_type, std::size_t> node_ring_index =
          std::make_pair(_ordered_crack_front_nodes[icfn], 1);
      _crack_front_node_to_node_map[node_ring_index].insert(connected_nodes_this_cfn.begin(),
                                                            connected_nodes_this_cfn.end());
 
      // Build rings of nodes around the crack front node
      for (std::size_t ring = 2; ring <= _last_ring; ++ring)
      {
 
        // Find nodes connected to the nodes of the previous ring, but exclude nodes in rings of
        // neighboring crack front nodes
        std::set<dof_id_type> new_ring_nodes_this_cfn;
        addNodesToQFunctionRing(new_ring_nodes_this_cfn,
                                old_ring_nodes_this_cfn,
                                connected_nodes_this_cfn,
                                connected_nodes_prev_cfn,
                                connected_nodes_next_cfn,
                                nodes_to_elem_map);
 
        std::set<dof_id_type> new_ring_nodes_prev_cfn;
        addNodesToQFunctionRing(new_ring_nodes_prev_cfn,
                                old_ring_nodes_prev_cfn,
                                connected_nodes_prev_cfn,
                                connected_nodes_this_cfn,
                                connected_nodes_next_cfn,
                                nodes_to_elem_map);
 
        std::set<dof_id_type> new_ring_nodes_next_cfn;
        addNodesToQFunctionRing(new_ring_nodes_next_cfn,
                                old_ring_nodes_next_cfn,
                                connected_nodes_next_cfn,
                                connected_nodes_prev_cfn,
                                connected_nodes_this_cfn,
                                nodes_to_elem_map);
 
        // Add new nodes to the three sets of nodes
        connected_nodes_prev_cfn.insert(new_ring_nodes_prev_cfn.begin(),
                                        new_ring_nodes_prev_cfn.end());
        connected_nodes_this_cfn.insert(new_ring_nodes_this_cfn.begin(),
                                        new_ring_nodes_this_cfn.end());
        connected_nodes_next_cfn.insert(new_ring_nodes_next_cfn.begin(),
                                        new_ring_nodes_next_cfn.end());
        old_ring_nodes_prev_cfn = new_ring_nodes_prev_cfn;
        old_ring_nodes_this_cfn = new_ring_nodes_this_cfn;
        old_ring_nodes_next_cfn = new_ring_nodes_next_cfn;
 
        std::pair<dof_id_type, std::size_t> node_ring_index =
            std::make_pair(_ordered_crack_front_nodes[icfn], ring);
        _crack_front_node_to_node_map[node_ring_index].insert(connected_nodes_this_cfn.begin(),
                                                              connected_nodes_this_cfn.end());
      }
    }
  }
}

Referenced by initialSetup().

◆ DomainIntegralQFunction()

Real CrackFrontDefinition::DomainIntegralQFunction	(	std::size_t	crack_front_point_index,
		std::size_t	ring_index,
		const Node *const	current_node
	)		const

Compute the q function for the case where it is defined geometrically.

Parameters

crack_front_point_index	Index of the point on the crack front
ring_index	Index of the volume integral ring
current_node	Node at which q is evaluated

Returns: q

Definition at line 1834 of file CrackFrontDefinition.C.

{
  Real dist_to_crack_front;
  Real dist_along_tangent;
  projectToFrontAtPoint(
      dist_to_crack_front, dist_along_tangent, crack_front_point_index, current_node);
 
  Real q = 1.0;
  if (dist_to_crack_front > _j_integral_radius_inner[ring_index] &&
      dist_to_crack_front < _j_integral_radius_outer[ring_index])
    q = (_j_integral_radius_outer[ring_index] - dist_to_crack_front) /
        (_j_integral_radius_outer[ring_index] - _j_integral_radius_inner[ring_index]);
  else if (dist_to_crack_front >= _j_integral_radius_outer[ring_index])
    q = 0.0;
 
  if (q > 0.0)
  {
    Real tangent_multiplier = 1.0;
    if (!_treat_as_2d)
    {
      const Real forward_segment_length =
          getCrackFrontForwardSegmentLength(crack_front_point_index);
      const Real backward_segment_length =
          getCrackFrontBackwardSegmentLength(crack_front_point_index);
 
      if (dist_along_tangent >= 0.0)
      {
        if (forward_segment_length > 0.0)
          tangent_multiplier = 1.0 - dist_along_tangent / forward_segment_length;
      }
      else
      {
        if (backward_segment_length > 0.0)
          tangent_multiplier = 1.0 + dist_along_tangent / backward_segment_length;
      }
    }
 
    tangent_multiplier = std::max(tangent_multiplier, 0.0);
    tangent_multiplier = std::min(tangent_multiplier, 1.0);
 
    // Set to zero if a node is on a designated free surface and its crack front node is not.
    if (isNodeOnIntersectingBoundary(current_node) &&
        !_is_point_on_intersecting_boundary[crack_front_point_index])
      tangent_multiplier = 0.0;
 
    q *= tangent_multiplier;
  }
 
  return q;
}

Referenced by JIntegral::execute().

◆ DomainIntegralTopologicalQFunction()

Real CrackFrontDefinition::DomainIntegralTopologicalQFunction	(	std::size_t	crack_front_point_index,
		std::size_t	ring_index,
		const Node *const	current_node
	)		const

Compute the q function for the case where it is defined through element connectivity.

Parameters

crack_front_point_index	Index of the point on the crack front
ring_index	Index of the volume integral ring
current_node	Node at which q is evaluated

Returns: q

Definition at line 1888 of file CrackFrontDefinition.C.

{
  Real q = 0;
  bool is_node_in_ring = isNodeInRing(ring_index, current_node->id(), crack_front_point_index);
  if (is_node_in_ring)
    q = 1;
 
  return q;
}

Referenced by JIntegral::execute().

◆ execute()

void CrackFrontDefinition::execute ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 276 of file CrackFrontDefinition.C.

{
  // Because J-Integral is based on original geometry, the crack front geometry
  // is never updated, so everything that needs to happen is done in initialSetup()
  if (_t_stress == true && _treat_as_2d == false)
    calculateTangentialStrainAlongFront();
}

◆ finalize()

void CrackFrontDefinition::finalize ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 392 of file CrackFrontDefinition.C.

{
  if (_t_stress)
    _communicator.max(_strain_along_front);
}

◆ getAngleAlongFront()

Real CrackFrontDefinition::getAngleAlongFront ( const std::size_t point_index ) const

Get the angle along the crack front from the beginning of the crack to the specified position.

Parameters

point_index Index of the point

Returns: Angle along crack

Definition at line 1265 of file CrackFrontDefinition.C.

{
  if (!hasAngleAlongFront())
    paramError(
        "crack_mouth_boundary",
        "In CrackFrontDefinition, Requested angle along crack front, but definition of crack mouth "
        "boundary using 'crack_mouth_boundary' parameter is necessary to do that.");
  return _angles_along_front[point_index];
}

Referenced by JIntegral::finalize().

◆ getCrackDirection()

const RealVectorValue & CrackFrontDefinition::getCrackDirection ( const std::size_t point_index ) const

Get the unit vector of the crack extension direction at the specified position.

Parameters

point_index Index of the point

Returns: Crack extension direction vector

Definition at line 1247 of file CrackFrontDefinition.C.

{
  return _crack_directions[point_index];
}

Referenced by JIntegral::computeQpIntegral().

◆ getCrackFrontBackwardSegmentLength()

Real CrackFrontDefinition::getCrackFrontBackwardSegmentLength ( const std::size_t point_index ) const

Get the length of the line segment on the crack front behind the specified position.

Parameters

point_index Index of the point

Returns: Line segment length

Definition at line 1241 of file CrackFrontDefinition.C.

{
  return _segment_lengths[point_index].first;
}

Referenced by JIntegral::computeQpIntegral(), DomainIntegralQFunction::computeValue(), and DomainIntegralQFunction().

◆ getCrackFrontForwardSegmentLength()

Real CrackFrontDefinition::getCrackFrontForwardSegmentLength ( const std::size_t point_index ) const

Get the length of the line segment on the crack front ahead of the specified position.

Parameters

point_index Index of the point

Returns: Line segment length

Definition at line 1235 of file CrackFrontDefinition.C.

{
  return _segment_lengths[point_index].second;
}

Referenced by JIntegral::computeQpIntegral(), DomainIntegralQFunction::computeValue(), and DomainIntegralQFunction().

◆ getCrackFrontNodePtr()

const Node * CrackFrontDefinition::getCrackFrontNodePtr ( const std::size_t node_index ) const

Get the node pointer for a specified node on the crack front.

Parameters

node_index Index of the node

Returns: Pointer to node

Definition at line 1198 of file CrackFrontDefinition.C.

{
  mooseAssert(node_index < _ordered_crack_front_nodes.size(), "node_index out of range");
  const Node * crack_front_node = _mesh.nodePtr(_ordered_crack_front_nodes[node_index]);
  mooseAssert(crack_front_node != nullptr, "invalid crack front node");
  return crack_front_node;
}

Referenced by calculateTangentialStrainAlongFront(), getCrackFrontPoint(), CrackFrontData::initialize(), and isPointWithIndexOnIntersectingBoundary().

◆ getCrackFrontNodes()

void CrackFrontDefinition::getCrackFrontNodes ( std::set< dof_id_type > & nodes )

protected

Get the set of all crack front nodes.

Parameters

nodes Set of nodes – populated by this method

Definition at line 399 of file CrackFrontDefinition.C.

{
  ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
  for (auto nd = bnd_nodes.begin(); nd != bnd_nodes.end(); ++nd)
  {
    const BndNode * bnode = *nd;
    BoundaryID boundary_id = bnode->_bnd_id;
 
    if (hasBoundary(boundary_id))
      nodes.insert(bnode->_node->id());
  }
 
  if (_treat_as_2d && _use_mesh_cutter == false)
  {
    if (nodes.size() > 1)
    {
      // Check that the nodes are collinear in the axis normal to the 2d plane
      unsigned int axis0;
      unsigned int axis1;
 
      switch (_axis_2d)
      {
        case 0:
          axis0 = 1;
          axis1 = 2;
          break;
        case 1:
          axis0 = 0;
          axis1 = 2;
          break;
        case 2:
          axis0 = 0;
          axis1 = 1;
          break;
        default:
          mooseError("Invalid axis.");
      }
 
      Real node0coor0 = 0;
      Real node0coor1 = 0;
 
      for (auto sit = nodes.begin(); sit != nodes.end(); ++sit)
      {
        Node & curr_node = _mesh.nodeRef(*sit);
        if (sit == nodes.begin())
        {
          node0coor0 = curr_node(axis0);
          node0coor1 = curr_node(axis1);
        }
        else
        {
          if (!MooseUtils::absoluteFuzzyEqual(curr_node(axis0), node0coor0, _tol) ||
              !MooseUtils::absoluteFuzzyEqual(curr_node(axis1), node0coor1, _tol))
            mooseError("Boundary provided in CrackFrontDefinition contains ",
                       nodes.size(),
                       " nodes, which are not collinear in the ",
                       _axis_2d,
                       " axis.  Must contain either 1 node or collinear nodes to treat as 2D.");
        }
      }
    }
  }
}

Referenced by initialSetup().

◆ getCrackFrontNormal()

const RealVectorValue & CrackFrontDefinition::getCrackFrontNormal ( const std::size_t point_index ) const

Get the vector normal to the crack front at a specified position.

Parameters

point_index Index of the point

Returns: normal vector

Definition at line 1228 of file CrackFrontDefinition.C.

{
  mooseAssert(point_index < _crack_plane_normals.size(), "point_index out of range");
  return _crack_plane_normals[point_index];
}

Referenced by CrackFrontNonlocalMaterialBase::execute().

◆ getCrackFrontPoint()

const Point * CrackFrontDefinition::getCrackFrontPoint ( const std::size_t point_index ) const

Get a Point object for a specified point on the crack front.

Parameters

point_index Index of the point

Returns: Point object

Definition at line 1207 of file CrackFrontDefinition.C.

{
  if (_geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES)
  {
    return getCrackFrontNodePtr(point_index);
  }
  else
  {
    mooseAssert(point_index < _crack_front_points.size(), "point_index out of range");
    return &_crack_front_points[point_index];
  }
}

Referenced by CrackFrontNonlocalMaterialBase::BoxWeightingFunction(), calculateRThetaToCrackFront(), calculateRThetaToCrackFront(), computeCurvedCrackFrontCrackPlaneNormals(), CrackFrontNonlocalMaterialBase::finalize(), JIntegral::finalize(), DomainIntegralQFunction::projectToFrontAtPoint(), projectToFrontAtPoint(), and updateCrackFrontGeometry().

◆ getCrackFrontTangent()

const RealVectorValue & CrackFrontDefinition::getCrackFrontTangent ( const std::size_t point_index ) const

Get the vector tangent to the crack front at a specified position.

Parameters

point_index Index of the point

Returns: tangent vector

Definition at line 1221 of file CrackFrontDefinition.C.

{
  mooseAssert(point_index < _tangent_directions.size(), "point_index out of range");
  return _tangent_directions[point_index];
}

Referenced by DomainIntegralQFunction::projectToFrontAtPoint(), and projectToFrontAtPoint().

◆ getCrackFrontTangentialStrain()

Real CrackFrontDefinition::getCrackFrontTangentialStrain ( const std::size_t node_index ) const

Get the strain in the direction tangent to the crack front at a given point.

Parameters

node_index the crack front node index

Returns: Tangential strain

Definition at line 1610 of file CrackFrontDefinition.C.

{
  Real strain;
  if (_t_stress)
  {
    strain = _strain_along_front[node_index];
    mooseAssert(strain > -std::numeric_limits<Real>::max(),
                "Failure in parallel communication of crack tangential strain");
  }
  else
    mooseError("In CrackFrontDefinition, tangential strain not available");
 
  return strain;
}

◆ getDistanceAlongFront()

Real CrackFrontDefinition::getDistanceAlongFront ( const std::size_t point_index ) const

Get the distance along the crack front from the beginning of the crack to the specified position.

Parameters

point_index Index of the point

Returns: Distance along crack

Definition at line 1253 of file CrackFrontDefinition.C.

{
  return _distances_along_front[point_index];
}

Referenced by CrackFrontNonlocalMaterialBase::finalize(), and JIntegral::finalize().

◆ getNumCrackFrontPoints()

std::size_t CrackFrontDefinition::getNumCrackFrontPoints ( ) const

Get the number of points defining the crack front as a set of line segments.

Returns: Number of points

Definition at line 1276 of file CrackFrontDefinition.C.

{
  if (_geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES)
    return _ordered_crack_front_nodes.size();
  else
    return _crack_front_points.size();
}

Referenced by calculateRThetaToCrackFront(), calculateRThetaToCrackFront(), computeCurvedCrackFrontCrackPlaneNormals(), initialize(), CrackFrontNonlocalMaterialBase::initialize(), JIntegral::initialize(), initialSetup(), isPointWithIndexOnIntersectingBoundary(), and updateCrackFrontGeometry().

◆ hasAngleAlongFront()

bool CrackFrontDefinition::hasAngleAlongFront ( ) const

Whether the distance along the crack front is available as an angle.

Returns: true if it is available as an angle

Definition at line 1259 of file CrackFrontDefinition.C.

{
  return (_crack_mouth_boundary_names.size() > 0);
}

Referenced by getAngleAlongFront(), and updateCrackFrontGeometry().

◆ hasCrackFrontNodes()

bool CrackFrontDefinition::hasCrackFrontNodes ( ) const

inline

Determine whether the crack front was defined using nodes.

Returns: true if it was defined using nodes

Definition at line 218 of file CrackFrontDefinition.h.

  {
    return _geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES;
  }

Referenced by CrackFrontData::initialize().

◆ includeCrackFrontDefinitionParams()

void CrackFrontDefinition::includeCrackFrontDefinitionParams ( InputParameters & params )

static

used by Actions to add CrackFrontDefinitionParams

Definition at line 42 of file CrackFrontDefinition.C.

{
  MooseEnum direction_method("CrackDirectionVector CrackMouth CurvedCrackFront");
  MooseEnum end_direction_method("NoSpecialTreatment CrackDirectionVector CrackTangentVector",
                                 "NoSpecialTreatment");
  params.addParam<std::vector<Point>>("crack_front_points", "Set of points to define crack front");
  params.addParam<bool>("closed_loop", false, "Set of points forms forms a closed loop");
  params.addRequiredParam<MooseEnum>(
      "crack_direction_method",
      direction_method,
      "Method to determine direction of crack propagation.  Choices are: " +
          direction_method.getRawNames());
  params.addParam<MooseEnum>(
      "crack_end_direction_method",
      end_direction_method,
      "Method to determine direction of crack propagation at ends of crack.  Choices are: " +
          end_direction_method.getRawNames());
  params.addParam<RealVectorValue>("crack_direction_vector", "Direction of crack propagation");
  params.addParam<RealVectorValue>(
      "crack_direction_vector_end_1",
      "Direction of crack propagation for the node at end 1 of the crack");
  params.addParam<RealVectorValue>(
      "crack_direction_vector_end_2",
      "Direction of crack propagation for the node at end 2 of the crack");
  params.addParam<RealVectorValue>("crack_tangent_vector_end_1",
                                   "Direction of crack tangent for the node at end 1 of the crack");
  params.addParam<RealVectorValue>("crack_tangent_vector_end_2",
                                   "Direction of crack tangent for the node at end 2 of the crack");
  params.addParam<std::vector<BoundaryName>>(
      "crack_mouth_boundary", "Boundaries whose average coordinate defines the crack mouth");
  params.addParam<std::vector<BoundaryName>>("intersecting_boundary",
                                             "Boundaries intersected by ends of crack");
  params.addParam<bool>("2d", false, "Treat body as two-dimensional");
  params.addRangeCheckedParam<unsigned int>(
      "axis_2d",
      2,
      "axis_2d>=0 & axis_2d<=2",
      "Out of plane axis for models treated as two-dimensional (0=x, 1=y, 2=z)");
  params.addParam<unsigned int>("symmetry_plane",
                                "Account for a symmetry plane passing through "
                                "the plane of the crack, normal to the specified "
                                "axis (0=x, 1=y, 2=z)");
  params.addParam<bool>("t_stress", false, "Calculate T-stress");
  params.addParam<bool>("q_function_rings", false, "Generate rings of nodes for q-function");
  params.addParam<unsigned int>("last_ring", "The number of rings of nodes to generate");
  params.addParam<unsigned int>("first_ring", "The number of rings of nodes to generate");
  params.addParam<unsigned int>("nrings", "The number of rings of nodes to generate");
  params.addParam<VariableName>("disp_x", "Variable containing the x displacement");
  params.addParam<VariableName>("disp_y", "Variable containing the y displacement");
  params.addParam<VariableName>("disp_z", "Variable containing the z displacement");
  params.addParam<std::vector<Real>>(
      "j_integral_radius_inner", {}, "Radius for J-Integral calculation");
  params.addParam<std::vector<Real>>(
      "j_integral_radius_outer", {}, "Radius for J-Integral calculation");
  MooseEnum q_function_type("Geometry Topology", "Geometry");
  params.addParam<MooseEnum>("q_function_type",
                             q_function_type,
                             "The method used to define the integration domain. Options are: " +
                                 q_function_type.getRawNames());
  params.addParam<UserObjectName>(
      "crack_front_points_provider",
      "The UserObject provides the crack front points from XFEM GeometricCutObject");
 
  params.addParam<unsigned int>("number_points_from_provider",
                                "The number of crack front points, only needed for "
                                "crack_front_points_provider that do not use a cut mesh.");
  params.addParam<Real>(
      "crack_front_node_tolerance",
      1e-10,
      "General tolerance for locating nodes on the crack front based on xyz coordinates.");
}

Referenced by DomainIntegralAction::validParams(), and validParams().

◆ initialize()

void CrackFrontDefinition::initialize ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 368 of file CrackFrontDefinition.C.

{
  // Update the crack front for fracture integral calculations
  // This is only useful for growing cracks which are currently described by the mesh
  // cutter
  if (_use_mesh_cutter && _is_cutter_modified)
  {
    // Automatically update the number of crack front points as crack grows
    _num_points_from_provider = _crack_front_points_provider->getNumberOfCrackFrontPoints();
 
    _crack_front_points =
        _crack_front_points_provider->getCrackFrontPoints(_num_points_from_provider);
    updateCrackFrontGeometry();
    std::size_t num_crack_front_points = getNumCrackFrontPoints();
    if (_q_function_type == "GEOMETRY")
      for (std::size_t i = 0; i < num_crack_front_points; ++i)
      {
        bool is_point_on_intersecting_boundary = isPointWithIndexOnIntersectingBoundary(i);
        _is_point_on_intersecting_boundary.push_back(is_point_on_intersecting_boundary);
      }
  }
}

◆ initialSetup()

void CrackFrontDefinition::initialSetup ( )

overridevirtual

Reimplemented from GeneralUserObject.

Definition at line 285 of file CrackFrontDefinition.C.

{
  if (isParamValid("crack_front_points_provider"))
  {
    _crack_front_points_provider = &getUserObjectByName<CrackFrontPointsProvider>(
        getParam<UserObjectName>("crack_front_points_provider"));
    if (_crack_front_points_provider->usesMesh())
    {
      _use_mesh_cutter = true;
 
      // Automatically get number of crack front points from mesh-based provider
      _num_points_from_provider = _crack_front_points_provider->getNumberOfCrackFrontPoints();
      mooseInfo("CrackFrontDefinition: Automatically detected ",
                _num_points_from_provider,
                " crack front points from mesh-based provider");
 
      if (_direction_method != DIRECTION_METHOD::CURVED_CRACK_FRONT)
        paramError("crack_direction_method",
                   "Using a `crack_front_points_provider` that uses an XFEM cutter mesh also "
                   "requires setting 'crack_direction_method = CurvedCrackFront'");
      if (isParamValid("crack_mouth_boundary"))
        paramError("crack_mouth_boundary",
                   "'crack_mouth_boundary' cannot be set when using a "
                   "'crack_front_points_provider' that uses an XFEM cutter mesh");
    }
    else if (isParamValid("number_points_from_provider"))
    {
      _num_points_from_provider = getParam<unsigned int>("number_points_from_provider");
    }
    else if (_num_points_from_provider == 0)
    {
      paramError(
          "number_points_from_provider",
          "CrackFrontDefinition error: When using a non-mesh-based crack_front_points_provider, "
          "the number_points_from_provider parameter must be provided.");
    }
  }
  if (_crack_front_points_provider != nullptr)
  {
    _crack_front_points =
        _crack_front_points_provider->getCrackFrontPoints(_num_points_from_provider);
  }
 
  _crack_mouth_boundary_ids = _mesh.getBoundaryIDs(_crack_mouth_boundary_names, true);
  _intersecting_boundary_ids = _mesh.getBoundaryIDs(_intersecting_boundary_names, true);
 
  if (_geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES)
  {
    std::set<dof_id_type> nodes;
    getCrackFrontNodes(nodes);
    orderCrackFrontNodes(nodes);
  }
 
  if (_closed_loop && _intersecting_boundary_names.size() > 0)
    paramError("intersecting_boundary", "Cannot use intersecting_boundary with closed-loop cracks");
 
  updateCrackFrontGeometry();
 
  if (_q_function_rings)
    createQFunctionRings();
 
  if (_t_stress)
  {
    std::size_t num_crack_front_nodes = _ordered_crack_front_nodes.size();
    for (std::size_t i = 0; i < num_crack_front_nodes; ++i)
      _strain_along_front.push_back(-std::numeric_limits<Real>::max());
  }
 
  std::size_t num_crack_front_points = getNumCrackFrontPoints();
  if (_q_function_type == "GEOMETRY")
  {
    if (!_treat_as_2d)
      if (num_crack_front_points < 1)
        mooseError("num_crack_front_points is not > 0");
    for (std::size_t i = 0; i < num_crack_front_points; ++i)
    {
      bool is_point_on_intersecting_boundary = isPointWithIndexOnIntersectingBoundary(i);
      _is_point_on_intersecting_boundary.push_back(is_point_on_intersecting_boundary);
    }
  }
}

◆ isCutterModified()

void CrackFrontDefinition::isCutterModified ( const bool is_cutter_modified )

Set the value of _is_cutter_modified.

Definition at line 1919 of file CrackFrontDefinition.C.

{
  _is_cutter_modified = is_cutter_modified;
}

Referenced by CrackMeshCut3DUserObject::initialize(), MeshCut2DFractureUserObject::initialize(), and MeshCut2DFunctionUserObject::initialize().

◆ isNodeInRing()

bool CrackFrontDefinition::isNodeInRing	(	const std::size_t	ring_index,
		const dof_id_type	connected_node_id,
		const std::size_t	node_index
	)		const

Determine whether a node is contained within a specified volume integral element ring for a given node on the crack front.

Parameters

ring_index	Index of the ring
connected_node_id	ID of the node
node_index	Index of the crack front node

Returns: true if the node is in the ring

Definition at line 1811 of file CrackFrontDefinition.C.

{
  bool is_node_in_ring = false;
  std::pair<dof_id_type, std::size_t> node_ring_key =
      std::make_pair(_ordered_crack_front_nodes[node_index], ring_index);
  auto nnmit = _crack_front_node_to_node_map.find(node_ring_key);
 
  if (nnmit == _crack_front_node_to_node_map.end())
    mooseError("Could not find crack front node ",
               _ordered_crack_front_nodes[node_index],
               " in the crack front node to q-function ring-node map for ring ",
               ring_index);
 
  std::set<dof_id_type> q_func_nodes = nnmit->second;
  if (q_func_nodes.find(connected_node_id) != q_func_nodes.end())
    is_node_in_ring = true;
 
  return is_node_in_ring;
}

Referenced by DomainIntegralTopologicalQFunction::computeValue(), and DomainIntegralTopologicalQFunction().

◆ isNodeOnIntersectingBoundary()

bool CrackFrontDefinition::isNodeOnIntersectingBoundary ( const Node *const node ) const

Determine whether a given node is on one of the boundaries that intersects an end of the crack front.

Parameters

node	Pointer to node

Returns: true if the node is on an intersecting boundary

Definition at line 1450 of file CrackFrontDefinition.C.

{
  bool is_on_boundary = false;
  mooseAssert(node, "Invalid node");
  dof_id_type node_id = node->id();
  for (std::size_t i = 0; i < _intersecting_boundary_ids.size(); ++i)
  {
    if (_mesh.isBoundaryNode(node_id, _intersecting_boundary_ids[i]))
    {
      is_on_boundary = true;
      break;
    }
  }
  return is_on_boundary;
}

Referenced by DomainIntegralQFunction::computeValue(), DomainIntegralQFunction(), and isPointWithIndexOnIntersectingBoundary().

◆ isPointWithIndexOnIntersectingBoundary()

bool CrackFrontDefinition::isPointWithIndexOnIntersectingBoundary ( const std::size_t point_index ) const

Determine whether a given crack front point is on one of the boundaries that intersects an end of the crack front.

Parameters

point_index the crack front point index

Returns: true if the point is on an intersecting boundary

Definition at line 1467 of file CrackFrontDefinition.C.

{
  bool is_on_boundary = false;
  if (_geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES)
  {
    const Node * crack_front_node = getCrackFrontNodePtr(point_index);
    is_on_boundary = isNodeOnIntersectingBoundary(crack_front_node);
  }
  else
  {
    // If the intersecting boundary option is used with crack front points, the
    // first and last points are assumed to be on the intersecting boundaries.
    std::size_t num_crack_front_points = getNumCrackFrontPoints();
    if (point_index == 0 || point_index == num_crack_front_points - 1)
      is_on_boundary = true;
  }
  return is_on_boundary;
}

Referenced by initialize(), DomainIntegralQFunction::initialSetup(), and initialSetup().

◆ maxNodeCoor()

dof_id_type CrackFrontDefinition::maxNodeCoor	(	std::vector< Node * > &	nodes,
		unsigned int	dir0 = `0`
	)

protected

Find the node with the maximum value of its coordinate.

This is used to deterministically find the first node on the crack front. First, the nodes with the maximum coordinate in one direction are found, and then if there are duplicates with that same coordinate, search through the other two coordinates to find the node with the maximum coordinate in all 3 directions.

Parameters

nodes	Set of all nodes on the crack front
dir0	First coordinate direction in which to order the coordinates

Definition at line 722 of file CrackFrontDefinition.C.

{
  Real dirs[3];
  if (dir0 == 0)
  {
    dirs[0] = 0;
    dirs[1] = 1;
    dirs[2] = 2;
  }
  else if (dir0 == 1)
  {
    dirs[0] = 1;
    dirs[1] = 2;
    dirs[2] = 0;
  }
  else if (dir0 == 2)
  {
    dirs[0] = 2;
    dirs[1] = 0;
    dirs[2] = 1;
  }
  else
    mooseError("Invalid dir0 in CrackFrontDefinition::maxNodeCoor()");
 
  Real max_coor0 = -std::numeric_limits<Real>::max();
  std::vector<Node *> max_coor0_nodes;
  for (std::size_t i = 0; i < nodes.size(); ++i)
  {
    Real coor0 = (*nodes[i])(dirs[0]);
    if (coor0 > max_coor0)
      max_coor0 = coor0;
  }
  for (std::size_t i = 0; i < nodes.size(); ++i)
  {
    Real coor0 = (*nodes[i])(dirs[0]);
    if (MooseUtils::absoluteFuzzyEqual(coor0, max_coor0, _tol))
      max_coor0_nodes.push_back(nodes[i]);
  }
  if (max_coor0_nodes.size() > 1)
  {
    Real max_coor1 = -std::numeric_limits<Real>::max();
    std::vector<Node *> max_coor1_nodes;
    for (std::size_t i = 0; i < nodes.size(); ++i)
    {
      Real coor1 = (*nodes[i])(dirs[1]);
      if (coor1 > max_coor1)
        max_coor1 = coor1;
    }
    for (std::size_t i = 0; i < nodes.size(); ++i)
    {
      Real coor1 = (*nodes[i])(dirs[1]);
      if (MooseUtils::absoluteFuzzyEqual(coor1, max_coor1, _tol))
        max_coor1_nodes.push_back(nodes[i]);
    }
    if (max_coor1_nodes.size() > 1)
    {
      Real max_coor2 = -std::numeric_limits<Real>::max();
      std::vector<Node *> max_coor2_nodes;
      for (std::size_t i = 0; i < nodes.size(); ++i)
      {
        Real coor2 = (*nodes[i])(dirs[2]);
        if (coor2 > max_coor2)
          max_coor2 = coor2;
      }
      for (std::size_t i = 0; i < nodes.size(); ++i)
      {
        Real coor2 = (*nodes[i])(dirs[2]);
        if (MooseUtils::absoluteFuzzyEqual(coor2, max_coor2, _tol))
          max_coor2_nodes.push_back(nodes[i]);
      }
      if (max_coor2_nodes.size() > 1)
        mooseError("Multiple nodes with same x,y,z coordinates within tolerance");
      else
        return max_coor2_nodes[0]->id();
    }
    else
      return max_coor1_nodes[0]->id();
  }
  else
    return max_coor0_nodes[0]->id();
}

Referenced by pickLoopCrackEndNodes().

◆ orderCrackFrontNodes()

void CrackFrontDefinition::orderCrackFrontNodes ( std::set< dof_id_type > & nodes )

protected

Arrange the crack front nodes by their position along the crack front, and put them in the _ordered_crack_front_nodes member variable.

Parameters

nodes Set of nodes to be ordered

Definition at line 464 of file CrackFrontDefinition.C.

{
  _ordered_crack_front_nodes.clear();
  if (nodes.size() < 1)
    mooseError("No crack front nodes");
  else if (nodes.size() == 1)
  {
    _ordered_crack_front_nodes.push_back(*nodes.begin());
    if (!_treat_as_2d)
      mooseError("Boundary provided in CrackFrontDefinition contains 1 node, but model is not "
                 "treated as 2d");
  }
  else if (_treat_as_2d && _use_mesh_cutter)
  {
    // This is for the 2D case that uses a mesh cutter object so every node is its own crack front
    // and is not connected to other crack front nodes.  Copying the order here makes it the same
    // as that given in the MeshCut2DFractureUserObject
    std::copy(nodes.begin(), nodes.end(), _ordered_crack_front_nodes.begin());
  }
  else
  {
    // Loop through the set of crack front nodes, and create a node to element map for just the
    // crack front nodes
    // The main reason for creating a second map is that we need to do a sort prior to the
    // set_intersection.
    // The original map contains vectors, and we can't sort them, so we create sets in the local
    // map.
    const auto & node_to_elem_map = _mesh.nodeToElemMap();
    std::map<dof_id_type, std::set<dof_id_type>> crack_front_node_to_elem_map;
 
    for (const auto & node_id : nodes)
    {
      const auto & node_to_elem_pair = node_to_elem_map.find(node_id);
      mooseAssert(node_to_elem_pair != node_to_elem_map.end(),
                  "Could not find crack front node " << node_id << " in the node to elem map");
 
      const std::vector<dof_id_type> & connected_elems = node_to_elem_pair->second;
      for (std::size_t i = 0; i < connected_elems.size(); ++i)
        crack_front_node_to_elem_map[node_id].insert(connected_elems[i]);
    }
 
    // Determine which nodes are connected to each other via elements, and construct line elements
    // to represent
    // those connections
    std::vector<std::vector<dof_id_type>> line_elems;
    std::map<dof_id_type, std::vector<dof_id_type>> node_to_line_elem_map;
 
    for (auto cfnemit = crack_front_node_to_elem_map.begin();
         cfnemit != crack_front_node_to_elem_map.end();
         ++cfnemit)
    {
      auto cfnemit2 = cfnemit;
      for (++cfnemit2; cfnemit2 != crack_front_node_to_elem_map.end(); ++cfnemit2)
      {
 
        std::vector<dof_id_type> common_elements;
        std::set<dof_id_type> & elements_connected_to_node1 = cfnemit->second;
        std::set<dof_id_type> & elements_connected_to_node2 = cfnemit2->second;
        std::set_intersection(elements_connected_to_node1.begin(),
                              elements_connected_to_node1.end(),
                              elements_connected_to_node2.begin(),
                              elements_connected_to_node2.end(),
                              std::inserter(common_elements, common_elements.end()));
 
        if (common_elements.size() > 0)
        {
          std::vector<dof_id_type> my_line_elem;
          my_line_elem.push_back(cfnemit->first);
          my_line_elem.push_back(cfnemit2->first);
          node_to_line_elem_map[cfnemit->first].push_back(line_elems.size());
          node_to_line_elem_map[cfnemit2->first].push_back(line_elems.size());
          line_elems.push_back(my_line_elem);
        }
      }
    }
 
    // Find nodes on ends of line (those connected to only one line element)
    std::vector<dof_id_type> end_nodes;
    for (auto nlemit = node_to_line_elem_map.begin(); nlemit != node_to_line_elem_map.end();
         ++nlemit)
    {
      std::size_t num_connected_elems = nlemit->second.size();
      if (num_connected_elems == 1)
        end_nodes.push_back(nlemit->first);
      else if (num_connected_elems != 2)
        mooseError(
            "Node ", nlemit->first, " is connected to >2 line segments in CrackFrontDefinition");
    }
 
    // For embedded crack with closed loop of crack front nodes, must pick the end nodes
    if (end_nodes.size() == 0) // Crack front is a loop.  Pick nodes to be end nodes.
    {
      pickLoopCrackEndNodes(end_nodes, nodes, node_to_line_elem_map, line_elems);
      _closed_loop = true;
      if (_end_direction_method == END_DIRECTION_METHOD::END_CRACK_DIRECTION_VECTOR ||
          _end_direction_method == END_DIRECTION_METHOD::END_CRACK_TANGENT_VECTOR)
        paramError("end_direction_method",
                   "In CrackFrontDefinition, end_direction_method cannot be CrackDirectionVector "
                   "or CrackTangentVector for a closed-loop crack");
      if (_intersecting_boundary_names.size() > 0)
        paramError("intersecting_boundary",
                   "In CrackFrontDefinition, intersecting_boundary cannot be specified for a "
                   "closed-loop crack");
    }
    else if (end_nodes.size() == 2) // Rearrange the order of the end nodes if needed
      orderEndNodes(end_nodes);
    else
      mooseError("In CrackFrontDefinition wrong number of end nodes.  Number end nodes = ",
                 end_nodes.size());
 
    // Create an ordered list of the nodes going along the line of the crack front
    _ordered_crack_front_nodes.push_back(end_nodes[0]);
 
    dof_id_type last_node = end_nodes[0];
    dof_id_type second_last_node = last_node;
    while (last_node != end_nodes[1])
    {
      std::vector<dof_id_type> & curr_node_line_elems = node_to_line_elem_map[last_node];
      bool found_new_node = false;
      for (std::size_t i = 0; i < curr_node_line_elems.size(); ++i)
      {
        std::vector<dof_id_type> curr_line_elem = line_elems[curr_node_line_elems[i]];
        for (std::size_t j = 0; j < curr_line_elem.size(); ++j)
        {
          dof_id_type line_elem_node = curr_line_elem[j];
          if (_closed_loop &&
              (last_node == end_nodes[0] &&
               line_elem_node == end_nodes[1])) // wrong direction around closed loop
            continue;
          if (line_elem_node != last_node && line_elem_node != second_last_node)
          {
            _ordered_crack_front_nodes.push_back(line_elem_node);
            found_new_node = true;
            break;
          }
        }
        if (found_new_node)
          break;
      }
      second_last_node = last_node;
      last_node = _ordered_crack_front_nodes.back();
    }
  }
}

Referenced by initialSetup().

◆ orderEndNodes()

void CrackFrontDefinition::orderEndNodes ( std::vector< dof_id_type > & end_nodes )

protected

Determine which of the end nodes should be the starting point of the crack front.

Parameters

end_nodes Vector containing two end nodes. The order of this is rearranged so that the first end node is the start of the crack front, and the second is at the end.

Definition at line 610 of file CrackFrontDefinition.C.

{
  // Choose the node to be the first node.  Do that based on undeformed coordinates for
  // repeatability.
  Node & node0 = _mesh.nodeRef(end_nodes[0]);
  Node & node1 = _mesh.nodeRef(end_nodes[1]);
 
  std::size_t num_positive_coor0 = 0;
  std::size_t num_positive_coor1 = 0;
  Real dist_from_origin0 = 0.0;
  Real dist_from_origin1 = 0.0;
  for (std::size_t i = 0; i < 3; ++i)
  {
    dist_from_origin0 += node0(i) * node0(i);
    dist_from_origin1 += node1(i) * node1(i);
    if (MooseUtils::absoluteFuzzyGreaterThan(node0(i), 0.0, _tol))
      ++num_positive_coor0;
    if (MooseUtils::absoluteFuzzyGreaterThan(node1(i), 0.0, _tol))
      ++num_positive_coor1;
  }
  dist_from_origin0 = std::sqrt(dist_from_origin0);
  dist_from_origin1 = std::sqrt(dist_from_origin1);
 
  bool switch_ends = false;
  if (num_positive_coor1 > num_positive_coor0)
  {
    switch_ends = true;
  }
  else
  {
    if (!MooseUtils::absoluteFuzzyEqual(dist_from_origin1, dist_from_origin0, _tol))
    {
      if (dist_from_origin1 < dist_from_origin0)
        switch_ends = true;
    }
    else
    {
      if (end_nodes[1] < end_nodes[0])
        switch_ends = true;
    }
  }
  if (switch_ends)
  {
    std::size_t tmp_node = end_nodes[1];
    end_nodes[1] = end_nodes[0];
    end_nodes[0] = tmp_node;
  }
}

Referenced by orderCrackFrontNodes().

◆ pickLoopCrackEndNodes()

void CrackFrontDefinition::pickLoopCrackEndNodes	(	std::vector< dof_id_type > &	end_nodes,
		std::set< dof_id_type > &	nodes,
		std::map< dof_id_type, std::vector< dof_id_type > > &	node_to_line_elem_map,
		std::vector< std::vector< dof_id_type > > &	line_elems
	)

protected

For the case of a crack that is a complete loop, determine which of the nodes should be the start and end nodes in a repeatable way.

Parameters

end_nodes	Vector containing two end nodes – populated by this method
nodes	Set of all nodes on the crack front
node_to_line_elem_map	Map from crack front nodes to line elements on crack front (see line_elems param)
line_elems	Line elements on crack front defined as vectors of the nodes on each end of the line elements.

Definition at line 660 of file CrackFrontDefinition.C.

{
  dof_id_type max_dist_node = 0;
  Real min_dist = std::numeric_limits<Real>::max();
  Real max_dist = -std::numeric_limits<Real>::max();
  // Pick the node farthest from the origin as the end node, or the one with
  // the greatest x coordinate if the nodes are equidistant from the origin
  for (auto nit = nodes.begin(); nit != nodes.end(); ++nit)
  {
    Node & node = _mesh.nodeRef(*nit);
    Real dist = node.norm();
    if (dist > max_dist)
    {
      max_dist = dist;
      max_dist_node = *nit;
    }
    else if (dist < min_dist)
      min_dist = dist;
  }
 
  dof_id_type end_node;
  if (MooseUtils::absoluteFuzzyGreaterThan(max_dist, min_dist, _tol))
    end_node = max_dist_node;
  else
  {
    std::vector<Node *> node_vec;
    for (auto nit = nodes.begin(); nit != nodes.end(); ++nit)
      node_vec.push_back(_mesh.nodePtr(*nit));
    end_node = maxNodeCoor(node_vec);
  }
 
  end_nodes.push_back(end_node);
 
  // Find the two nodes connected to the node identified as the end node, and pick one of those to
  // be the other end node
  auto end_node_line_elems = node_to_line_elem_map[end_node];
  if (end_node_line_elems.size() != 2)
    mooseError(
        "Crack front nodes are in a loop, but crack end node is only connected to one other node");
  std::vector<Node *> candidate_other_end_nodes;
 
  for (std::size_t i = 0; i < 2; ++i)
  {
    auto end_line_elem = line_elems[end_node_line_elems[i]];
    for (std::size_t j = 0; j < end_line_elem.size(); ++j)
    {
      auto line_elem_node = end_line_elem[j];
      if (line_elem_node != end_node)
        candidate_other_end_nodes.push_back(_mesh.nodePtr(line_elem_node));
    }
  }
  if (candidate_other_end_nodes.size() != 2)
    mooseError(
        "Crack front nodes are in a loop, but crack end node is not connected to two other nodes");
  end_nodes.push_back(maxNodeCoor(candidate_other_end_nodes, 1));
}

Referenced by orderCrackFrontNodes().

◆ projectToFrontAtPoint()

void CrackFrontDefinition::projectToFrontAtPoint	(	Real &	dist_to_front,
		Real &	dist_along_tangent,
		std::size_t	crack_front_point_index,
		const Node *const	current_node
	)		const

protected

Project a point to a specified point along the crack front and compute the projected normal and tangential distance to the front.

Parameters

dist_to_front	Projected normal distance to the front – computed by this method
dist_along_tangent	Project tangent distance to the front – computed by this method
crack_front_point_index	Index of the point on the crack front
current_node	Node to be projected to the front

Definition at line 1901 of file CrackFrontDefinition.C.

{
  const Point * crack_front_point = getCrackFrontPoint(crack_front_point_index);
 
  Point p = *current_node;
  const RealVectorValue & crack_front_tangent = getCrackFrontTangent(crack_front_point_index);
 
  RealVectorValue crack_node_to_current_node = p - *crack_front_point;
  dist_along_tangent = crack_node_to_current_node * crack_front_tangent;
  RealVectorValue projection_point = *crack_front_point + dist_along_tangent * crack_front_tangent;
  RealVectorValue axis_to_current_node = p - projection_point;
  dist_to_front = axis_to_current_node.norm();
}

Referenced by DomainIntegralQFunction().

◆ rotateFromCrackFrontCoordsToGlobal()

RealVectorValue CrackFrontDefinition::rotateFromCrackFrontCoordsToGlobal	(	const RealVectorValue	vector,
		const std::size_t	point_index
	)		const

Rotate a vector from crack front cartesian coordinate to global cartesian coordinate.

Parameters

vector	Vector in crack local coordinates
point_index	Index of the point

Returns: Vector in global coordinates

Definition at line 1292 of file CrackFrontDefinition.C.

{
  RealVectorValue vec = _rot_matrix[point_index].transpose() * vector;
  return vec;
}

Referenced by CrackMeshCut3DUserObject::findActiveBoundaryDirection(), MeshCut2DFractureUserObject::findActiveBoundaryGrowth(), and EnrichmentFunctionCalculation::rotateFromCrackFrontCoordsToGlobal().

◆ rotateToCrackFrontCoords() [1/2]

RankTwoTensor CrackFrontDefinition::rotateToCrackFrontCoords	(	const RankTwoTensor	tensor,
		const std::size_t	point_index
	)		const

Rotate a RankTwoTensor in the global coordinate coordinate system to the crack front local coordinate system at a specified point on the crack.

Parameters

tensor	Tensor in global coordinates
point_index	Index of the point

Returns: Tensor in crack local coordinates

Definition at line 1300 of file CrackFrontDefinition.C.

{
  RankTwoTensor tmp_tensor(tensor);
  tmp_tensor.rotate(_rot_matrix[point_index]);
  return tmp_tensor;
}

◆ rotateToCrackFrontCoords() [2/2]

RealVectorValue CrackFrontDefinition::rotateToCrackFrontCoords	(	const RealVectorValue	vector,
		const std::size_t	point_index
	)		const

Rotate a vector in the global coordinate coordinate system to the crack front local coordinate system at a specified point on the crack.

Parameters

vector	Vector in global coordinates
point_index	Index of the point

Returns: Vector in crack local coordinates

Definition at line 1285 of file CrackFrontDefinition.C.

{
  return _rot_matrix[point_index] * vector;
}

Referenced by CrackFrontNonlocalMaterialBase::BoxWeightingFunction(), and calculateRThetaToCrackFront().

◆ treatAs2D()

bool CrackFrontDefinition::treatAs2D ( ) const

inline

Whether the fracture computations are treated as 2D for the model.

Returns: true if treated as 2D

Definition at line 131 of file CrackFrontDefinition.h.

131{ return _treat_as_2d; }

Referenced by JIntegral::computeQpIntegral(), DomainIntegralQFunction::initialSetup(), DomainIntegralTopologicalQFunction::initialSetup(), and JIntegral::initialSetup().

◆ updateCrackFrontGeometry()

void CrackFrontDefinition::updateCrackFrontGeometry ( )

protected

Update the data structures defining the crack front geometry such as the ordered crack front nodes/points and other auxiliary data.

Definition at line 805 of file CrackFrontDefinition.C.

{
  computeCrackMouthNodes();
  _segment_lengths.clear();
  _tangent_directions.clear();
  _crack_directions.clear();
  _overall_length = 0.0;
  _rot_matrix.clear();
  _distances_along_front.clear();
  _angles_along_front.clear();
  _strain_along_front.clear();
  _crack_plane_normals.clear();
 
  if (_treat_as_2d)
  {
    std::size_t num_crack_front_points = getNumCrackFrontPoints();
    _segment_lengths.reserve(num_crack_front_points);
    _tangent_directions.reserve(num_crack_front_points);
    _crack_directions.reserve(num_crack_front_points);
    if (_use_mesh_cutter)
      _crack_plane_normals =
          _crack_front_points_provider->getCrackPlaneNormals(num_crack_front_points);
 
    for (std::size_t i = 0; i < num_crack_front_points; ++i)
    {
      RealVectorValue tangent_direction;
      RealVectorValue crack_direction;
      tangent_direction(_axis_2d) = 1.0;
      _tangent_directions.push_back(tangent_direction);
      const Point * crack_front_point = getCrackFrontPoint(i);
 
      crack_direction =
          calculateCrackFrontDirection(*crack_front_point, tangent_direction, MIDDLE_NODE, i);
      _crack_directions.push_back(crack_direction);
 
      RankTwoTensor rot_mat;
      rot_mat.fillRow(0, crack_direction);
      rot_mat(2, _axis_2d) = 1.0;
 
      if (!_use_mesh_cutter)
        _crack_plane_normals.push_back(tangent_direction.cross(crack_direction));
 
      mooseAssert(i <= _crack_plane_normals.size(), "_crack_plane_normals is the wrong size.");
      rot_mat.fillRow(1, _crack_plane_normals[i]);
      _rot_matrix.push_back(rot_mat);
 
      _segment_lengths.push_back(std::make_pair(0.0, 0.0));
      _distances_along_front.push_back(0.0);
      _angles_along_front.push_back(0.0);
    }
  }
  else
  {
    // filling crack_plane_normals from mesh_cutter
    if (_use_mesh_cutter)
      _crack_plane_normals =
          _crack_front_points_provider->getCrackPlaneNormals(_num_points_from_provider);
    // else filling crack_plane_normals from curvedCrackFront
    computeCurvedCrackFrontCrackPlaneNormals();
 
    std::size_t num_crack_front_points = getNumCrackFrontPoints();
    _segment_lengths.reserve(num_crack_front_points);
    _tangent_directions.reserve(num_crack_front_points);
    _crack_directions.reserve(num_crack_front_points);
 
    RealVectorValue back_segment;
    Real back_segment_len = 0.0;
    if (_closed_loop)
    {
      back_segment = *getCrackFrontPoint(0) - *getCrackFrontPoint(num_crack_front_points - 1);
      back_segment_len = back_segment.norm();
    }
 
    for (std::size_t i = 0; i < num_crack_front_points; ++i)
    {
      CRACK_NODE_TYPE ntype;
      if (_closed_loop)
        ntype = MIDDLE_NODE;
      else if (i == 0)
        ntype = END_1_NODE;
      else if (i == num_crack_front_points - 1)
        ntype = END_2_NODE;
      else
        ntype = MIDDLE_NODE;
 
      RealVectorValue forward_segment;
      Real forward_segment_len;
      if (ntype == END_2_NODE)
        forward_segment_len = 0.0;
      else if (_closed_loop && i == num_crack_front_points - 1)
      {
        forward_segment = *getCrackFrontPoint(0) - *getCrackFrontPoint(i);
        forward_segment_len = forward_segment.norm();
      }
      else
      {
        forward_segment = *getCrackFrontPoint(i + 1) - *getCrackFrontPoint(i);
        forward_segment_len = forward_segment.norm();
        _overall_length += forward_segment_len;
      }
 
      _segment_lengths.push_back(std::make_pair(back_segment_len, forward_segment_len));
      if (i == 0)
        _distances_along_front.push_back(0.0);
      else
        _distances_along_front.push_back(back_segment_len + _distances_along_front[i - 1]);
 
      RealVectorValue tangent_direction = back_segment + forward_segment;
      tangent_direction = tangent_direction / tangent_direction.norm();
 
      // If end tangent directions are given, correct the tangent at the end nodes
      if (_direction_method == DIRECTION_METHOD::CURVED_CRACK_FRONT &&
          _end_direction_method == END_DIRECTION_METHOD::END_CRACK_TANGENT_VECTOR)
      {
        if (ntype == END_1_NODE)
          tangent_direction = _crack_tangent_vector_end_1;
        else if (ntype == END_2_NODE)
          tangent_direction = _crack_tangent_vector_end_2;
      }
 
      _tangent_directions.push_back(tangent_direction);
      _crack_directions.push_back(
          calculateCrackFrontDirection(*getCrackFrontPoint(i), tangent_direction, ntype, i));
 
      // correct tangent direction in the case of _use_mesh_cutter
      if (_use_mesh_cutter)
        _tangent_directions[i] = _crack_plane_normals[i].cross(_crack_directions[i]);
 
      // If the end directions are given by the user, correct also the tangent at the end nodes
      if (_direction_method == DIRECTION_METHOD::CURVED_CRACK_FRONT &&
          _end_direction_method == END_DIRECTION_METHOD::END_CRACK_DIRECTION_VECTOR &&
          (ntype == END_1_NODE || ntype == END_2_NODE))
      {
        _tangent_directions[i] = _crack_plane_normals[i].cross(_crack_directions[i]);
      }
 
      back_segment = forward_segment;
      back_segment_len = forward_segment_len;
    }
 
    // For CURVED_CRACK_FRONT, _crack_plane_normals gets computed in
    // computeCurvedCrackFrontCrackPlaneNormals
    if (_direction_method != DIRECTION_METHOD::CURVED_CRACK_FRONT && !_use_mesh_cutter)
    {
      std::size_t mid_id = (num_crack_front_points - 1) / 2;
      _crack_plane_normals.assign(num_crack_front_points,
                                  _tangent_directions[mid_id].cross(_crack_directions[mid_id]));
 
      // Make sure the normal vector is non-zero
      RealVectorValue zero_vec(0.0);
      if (_crack_plane_normals.front().absolute_fuzzy_equals(zero_vec, _tol))
        mooseError("Crack plane normal vector evaluates to zero");
    }
 
    // Calculate angles of each point along the crack front for an elliptical crack projected
    // to a circle.
    if (hasAngleAlongFront())
    {
      RealVectorValue origin_to_first_node = *getCrackFrontPoint(0) - _crack_mouth_coordinates;
      Real hyp = origin_to_first_node.norm();
      RealVectorValue norm_origin_to_first_node = origin_to_first_node / hyp;
      RealVectorValue tangent_to_first_node =
          -norm_origin_to_first_node.cross(_crack_plane_normals.front());
      tangent_to_first_node /= tangent_to_first_node.norm();
 
      for (std::size_t i = 0; i < num_crack_front_points; ++i)
      {
        RealVectorValue origin_to_curr_node = *getCrackFrontPoint(i) - _crack_mouth_coordinates;
 
        Real adj = origin_to_curr_node * norm_origin_to_first_node;
        Real opp = origin_to_curr_node * tangent_to_first_node;
 
        Real angle = acos(adj / hyp) * 180.0 / libMesh::pi;
        if (opp < 0.0)
          angle = 360.0 - angle;
        _angles_along_front.push_back(angle);
      }
 
      // Correct angle on end nodes if they are 0 or 360 to be consistent with neighboring node
      if (num_crack_front_points > 1)
      {
        if (MooseUtils::absoluteFuzzyEqual(_angles_along_front[0], 0.0, _tol) &&
            _angles_along_front[1] > 180.0)
          _angles_along_front[0] = 360.0;
        else if (MooseUtils::absoluteFuzzyEqual(_angles_along_front[0], 360.0, _tol) &&
                 _angles_along_front[1] < 180.0)
          _angles_along_front[0] = 0.0;
 
        if (MooseUtils::absoluteFuzzyEqual(
                _angles_along_front[num_crack_front_points - 1], 0.0, _tol) &&
            _angles_along_front[num_crack_front_points - 2] > 180.0)
          _angles_along_front[num_crack_front_points - 1] = 360.0;
        else if (MooseUtils::absoluteFuzzyEqual(
                     _angles_along_front[num_crack_front_points - 1], 360.0, _tol) &&
                 _angles_along_front[num_crack_front_points - 2] < 180.0)
          _angles_along_front[num_crack_front_points - 1] = 0.0;
      }
    }
    else
      _angles_along_front.resize(num_crack_front_points, 0.0);
 
    // Create rotation matrix
    for (std::size_t i = 0; i < num_crack_front_points; ++i)
    {
      RankTwoTensor rot_mat;
      rot_mat.fillRow(0, _crack_directions[i]);
      rot_mat.fillRow(1, _crack_plane_normals[i]);
      rot_mat.fillRow(2, _tangent_directions[i]);
      _rot_matrix.push_back(rot_mat);
    }
 
    _console << "Summary of crack front geometry (used for fracture integrals):" << std::endl;
    _console << "index   node id   x coord       y coord       z coord       x dir         y dir   "
                "       z dir        angle        position     seg length"
             << std::endl;
    for (std::size_t i = 0; i < num_crack_front_points; ++i)
    {
      std::size_t point_id;
      if (_geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES)
        point_id = _ordered_crack_front_nodes[i];
      else
        point_id = i;
      _console << std::left << std::setw(8) << i + 1 << std::setw(10) << point_id << std::setw(14)
               << (*getCrackFrontPoint(i))(0) << std::setw(14) << (*getCrackFrontPoint(i))(1)
               << std::setw(14) << (*getCrackFrontPoint(i))(2) << std::setw(14)
               << _crack_directions[i](0) << std::setw(14) << _crack_directions[i](1)
               << std::setw(14) << _crack_directions[i](2);
      if (hasAngleAlongFront())
        _console << std::left << std::setw(14) << _angles_along_front[i];
      else
        _console << std::left << std::setw(14) << "--";
      _console << std::left << std::setw(14) << _distances_along_front[i] << std::setw(14)
               << (_segment_lengths[i].first + _segment_lengths[i].second) / 2.0 << std::endl;
    }
    _console << "overall length: " << _overall_length << std::endl;
  }
}

Referenced by initialize(), and initialSetup().

◆ updateNumberOfCrackFrontPoints()

void CrackFrontDefinition::updateNumberOfCrackFrontPoints ( const std::size_t num_points )

Change the number of crack front nodes.

As the crack grows, the number of crack fronts nodes may keep increasing in many cases.

Definition at line 1192 of file CrackFrontDefinition.C.

{
  _num_points_from_provider = num_points;
}

Referenced by MeshCut2DFractureUserObject::initialize(), and CrackMeshCut3DUserObject::refineFront().

◆ usingMeshCutter()

bool CrackFrontDefinition::usingMeshCutter ( ) const

inline

Is the crack defined by a mesh cutter object.

Returns: true if using a mesh cutter

Definition at line 137 of file CrackFrontDefinition.h.

137{ return _use_mesh_cutter; }

Referenced by DomainIntegralQFunction::initialSetup(), and JIntegral::initialSetup().

◆ validParams()

InputParameters CrackFrontDefinition::validParams ( )

static

Definition at line 25 of file CrackFrontDefinition.C.

{
  InputParameters params = GeneralUserObject::validParams();
  params.addClassDescription("Used to describe geometric characteristics of the crack front for "
                             "fracture integral calculations");
  params += BoundaryRestrictable::validParams();
  CrackFrontDefinition::includeCrackFrontDefinitionParams(params);
  params.set<bool>("use_displaced_mesh") = false;
 
  params.addRelationshipManager("ElementSideNeighborLayers",
                                Moose::RelationshipManagerType::ALGEBRAIC,
                                [](const InputParameters &, InputParameters & rm_params)
                                { rm_params.set<unsigned short>("layers") = 2; });
  return params;
}

Member Data Documentation

◆ _angles_along_front

std::vector<Real> CrackFrontDefinition::_angles_along_front

protected

Vector of angles along the crack front.

Definition at line 311 of file CrackFrontDefinition.h.

Referenced by getAngleAlongFront(), and updateCrackFrontGeometry().

◆ _aux

AuxiliarySystem& CrackFrontDefinition::_aux

protected

Reference to the auxiliary system.

Definition at line 294 of file CrackFrontDefinition.h.

◆ _axis_2d

unsigned int CrackFrontDefinition::_axis_2d

protected

Out of plane axis when crack is treated as 2D.

Definition at line 349 of file CrackFrontDefinition.h.

Referenced by getCrackFrontNodes(), and updateCrackFrontGeometry().

◆ _closed_loop

bool CrackFrontDefinition::_closed_loop

protected

Whether the crack forms a closed loop.

Definition at line 347 of file CrackFrontDefinition.h.

Referenced by computeCurvedCrackFrontCrackPlaneNormals(), createQFunctionRings(), initialSetup(), orderCrackFrontNodes(), and updateCrackFrontGeometry().

◆ _crack_direction_vector

RealVectorValue CrackFrontDefinition::_crack_direction_vector

protected

Fixed vector optionally used to define crack extension direction.

Definition at line 319 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), and CrackFrontDefinition().

◆ _crack_direction_vector_end_1

RealVectorValue CrackFrontDefinition::_crack_direction_vector_end_1

protected

Fixed vector optionally used to define crack extension direction at end 1 of crack front.

Definition at line 321 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), and CrackFrontDefinition().

◆ _crack_direction_vector_end_2

RealVectorValue CrackFrontDefinition::_crack_direction_vector_end_2

protected

Fixed vector optionally used to define crack extension direction at end 2 of crack front.

Definition at line 323 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), and CrackFrontDefinition().

◆ _crack_directions

std::vector<RealVectorValue> CrackFrontDefinition::_crack_directions

protected

Vector of crack extension directions along the crack front.

Definition at line 305 of file CrackFrontDefinition.h.

Referenced by getCrackDirection(), and updateCrackFrontGeometry().

◆ _crack_front_node_to_node_map

std::map<std::pair<dof_id_type, std::size_t>, std::set<dof_id_type> > CrackFrontDefinition::_crack_front_node_to_node_map

protected

Data structure used to store information about topological rings Key is a pair of the crack front node index and ring id Data is a set of the IDs of the nodes in the ring for that crack front node.

Definition at line 372 of file CrackFrontDefinition.h.

Referenced by createQFunctionRings(), and isNodeInRing().

◆ _crack_front_points

std::vector<Point> CrackFrontDefinition::_crack_front_points

protected

Vector of points along the crack front.

Definition at line 301 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), getCrackFrontPoint(), getNumCrackFrontPoints(), initialize(), and initialSetup().

◆ _crack_front_points_provider

const CrackFrontPointsProvider* CrackFrontDefinition::_crack_front_points_provider

protected

Pointer to a CrackFrontPointsProvider object optionally used to define the crack front points.

Definition at line 384 of file CrackFrontDefinition.h.

Referenced by initialize(), initialSetup(), and updateCrackFrontGeometry().

◆ _crack_mouth_boundary_ids

std::vector<BoundaryID> CrackFrontDefinition::_crack_mouth_boundary_ids

protected

IDs of boundaries used to define location of crack mouth.

Definition at line 331 of file CrackFrontDefinition.h.

Referenced by computeCrackMouthNodes(), and initialSetup().

◆ _crack_mouth_boundary_names

std::vector<BoundaryName> CrackFrontDefinition::_crack_mouth_boundary_names

protected

Names of boundaries used to define location of crack mouth.

Definition at line 329 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), hasAngleAlongFront(), and initialSetup().

◆ _crack_mouth_coordinates

RealVectorValue CrackFrontDefinition::_crack_mouth_coordinates

protected

Coordinates of crack mouth.

Definition at line 337 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), computeCrackMouthNodes(), and updateCrackFrontGeometry().

◆ _crack_plane_normals

std::vector<RealVectorValue> CrackFrontDefinition::_crack_plane_normals

protected

Vector normals to a nonplanar crack.

Definition at line 339 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), calculateRThetaToCrackFront(), computeCurvedCrackFrontCrackPlaneNormals(), getCrackFrontNormal(), and updateCrackFrontGeometry().

◆ _crack_tangent_vector_end_1

RealVectorValue CrackFrontDefinition::_crack_tangent_vector_end_1

protected

Fixed vector optionally used to define crack tangent direction at end 1 of crack front.

Definition at line 325 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and updateCrackFrontGeometry().

◆ _crack_tangent_vector_end_2

RealVectorValue CrackFrontDefinition::_crack_tangent_vector_end_2

protected

Fixed vector optionally used to define crack tangent direction at end 2 of crack front.

Definition at line 327 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and updateCrackFrontGeometry().

◆ _direction_method

enum CrackFrontDefinition::DIRECTION_METHOD CrackFrontDefinition::_direction_method

protected

Referenced by calculateCrackFrontDirection(), computeCurvedCrackFrontCrackPlaneNormals(), CrackFrontDefinition(), initialSetup(), and updateCrackFrontGeometry().

◆ _disp_x_var_name

std::string CrackFrontDefinition::_disp_x_var_name

protected

Names of the x, y, and z displacement variables.

Definition at line 356 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), and CrackFrontDefinition().

◆ _disp_y_var_name

std::string CrackFrontDefinition::_disp_y_var_name

protected

Definition at line 357 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), and CrackFrontDefinition().

◆ _disp_z_var_name

std::string CrackFrontDefinition::_disp_z_var_name

protected

Definition at line 358 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), and CrackFrontDefinition().

◆ _distances_along_front

std::vector<Real> CrackFrontDefinition::_distances_along_front

protected

Vector of distances along the crack front.

Definition at line 309 of file CrackFrontDefinition.h.

Referenced by getDistanceAlongFront(), and updateCrackFrontGeometry().

◆ _end_direction_method

enum CrackFrontDefinition::END_DIRECTION_METHOD CrackFrontDefinition::_end_direction_method

protected

Referenced by calculateCrackFrontDirection(), CrackFrontDefinition(), orderCrackFrontNodes(), and updateCrackFrontGeometry().

◆ _first_ring

std::size_t CrackFrontDefinition::_first_ring

protected

Numer of elements from crack tip to first topological ring.

Definition at line 367 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition().

◆ _geom_definition_method

enum CrackFrontDefinition::CRACK_GEOM_DEFINITION CrackFrontDefinition::_geom_definition_method

protected

Referenced by CrackFrontDefinition(), getCrackFrontPoint(), getNumCrackFrontPoints(), hasCrackFrontNodes(), initialSetup(), isPointWithIndexOnIntersectingBoundary(), and updateCrackFrontGeometry().

◆ _has_symmetry_plane

bool CrackFrontDefinition::_has_symmetry_plane

protected

Whether the crack plane is also a symmetry plane in the model.

Definition at line 351 of file CrackFrontDefinition.h.

Referenced by computeCrackMouthNodes(), and CrackFrontDefinition().

◆ _intersecting_boundary_ids

std::vector<BoundaryID> CrackFrontDefinition::_intersecting_boundary_ids

protected

IDs of boundaries that intersect crack at its ends.

Definition at line 335 of file CrackFrontDefinition.h.

Referenced by initialSetup(), and isNodeOnIntersectingBoundary().

◆ _intersecting_boundary_names

std::vector<BoundaryName> CrackFrontDefinition::_intersecting_boundary_names

protected

Names of boundaries that intersect crack at its ends.

Definition at line 333 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), initialSetup(), and orderCrackFrontNodes().

◆ _is_cutter_modified

bool CrackFrontDefinition::_is_cutter_modified

protected

Indicator that shows if the cutter mesh is modified or not in the calculation step.

Definition at line 345 of file CrackFrontDefinition.h.

Referenced by initialize(), and isCutterModified().

◆ _is_point_on_intersecting_boundary

std::vector<bool> CrackFrontDefinition::_is_point_on_intersecting_boundary

protected

Vector of bools indicating whether individual crack front points are on an intersecting boundary.

Definition at line 377 of file CrackFrontDefinition.h.

Referenced by DomainIntegralQFunction(), initialize(), and initialSetup().

◆ _j_integral_radius_inner

std::vector<Real> CrackFrontDefinition::_j_integral_radius_inner

protected

Vector of inner radii of the rings used for geometric q functions.

Definition at line 379 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and DomainIntegralQFunction().

◆ _j_integral_radius_outer

std::vector<Real> CrackFrontDefinition::_j_integral_radius_outer

protected

Vector of outer radii of the rings used for geometric q functions.

Definition at line 381 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and DomainIntegralQFunction().

◆ _last_ring

std::size_t CrackFrontDefinition::_last_ring

protected

Numer of elements from crack tip to last topological ring.

Definition at line 365 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and createQFunctionRings().

◆ _mesh

MooseMesh& CrackFrontDefinition::_mesh

protected

Reference to the mesh.

Definition at line 296 of file CrackFrontDefinition.h.

Referenced by addNodesToQFunctionRing(), computeCrackMouthNodes(), createQFunctionRings(), getCrackFrontNodePtr(), getCrackFrontNodes(), initialSetup(), isNodeOnIntersectingBoundary(), orderCrackFrontNodes(), orderEndNodes(), and pickLoopCrackEndNodes().

◆ _num_points_from_provider

std::size_t CrackFrontDefinition::_num_points_from_provider

protected

Number of points coming from the CrackFrontPointsProvider.

Definition at line 386 of file CrackFrontDefinition.h.

Referenced by initialize(), initialSetup(), updateCrackFrontGeometry(), and updateNumberOfCrackFrontPoints().

◆ _ordered_crack_front_nodes

std::vector<dof_id_type> CrackFrontDefinition::_ordered_crack_front_nodes

protected

Crack front nodes ordered from the start to end of the crack front.

Definition at line 299 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), createQFunctionRings(), getCrackFrontNodePtr(), getNumCrackFrontPoints(), initialSetup(), isNodeInRing(), orderCrackFrontNodes(), and updateCrackFrontGeometry().

◆ _overall_length

Real CrackFrontDefinition::_overall_length

protected

Overall length of the crack.

Definition at line 317 of file CrackFrontDefinition.h.

Referenced by updateCrackFrontGeometry().

◆ _q_function_rings

bool CrackFrontDefinition::_q_function_rings

protected

Whether topological rings are used to define the q functions.

Definition at line 363 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and initialSetup().

◆ _q_function_type

MooseEnum CrackFrontDefinition::_q_function_type

protected

Method used to define the q function.

Definition at line 374 of file CrackFrontDefinition.h.

Referenced by initialize(), and initialSetup().

◆ _rot_matrix

std::vector<RankTwoTensor> CrackFrontDefinition::_rot_matrix

protected

Vector of rotation matrices along the crack front.

Definition at line 315 of file CrackFrontDefinition.h.

Referenced by rotateFromCrackFrontCoordsToGlobal(), rotateToCrackFrontCoords(), rotateToCrackFrontCoords(), and updateCrackFrontGeometry().

◆ _segment_lengths

std::vector<std::pair<Real, Real> > CrackFrontDefinition::_segment_lengths

protected

Vector of segment lengths along the crack front.

Definition at line 307 of file CrackFrontDefinition.h.

Referenced by getCrackFrontBackwardSegmentLength(), getCrackFrontForwardSegmentLength(), and updateCrackFrontGeometry().

◆ _strain_along_front

std::vector<Real> CrackFrontDefinition::_strain_along_front

protected

Vector of tangential strain along the crack front.

Definition at line 313 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), finalize(), getCrackFrontTangentialStrain(), initialSetup(), and updateCrackFrontGeometry().

◆ _symmetry_plane

unsigned int CrackFrontDefinition::_symmetry_plane

protected

Which plane is the symmetry plane.

Definition at line 353 of file CrackFrontDefinition.h.

Referenced by computeCrackMouthNodes(), and CrackFrontDefinition().

◆ _t_stress

bool CrackFrontDefinition::_t_stress

protected

Whether the T-stress is being computed.

Definition at line 361 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), execute(), finalize(), getCrackFrontTangentialStrain(), and initialSetup().

◆ _tangent_directions

std::vector<RealVectorValue> CrackFrontDefinition::_tangent_directions

protected

Vector of tangent directions along the crack front.

Definition at line 303 of file CrackFrontDefinition.h.

Referenced by calculateRThetaToCrackFront(), calculateTangentialStrainAlongFront(), getCrackFrontTangent(), and updateCrackFrontGeometry().

◆ _tol

const Real CrackFrontDefinition::_tol

protected

tolerance for matching nodes at crack front

Definition at line 388 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), calculateRThetaToCrackFront(), computeCurvedCrackFrontCrackPlaneNormals(), getCrackFrontNodes(), maxNodeCoor(), orderEndNodes(), pickLoopCrackEndNodes(), and updateCrackFrontGeometry().

◆ _treat_as_2d

bool CrackFrontDefinition::_treat_as_2d

protected

Whether to treat the model as 2D for computation of fracture integrals.

Definition at line 341 of file CrackFrontDefinition.h.

Referenced by calculateRThetaToCrackFront(), CrackFrontDefinition(), createQFunctionRings(), DomainIntegralQFunction(), execute(), getCrackFrontNodes(), initialSetup(), orderCrackFrontNodes(), treatAs2D(), and updateCrackFrontGeometry().

◆ _use_mesh_cutter

bool CrackFrontDefinition::_use_mesh_cutter

protected

Whether to describe the crack as a mesh cutter.

Definition at line 343 of file CrackFrontDefinition.h.

Referenced by computeCurvedCrackFrontCrackPlaneNormals(), createQFunctionRings(), getCrackFrontNodes(), initialize(), initialSetup(), orderCrackFrontNodes(), updateCrackFrontGeometry(), and usingMeshCutter().

The documentation for this class was generated from the following files:

solid_mechanics/include/userobjects/CrackFrontDefinition.h
solid_mechanics/src/userobjects/CrackFrontDefinition.C

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

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CRACK_GEOM_DEFINITION

◆ CRACK_NODE_TYPE

◆ DIRECTION_METHOD

◆ END_DIRECTION_METHOD

Constructor & Destructor Documentation

◆ CrackFrontDefinition()

Member Function Documentation

◆ addNodesToQFunctionRing()

◆ calculateCrackFrontDirection()

◆ calculateRThetaToCrackFront() [1/2]

◆ calculateRThetaToCrackFront() [2/2]

◆ calculateTangentialStrainAlongFront()

◆ computeCrackMouthNodes()

◆ computeCurvedCrackFrontCrackPlaneNormals()

◆ createQFunctionRings()

◆ DomainIntegralQFunction()

◆ DomainIntegralTopologicalQFunction()

◆ execute()

◆ finalize()

◆ getAngleAlongFront()

◆ getCrackDirection()

◆ getCrackFrontBackwardSegmentLength()

◆ getCrackFrontForwardSegmentLength()

◆ getCrackFrontNodePtr()

◆ getCrackFrontNodes()

◆ getCrackFrontNormal()

◆ getCrackFrontPoint()

◆ getCrackFrontTangent()

◆ getCrackFrontTangentialStrain()

◆ getDistanceAlongFront()

◆ getNumCrackFrontPoints()

◆ hasAngleAlongFront()

◆ hasCrackFrontNodes()

◆ includeCrackFrontDefinitionParams()

◆ initialize()

◆ initialSetup()

◆ isCutterModified()

◆ isNodeInRing()

◆ isNodeOnIntersectingBoundary()

◆ isPointWithIndexOnIntersectingBoundary()

◆ maxNodeCoor()

◆ orderCrackFrontNodes()

◆ orderEndNodes()

◆ pickLoopCrackEndNodes()

◆ projectToFrontAtPoint()

◆ rotateFromCrackFrontCoordsToGlobal()

◆ rotateToCrackFrontCoords() [1/2]

◆ rotateToCrackFrontCoords() [2/2]

◆ treatAs2D()

◆ updateCrackFrontGeometry()

◆ updateNumberOfCrackFrontPoints()

◆ usingMeshCutter()

◆ validParams()

Member Data Documentation

◆ _angles_along_front

◆ _aux

◆ _axis_2d

◆ _closed_loop

◆ _crack_direction_vector

◆ _crack_direction_vector_end_1

◆ _crack_direction_vector_end_2

◆ _crack_directions

◆ _crack_front_node_to_node_map

◆ _crack_front_points

◆ _crack_front_points_provider