Peridynamics mesh class. More...

#include <PeridynamicsMesh.h>

Inheritance diagram for PeridynamicsMesh:

Public Types
enum	ParallelType { ParallelType::DEFAULT, ParallelType::REPLICATED, ParallelType::DISTRIBUTED }

typedef std::pair< const Node *, BoundaryID >	PeriodicNodeInfo

typedef DataFileName	DataFileParameterType

Public Member Functions
	PeridynamicsMesh (const InputParameters &parameters)

	PeridynamicsMesh (const PeridynamicsMesh &)=default

PeridynamicsMesh &	operator= (const PeridynamicsMesh &other_mesh)=delete

virtual std::unique_ptr< MooseMesh >	safeClone () const override

virtual void	buildMesh () override

virtual unsigned int	dimension () const override

dof_id_type	nPDNodes () const
	Function to return number of PD nodes. More...

dof_id_type	nPDBonds () const
	Function to return number of PD Edge elements. More...

void	createPeridynamicsMeshData (MeshBase &fe_mesh, std::set< dof_id_type > converted_elem_id, std::multimap< SubdomainID, SubdomainID > bonding_block_pairs, std::multimap< SubdomainID, SubdomainID > non_bonding_block_pairs)
	Function to assign values to member variables (PD mesh data) of this class this function will be called in the PD mesh generator class. More...

std::vector< dof_id_type >	getNeighbors (dof_id_type node_id)
	Function to return neighbor nodes indices for node node_id. More...

dof_id_type	getNeighborIndex (dof_id_type node_i, dof_id_type node_j)
	Function to return the local neighbor index of node_j from node_i's neighbor list. More...

std::vector< dof_id_type >	getBonds (dof_id_type node_id)
	Function to return the bond number connected with node node_id. More...

std::vector< dof_id_type >	getBondDeformationGradientNeighbors (dof_id_type node_id, dof_id_type neighbor_id)
	Function to return indices of neighbors used in formulation of bond-associated deformation gradient for bond connecting node_id and neighbor_id. More...

SubdomainID	getNodeBlockID (dof_id_type node_id)
	Function to return block ID for node node_id. More...

void	setNodeBlockID (SubdomainID id)
	Function to set block ID for all PD nodes. More...

Point	getNodeCoord (dof_id_type node_id)
	Function to return coordinates for node node_id. More...

std::vector< dof_id_type >	getPDNodeIDToFEElemIDMap ()
	Function to return the correspondence between PD node IDs and FE element IDs. More...

Real	getNodeVolume (dof_id_type node_id)
	Function to return nodal volume for node node_id. More...

Real	getHorizonVolume (dof_id_type node_id)
	Function to return summation of neighbor nodal volumes for node node_id. More...

Real	getHorizonSubsetVolume (dof_id_type node_id, dof_id_type neighbor_id)
	Function to return the volume of a horizon subset for bond-associated deformation gradient calculation for bond connecting node node_id and its neighbor neighbor_id. More...

Real	getHorizonSubsetVolumeSum (dof_id_type node_id)
	Function to return the summation of all horizon subset volumes for node node_id. More...

Real	getHorizonSubsetVolumeFraction (dof_id_type node_id, dof_id_type neighbor_id)
	Function to return the volume fraction of a horizon subset used for bond-associated deformation gradient calculation for bond connecting node node_id and its neighbor neighbor_id. More...

Real	getNodeAverageSpacing (dof_id_type node_id)
	Function to return the average spacing between node node_id with its most adjacent neighbors. More...

Real	getHorizon (dof_id_type node_id)
	Function to return horizon size. More...

Real	getBoundaryOffset (dof_id_type node_id)
	Function to return offset for boundary nodes. More...

Real	getNeighborWeight (dof_id_type node_id, dof_id_type neighbor_id)
	Function to return normalized weight for neighbor neighbor_id of node node_id based on predefined weight function. More...

virtual MooseMesh &	clone () const

void	determineUseDistributedMesh ()

std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< T >	buildTypedMesh (unsigned int dim=libMesh::invalid_uint)

void	setMeshBase (std::unique_ptr< MeshBase > mesh_base)

virtual void	init ()

virtual unsigned int	spatialDimension () const

virtual unsigned int	effectiveSpatialDimension () const

unsigned int	getBlocksMaxDimension (const std::vector< SubdomainName > &blocks) const

std::vector< BoundaryID >	getBoundaryIDs (const Elem *const elem, const unsigned short int side) const

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

std::vector< BoundaryID >	getBoundaryIDs (const std::vector< BoundaryName > &boundary_name, bool generate_unknown=false) const

const Elem *	getLowerDElem (const Elem *, unsigned short int) const

unsigned int	getHigherDSide (const Elem *elem) const

void	buildNodeList ()

void	buildBndElemList ()

const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToElemMap ()

const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToActiveSemilocalElemMap ()

virtual bnd_node_iterator	bndNodesBegin ()

virtual bnd_node_iterator	bndNodesEnd ()

virtual bnd_elem_iterator	bndElemsBegin ()

virtual bnd_elem_iterator	bndElemsEnd ()

void	buildNodeListFromSideList ()

void	buildSideList (std::vector< dof_id_type > &el, std::vector< unsigned short int > &sl, std::vector< boundary_id_type > &il)

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildSideList ()

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildActiveSideList () const

unsigned int	sideWithBoundaryID (const Elem *const elem, const BoundaryID boundary_id) const

MeshBase::node_iterator	localNodesBegin ()

MeshBase::const_node_iterator	localNodesBegin () const

MeshBase::node_iterator	localNodesEnd ()

MeshBase::const_node_iterator	localNodesEnd () const

MeshBase::element_iterator	activeLocalElementsBegin ()

MeshBase::const_element_iterator	activeLocalElementsBegin () const

const MeshBase::element_iterator	activeLocalElementsEnd ()

const MeshBase::const_element_iterator	activeLocalElementsEnd () const

virtual dof_id_type	nNodes () const

virtual dof_id_type	nElem () const

virtual dof_id_type	nLocalNodes () const

virtual dof_id_type	nActiveElem () const

virtual dof_id_type	nActiveLocalElem () const

virtual SubdomainID	nSubdomains () const

virtual unsigned int	nPartitions () const

virtual bool	skipPartitioning () const

virtual bool	skipNoncriticalPartitioning () const

virtual dof_id_type	maxNodeId () const

virtual dof_id_type	maxElemId () const

virtual const Node &	node (const dof_id_type i) const

virtual Node &	node (const dof_id_type i)

virtual const Node &	nodeRef (const dof_id_type i) const

virtual Node &	nodeRef (const dof_id_type i)

virtual const Node *	nodePtr (const dof_id_type i) const

virtual Node *	nodePtr (const dof_id_type i)

virtual const Node *	queryNodePtr (const dof_id_type i) const

virtual Node *	queryNodePtr (const dof_id_type i)

virtual Elem *	elem (const dof_id_type i)

virtual const Elem *	elem (const dof_id_type i) const

virtual Elem *	elemPtr (const dof_id_type i)

virtual const Elem *	elemPtr (const dof_id_type i) const

virtual Elem *	queryElemPtr (const dof_id_type i)

virtual const Elem *	queryElemPtr (const dof_id_type i) const

bool	prepared () const

virtual void	prepared (bool state)

void	needsPrepareForUse ()

void	meshChanged ()

virtual void	onMeshChanged ()

void	cacheChangedLists ()

ConstElemPointerRange *	refinedElementRange () const

ConstElemPointerRange *	coarsenedElementRange () const

const std::vector< const Elem *> &	coarsenedElementChildren (const Elem *elem) const

void	updateActiveSemiLocalNodeRange (std::set< dof_id_type > &ghosted_elems)

bool	isSemiLocal (Node *const node) const

const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > &	getBoundariesToElems () const

const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > &	getBoundariesToActiveSemiLocalElemIds () const

std::unordered_set< dof_id_type >	getBoundaryActiveSemiLocalElemIds (BoundaryID bid) const

std::unordered_set< dof_id_type >	getBoundaryActiveNeighborElemIds (BoundaryID bid) const

bool	isBoundaryFullyExternalToSubdomains (BoundaryID bid, const std::set< SubdomainID > &blk_group) const

const std::set< SubdomainID > &	meshSubdomains () const

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

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

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

void	setBoundaryToNormalMap (std::unique_ptr< std::map< BoundaryID, RealVectorValue >> boundary_map)

void	setBoundaryToNormalMap (std::map< BoundaryID, RealVectorValue > *boundary_map)

void	setMeshBoundaryIDs (std::set< BoundaryID > boundary_IDs)

const RealVectorValue &	getNormalByBoundaryID (BoundaryID id) const

bool	prepare (const MeshBase *mesh_to_clone)

void	update ()

unsigned int	uniformRefineLevel () const

void	setUniformRefineLevel (unsigned int, bool deletion=true)

bool	skipDeletionRepartitionAfterRefine () const

bool	skipRefineWhenUseSplit () const

void	addGhostedBoundary (BoundaryID boundary_id)

void	setGhostedBoundaryInflation (const std::vector< Real > &inflation)

const std::set< unsigned int > &	getGhostedBoundaries () const

const std::vector< Real > &	getGhostedBoundaryInflation () const

void	ghostGhostedBoundaries ()

void	needGhostGhostedBoundaries (bool needghost)

unsigned int	getPatchSize () const

unsigned int	getGhostingPatchSize () const

unsigned int	getMaxLeafSize () const

void	setPatchUpdateStrategy (Moose::PatchUpdateType patch_update_strategy)

const Moose::PatchUpdateType &	getPatchUpdateStrategy () const

libMesh::BoundingBox	getInflatedProcessorBoundingBox (Real inflation_multiplier=0.01) const

	operator libMesh::MeshBase & ()

	operator const libMesh::MeshBase & () const

MeshBase &	getMesh ()

MeshBase &	getMesh (const std::string &name)

const MeshBase &	getMesh () const

const MeshBase &	getMesh (const std::string &name) const

const MeshBase *	getMeshPtr () const

void	printInfo (std::ostream &os=libMesh::out, const unsigned int verbosity=0) const

const std::set< SubdomainID > &	getNodeBlockIds (const Node &node) const

const std::vector< dof_id_type > &	getNodeList (boundary_id_type nodeset_id) const

const Node *	addUniqueNode (const Point &p, Real tol=1e-6)

Node *	addQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)

Node *	getQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp)

void	clearQuadratureNodes ()

BoundaryID	getBoundaryID (const BoundaryName &boundary_name) const

SubdomainID	getSubdomainID (const SubdomainName &subdomain_name) const

std::vector< SubdomainID >	getSubdomainIDs (const std::vector< SubdomainName > &subdomain_names) const

std::set< SubdomainID >	getSubdomainIDs (const std::set< SubdomainName > &subdomain_names) const

void	setSubdomainName (SubdomainID subdomain_id, const SubdomainName &name)

const std::string &	getSubdomainName (SubdomainID subdomain_id) const

std::vector< SubdomainName >	getSubdomainNames (const std::vector< SubdomainID > &subdomain_ids) const

void	setBoundaryName (BoundaryID boundary_id, BoundaryName name)

const std::string &	getBoundaryName (BoundaryID boundary_id)

void	buildPeriodicNodeMap (std::multimap< dof_id_type, dof_id_type > &periodic_node_map, unsigned int var_number, libMesh::PeriodicBoundaries *pbs) const

void	buildPeriodicNodeSets (std::map< BoundaryID, std::set< dof_id_type >> &periodic_node_sets, unsigned int var_number, libMesh::PeriodicBoundaries *pbs) const

Real	dimensionWidth (unsigned int component) const

bool	detectOrthogonalDimRanges (Real tol=1e-6)

void	addPeriodicVariable (unsigned int var_num, BoundaryID primary, BoundaryID secondary)

bool	isTranslatedPeriodic (unsigned int nonlinear_var_num, unsigned int component) const

RealVectorValue	minPeriodicVector (unsigned int nonlinear_var_num, Point p, Point q) const

Real	minPeriodicDistance (unsigned int nonlinear_var_num, Point p, Point q) const

const std::pair< BoundaryID, BoundaryID > *	getPairedBoundaryMapping (unsigned int component)

void	buildRefinementAndCoarseningMaps (Assembly *assembly)

const std::vector< std::vector< QpMap > > &	getRefinementMap (const Elem &elem, int parent_side, int child, int child_side)

const std::vector< std::pair< unsigned int, QpMap > > &	getCoarseningMap (const Elem &elem, int input_side)

void	changeBoundaryId (const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)

const std::set< BoundaryID > &	getSubdomainBoundaryIds (const SubdomainID subdomain_id) const

std::set< BoundaryID >	getSubdomainInterfaceBoundaryIds (const SubdomainID subdomain_id) const

std::set< SubdomainID >	getBoundaryConnectedBlocks (const BoundaryID bid) const

std::set< SubdomainID >	getBoundaryConnectedSecondaryBlocks (const BoundaryID bid) const

std::set< SubdomainID >	getInterfaceConnectedBlocks (const BoundaryID bid) const

const std::set< SubdomainID > &	getBlockConnectedBlocks (const SubdomainID subdomain_id) const

bool	isBoundaryNode (dof_id_type node_id) const

bool	isBoundaryNode (dof_id_type node_id, BoundaryID bnd_id) const

bool	isBoundaryElem (dof_id_type elem_id) const

bool	isBoundaryElem (dof_id_type elem_id, BoundaryID bnd_id) const

void	errorIfDistributedMesh (std::string name) const

virtual bool	isDistributedMesh () const

bool	isParallelTypeForced () const

void	setParallelType (ParallelType parallel_type)

ParallelType	getParallelType () const

const MooseEnum &	partitionerName () const

bool	isPartitionerForced () const

void	allowRecovery (bool allow)

void	setCustomPartitioner (libMesh::Partitioner *partitioner)

bool	isRegularOrthogonal ()

bool	hasSecondOrderElements ()

virtual std::unique_ptr< libMesh::PointLocatorBase >	getPointLocator () const

virtual std::string	getFileName () const

void	needsRemoteElemDeletion (bool need_delete)

bool	needsRemoteElemDeletion () const

void	allowRemoteElementRemoval (bool allow_removal)

bool	allowRemoteElementRemoval () const

void	deleteRemoteElements ()

bool	hasMeshBase () const

bool	hasElementID (const std::string &id_name) const

unsigned int	getElementIDIndex (const std::string &id_name) const

dof_id_type	maxElementID (unsigned int elem_id_index) const

dof_id_type	minElementID (unsigned int elem_id_index) const

bool	areElemIDsIdentical (const std::string &id_name1, const std::string &id_name2) const

std::set< dof_id_type >	getAllElemIDs (unsigned int elem_id_index) const

std::set< dof_id_type >	getElemIDsOnBlocks (unsigned int elem_id_index, const std::set< SubdomainID > &blks) const

std::unordered_map< dof_id_type, std::set< dof_id_type > >	getElemIDMapping (const std::string &from_id_name, const std::string &to_id_name) const

void	cacheFaceInfoVariableOwnership () const

void	cacheFVElementalDoFs () const

void	computeFiniteVolumeCoords () const

void	isDisplaced (bool is_displaced)

bool	isDisplaced () const

const std::map< boundary_id_type, std::vector< dof_id_type > > &	nodeSetNodes () const

Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const

const std::map< SubdomainID, Moose::CoordinateSystemType > &	getCoordSystem () const

Moose::CoordinateSystemType	getUniqueCoordSystem () const

void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)

void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)

void	setGeneralAxisymmetricCoordAxes (const std::vector< SubdomainName > &blocks, const std::vector< std::pair< Point, RealVectorValue >> &axes)

const std::pair< Point, RealVectorValue > &	getGeneralAxisymmetricCoordAxis (SubdomainID subdomain_id) const

bool	usingGeneralAxisymmetricCoordAxes () const

unsigned int	getAxisymmetricRadialCoord () const

void	checkCoordinateSystems ()

void	setCoordData (const MooseMesh &other_mesh)

void	markFiniteVolumeInfoDirty ()

bool	isFiniteVolumeInfoDirty () const

MooseAppCoordTransform &	coordTransform ()

const MooseUnits &	lengthUnit () const

const std::unordered_map< std::pair< const Elem , unsigned short int >, const Elem > &	getLowerDElemMap () const

bool	isSplit () const

void	buildFiniteVolumeInfo () const

void	setupFiniteVolumeMeshData () const

void	doingPRefinement (bool doing_p_refinement)

bool	doingPRefinement () const

unsigned int	maxPLevel () const

unsigned int	maxHLevel () const

const std::vector< QpMap > &	getPRefinementMap (const Elem &elem) const

const std::vector< QpMap > &	getPRefinementSideMap (const Elem &elem) const

const std::vector< QpMap > &	getPCoarseningMap (const Elem &elem) const

const std::vector< QpMap > &	getPCoarseningSideMap (const Elem &elem) const

void	buildPRefinementAndCoarseningMaps (Assembly *assembly)

bool	isLowerD (const SubdomainID subdomain_id) const

bool	hasLowerD () const

const std::set< SubdomainID > &	interiorLowerDBlocks () const

const std::set< SubdomainID > &	boundaryLowerDBlocks () const

bool	getConstructNodeListFromSideList ()

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 *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &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 &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

libMesh::ConstElemRange *	getActiveLocalElementRange ()

libMesh::ConstElemRange *	getActiveLocalElementRange ()

libMesh::NodeRange *	getActiveNodeRange ()

libMesh::NodeRange *	getActiveNodeRange ()

SemiLocalNodeRange *	getActiveSemiLocalNodeRange () const

SemiLocalNodeRange *	getActiveSemiLocalNodeRange () const

libMesh::ConstNodeRange *	getLocalNodeRange ()

libMesh::ConstNodeRange *	getLocalNodeRange ()

libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode >	getBoundaryNodeRange ()

libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode >	getBoundaryNodeRange ()

libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement >	getBoundaryElementRange ()

libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement >	getBoundaryElementRange ()

virtual Real	getMinInDimension (unsigned int component) const

virtual Real	getMinInDimension (unsigned int component) const

virtual Real	getMaxInDimension (unsigned int component) const

virtual Real	getMaxInDimension (unsigned int component) const

bool	isCustomPartitionerRequested () const

bool	isCustomPartitionerRequested () const

void	setIsCustomPartitionerRequested (bool cpr)

void	setIsCustomPartitionerRequested (bool cpr)

unsigned int	nFace () const

unsigned int	nFace () const

const std::vector< const FaceInfo *> &	faceInfo () const

const FaceInfo *	faceInfo (const Elem *elem, unsigned int side) const

const std::vector< const FaceInfo *> &	faceInfo () const

const FaceInfo *	faceInfo (const Elem *elem, unsigned int side) const

face_info_iterator	ownedFaceInfoBegin ()

face_info_iterator	ownedFaceInfoBegin ()

face_info_iterator	ownedFaceInfoEnd ()

face_info_iterator	ownedFaceInfoEnd ()

elem_info_iterator	ownedElemInfoBegin ()

elem_info_iterator	ownedElemInfoBegin ()

elem_info_iterator	ownedElemInfoEnd ()

elem_info_iterator	ownedElemInfoEnd ()

const ElemInfo &	elemInfo (const dof_id_type id) const

const ElemInfo &	elemInfo (const dof_id_type id) const

const std::vector< const ElemInfo *> &	elemInfoVector () const

const std::vector< const ElemInfo *> &	elemInfoVector () const

const std::vector< FaceInfo > &	allFaceInfo () const

const std::vector< FaceInfo > &	allFaceInfo () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	setSubdomainName (MeshBase &mesh, SubdomainID subdomain_id, const SubdomainName &name)

static void	changeBoundaryId (MeshBase &mesh, const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)

static MooseEnum	partitioning ()

static MooseEnum	elemTypes ()

static void	setPartitioner (MeshBase &mesh_base, MooseEnum &partitioner, bool use_distributed_mesh, const InputParameters &params, MooseObject &context_obj)

Public Attributes
const ConsoleStream	_console

Protected Types
typedef std::vector< BndNode *>::iterator	bnd_node_iterator_imp

typedef std::vector< BndNode *>::const_iterator	const_bnd_node_iterator_imp

typedef std::vector< BndElement *>::iterator	bnd_elem_iterator_imp

typedef std::vector< BndElement *>::const_iterator	const_bnd_elem_iterator_imp

Protected Member Functions
void	createNodeHorizBasedData (std::multimap< SubdomainID, SubdomainID > bonding_block_pairs, std::multimap< SubdomainID, SubdomainID > non_bonding_block_pairs)
	Function to create neighbors and other data for each material point with given horizon. More...

bool	checkInterface (SubdomainID pdnode_blockID_i, SubdomainID pdnode_blockID_j, std::multimap< SubdomainID, SubdomainID > blockID_pairs)
	Function to check existence of interface between two blocks. More...

void	createNeighborHorizonBasedData ()
	Function to create node neighbors and other data for each material point based on NEIGHBOR_HORIZON based horizon partition for deformation gradient calculation. More...

bool	checkPointInsideRectangle (Point point, Point rec_p1, Point rec_p2, Real rec_height, Real tol=0)
	Function to check whether a material point falls within a given rectangular crack geometry. More...

bool	checkCrackIntersectBond (Point crack_p1, Point crack_p2, Real crack_width, Point bond_p1, Point bond_p2)
	Function to check whether a bond crosses crack surface. More...

bool	checkSegmentIntersectSegment (Point seg1_p1, Point seg1_p2, Point seg2_p1, Point seg2_p2)
	Function to check whether a segment crosses another segment. More...

void	cacheInfo ()

void	freeBndNodes ()

void	freeBndElems ()

void	setPartitionerHelper (MeshBase *mesh=nullptr)

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

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

Protected Attributes
unsigned int &	_dim
	Mesh dimension. More...

unsigned int &	_n_pdnodes
	Number of total material points. More...

unsigned int &	_n_pdbonds
	Number of total bonds. More...

std::vector< std::vector< dof_id_type > > &	_pdnode_neighbors
	Neighbor lists for each material point determined using the horizon. More...

std::vector< std::vector< dof_id_type > > &	_pdnode_bonds
	Bond lists associated with material points. More...

std::vector< std::vector< std::vector< dof_id_type > > > &	_dg_neighbors
	Neighbor lists for deformation gradient calculation using bond-associated horizon. More...

std::vector< std::vector< Real > > &	_pdnode_sub_vol
	Volume of horizon subsets for bond-associated deformation gradients at a node. More...

std::vector< Real > &	_pdnode_sub_vol_sum
	Summation of volumes of all horizon subsets at a node. More...

std::map< dof_id_type, Real > &	_boundary_node_offset
	Offset of each boundary node to its original FE element boundary edge or face. More...

std::vector< Real > &	_pdnode_weight_normalizer
	normalizer for calculating weighted values at a node from elemental values within its horizon More...

	X

	Y

	Z

	MIN

	MAX

std::vector< std::unique_ptr< libMesh::GhostingFunctor > >	_ghosting_functors

std::vector< std::shared_ptr< RelationshipManager > >	_relationship_managers

bool	_built_from_other_mesh

ParallelType	_parallel_type

bool	_use_distributed_mesh

bool	_distribution_overridden

bool	_parallel_type_overridden

std::unique_ptr< libMesh::MeshBase >	_mesh

MooseEnum	_partitioner_name

bool	_partitioner_overridden

std::unique_ptr< libMesh::Partitioner >	_custom_partitioner

bool	_custom_partitioner_requested

unsigned int	_uniform_refine_level

bool	_skip_refine_when_use_split

bool	_skip_deletion_repartition_after_refine

bool	_is_changed

bool	_is_nemesis

bool	_moose_mesh_prepared

std::unique_ptr< ConstElemPointerRange >	_refined_elements

std::unique_ptr< ConstElemPointerRange >	_coarsened_elements

std::map< const Elem , std::vector< const Elem > >	_coarsened_element_children

std::set< Node *>	_semilocal_node_list

std::unique_ptr< libMesh::ConstElemRange >	_active_local_elem_range

std::unique_ptr< SemiLocalNodeRange >	_active_semilocal_node_range

std::unique_ptr< libMesh::NodeRange >	_active_node_range

std::unique_ptr< libMesh::ConstNodeRange >	_local_node_range

std::unique_ptr< libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode *> >	_bnd_node_range

std::unique_ptr< libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement *> >	_bnd_elem_range

std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_elem_map

bool	_node_to_elem_map_built

std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_active_semilocal_elem_map

bool	_node_to_active_semilocal_elem_map_built

std::set< SubdomainID >	_mesh_subdomains

std::unique_ptr< std::map< BoundaryID, RealVectorValue > >	_boundary_to_normal_map

std::vector< BndNode *>	_bnd_nodes

std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_node_ids

std::vector< BndElement *>	_bnd_elems

std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > >	_bnd_elem_ids

std::map< dof_id_type, Node *>	_quadrature_nodes

std::map< dof_id_type, std::map< unsigned int, std::map< dof_id_type, Node *> > >	_elem_to_side_to_qp_to_quadrature_nodes

std::vector< BndNode >	_extra_bnd_nodes

std::map< dof_id_type, std::set< SubdomainID > >	_block_node_list

std::map< boundary_id_type, std::vector< dof_id_type > >	_node_set_nodes

std::set< unsigned int >	_ghosted_boundaries

std::vector< Real >	_ghosted_boundaries_inflation

unsigned int	_patch_size

unsigned int	_ghosting_patch_size

unsigned int	_max_leaf_size

Moose::PatchUpdateType	_patch_update_strategy

std::vector< Node *>	_node_map

bool	_regular_orthogonal_mesh

std::vector< std::vector< Real > >	_bounds

std::vector< std::pair< BoundaryID, BoundaryID > >	_paired_boundary

const bool	_is_split

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

MooseApp &	_pg_moose_app

const std::string	_prefix

std::set< BoundaryID >	_mesh_boundary_ids

std::set< BoundaryID >	_mesh_sideset_ids

std::set< BoundaryID >	_mesh_nodeset_ids

const Parallel::Communicator &	_communicator


const Real	_horizon_radius
	Horizon size control parameters. More...

const bool	_has_horizon_number

const Real	_horizon_number

const Real	_bah_ratio


const bool	_has_cracks
	Information for crack generation. More...

std::vector< Point >	_cracks_start

std::vector< Point >	_cracks_end

std::vector< Real >	_cracks_width


std::vector< Point >	_pdnode_coord
	Data associated with each peridynamics node. More...

std::vector< Real > &	_pdnode_average_spacing

std::vector< Real > &	_pdnode_horizon_radius

std::vector< Real > &	_pdnode_vol

std::vector< Real > &	_pdnode_horizon_vol

std::vector< SubdomainID > &	_pdnode_blockID

std::vector< dof_id_type > &	_pdnode_elemID

Detailed Description

Peridynamics mesh class.

Definition at line 20 of file PeridynamicsMesh.h.

Constructor & Destructor Documentation

◆ PeridynamicsMesh() [1/2]

PeridynamicsMesh::PeridynamicsMesh ( const InputParameters & parameters )

Definition at line 41 of file PeridynamicsMesh.C.

   : MooseMesh(parameters),
     _horizon_radius(isParamValid("horizon_radius") ? getParam<Real>("horizon_radius") : 0),
     _has_horizon_number(isParamValid("horizon_number")),
     _horizon_number(_has_horizon_number ? getParam<Real>("horizon_number") : 0),
     _bah_ratio(getParam<Real>("bond_associated_horizon_ratio")),
     _has_cracks(isParamValid("cracks_start") || isParamValid("cracks_end")),
     _dim(declareRestartableData<unsigned int>("dim")),
     _n_pdnodes(declareRestartableData<unsigned int>("n_pdnodes")),
     _n_pdbonds(declareRestartableData<unsigned int>("n_pdbonds")),
     _pdnode_average_spacing(declareRestartableData<std::vector<Real>>("pdnode_average_spacing")),
     _pdnode_horizon_radius(declareRestartableData<std::vector<Real>>("pdnode_horizon_radius")),
     _pdnode_vol(declareRestartableData<std::vector<Real>>("pdnode_vol")),
     _pdnode_horizon_vol(declareRestartableData<std::vector<Real>>("pdnode_horizon_vol")),
     _pdnode_blockID(declareRestartableData<std::vector<SubdomainID>>("pdnode_blockID")),
     _pdnode_elemID(declareRestartableData<std::vector<dof_id_type>>("pdnode_elemID")),
     _pdnode_neighbors(
         declareRestartableData<std::vector<std::vector<dof_id_type>>>("pdnode_neighbors")),
     _pdnode_bonds(declareRestartableData<std::vector<std::vector<dof_id_type>>>("pdnode_bonds")),
     _dg_neighbors(
         declareRestartableData<std::vector<std::vector<std::vector<dof_id_type>>>>("dg_neighbors")),
     _pdnode_sub_vol(declareRestartableData<std::vector<std::vector<Real>>>("pdnode_sub_vol")),
     _pdnode_sub_vol_sum(declareRestartableData<std::vector<Real>>("pdnode_sub_vol_sum")),
     _boundary_node_offset(
         declareRestartableData<std::map<dof_id_type, Real>>("boundary_node_offset")),
     _pdnode_weight_normalizer(declareRestartableData<std::vector<Real>>("pdnode_weight_normalizer"))
 {
   if (!(isParamValid("horizon_radius") || _has_horizon_number))
     mooseError("Must specify either horizon_radius or horizon_number to determine horizon size in "
                "the mesh block!");
 
   if (_has_cracks)
   {
     _cracks_start = getParam<std::vector<Point>>("cracks_start");
     _cracks_end = getParam<std::vector<Point>>("cracks_end");
   }
   else
   {
     _cracks_start.push_back(Point(0., 0., 0.));
     _cracks_end.push_back(Point(0., 0., 0.));
   }
 
   if (_cracks_start.size() != _cracks_end.size())
     mooseError(
         "Number of cracks starting points is NOT the same as number of cracks ending points!");
 
   if (_has_cracks)
   {
     if (isParamValid("cracks_width"))
     {
       _cracks_width = getParam<std::vector<Real>>("cracks_width");
       if (_cracks_width.size() != _cracks_start.size())
         mooseError("Number of cracks width is NOT the same as number of cracks!");
     }
     else
     {
       for (unsigned int i = 0; i < _cracks_start.size(); ++i)
         _cracks_width.push_back(0);
     }
   }
   else
     _cracks_width.push_back(0);
 }

◆ PeridynamicsMesh() [2/2]

PeridynamicsMesh::PeridynamicsMesh ( const PeridynamicsMesh & )

default

Member Function Documentation

◆ buildMesh()

void PeridynamicsMesh::buildMesh ( )

overridevirtual

Implements MooseMesh.

Definition at line 112 of file PeridynamicsMesh.C.

 {
   if (!hasMeshBase())
   {
     auto & entry = _app.getMeshGeneratorSystem();
     _mesh = entry.getSavedMesh(entry.mainMeshGeneratorName());
   }
   _mesh->allow_renumbering(false);
   _mesh->prepare_for_use();
   _mesh->allow_renumbering(true);
 }

◆ checkCrackIntersectBond()

bool PeridynamicsMesh::checkCrackIntersectBond	(	Point	crack_p1,
		Point	crack_p2,
		Real	crack_width,
		Point	bond_p1,
		Point	bond_p2
	)

protected

Function to check whether a bond crosses crack surface.

Parameters

crack_p1	Crack starting point
crack_p2	Crack ending point
crack_width	Crack width
bond_p1	Bond starting point
bond_p2	Bond ending point

Returns: Whether the given bond crosses the given crack surface

Definition at line 566 of file PeridynamicsMesh.C.

Referenced by createNodeHorizBasedData().

 {
   bool intersect0 = false;
   bool intersect1 = false;
   bool intersect2 = false;
   if ((crack_p2 - crack_p1).norm())
   {
     intersect0 = checkSegmentIntersectSegment(crack_p1, crack_p2, bond_p1, bond_p2);
     if (crack_width != 0.)
     {
       Real crack_len = (crack_p1 - crack_p2).norm();
       Real cos_crack = (crack_p2(0) - crack_p1(0)) / crack_len;
       Real sin_crack = (crack_p2(1) - crack_p1(1)) / crack_len;
       Real new_crack_p1x = crack_p1(0) - crack_width / 2.0 * sin_crack;
       Real new_crack_p1y = crack_p1(1) + crack_width / 2.0 * cos_crack;
       Real new_crack_p2x = crack_p2(0) - crack_width / 2.0 * sin_crack;
       Real new_crack_p2y = crack_p2(1) + crack_width / 2.0 * cos_crack;
       Point new_crack_p1 = Point(new_crack_p1x, new_crack_p1y, 0.);
       Point new_crack_p2 = Point(new_crack_p2x, new_crack_p2y, 0.);
       intersect1 = checkSegmentIntersectSegment(new_crack_p1, new_crack_p2, bond_p1, bond_p2);
       new_crack_p1x = crack_p1(0) + crack_width / 2.0 * sin_crack;
       new_crack_p1y = crack_p1(1) - crack_width / 2.0 * cos_crack;
       new_crack_p2x = crack_p2(0) + crack_width / 2.0 * sin_crack;
       new_crack_p2y = crack_p2(1) - crack_width / 2.0 * cos_crack;
       new_crack_p1 = Point(new_crack_p1x, new_crack_p1y, 0.);
       new_crack_p2 = Point(new_crack_p2x, new_crack_p2y, 0.);
       intersect2 = checkSegmentIntersectSegment(new_crack_p1, new_crack_p2, bond_p1, bond_p2);
     }
   }
 
   return intersect0 || intersect1 || intersect2;
 }

◆ checkInterface()

bool PeridynamicsMesh::checkInterface	(	SubdomainID	pdnode_blockID_i,
		SubdomainID	pdnode_blockID_j,
		std::multimap< SubdomainID, SubdomainID >	blockID_pairs
	)

protected

Function to check existence of interface between two blocks.

Parameters

blockID_i	& blockID_j IDs of two querying blocks
blockID_pairs	ID pairs of neighboring blocks

Definition at line 316 of file PeridynamicsMesh.C.

Referenced by createNodeHorizBasedData().

 {
   bool is_interface = false;
   std::pair<std::multimap<SubdomainID, SubdomainID>::iterator,
             std::multimap<SubdomainID, SubdomainID>::iterator>
       ret;
   // check existence of the case when i is the key and j is the value
   ret = blockID_pairs.equal_range(pdnode_blockID_i);
   for (std::multimap<SubdomainID, SubdomainID>::iterator it = ret.first; it != ret.second; ++it)
     if (pdnode_blockID_j == it->second)
       is_interface = true;
 
   // check existence of the case when j is the key and i is the value
   ret = blockID_pairs.equal_range(pdnode_blockID_j);
   for (std::multimap<SubdomainID, SubdomainID>::iterator it = ret.first; it != ret.second; ++it)
     if (pdnode_blockID_i == it->second)
       is_interface = true;
 
   return is_interface;
 }

◆ checkPointInsideRectangle()

bool PeridynamicsMesh::checkPointInsideRectangle	(	Point	point,
		Point	rec_p1,
		Point	rec_p2,
		Real	rec_height,
		Real	tol = `0`
	)

protected

Function to check whether a material point falls within a given rectangular crack geometry.

Parameters

point	The querying point
rec_p1	The center of one edge of a rectangle
rec_p2	The center of the opposite edge of the retangle
rec_height	The distance between the rest two edges of the rectangle
tol	Acceptable tolerence

Returns: Whether the given point is within the given rectangule

Definition at line 540 of file PeridynamicsMesh.C.

Referenced by createNodeHorizBasedData().

 {
   Real crack_length = (rec_p2 - rec_p1).norm();
   bool inside = crack_length;
 
   if (inside)
   {
     Real a = rec_p2(1) - rec_p1(1);
     Real b = rec_p1(0) - rec_p2(0);
     Real c = rec_p2(0) * rec_p1(1) - rec_p2(1) * rec_p1(0);
     inside =
         inside && (std::abs(a * point(0) + b * point(1) + c) / crack_length < rec_height / 2.0);
 
     a = rec_p2(0) - rec_p1(0);
     b = rec_p2(1) - rec_p1(1);
     c = 0.5 * (rec_p1(1) * rec_p1(1) - rec_p2(1) * rec_p2(1) - rec_p2(0) * rec_p2(0) +
                rec_p1(0) * rec_p1(0));
     inside = inside && (std::abs(a * point(0) + b * point(1) + c) / crack_length <
                         (tol + crack_length) / 2.0);
   }
 
   return inside;
 }

◆ checkSegmentIntersectSegment()

bool PeridynamicsMesh::checkSegmentIntersectSegment	(	Point	seg1_p1,
		Point	seg1_p2,
		Point	seg2_p1,
		Point	seg2_p2
	)

protected

Function to check whether a segment crosses another segment.

Parameters

seg1_p1	The starting point of segment 1
seg1_p2	The ending point of segment 1
seg2_p1	The starting point of segment 2
seg2_p2	The ending point of segment 2

Returns: Whether the given segements cross each other

Definition at line 601 of file PeridynamicsMesh.C.

Referenced by checkCrackIntersectBond().

 {
   // Fail if the segments share an end-point
   if ((seg1_p1(0) == seg2_p1(0) && seg1_p1(1) == seg2_p1(1)) ||
       (seg1_p2(0) == seg2_p1(0) && seg1_p2(1) == seg2_p1(1)) ||
       (seg1_p1(0) == seg2_p2(0) && seg1_p1(1) == seg2_p2(1)) ||
       (seg1_p2(0) == seg2_p2(0) && seg1_p2(1) == seg2_p2(1)))
   {
     return false;
   }
 
   // Fail if the segments intersect at a given end-point but not normal to the crack
   if ((seg1_p1(1) - seg1_p2(1)) / (seg1_p1(0) - seg1_p2(0)) ==
           (seg1_p1(1) - seg2_p1(1)) / (seg1_p1(0) - seg2_p1(0)) ||
       (seg1_p1(1) - seg1_p2(1)) / (seg1_p1(0) - seg1_p2(0)) ==
           (seg1_p1(1) - seg2_p2(1)) / (seg1_p1(0) - seg2_p2(0)) ||
       (seg2_p1(1) - seg2_p2(1)) / (seg2_p1(0) - seg2_p2(0)) ==
           (seg2_p1(1) - seg1_p1(1)) / (seg2_p1(0) - seg1_p1(0)) ||
       (seg2_p1(1) - seg2_p2(1)) / (seg2_p1(0) - seg2_p2(0)) ==
           (seg2_p1(1) - seg1_p2(1)) / (seg2_p1(0) - seg1_p2(0)))
   {
     Real COSseg1_seg2 = (seg1_p2 - seg1_p1) * (seg2_p2 - seg2_p1) /
                         ((seg1_p2 - seg1_p1).norm() * (seg2_p2 - seg2_p1).norm());
     if (COSseg1_seg2 > -0.08715574 && COSseg1_seg2 < 0.08715574)
       return false;
   }
 
   // Translate the system so that point seg1_p1 is on the origin
   seg1_p2(0) -= seg1_p1(0);
   seg1_p2(1) -= seg1_p1(1);
   seg2_p1(0) -= seg1_p1(0);
   seg2_p1(1) -= seg1_p1(1);
   seg2_p2(0) -= seg1_p1(0);
   seg2_p2(1) -= seg1_p1(1);
 
   // Length of segment seg1_p1-seg1_p2
   Real seg1_len = seg1_p2.norm();
 
   // Rotate the system so that point seg1_p2 is on the positive X axis
   Real cos_seg1 = seg1_p2(0) / seg1_len;
   Real sin_seg1 = seg1_p2(1) / seg1_len;
   Real newX = seg2_p1(0) * cos_seg1 + seg2_p1(1) * sin_seg1;
   seg2_p1(1) = seg2_p1(1) * cos_seg1 - seg2_p1(0) * sin_seg1;
   seg2_p1(0) = newX;
   newX = seg2_p2(0) * cos_seg1 + seg2_p2(1) * sin_seg1;
   seg2_p2(1) = seg2_p2(1) * cos_seg1 - seg2_p2(0) * sin_seg1;
   seg2_p2(0) = newX;
 
   // Fail if segment seg2_p1-seg2_p2 doesn't cross segment seg1_p1-seg1_p2
   if ((seg2_p1(1) < 0. && seg2_p2(1) < 0.) || (seg2_p1(1) >= 0. && seg2_p2(1) >= 0.))
     return false;
 
   // Fail if segment seg2_p1-seg2_p2 crosses segment seg1_p1-seg1_p2 outside of segment
   // seg1_p1-seg1_p2
   Real seg1_pos = seg2_p2(0) + (seg2_p1(0) - seg2_p2(0)) * seg2_p2(1) / (seg2_p2(1) - seg2_p1(1));
   if (seg1_pos < 0. || seg1_pos > seg1_len)
     return false;
 
   return true;
 }

◆ createNeighborHorizonBasedData()

void PeridynamicsMesh::createNeighborHorizonBasedData ( )

protected

Function to create node neighbors and other data for each material point based on NEIGHBOR_HORIZON based horizon partition for deformation gradient calculation.

Definition at line 340 of file PeridynamicsMesh.C.

Referenced by createPeridynamicsMeshData().

 {
   for (unsigned int i = 0; i < _n_pdnodes; ++i)
   {
     std::vector<dof_id_type> n_pd_neighbors = _pdnode_neighbors[i];
     _dg_neighbors[i].resize(n_pd_neighbors.size());
     _pdnode_sub_vol[i].resize(n_pd_neighbors.size(), 0.0);
 
     for (unsigned int j = 0; j < n_pd_neighbors.size(); ++j)
       for (unsigned int k = j; k < n_pd_neighbors.size(); ++k) // only search greater number index
         if ((_pdnode_coord[n_pd_neighbors[j]] - _pdnode_coord[n_pd_neighbors[k]]).norm() <=
             _bah_ratio * _pdnode_horizon_radius[i])
         {
           // only save the corresponding index in neighbor list, rather than the actual node id
           // for neighbor j
           _dg_neighbors[i][j].push_back(k);
           _pdnode_sub_vol[i][j] += _pdnode_vol[n_pd_neighbors[k]];
           _pdnode_sub_vol_sum[i] += _pdnode_vol[n_pd_neighbors[k]];
           // for neighbor k
           if (k > j)
           {
             _dg_neighbors[i][k].push_back(j);
             _pdnode_sub_vol[i][k] += _pdnode_vol[n_pd_neighbors[j]];
             _pdnode_sub_vol_sum[i] += _pdnode_vol[n_pd_neighbors[j]];
           }
         }
   }
 }

◆ createNodeHorizBasedData()

void PeridynamicsMesh::createNodeHorizBasedData	(	std::multimap< SubdomainID, SubdomainID >	bonding_block_pairs,
		std::multimap< SubdomainID, SubdomainID >	non_bonding_block_pairs
	)

protected

Function to create neighbors and other data for each material point with given horizon.

Parameters

bonding_block_pairs	ID pairs of blocks to be connected via interfacial bonds
non_bonding_block_pairs	ID pairs of blocks not to be connected

Definition at line 246 of file PeridynamicsMesh.C.

Referenced by createPeridynamicsMeshData().

 {
   // search neighbors
   for (unsigned int i = 0; i < _n_pdnodes; ++i)
   {
     Real dis = 0.0;
     for (unsigned int j = 0; j < _n_pdnodes; ++j)
     {
       dis = (_pdnode_coord[i] - _pdnode_coord[j]).norm();
       if (dis <= 1.0001 * _pdnode_horizon_radius[i] && j != i)
       {
         bool is_interface = false;
         if (!bonding_block_pairs.empty())
           is_interface =
               checkInterface(_pdnode_blockID[i], _pdnode_blockID[j], bonding_block_pairs);
 
         if (!non_bonding_block_pairs.empty())
           is_interface =
               !checkInterface(_pdnode_blockID[i], _pdnode_blockID[j], non_bonding_block_pairs);
 
         if (_pdnode_blockID[i] == _pdnode_blockID[j] || is_interface)
         {
           // check whether pdnode i falls in the region whose bonds may need to be removed due to
           // the pre-existing cracks
           bool intersect = false;
           for (unsigned int k = 0; k < _cracks_start.size(); ++k)
           {
             if (checkPointInsideRectangle(_pdnode_coord[i],
                                           _cracks_start[k],
                                           _cracks_end[k],
                                           _cracks_width[k] + 4.0 * _pdnode_horizon_radius[i],
                                           4.0 * _pdnode_horizon_radius[i]))
               intersect = intersect || checkCrackIntersectBond(_cracks_start[k],
                                                                _cracks_end[k],
                                                                _cracks_width[k],
                                                                _pdnode_coord[i],
                                                                _pdnode_coord[j]);
           }
           // remove bonds cross the crack to form crack surface
           if (!intersect)
           {
             // Use the addition balance scheme to remove unbalanced interactions
             // check whether j was already considered as a neighbor of i, if not, add j to i's
             // neighborlist
             if (std::find(_pdnode_neighbors[i].begin(), _pdnode_neighbors[i].end(), j) ==
                 _pdnode_neighbors[i].end())
             {
               _pdnode_neighbors[i].push_back(j);
               _pdnode_horizon_vol[i] += _pdnode_vol[j];
               _pdnode_weight_normalizer[i] += _pdnode_horizon_radius[i] / dis;
             }
             // check whether i was also considered as a neighbor of j, if not, add i to j's
             // neighborlist
             if (std::find(_pdnode_neighbors[j].begin(), _pdnode_neighbors[j].end(), i) ==
                 _pdnode_neighbors[j].end())
             {
               _pdnode_neighbors[j].push_back(i);
               _pdnode_horizon_vol[j] += _pdnode_vol[i];
               _pdnode_weight_normalizer[j] += _pdnode_horizon_radius[j] / dis;
             }
           }
         }
       }
     }
   }
 }

◆ createPeridynamicsMeshData()

void PeridynamicsMesh::createPeridynamicsMeshData	(	MeshBase &	fe_mesh,
		std::set< dof_id_type >	converted_elem_id,
		std::multimap< SubdomainID, SubdomainID >	bonding_block_pairs,
		std::multimap< SubdomainID, SubdomainID >	non_bonding_block_pairs
	)

Function to assign values to member variables (PD mesh data) of this class this function will be called in the PD mesh generator class.

Parameters

fe_mesh	The finite element mesh based on which the peridynamics mesh will be created
converted_elem_id	The IDs of finite elements to be converted to peridynamics mesh

Definition at line 143 of file PeridynamicsMesh.C.

Referenced by MeshGeneratorPD::generate().

 {
   _dim = fe_mesh.mesh_dimension();
   _n_pdnodes = converted_elem_id.size();
 
   // initialize data size
   _pdnode_coord.resize(_n_pdnodes);
   _pdnode_average_spacing.resize(_n_pdnodes);
   _pdnode_horizon_radius.resize(_n_pdnodes);
   _pdnode_vol.resize(_n_pdnodes);
   _pdnode_horizon_vol.resize(_n_pdnodes, 0.0);
   _pdnode_blockID.resize(_n_pdnodes);
   _pdnode_elemID.resize(_n_pdnodes);
   _pdnode_neighbors.resize(_n_pdnodes);
   _pdnode_bonds.resize(_n_pdnodes);
   _dg_neighbors.resize(_n_pdnodes);
   _pdnode_sub_vol.resize(_n_pdnodes);
   _pdnode_sub_vol_sum.resize(_n_pdnodes, 0.0);
   _pdnode_weight_normalizer.resize(_n_pdnodes, 0.0);
 
   // loop through converted fe elements to generate PD nodes structure
   unsigned int id = 0; // make pd nodes start at 0 in the new mesh
   for (const auto & eid : converted_elem_id)
   {
     Elem * fe_elem = fe_mesh.elem_ptr(eid);
     // calculate the nodes spacing as average distance between fe element with its neighbors
     unsigned int n_fe_neighbors = 0;
     Real dist_sum = 0.0;
     for (unsigned int j = 0; j < fe_elem->n_neighbors(); ++j)
       if (fe_elem->neighbor_ptr(j) != nullptr)
       {
         dist_sum += (fe_elem->vertex_average() - fe_elem->neighbor_ptr(j)->vertex_average()).norm();
         n_fe_neighbors++;
       }
       else // this side is on boundary and calculate the distance to the centroid
       {
         Real dist = 0.0;
         std::vector<unsigned int> nid = fe_elem->nodes_on_side(j);
         Point p0 = fe_elem->vertex_average();
         Point p1 = fe_elem->point(nid[0]);
         if (fe_elem->dim() == 2) // 2D elems
         {
           Point p2 = fe_elem->point(nid.back());
           Real area = 0.5 * std::abs(p0(0) * (p1(1) - p2(1)) + p1(0) * (p2(1) - p0(1)) +
                                      p2(0) * (p0(1) - p1(1)));
           dist = 2.0 * area / fe_elem->length(nid[0], nid[1]);
         }
         else // 3D elems
         {
           Point p2 = fe_elem->point(nid[1]);
           Point p3 = fe_elem->point(nid.back());
           Point vec0 = p1 - p2;
           Point vec1 = p1 - p3;
           Point normal = vec0.cross(vec1);
           normal /= normal.norm();
           dist = std::abs(normal(0) * (p0(0) - p1(0)) + normal(1) * (p0(1) - p1(1)) +
                           normal(2) * (p0(2) - p1(2)));
         }
         _boundary_node_offset.insert(std::make_pair(id, -dist));
       }
 
     _pdnode_coord[id] = fe_elem->vertex_average();
     _pdnode_average_spacing[id] = dist_sum / n_fe_neighbors;
     _pdnode_horizon_radius[id] =
         (_has_horizon_number ? _horizon_number * dist_sum / n_fe_neighbors : _horizon_radius);
     // NOTE: PeridynamicsMesh does not support RZ/RSpherical so using volume from libmesh elem is
     // fine
     _pdnode_vol[id] = fe_elem->volume();
     _pdnode_blockID[id] = fe_elem->subdomain_id() + 1000; // set new subdomain id for PD mesh in
                                                           //  case FE mesh is retained
     _pdnode_elemID[id] = fe_elem->id();
 
     ++id;
   }
 
   // search node neighbors and create other nodal data
   createNodeHorizBasedData(bonding_block_pairs, non_bonding_block_pairs);
 
   createNeighborHorizonBasedData(); // applies to non-ordinary state-based model only.
 
   // total number of peridynamic bonds
   _n_pdbonds = 0;
   for (unsigned int i = 0; i < _n_pdnodes; ++i)
     _n_pdbonds += _pdnode_neighbors[i].size();
   _n_pdbonds /= 2;
 
   unsigned int k = 0;
   for (unsigned int i = 0; i < _n_pdnodes; ++i)
     for (unsigned int j = 0; j < _pdnode_neighbors[i].size(); ++j)
       if (_pdnode_neighbors[i][j] > i)
       {
         // build the bond list for each node
         _pdnode_bonds[i].push_back(k);
         _pdnode_bonds[_pdnode_neighbors[i][j]].push_back(k);
         ++k;
       }
 }

◆ dimension()

unsigned int PeridynamicsMesh::dimension ( ) const

overridevirtual

Reimplemented from MooseMesh.

Definition at line 125 of file PeridynamicsMesh.C.

Referenced by RBMPresetOldValuePD::shouldApply().

 {
   return _dim;
 }

◆ getBondDeformationGradientNeighbors()

std::vector< dof_id_type > PeridynamicsMesh::getBondDeformationGradientNeighbors	(	dof_id_type	node_id,
		dof_id_type	neighbor_id
	)

Function to return indices of neighbors used in formulation of bond-associated deformation gradient for bond connecting node_id and neighbor_id.

Parameters

node_id	The ID of the node providing the neighbor list
neighbor_id	The ID of the node querying the neighbor list

Returns: The neighbor list for calculation of bond-associated deformation gradient for the neighbor

Definition at line 399 of file PeridynamicsMesh.C.

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   if (neighbor_id > _pdnode_neighbors[node_id].size() - 1)
     mooseError("Querying neighbor index exceeds the available neighbors!");
 
   std::vector<dof_id_type> dg_neighbors = _dg_neighbors[node_id][neighbor_id];
   if (dg_neighbors.size() < _dim)
     mooseError("Not enough number of neighbors to calculate deformation gradient at PD node: ",
                node_id);
 
   return dg_neighbors;
 }

◆ getBonds()

std::vector< dof_id_type > PeridynamicsMesh::getBonds ( dof_id_type node_id )

Function to return the bond number connected with node node_id.

Parameters

node_id The querying node index

Returns: List of associated bond IDs

Definition at line 390 of file PeridynamicsMesh.C.

Referenced by SingularShapeTensorEliminatorUserObjectPD::checkShapeTensorSingularity(), NodalRankTwoPD::computeRankTwoTensors(), GeneralizedPlaneStrainUserObjectOSPD::execute(), GhostElemPD::ghostElements(), and RBMPresetOldValuePD::shouldApply().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_bonds[node_id];
 }

◆ getBoundaryOffset()

Real PeridynamicsMesh::getBoundaryOffset ( dof_id_type node_id )

Function to return offset for boundary nodes.

Parameters

node_id The querying node index

Returns: The offset

Definition at line 515 of file PeridynamicsMesh.C.

Referenced by BoundaryOffsetPD::computeValue().

 {
   if (_boundary_node_offset.count(node_id))
     return _boundary_node_offset[node_id];
   else
     return 0.0;
 }

◆ getHorizon()

Real PeridynamicsMesh::getHorizon ( dof_id_type node_id )

Function to return horizon size.

Parameters

node_id The querying node index

Returns: The horizon radius

Definition at line 506 of file PeridynamicsMesh.C.

Referenced by SingularShapeTensorEliminatorUserObjectPD::checkShapeTensorSingularity(), NodalRankTwoPD::computeRankTwoTensors(), PeridynamicsKernelBase::prepare(), and PeridynamicsMaterialBase::setupMeshRelatedData().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_horizon_radius[node_id];
 }

◆ getHorizonSubsetVolume()

Real PeridynamicsMesh::getHorizonSubsetVolume	(	dof_id_type	node_id,
		dof_id_type	neighbor_id
	)

Function to return the volume of a horizon subset for bond-associated deformation gradient calculation for bond connecting node node_id and its neighbor neighbor_id.

Parameters

node_id	The ID of the node
neighbor_id	The ID of the querying neighbor in the list of node node_id

Returns: The horizon subset volume

Definition at line 464 of file PeridynamicsMesh.C.

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   if (neighbor_id > _pdnode_neighbors[node_id].size() - 1)
     mooseError("Querying neighbor index exceeds the available neighbors!");
 
   return _pdnode_sub_vol[node_id][neighbor_id];
 }

◆ getHorizonSubsetVolumeFraction()

Real PeridynamicsMesh::getHorizonSubsetVolumeFraction	(	dof_id_type	node_id,
		dof_id_type	neighbor_id
	)

Function to return the volume fraction of a horizon subset used for bond-associated deformation gradient calculation for bond connecting node node_id and its neighbor neighbor_id.

Parameters

node_id	The ID of the node
neighbor_id	The ID of the querying neighbor in the list of node node_id

Returns: The horizon subset volume fraction for neighbor neighbor_id of node node_id

Definition at line 485 of file PeridynamicsMesh.C.

Referenced by GeneralizedPlaneStrainUserObjectNOSPD::execute(), and PeridynamicsKernelBase::prepare().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   if (neighbor_id > _pdnode_neighbors[node_id].size() - 1)
     mooseError("Querying neighbor index exceeds the available neighbors!");
 
   return _pdnode_sub_vol[node_id][neighbor_id] / _pdnode_sub_vol_sum[node_id];
 }

◆ getHorizonSubsetVolumeSum()

Real PeridynamicsMesh::getHorizonSubsetVolumeSum ( dof_id_type node_id )

Function to return the summation of all horizon subset volumes for node node_id.

Parameters

node_id The querying node index

Returns: The summation of all horizon subset volumes

Definition at line 476 of file PeridynamicsMesh.C.

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_sub_vol_sum[node_id];
 }

◆ getHorizonVolume()

Real PeridynamicsMesh::getHorizonVolume ( dof_id_type node_id )

Function to return summation of neighbor nodal volumes for node node_id.

Parameters

node_id The querying node index

Returns: The summation of the volume of all the neighbors

Definition at line 455 of file PeridynamicsMesh.C.

Referenced by NodalDamageIndexPD::computeValue(), PeridynamicsKernelBase::prepare(), and PeridynamicsMaterialBase::setupMeshRelatedData().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_horizon_vol[node_id];
 }

◆ getNeighborIndex()

dof_id_type PeridynamicsMesh::getNeighborIndex	(	dof_id_type	node_i,
		dof_id_type	node_j
	)

Function to return the local neighbor index of node_j from node_i's neighbor list.

Parameters

node_i	The ID of the node providing the neighbor list for query
node_j	The ID of the node querying the neighbor index

Returns: The local index in the neighbor list

Definition at line 376 of file PeridynamicsMesh.C.

Referenced by NodalRankTwoUserObjectBasePD::computeValue(), GeneralizedPlaneStrainUserObjectNOSPD::execute(), and PeridynamicsKernelBase::prepare().

 {
   std::vector<dof_id_type> n_pd_neighbors = _pdnode_neighbors[node_i];
   auto it = std::find(n_pd_neighbors.begin(), n_pd_neighbors.end(), node_j);
   if (it != n_pd_neighbors.end())
     return it - n_pd_neighbors.begin();
   else
     mooseError(
         "Material point ", node_j, " is not in the neighbor list of material point ", node_i);
 
   return -1;
 }

◆ getNeighbors()

std::vector< dof_id_type > PeridynamicsMesh::getNeighbors ( dof_id_type node_id )

Function to return neighbor nodes indices for node node_id.

Parameters

node_id The querying node index

Returns: List of neighbor IDs

Definition at line 370 of file PeridynamicsMesh.C.

Referenced by SingularShapeTensorEliminatorUserObjectPD::checkShapeTensorSingularity(), HeatSourceBPD::computeLocalResidual(), NodalRankTwoPD::computeRankTwoTensors(), MeshGeneratorPD::generate(), and GhostElemPD::ghostElements().

 {
   return _pdnode_neighbors[node_id];
 }

◆ getNeighborWeight()

Real PeridynamicsMesh::getNeighborWeight	(	dof_id_type	node_id,
		dof_id_type	neighbor_id
	)

Function to return normalized weight for neighbor neighbor_id of node node_id based on predefined weight function.

Parameters

node_id	The ID of the node
neighbor_id	The ID of the querying neighbor in the list of node node_id

Returns: The normalized weight for neighbor neighbor_id of node node_id

Definition at line 524 of file PeridynamicsMesh.C.

Referenced by NodalRankTwoUserObjectBasePD::computeValue().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   if (neighbor_id > _pdnode_neighbors[node_id].size() - 1)
     mooseError("Querying neighbor index exceeds the available neighbors!");
 
   Real dis =
       (_pdnode_coord[node_id] - _pdnode_coord[_pdnode_neighbors[node_id][neighbor_id]]).norm();
   Real result = _pdnode_horizon_radius[node_id] / dis / _pdnode_weight_normalizer[node_id];
 
   return result;
 }

◆ getNodeAverageSpacing()

Real PeridynamicsMesh::getNodeAverageSpacing ( dof_id_type node_id )

Function to return the average spacing between node node_id with its most adjacent neighbors.

Parameters

node_id The querying node index

Returns: The node average spacing

Definition at line 497 of file PeridynamicsMesh.C.

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_average_spacing[node_id];
 }

◆ getNodeBlockID()

SubdomainID PeridynamicsMesh::getNodeBlockID ( dof_id_type node_id )

Function to return block ID for node node_id.

Parameters

node_id The querying node index

Returns: The block ID of a node

Definition at line 416 of file PeridynamicsMesh.C.

Referenced by MeshGeneratorPD::generate().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_blockID[node_id];
 }

◆ getNodeCoord()

Point PeridynamicsMesh::getNodeCoord ( dof_id_type node_id )

Function to return coordinates for node node_id.

Parameters

node_id The querying node index

Returns: The coordinates of a node

Definition at line 431 of file PeridynamicsMesh.C.

Referenced by SingularShapeTensorEliminatorUserObjectPD::checkShapeTensorSingularity(), MechanicsMaterialBasePD::computeBondCurrentLength(), NodalRankTwoPD::computeRankTwoTensors(), GeneralizedPlaneStrainUserObjectNOSPD::execute(), GeneralizedPlaneStrainUserObjectOSPD::execute(), PeridynamicsKernelBase::prepare(), and PeridynamicsMaterialBase::setupMeshRelatedData().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_coord[node_id];
 }

◆ getNodeVolume()

Real PeridynamicsMesh::getNodeVolume ( dof_id_type node_id )

Function to return nodal volume for node node_id.

Parameters

node_id The querying node index

Returns: The volume of a node

Definition at line 446 of file PeridynamicsMesh.C.

Referenced by SingularShapeTensorEliminatorUserObjectPD::checkShapeTensorSingularity(), NodalRankTwoPD::computeRankTwoTensors(), NodalDamageIndexPD::computeValue(), NodalVolumePD::computeValue(), GeneralizedPlaneStrainUserObjectOSPD::execute(), GeneralizedPlaneStrainUserObjectNOSPD::execute(), NodalIntegralPostprocessorBasePD::execute(), PeridynamicsKernelBase::prepare(), and PeridynamicsMaterialBase::setupMeshRelatedData().

 {
   if (node_id > _n_pdnodes)
     mooseError("Querying node ID exceeds the available PD node IDs!");
 
   return _pdnode_vol[node_id];
 }

◆ getPDNodeIDToFEElemIDMap()

std::vector< dof_id_type > PeridynamicsMesh::getPDNodeIDToFEElemIDMap ( )

Function to return the correspondence between PD node IDs and FE element IDs.

Returns: The coordinates of a node

Definition at line 440 of file PeridynamicsMesh.C.

 {
   return _pdnode_elemID;
 }

◆ nPDBonds()

dof_id_type PeridynamicsMesh::nPDBonds ( ) const

Function to return number of PD Edge elements.

Returns: Total number of PD bonds

Definition at line 137 of file PeridynamicsMesh.C.

Referenced by MeshGeneratorPD::generate().

 {
   return _n_pdbonds;
 }

◆ nPDNodes()

dof_id_type PeridynamicsMesh::nPDNodes ( ) const

Function to return number of PD nodes.

Returns: Total number of PD nodes

Definition at line 131 of file PeridynamicsMesh.C.

Referenced by MeshGeneratorPD::generate().

 {
   return _n_pdnodes;
 }

◆ operator=()

PeridynamicsMesh& PeridynamicsMesh::operator= ( const PeridynamicsMesh & other_mesh )

delete

◆ safeClone()

std::unique_ptr< MooseMesh > PeridynamicsMesh::safeClone ( ) const

overridevirtual

Implements MooseMesh.

Definition at line 106 of file PeridynamicsMesh.C.

 {
   return _app.getFactory().copyConstruct(*this);
 }

◆ setNodeBlockID()

void PeridynamicsMesh::setNodeBlockID ( SubdomainID id )

Function to set block ID for all PD nodes.

Parameters

id	The subdomain ID for all PD nodes

Definition at line 425 of file PeridynamicsMesh.C.

Referenced by MeshGeneratorPD::generate().

 {
   _pdnode_blockID.assign(_n_pdnodes, id);
 }

◆ validParams()

InputParameters PeridynamicsMesh::validParams ( )

static

Definition at line 17 of file PeridynamicsMesh.C.

 {
   InputParameters params = MooseMesh::validParams();
   params.addClassDescription("Mesh class to store and return peridynamics specific mesh data");
 
   params.addParam<Real>("horizon_radius", "Value of horizon size in terms of radius");
   params.addParam<Real>("horizon_number",
                         "The material points spacing number, i.e. ratio of horizon radius to the "
                         "effective average spacing");
   params.addParam<Real>("bond_associated_horizon_ratio",
                         1.5,
                         "Ratio of bond-associated horizon to nodal horizon. This is the only "
                         "parameters to control the size of bond-associated horizon");
   params.addParam<std::vector<Point>>("cracks_start",
                                       "Cartesian coordinates where predefined line cracks start");
   params.addParam<std::vector<Point>>("cracks_end",
                                       "Cartesian coordinates where predefined line cracks end");
   params.addParam<std::vector<Real>>("cracks_width", "Widths of predefined line cracks");
 
   params.set<bool>("_mesh_generator_mesh") = true;
 
   return params;
 }

Member Data Documentation

◆ _bah_ratio

const Real PeridynamicsMesh::_bah_ratio

protected

Definition at line 189 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData().

◆ _boundary_node_offset

std::map<dof_id_type, Real>& PeridynamicsMesh::_boundary_node_offset

protected

Offset of each boundary node to its original FE element boundary edge or face.

Definition at line 234 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getBoundaryOffset().

◆ _cracks_end

std::vector<Point> PeridynamicsMesh::_cracks_end

protected

Definition at line 195 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), and PeridynamicsMesh().

◆ _cracks_start

std::vector<Point> PeridynamicsMesh::_cracks_start

protected

Definition at line 194 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), and PeridynamicsMesh().

◆ _cracks_width

std::vector<Real> PeridynamicsMesh::_cracks_width

protected

Definition at line 196 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), and PeridynamicsMesh().

◆ _dg_neighbors

std::vector<std::vector<std::vector<dof_id_type> > >& PeridynamicsMesh::_dg_neighbors

protected

Neighbor lists for deformation gradient calculation using bond-associated horizon.

Definition at line 225 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createPeridynamicsMeshData(), and getBondDeformationGradientNeighbors().

◆ _dim

unsigned int& PeridynamicsMesh::_dim

protected

Mesh dimension.

Definition at line 200 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), dimension(), and getBondDeformationGradientNeighbors().

◆ _has_cracks

const bool PeridynamicsMesh::_has_cracks

protected

Information for crack generation.

Definition at line 193 of file PeridynamicsMesh.h.

Referenced by PeridynamicsMesh().

◆ _has_horizon_number

const bool PeridynamicsMesh::_has_horizon_number

protected

Definition at line 187 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and PeridynamicsMesh().

◆ _horizon_number

const Real PeridynamicsMesh::_horizon_number

protected

Definition at line 188 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData().

◆ _horizon_radius

const Real PeridynamicsMesh::_horizon_radius

protected

Horizon size control parameters.

Definition at line 186 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData().

◆ _n_pdbonds

unsigned int& PeridynamicsMesh::_n_pdbonds

protected

Number of total bonds.

Definition at line 206 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and nPDBonds().

◆ _n_pdnodes

unsigned int& PeridynamicsMesh::_n_pdnodes

protected

Number of total material points.

Definition at line 203 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), getBondDeformationGradientNeighbors(), getBonds(), getHorizon(), getHorizonSubsetVolume(), getHorizonSubsetVolumeFraction(), getHorizonSubsetVolumeSum(), getHorizonVolume(), getNeighborWeight(), getNodeAverageSpacing(), getNodeBlockID(), getNodeCoord(), getNodeVolume(), nPDNodes(), and setNodeBlockID().

◆ _pdnode_average_spacing

std::vector<Real>& PeridynamicsMesh::_pdnode_average_spacing

protected

Definition at line 210 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getNodeAverageSpacing().

◆ _pdnode_blockID

std::vector<SubdomainID>& PeridynamicsMesh::_pdnode_blockID

protected

Definition at line 214 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), createPeridynamicsMeshData(), getNodeBlockID(), and setNodeBlockID().

◆ _pdnode_bonds

std::vector<std::vector<dof_id_type> >& PeridynamicsMesh::_pdnode_bonds

protected

Bond lists associated with material points.

Definition at line 222 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getBonds().

◆ _pdnode_coord

std::vector<Point> PeridynamicsMesh::_pdnode_coord

protected

Data associated with each peridynamics node.

Definition at line 209 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), getNeighborWeight(), and getNodeCoord().

◆ _pdnode_elemID

std::vector<dof_id_type>& PeridynamicsMesh::_pdnode_elemID

protected

Definition at line 215 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getPDNodeIDToFEElemIDMap().

◆ _pdnode_horizon_radius

std::vector<Real>& PeridynamicsMesh::_pdnode_horizon_radius

protected

Definition at line 211 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), getHorizon(), and getNeighborWeight().

◆ _pdnode_horizon_vol

std::vector<Real>& PeridynamicsMesh::_pdnode_horizon_vol

protected

Definition at line 213 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), createPeridynamicsMeshData(), and getHorizonVolume().

◆ _pdnode_neighbors

std::vector<std::vector<dof_id_type> >& PeridynamicsMesh::_pdnode_neighbors

protected

Neighbor lists for each material point determined using the horizon.

Definition at line 219 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), getBondDeformationGradientNeighbors(), getHorizonSubsetVolume(), getHorizonSubsetVolumeFraction(), getNeighborIndex(), getNeighbors(), and getNeighborWeight().

◆ _pdnode_sub_vol

std::vector<std::vector<Real> >& PeridynamicsMesh::_pdnode_sub_vol

protected

Volume of horizon subsets for bond-associated deformation gradients at a node.

Definition at line 228 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createPeridynamicsMeshData(), getHorizonSubsetVolume(), and getHorizonSubsetVolumeFraction().

◆ _pdnode_sub_vol_sum

std::vector<Real>& PeridynamicsMesh::_pdnode_sub_vol_sum

protected

Summation of volumes of all horizon subsets at a node.

Definition at line 231 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createPeridynamicsMeshData(), getHorizonSubsetVolumeFraction(), and getHorizonSubsetVolumeSum().

◆ _pdnode_vol

std::vector<Real>& PeridynamicsMesh::_pdnode_vol

protected

Definition at line 212 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), and getNodeVolume().

◆ _pdnode_weight_normalizer

std::vector<Real>& PeridynamicsMesh::_pdnode_weight_normalizer

protected

normalizer for calculating weighted values at a node from elemental values within its horizon

Definition at line 237 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), createPeridynamicsMeshData(), and getNeighborWeight().

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

peridynamics/include/mesh/PeridynamicsMesh.h
peridynamics/src/mesh/PeridynamicsMesh.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PeridynamicsMesh() [1/2]

◆ PeridynamicsMesh() [2/2]

Member Function Documentation

◆ buildMesh()

◆ checkCrackIntersectBond()

◆ checkInterface()

◆ checkPointInsideRectangle()

◆ checkSegmentIntersectSegment()

◆ createNeighborHorizonBasedData()

◆ createNodeHorizBasedData()

◆ createPeridynamicsMeshData()

◆ dimension()

◆ getBondDeformationGradientNeighbors()

◆ getBonds()

◆ getBoundaryOffset()

◆ getHorizon()

◆ getHorizonSubsetVolume()

◆ getHorizonSubsetVolumeFraction()

◆ getHorizonSubsetVolumeSum()

◆ getHorizonVolume()

◆ getNeighborIndex()

◆ getNeighbors()

◆ getNeighborWeight()

◆ getNodeAverageSpacing()

◆ getNodeBlockID()

◆ getNodeCoord()

◆ getNodeVolume()

◆ getPDNodeIDToFEElemIDMap()

◆ nPDBonds()

◆ nPDNodes()

◆ operator=()

◆ safeClone()

◆ setNodeBlockID()

◆ validParams()

Member Data Documentation

◆ _bah_ratio

◆ _boundary_node_offset

◆ _cracks_end

◆ _cracks_start

◆ _cracks_width

◆ _dg_neighbors

◆ _dim

◆ _has_cracks

◆ _has_horizon_number

◆ _horizon_number

◆ _horizon_radius

◆ _n_pdbonds

◆ _n_pdnodes

◆ _pdnode_average_spacing

◆ _pdnode_blockID

◆ _pdnode_bonds

◆ _pdnode_coord

◆ _pdnode_elemID

◆ _pdnode_horizon_radius

◆ _pdnode_horizon_vol

◆ _pdnode_neighbors

◆ _pdnode_sub_vol

◆ _pdnode_sub_vol_sum

◆ _pdnode_vol

◆ _pdnode_weight_normalizer