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	~CrackFrontDefinition ()

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. More...

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

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

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

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. More...

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

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

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. More...

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

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. More...

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

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

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

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. More...

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. More...

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

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. More...

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. More...

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. More...

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. More...

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

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

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. More...

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. More...

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. More...

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

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

virtual Real	spatialValue (const Point &) const

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

void	gatherSum (T &value)

void	gatherMax (T &value)

void	gatherMin (T &value)

void	gatherProxyValueMax (T1 &value, T2 &proxy)

void	gatherProxyValueMin (T1 &value, T2 &proxy)

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

std::set< UserObjectName >	getDependObjects () const

virtual bool	needThreadedCopy () const

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

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

unsigned int	systemNumber () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &	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 &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &name, const std::string *param=nullptr) 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 UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) 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)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (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)

bool	getMaterialPropertyCalled () const

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

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

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

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

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

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

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	sort (typename std::vector< T > &vector)

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

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

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

Public Attributes
const ConsoleStream	_console

	ALL

	ANY

Static Public Attributes
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	DIRECTION_METHOD { DIRECTION_METHOD::CRACK_DIRECTION_VECTOR, DIRECTION_METHOD::CRACK_MOUTH, DIRECTION_METHOD::CURVED_CRACK_FRONT }
	Enum used to define the method for computing the crack extension direction. More...

enum	END_DIRECTION_METHOD { END_DIRECTION_METHOD::NO_SPECIAL_TREATMENT, END_DIRECTION_METHOD::END_CRACK_DIRECTION_VECTOR, END_DIRECTION_METHOD::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	CRACK_GEOM_DEFINITION { CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES, CRACK_GEOM_DEFINITION::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. More...

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. More...

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

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. More...

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

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

void	updateDataForCrackDirection ()
	Update the data structures used to determine the crack front direction vectors such as crack mouth coordinates. More...

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. More...

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

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. More...

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. More...

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. More...

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override

virtual void	addUserObjectDependencyHelper (const UserObject &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

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

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

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

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

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

void	markMatPropRequested (const std::string &)

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

void	checkExecutionStage ()

Moose::StateArg	determineState () const

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

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. More...

MooseMesh &	_mesh
	Reference to the mesh. More...

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

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

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

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

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

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

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

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

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

Real	_overall_length
	Overall length of the crack. More...

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

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

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

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

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

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

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

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

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

RealVectorValue	_crack_mouth_coordinates
	Coordinates of crack mouth. More...

RealVectorValue	_crack_plane_normal
	Vector normal to the crack plane of a planar crack. More...

std::vector< RealVectorValue >	_crack_plane_normals
	Vector normals to a nonplanar crack described by the cutter mesh when _use_mesh_cutter = true. More...

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

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

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

bool	_closed_loop
	Whether the crack forms a closed loop. More...

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

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

unsigned int	_symmetry_plane
	Which plane is the symmetry plane. More...

bool	_t_stress
	Whether the T-stress is being computed. More...

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

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

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

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. More...

MooseEnum	_q_function_type
	Method used to define the q function. More...

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

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

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

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

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

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

const THREAD_ID	_tid

Assembly &	_assembly

const Moose::CoordinateSystemType &	_coord_sys

const bool	_duplicate_initial_execution

std::set< std::string >	_depend_uo

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

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 &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

MooseApp &	_pg_moose_app

const std::string	_prefix

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

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. More...

std::string	_disp_y_var_name

std::string	_disp_z_var_name

Static Protected Attributes
static const Real	_tol = 1e-10
	Tolerance used in geometric calculations. More...

static const std::string	_interpolated_old

static const std::string	_interpolated_older

Detailed Description

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

Definition at line 31 of file CrackFrontDefinition.h.

Member Enumeration Documentation

◆ CRACK_GEOM_DEFINITION

enum 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 280 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 272 of file CrackFrontDefinition.h.

   {
     MIDDLE_NODE,
     END_1_NODE,
     END_2_NODE
   };

◆ DIRECTION_METHOD

enum 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 257 of file CrackFrontDefinition.h.

                                     {
     CRACK_DIRECTION_VECTOR,
     CRACK_MOUTH,
     CURVED_CRACK_FRONT
   } _direction_method;

◆ END_DIRECTION_METHOD

enum 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 265 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 111 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)
 {
   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.");
     if (!isParamValid("number_points_from_provider"))
       paramError("number_points_from_provider",
                  "CrackFrontDefinition error: When crack_front_points_provider is used, the "
                  "number_points_from_provider must be provided.");
 
     _num_points_from_provider = getParam<unsigned int>("number_points_from_provider");
     _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");
   }
 }

◆ ~CrackFrontDefinition()

CrackFrontDefinition::~CrackFrontDefinition ( )

virtual

Definition at line 276 of file CrackFrontDefinition.C.

276 {}

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 1769 of file CrackFrontDefinition.C.

Referenced by createQFunctionRings().

 {
   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());
     }
   }
 }

◆ 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 1116 of file CrackFrontDefinition.C.

Referenced by updateCrackFrontGeometry().

 {
   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)
     {
       if (_use_mesh_cutter)
         crack_dir = tangent_direction.cross(_crack_plane_normals[crack_front_point_index]);
       else
         crack_dir = tangent_direction.cross(_crack_plane_normal);
     }
   }
   crack_dir = crack_dir.unit();
 
   return crack_dir;
 }

◆ 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 1291 of file CrackFrontDefinition.C.

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

 {
   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;
   if (_use_mesh_cutter)
     crack_plane_normal = rotateToCrackFrontCoords(_crack_plane_normals[point_index], point_index);
   else
     crack_plane_normal = rotateToCrackFrontCoords(_crack_plane_normal, 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");
 }

◆ 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 1409 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 1472 of file CrackFrontDefinition.C.

Referenced by execute().

 {
   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;
   }
 }

◆ 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 1611 of file CrackFrontDefinition.C.

Referenced by initialSetup().

 {
   // 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 // 3D: 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());
       }
     }
   }
 }

◆ 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 1820 of file CrackFrontDefinition.C.

Referenced by JIntegral::execute().

 {
   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;
 }

◆ 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 1874 of file CrackFrontDefinition.C.

Referenced by JIntegral::execute().

 {
   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;
 }

◆ execute()

void CrackFrontDefinition::execute ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 279 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()
   // fixme Lynn Help with this Benjamin Spencer.  Not suer if this is true after this commit
   if (_t_stress == true && _treat_as_2d == false)
     calculateTangentialStrainAlongFront();
 }

◆ finalize()

void CrackFrontDefinition::finalize ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 383 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 1247 of file CrackFrontDefinition.C.

Referenced by JIntegral::finalize().

 {
   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];
 }

◆ 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 1229 of file CrackFrontDefinition.C.

Referenced by JIntegral::computeQpIntegral().

 {
   return _crack_directions[point_index];
 }

◆ 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 1223 of file CrackFrontDefinition.C.

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

 {
   return _segment_lengths[point_index].first;
 }

◆ 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 1217 of file CrackFrontDefinition.C.

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

 {
   return _segment_lengths[point_index].second;
 }

◆ 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 1187 of file CrackFrontDefinition.C.

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

 {
   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;
 }

◆ 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 390 of file CrackFrontDefinition.C.

Referenced by initialSetup().

 {
   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.");
         }
       }
     }
   }
 }

◆ 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 1196 of file CrackFrontDefinition.C.

Referenced by calculateRThetaToCrackFront(), JIntegral::finalize(), DomainIntegralQFunction::projectToFrontAtPoint(), projectToFrontAtPoint(), updateCrackFrontGeometry(), and updateDataForCrackDirection().

 {
   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];
   }
 }

◆ 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 1210 of file CrackFrontDefinition.C.

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

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

◆ 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 1595 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 1235 of file CrackFrontDefinition.C.

Referenced by JIntegral::finalize().

 {
   return _distances_along_front[point_index];
 }

◆ 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 1258 of file CrackFrontDefinition.C.

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

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

◆ 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 1241 of file CrackFrontDefinition.C.

Referenced by getAngleAlongFront(), and updateCrackFrontGeometry().

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

◆ 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 211 of file CrackFrontDefinition.h.

Referenced by CrackFrontData::initialize().

   {
     return _geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES;
   }

◆ initialize()

void CrackFrontDefinition::initialize ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 360 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)
   {
     _crack_front_points =
         _crack_front_points_provider->getCrackFrontPoints(_num_points_from_provider);
     _crack_plane_normals =
         _crack_front_points_provider->getCrackPlaneNormals(_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 289 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;
       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");
     }
   }
   if (_crack_front_points_provider != nullptr)
   {
     // TODO: For crack nucleation, should call a new method on the _crack_front_points_provider to
     // get the number of crack front points IF the crack_front_points_provider's initialSetup has
     // been called
     _crack_front_points =
         _crack_front_points_provider->getCrackFrontPoints(_num_points_from_provider);
     if (_use_mesh_cutter)
       _crack_plane_normals =
           _crack_front_points_provider->getCrackPlaneNormals(_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 1905 of file CrackFrontDefinition.C.

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

 {
   _is_cutter_modified = is_cutter_modified;
 }

◆ 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 1797 of file CrackFrontDefinition.C.

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

 {
   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;
 }

◆ 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 1435 of file CrackFrontDefinition.C.

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

 {
   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;
 }

◆ 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 1452 of file CrackFrontDefinition.C.

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

 {
   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;
 }

◆ 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 714 of file CrackFrontDefinition.C.

Referenced by pickLoopCrackEndNodes().

 {
   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();
 }

◆ 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 455 of file CrackFrontDefinition.C.

Referenced by initialSetup().

 {
   _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 std::map<dof_id_type, std::vector<dof_id_type>> & 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();
     }
   }
 }

◆ 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 602 of file CrackFrontDefinition.C.

Referenced by orderCrackFrontNodes().

 {
   // 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;
   }
 }

◆ 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 652 of file CrackFrontDefinition.C.

Referenced by orderCrackFrontNodes().

 {
   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));
 }

◆ 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 1887 of file CrackFrontDefinition.C.

Referenced by DomainIntegralQFunction().

 {
   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();
 }

◆ 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 1274 of file CrackFrontDefinition.C.

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

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

◆ rotateToCrackFrontCoords() [1/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 1267 of file CrackFrontDefinition.C.

Referenced by calculateRThetaToCrackFront().

 {
   return _rot_matrix[point_index] * vector;
 }

◆ rotateToCrackFrontCoords() [2/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 1282 of file CrackFrontDefinition.C.

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

◆ 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 124 of file CrackFrontDefinition.h.

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

124 { return _treat_as_2d; }

CrackFrontDefinition::_treat_as_2d

bool _treat_as_2d

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

Definition: CrackFrontDefinition.h:338

◆ 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 797 of file CrackFrontDefinition.C.

Referenced by initialize(), and initialSetup().

 {
   updateDataForCrackDirection();
 
   _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);
 
     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 =
             _crack_front_points_provider->getCrackPlaneNormals(num_crack_front_points);
         mooseAssert(!_crack_plane_normals.empty(), "_crack_plane_normals is empty.");
         rot_mat.fillRow(1, _crack_plane_normals[i]);
       }
       else
       {
         _crack_plane_normal = tangent_direction.cross(crack_direction);
         rot_mat.fillRow(1, _crack_plane_normal);
       }
       _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
   {
     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))
       {
         if (_use_mesh_cutter)
           _tangent_directions[i] = _crack_plane_normals[i].cross(_crack_directions[i]);
         else
           _tangent_directions[i] = _crack_plane_normal.cross(_crack_directions[i]);
       }
 
       back_segment = forward_segment;
       back_segment_len = forward_segment_len;
     }
 
     // For CURVED_CRACK_FRONT, _crack_plane_normal gets computed in updateDataForCrackDirection
     if (_direction_method != DIRECTION_METHOD::CURVED_CRACK_FRONT)
     {
       std::size_t mid_id = (num_crack_front_points - 1) / 2;
       _crack_plane_normal = _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_normal.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_normal);
       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]);
       if (_use_mesh_cutter)
         rot_mat.fillRow(1, _crack_plane_normals[i]);
       else
         rot_mat.fillRow(1, _crack_plane_normal);
       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;
   }
 }

◆ updateDataForCrackDirection()

void CrackFrontDefinition::updateDataForCrackDirection ( )

protected

Update the data structures used to determine the crack front direction vectors such as crack mouth coordinates.

Definition at line 1035 of file CrackFrontDefinition.C.

Referenced by updateCrackFrontGeometry().

 {
   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;
   }
 
   if (_direction_method == DIRECTION_METHOD::CURVED_CRACK_FRONT && !_use_mesh_cutter)
   {
     _crack_plane_normal.zero();
 
     // 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
     _crack_plane_normal = v1.cross(v2);
     _crack_plane_normal = _crack_plane_normal.unit();
 
     // Make sure they're not collinear
     RealVectorValue zero_vec(0.0);
     if (_crack_plane_normal.absolute_fuzzy_equals(zero_vec, _tol))
     {
       mooseError("Nodes on crack front are too close to being collinear");
     }
   }
 }

◆ 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 1181 of file CrackFrontDefinition.C.

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

 {
   _num_points_from_provider = num_points;
 }

◆ 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 130 of file CrackFrontDefinition.h.

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

130 { return _use_mesh_cutter; }

CrackFrontDefinition::_use_mesh_cutter

bool _use_mesh_cutter

Whether to describe the crack as a mesh cutter.

Definition: CrackFrontDefinition.h:340

◆ validParams()

InputParameters CrackFrontDefinition::validParams ( )

static

Definition at line 24 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();
   addCrackFrontDefinitionParams(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 306 of file CrackFrontDefinition.h.

Referenced by getAngleAlongFront(), and updateCrackFrontGeometry().

◆ _aux

AuxiliarySystem& CrackFrontDefinition::_aux

protected

Reference to the auxiliary system.

Definition at line 287 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 346 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 344 of file CrackFrontDefinition.h.

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

◆ _crack_direction_vector

RealVectorValue CrackFrontDefinition::_crack_direction_vector

protected

Fixed vector optionally used to define crack extension direction.

Definition at line 314 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 316 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 318 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 300 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 369 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 296 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 381 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 326 of file CrackFrontDefinition.h.

Referenced by initialSetup(), and updateDataForCrackDirection().

◆ _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 324 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 332 of file CrackFrontDefinition.h.

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

◆ _crack_plane_normal

RealVectorValue CrackFrontDefinition::_crack_plane_normal

protected

Vector normal to the crack plane of a planar crack.

Definition at line 334 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), calculateRThetaToCrackFront(), updateCrackFrontGeometry(), and updateDataForCrackDirection().

◆ _crack_plane_normals

std::vector<RealVectorValue> CrackFrontDefinition::_crack_plane_normals

protected

Vector normals to a nonplanar crack described by the cutter mesh when _use_mesh_cutter = true.

Definition at line 336 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), calculateRThetaToCrackFront(), initialize(), initialSetup(), 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 320 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 322 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and updateCrackFrontGeometry().

◆ _direction_method

enum CrackFrontDefinition::DIRECTION_METHOD CrackFrontDefinition::_direction_method

protected

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

◆ _disp_x_var_name

std::string CrackFrontDefinition::_disp_x_var_name

protected

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

Definition at line 353 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), and CrackFrontDefinition().

◆ _disp_y_var_name

std::string CrackFrontDefinition::_disp_y_var_name

protected

Definition at line 354 of file CrackFrontDefinition.h.

Referenced by calculateTangentialStrainAlongFront(), and CrackFrontDefinition().

◆ _disp_z_var_name

std::string CrackFrontDefinition::_disp_z_var_name

protected

Definition at line 355 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 304 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 364 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 348 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and updateDataForCrackDirection().

◆ _intersecting_boundary_ids

std::vector<BoundaryID> CrackFrontDefinition::_intersecting_boundary_ids

protected

IDs of boundaries that intersect crack at its ends.

Definition at line 330 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 328 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 342 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 374 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 376 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 378 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 362 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and createQFunctionRings().

◆ _mesh

MooseMesh& CrackFrontDefinition::_mesh

protected

Reference to the mesh.

Definition at line 289 of file CrackFrontDefinition.h.

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

◆ _num_points_from_provider

std::size_t CrackFrontDefinition::_num_points_from_provider

protected

Number of points coming from the CrackFrontPointsProvider.

Definition at line 383 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), initialize(), initialSetup(), 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 294 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 312 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 360 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 371 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 310 of file CrackFrontDefinition.h.

Referenced by rotateFromCrackFrontCoordsToGlobal(), 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 302 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 308 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 350 of file CrackFrontDefinition.h.

Referenced by CrackFrontDefinition(), and updateDataForCrackDirection().

◆ _t_stress

bool CrackFrontDefinition::_t_stress

protected

Whether the T-stress is being computed.

Definition at line 358 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 298 of file CrackFrontDefinition.h.

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

◆ _tol

const Real CrackFrontDefinition::_tol = 1e-10

staticprotected

Tolerance used in geometric calculations.

Definition at line 291 of file CrackFrontDefinition.h.

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

◆ _treat_as_2d

bool CrackFrontDefinition::_treat_as_2d

protected

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

Definition at line 338 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 340 of file CrackFrontDefinition.h.

Referenced by calculateCrackFrontDirection(), calculateRThetaToCrackFront(), createQFunctionRings(), getCrackFrontNodes(), initialize(), initialSetup(), orderCrackFrontNodes(), updateCrackFrontGeometry(), updateDataForCrackDirection(), 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

Detailed Description

Member Enumeration Documentation

◆ CRACK_GEOM_DEFINITION

◆ CRACK_NODE_TYPE

◆ DIRECTION_METHOD

◆ END_DIRECTION_METHOD

Constructor & Destructor Documentation

◆ CrackFrontDefinition()

◆ ~CrackFrontDefinition()

Member Function Documentation

◆ addNodesToQFunctionRing()

◆ calculateCrackFrontDirection()

◆ calculateRThetaToCrackFront() [1/2]

◆ calculateRThetaToCrackFront() [2/2]

◆ calculateTangentialStrainAlongFront()

◆ createQFunctionRings()

◆ DomainIntegralQFunction()

◆ DomainIntegralTopologicalQFunction()

◆ execute()

◆ finalize()

◆ getAngleAlongFront()

◆ getCrackDirection()

◆ getCrackFrontBackwardSegmentLength()

◆ getCrackFrontForwardSegmentLength()

◆ getCrackFrontNodePtr()

◆ getCrackFrontNodes()

◆ getCrackFrontPoint()

◆ getCrackFrontTangent()

◆ getCrackFrontTangentialStrain()

◆ getDistanceAlongFront()

◆ getNumCrackFrontPoints()

◆ hasAngleAlongFront()

◆ hasCrackFrontNodes()

◆ initialize()

◆ initialSetup()

◆ isCutterModified()

◆ isNodeInRing()

◆ isNodeOnIntersectingBoundary()

◆ isPointWithIndexOnIntersectingBoundary()

◆ maxNodeCoor()

◆ orderCrackFrontNodes()

◆ orderEndNodes()

◆ pickLoopCrackEndNodes()

◆ projectToFrontAtPoint()

◆ rotateFromCrackFrontCoordsToGlobal()

◆ rotateToCrackFrontCoords() [1/2]

◆ rotateToCrackFrontCoords() [2/2]

◆ treatAs2D()

◆ updateCrackFrontGeometry()

◆ updateDataForCrackDirection()

◆ 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

◆ _crack_mouth_boundary_ids

◆ _crack_mouth_boundary_names

◆ _crack_mouth_coordinates

◆ _crack_plane_normal

◆ _crack_plane_normals