geometry Namespace Reference

Collection of methods and data related to geometry. More...

Data Structures
class	Fracture
	A class for fracture state of bonds. More...

Functions
bool	segmentCrossesVerticalLine (double x0, double y0, double x1, double y1, double xLine, double yLo, double yHi)
	Pre-notch by breaking peridynamic bonds.
bool	segmentEntersSlot (double x0, double y0, double x1, double y1, double xCenter, double halfWidth, double yLo, double yHi, int nSamples=8)
	Checks whether the segment enters the open slot centred on xCenter.
std::size_t	breakBondsCrossingVerticalLines (Fracture &fracture, const std::vector< util::Point > &xRef, const std::vector< std::vector< std::size_t > > &neighbors, const std::vector< std::size_t > &nodeParticleId, std::size_t particleId, const std::vector< double > &xLines, double yLo, double yHi)
	Break the bonds of one particle that cross vertical cut lines.
std::size_t	breakBondsInSlots (Fracture &fracture, const std::vector< util::Point > &xRef, const std::vector< std::vector< std::size_t > > &neighbors, const std::vector< std::size_t > &nodeParticleId, std::size_t particleId, const std::vector< double > &xCenters, double width, double yLo, double yHi)
	Break the bonds of one particle that enter open notch slots.

Detailed Description

Collection of methods and data related to geometry.

Function Documentation

breakBondsCrossingVerticalLines()

std::size_t geometry::breakBondsCrossingVerticalLines	(	Fracture &	fracture,
		const std::vector< util::Point > &	xRef,
		const std::vector< std::vector< std::size_t > > &	neighbors,
		const std::vector< std::size_t > &	nodeParticleId,
		std::size_t	particleId,
		const std::vector< double > &	xLines,
		double	yLo,
		double	yHi
	)

Break the bonds of one particle that cross vertical cut lines.

This is the zero-width pre-notch: a cut along each line in xLines between yLo and yHi. A V-notch seeded on its midplane is the same geometric test and uses this function.

Only bonds with both ends in particle particleId are considered.

Parameters

fracture	Bond-state store to modify
xRef	Reference coordinates of all nodes
neighbors	Peridynamic neighbour list
nodeParticleId	Particle id of each node
particleId	Particle to cut
xLines	Positions of the cut lines
yLo	Lower end of the cuts
yHi	Upper end of the cuts

Returns

n Number of bonds broken

Definition at line 84 of file prenotch.cpp.

                                                             {
  return breakBondsIf(
      fracture, xRef, neighbors, nodeParticleId, particleId,
      [&](double x0, double y0, double x1, double y1) {
        for (double xl : xLines)
          if (segmentCrossesVerticalLine(x0, y0, x1, y1, xl, yLo, yHi))
            return true;
        return false;
      });
}

References segmentCrossesVerticalLine().

Referenced by anonymous_namespace{main.cpp}::applyNotches(), and anonymous_namespace{main.cpp}::applyNotchMidplanes().

Here is the call graph for this function:

Here is the caller graph for this function:

breakBondsInSlots()

std::size_t geometry::breakBondsInSlots	(	Fracture &	fracture,
		const std::vector< util::Point > &	xRef,
		const std::vector< std::vector< std::size_t > > &	neighbors,
		const std::vector< std::size_t > &	nodeParticleId,
		std::size_t	particleId,
		const std::vector< double > &	xCenters,
		double	width,
		double	yLo,
		double	yHi
	)

Break the bonds of one particle that enter open notch slots.

This is the finite-width pre-notch: each slot is width across, centred on an entry of xCenters, spanning yLo to yHi.

Only bonds with both ends in particle particleId are considered.

Parameters

fracture	Bond-state store to modify
xRef	Reference coordinates of all nodes
neighbors	Peridynamic neighbour list
nodeParticleId	Particle id of each node
particleId	Particle to cut
xCenters	Slot centrelines
width	Full slot width
yLo	Lower end of the slots
yHi	Upper end of the slots

Returns

n Number of bonds broken

Definition at line 99 of file prenotch.cpp.

                {
  if (width < 0.)
    throw std::invalid_argument("prenotch: slot width must not be negative");
  const double hw = 0.5 * width;
  return breakBondsIf(
      fracture, xRef, neighbors, nodeParticleId, particleId,
      [&](double x0, double y0, double x1, double y1) {
        for (double xc : xCenters)
          if (segmentEntersSlot(x0, y0, x1, y1, xc, hw, yLo, yHi))
            return true;
        return false;
      });
}

References segmentEntersSlot().

Referenced by anonymous_namespace{main.cpp}::applyNotchSlots().

Here is the call graph for this function:

Here is the caller graph for this function:

segmentCrossesVerticalLine()

bool geometry::segmentCrossesVerticalLine	(	double	x0,
		double	y0,
		double	x1,
		double	y1,
		double	xLine,
		double	yLo,
		double	yHi
	)

Pre-notch by breaking peridynamic bonds.

Removing the notch from the mesh does not by itself open it. The horizon is wider than the notch in the cases here, so bonds still span the gap and carry force across it. These functions break those bonds, after the model is initialised and before the time loop starts.

They take the node data rather than a model object, so that src/ does not depend on the driver. Call them with data.d_xRef, data.d_neighPd, data.d_ptId and *data.d_fracture_p.

Checks whether the segment (x0,y0)-(x1,y1) crosses the vertical line x = xLine within [yLo, yHi]

Parameters

x0	First endpoint x
y0	First endpoint y
x1	Second endpoint x
y1	Second endpoint y
xLine	Position of the cut line
yLo	Lower end of the cut
yHi	Upper end of the cut

Returns

bool True if the segment crosses the cut

Definition at line 52 of file prenotch.cpp.

                                                                      {
  // The endpoints lie on opposite sides of the line. This excludes x1 == x0,
  // so the division is defined and the parameter lies in (0, 1).
  if ((x0 - xLine) * (x1 - xLine) >= 0.)
    return false;
  const double t = (xLine - x0) / (x1 - x0);
  const double y = y0 + t * (y1 - y0);
  return y >= yLo && y <= yHi;
}

Referenced by breakBondsCrossingVerticalLines(), main(), and segmentEntersSlot().

Here is the caller graph for this function:

segmentEntersSlot()

bool geometry::segmentEntersSlot	(	double	x0,
		double	y0,
		double	x1,
		double	y1,
		double	xCenter,
		double	halfWidth,
		double	yLo,
		double	yHi,
		int	nSamples = 8
	)

Checks whether the segment enters the open slot centred on xCenter.

The slot spans xCenter +/- halfWidth and yLo to yHi. The segment is sampled at nSamples interior points, so that a bond with an endpoint inside the slot is detected and not only one that crosses the slot entirely.

Parameters

x0	First endpoint x
y0	First endpoint y
x1	Second endpoint x
y1	Second endpoint y
xCenter	Slot centreline
halfWidth	Half of the slot width
yLo	Lower end of the slot
yHi	Upper end of the slot
nSamples	Number of interior samples along the segment

Returns

bool True if the segment enters the slot

Definition at line 63 of file prenotch.cpp.

                                                 {
  const double xa = xCenter - halfWidth, xb = xCenter + halfWidth;
  auto inSlot = [&](double x, double y) {
    return x >= xa && x <= xb && y >= yLo && y <= yHi;
  };
  if (inSlot(x0, y0) || inSlot(x1, y1))
    return true;
  if (nSamples > 0) {
    for (int s = 0; s <= nSamples; ++s) {
      const double t = static_cast<double>(s) / nSamples;
      if (inSlot(x0 + t * (x1 - x0), y0 + t * (y1 - y0)))
        return true;
    }
  }
  // A slot narrower than the sample spacing can be crossed with no sample
  // inside it.
  return segmentCrossesVerticalLine(x0, y0, x1, y1, xCenter, yLo, yHi);
}

References segmentCrossesVerticalLine().

Referenced by breakBondsInSlots().

Here is the call graph for this function:

Here is the caller graph for this function: