PeridynamicsMesh Class Reference

Peridynamics mesh class. More...

#include <PeridynamicsMesh.h>

Inheritance diagram for PeridynamicsMesh:

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 > connect_block_id_pairs, std::multimap< SubdomainID, SubdomainID > non_connect_block_id_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 >	getDefGradNeighbors (dof_id_type node_id, unsigned int 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	getPDNodeCoord (dof_id_type node_id)
	Function to return coordinates for node node_id. More...
std::vector< dof_id_type >	getPDNodeIDToFiniteElemIDMap ()
	Function to return the correspondence between PD node IDs and FE element IDs. More...
Real	getPDNodeVolume (dof_id_type node_id)
	Function to return nodal volume for node node_id. More...
Real	getHorizVolume (dof_id_type node_id)
	Function to return summation of neighbor nodal volumes for node node_id. More...
Real	getDefGradVolFraction (dof_id_type node_id, dof_id_type neighbor_id)
	Function to return summation of volumes of bond-associated neighbors used in the deformation gradient calculation for bond connecting node node_id and its neighbor neighbor_id. More...
Real	getNodeAvgSpacing (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...

Protected Member Functions
void	createNodeHorizBasedData (std::multimap< SubdomainID, SubdomainID > connect_block_id_pairs, std::multimap< SubdomainID, SubdomainID > non_connect_block_id_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...

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 > > &	_dg_vol_frac
	Volume fraction of deformation gradient region to its sum 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...
const Real	_horiz_rad
	Horizon size control parameters. More...
const bool	_has_horiz_num
const Real	_horiz_num
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_avg_spacing
std::vector< Real > &	_pdnode_horiz_rad
std::vector< Real > &	_pdnode_vol
std::vector< Real > &	_pdnode_horiz_vol
std::vector< SubdomainID > &	_pdnode_blockID
std::vector< dof_id_type > &	_pdnode_elemID

Detailed Description

Peridynamics mesh class.

Definition at line 25 of file PeridynamicsMesh.h.

Constructor & Destructor Documentation

PeridynamicsMesh() [1/2]

PeridynamicsMesh::PeridynamicsMesh

(

const InputParameters &

parameters

)

Definition at line 42 of file PeridynamicsMesh.C.

  : MooseMesh(parameters),
    _horiz_rad(isParamValid("horizon_radius") ? getParam<Real>("horizon_radius") : 0),
    _has_horiz_num(isParamValid("horizon_number")),
    _horiz_num(_has_horiz_num ? 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_avg_spacing(declareRestartableData<std::vector<Real>>("pdnode_avg_spacing")),
    _pdnode_horiz_rad(declareRestartableData<std::vector<Real>>("pdnode_horiz_radius")),
    _pdnode_vol(declareRestartableData<std::vector<Real>>("pdnode_vol")),
    _pdnode_horiz_vol(declareRestartableData<std::vector<Real>>("pdnode_horiz_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")),
    _dg_vol_frac(declareRestartableData<std::vector<std::vector<Real>>>("dg_vol_fraction")),
    _boundary_node_offset(
        declareRestartableData<std::map<dof_id_type, Real>>("boundary_node_offset"))
{
  if (!(isParamValid("horizon_radius") || _has_horiz_num))
    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

Definition at line 111 of file PeridynamicsMesh.C.

{
  if (!hasMeshBase())
    _mesh = _app.getMeshGeneratorMesh();
 
  _mesh->prepare_for_use(/*skip_renumber =*/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 513 of file PeridynamicsMesh.C.

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

Referenced by createNodeHorizBasedData().

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 305 of file PeridynamicsMesh.C.

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

Referenced by createNodeHorizBasedData().

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 489 of file PeridynamicsMesh.C.

{
  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 *= 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 *= std::abs(a * point(0) + b * point(1) + c) / crack_length < (tol + crack_length) / 2.0;
  }
 
  return inside;
}

Referenced by createNodeHorizBasedData().

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 548 of file PeridynamicsMesh.C.

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

Referenced by checkCrackIntersectBond().

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 329 of file PeridynamicsMesh.C.

{
  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());
    _dg_vol_frac[i].resize(n_pd_neighbors.size());
    Real dg_vol_sum = 0.0;
    std::vector<Real> dg_vol(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_horiz_rad[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);
          dg_vol[j] += _pdnode_vol[n_pd_neighbors[k]];
          dg_vol_sum += _pdnode_vol[n_pd_neighbors[k]];
          // for neighbor k
          if (k > j)
          {
            _dg_neighbors[i][k].push_back(j);
            dg_vol[k] += _pdnode_vol[n_pd_neighbors[j]];
            dg_vol_sum += _pdnode_vol[n_pd_neighbors[j]];
          }
        }
    for (unsigned int j = 0; j < n_pd_neighbors.size(); ++j)
      _dg_vol_frac[i][j] = dg_vol[j] / dg_vol_sum;
  }
}

Referenced by createPeridynamicsMeshData().

createNodeHorizBasedData()

void PeridynamicsMesh::createNodeHorizBasedData ( std::multimap< SubdomainID, SubdomainID >  connect_block_id_pairs, std::multimap< SubdomainID, SubdomainID >  non_connect_block_id_pairs  )

protected

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

Parameters

connect_block_id_pairs	ID pairs of blocks to be connected via interfacial bonds
non_connect_block_id_pairs	ID pairs of blocks not to be connected

Definition at line 237 of file PeridynamicsMesh.C.

{
  // 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_horiz_rad[i] && j != i)
      {
        bool is_interface = false;
        if (!connect_block_id_pairs.empty())
          is_interface =
              checkInterface(_pdnode_blockID[i], _pdnode_blockID[j], connect_block_id_pairs);
 
        if (!non_connect_block_id_pairs.empty())
          is_interface =
              !checkInterface(_pdnode_blockID[i], _pdnode_blockID[j], non_connect_block_id_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_horiz_rad[i],
                                          4.0 * _pdnode_horiz_rad[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_horiz_vol[i] += _pdnode_vol[j];
            }
            // 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_horiz_vol[j] += _pdnode_vol[i];
            }
          }
        }
      }
    }
  }
}

Referenced by createPeridynamicsMeshData().

createPeridynamicsMeshData()

void PeridynamicsMesh::createPeridynamicsMeshData	(	MeshBase &	fe_mesh,
		std::set< dof_id_type >	converted_elem_id,
		std::multimap< SubdomainID, SubdomainID >	connect_block_id_pairs,
		std::multimap< SubdomainID, SubdomainID >	non_connect_block_id_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 138 of file PeridynamicsMesh.C.

{
  _dim = fe_mesh.mesh_dimension();
  _n_pdnodes = converted_elem_id.size();
 
  // initialize data size
  _pdnode_coord.resize(_n_pdnodes);
  _pdnode_avg_spacing.resize(_n_pdnodes);
  _pdnode_horiz_rad.resize(_n_pdnodes);
  _pdnode_vol.resize(_n_pdnodes);
  _pdnode_horiz_vol.resize(_n_pdnodes);
  _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);
  _dg_vol_frac.resize(_n_pdnodes);
 
  // 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->centroid() - fe_elem->neighbor_ptr(j)->centroid()).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->centroid();
        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->centroid();
    _pdnode_avg_spacing[id] = dist_sum / n_fe_neighbors;
    _pdnode_horiz_rad[id] = (_has_horiz_num ? _horiz_num * dist_sum / n_fe_neighbors : _horiz_rad);
    _pdnode_vol[id] = fe_elem->volume();
    _pdnode_horiz_vol[id] = 0.0;
    _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(connect_block_id_pairs, non_connect_block_id_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;
      }
}

Referenced by MeshGeneratorPD::generate().

dimension()

unsigned int PeridynamicsMesh::dimension ( ) const

overridevirtual

Definition at line 120 of file PeridynamicsMesh.C.

{
  return _dim;
}

Referenced by RBMPresetOldValuePD::shouldApply().

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 382 of file PeridynamicsMesh.C.

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

Referenced by NodalRankTwoPD::computeNodalTotalStrain(), GhostElemPD::ghostElements(), and RBMPresetOldValuePD::shouldApply().

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 480 of file PeridynamicsMesh.C.

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

Referenced by BoundaryOffsetPD::computeValue().

getDefGradNeighbors()

std::vector< dof_id_type > PeridynamicsMesh::getDefGradNeighbors	(	dof_id_type	node_id,
		unsigned int	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 391 of file PeridynamicsMesh.C.

{
  if (node_id > _n_pdnodes)
    mooseError("Querying node ID exceeds the available PD node IDs!");
 
  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;
}

getDefGradVolFraction()

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

Function to return summation of volumes of bond-associated neighbors used in the deformation gradient calculation for bond connecting node node_id and its neighbor neighbor_id.

Parameters

node_id	The ID of the node providing the neighbor's bond-associated volume
neighbor_id	The ID of the querying neighbor

Returns

The volume used in the calculation of bond-associated deformation gradeint for the querying neighbor

Definition at line 453 of file PeridynamicsMesh.C.

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

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

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 471 of file PeridynamicsMesh.C.

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

Referenced by NodalRankTwoPD::computeNodalTotalStrain(), PeridynamicsKernelBase::prepare(), PeridynamicsMaterialBase::setupMeshRelatedData(), and RBMPresetOldValuePD::shouldApply().

getHorizVolume()

Real PeridynamicsMesh::getHorizVolume

(

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 444 of file PeridynamicsMesh.C.

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

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

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 368 of file PeridynamicsMesh.C.

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

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

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 362 of file PeridynamicsMesh.C.

{
  return _pdnode_neighbors[node_id];
}

Referenced by HeatSourceBPD::computeLocalResidual(), NodalRankTwoPD::computeNodalTotalStrain(), GeneralizedPlaneStrainUserObjectOSPD::execute(), MeshGeneratorPD::generate(), GhostElemPD::ghostElements(), and RBMPresetOldValuePD::shouldApply().

getNodeAvgSpacing()

Real PeridynamicsMesh::getNodeAvgSpacing

(

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 462 of file PeridynamicsMesh.C.

{
  if (node_id > _n_pdnodes)
    mooseError("Querying node ID exceeds the available PD node IDs!");
 
  return _pdnode_avg_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 405 of file PeridynamicsMesh.C.

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

Referenced by MeshGeneratorPD::generate().

getPDNodeCoord()

Point PeridynamicsMesh::getPDNodeCoord

(

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 420 of file PeridynamicsMesh.C.

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

Referenced by MechanicsMaterialBasePD::computeBondCurrentLength(), PeridynamicsKernelBase::prepare(), and PeridynamicsMaterialBase::setupMeshRelatedData().

getPDNodeIDToFiniteElemIDMap()

std::vector< dof_id_type > PeridynamicsMesh::getPDNodeIDToFiniteElemIDMap

(

)

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

Returns

The coordinates of a node

Definition at line 429 of file PeridynamicsMesh.C.

{
  return _pdnode_elemID;
}

getPDNodeVolume()

Real PeridynamicsMesh::getPDNodeVolume

(

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 435 of file PeridynamicsMesh.C.

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

Referenced by NodalRankTwoPD::computeNodalTotalStrain(), NodalDamageIndexPD::computeValue(), NodalVolumePD::computeValue(), GeneralizedPlaneStrainUserObjectOSPD::execute(), GeneralizedPlaneStrainUserObjectNOSPD::execute(), NodalIntegralPostprocessorBasePD::execute(), PeridynamicsKernelBase::prepare(), PeridynamicsMaterialBase::setupMeshRelatedData(), and RBMPresetOldValuePD::shouldApply().

nPDBonds()

dof_id_type PeridynamicsMesh::nPDBonds

(

)

const

Function to return number of PD Edge elements.

Returns

Total number of PD bonds

Definition at line 132 of file PeridynamicsMesh.C.

{
  return _n_pdbonds;
}

Referenced by MeshGeneratorPD::generate().

nPDNodes()

dof_id_type PeridynamicsMesh::nPDNodes

(

)

const

Function to return number of PD nodes.

Returns

Total number of PD nodes

Definition at line 126 of file PeridynamicsMesh.C.

{
  return _n_pdnodes;
}

Referenced by MeshGeneratorPD::generate().

operator=()

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

delete

safeClone()

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

overridevirtual

Definition at line 105 of file PeridynamicsMesh.C.

{
  return libmesh_make_unique<PeridynamicsMesh>(*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 414 of file PeridynamicsMesh.C.

{
  _pdnode_blockID.assign(_n_pdnodes, id);
}

Referenced by MeshGeneratorPD::generate().

Member Data Documentation

_bah_ratio

const Real PeridynamicsMesh::_bah_ratio

protected

Definition at line 169 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 211 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getBoundaryOffset().

_cracks_end

std::vector<Point> PeridynamicsMesh::_cracks_end

protected

Definition at line 175 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), and PeridynamicsMesh().

_cracks_start

std::vector<Point> PeridynamicsMesh::_cracks_start

protected

Definition at line 174 of file PeridynamicsMesh.h.

Referenced by createNodeHorizBasedData(), and PeridynamicsMesh().

_cracks_width

std::vector<Real> PeridynamicsMesh::_cracks_width

protected

Definition at line 176 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 205 of file PeridynamicsMesh.h.

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

_dg_vol_frac

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

protected

Volume fraction of deformation gradient region to its sum at a node.

Definition at line 208 of file PeridynamicsMesh.h.

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

_dim

unsigned int& PeridynamicsMesh::_dim

protected

Mesh dimension.

Definition at line 180 of file PeridynamicsMesh.h.

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

_has_cracks

const bool PeridynamicsMesh::_has_cracks

protected

Information for crack generation.

Definition at line 173 of file PeridynamicsMesh.h.

Referenced by PeridynamicsMesh().

_has_horiz_num

const bool PeridynamicsMesh::_has_horiz_num

protected

Definition at line 167 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and PeridynamicsMesh().

_horiz_num

const Real PeridynamicsMesh::_horiz_num

protected

Definition at line 168 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData().

_horiz_rad

const Real PeridynamicsMesh::_horiz_rad

protected

Horizon size control parameters.

Definition at line 166 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData().

_n_pdbonds

unsigned int& PeridynamicsMesh::_n_pdbonds

protected

Number of total bonds.

Definition at line 186 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 183 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), getBonds(), getDefGradNeighbors(), getDefGradVolFraction(), getHorizon(), getHorizVolume(), getNodeAvgSpacing(), getNodeBlockID(), getPDNodeCoord(), getPDNodeVolume(), nPDNodes(), and setNodeBlockID().

_pdnode_avg_spacing

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

protected

Definition at line 190 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getNodeAvgSpacing().

_pdnode_blockID

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

protected

Definition at line 194 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 202 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 189 of file PeridynamicsMesh.h.

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

_pdnode_elemID

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

protected

Definition at line 195 of file PeridynamicsMesh.h.

Referenced by createPeridynamicsMeshData(), and getPDNodeIDToFiniteElemIDMap().

_pdnode_horiz_rad

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

protected

Definition at line 191 of file PeridynamicsMesh.h.

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

_pdnode_horiz_vol

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

protected

Definition at line 193 of file PeridynamicsMesh.h.

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

_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 199 of file PeridynamicsMesh.h.

Referenced by createNeighborHorizonBasedData(), createNodeHorizBasedData(), createPeridynamicsMeshData(), getNeighborIndex(), and getNeighbors().

_pdnode_vol

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

protected

Definition at line 192 of file PeridynamicsMesh.h.

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

---

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

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