#include <TriangleMeshWall.h>

Inheritance diagram for TriangleMeshWall:

Classes
struct	Triangle

struct	Vertex

Public Member Functions
	TriangleMeshWall ()=default
	Default constructor. More...

	TriangleMeshWall (const TriangleMeshWall &other)
	Copy constructor. More...

	TriangleMeshWall (const std::vector< Vec3D > &points, const std::vector< std::array< unsigned, 3 >> &cells, const ParticleSpecies *species=nullptr)
	Constructor creating triangles. More...

	TriangleMeshWall (const Vec3D &P0, const Vec3D &P1, const Vec3D &P, Mdouble resolutionU, Mdouble resolutionV, const ParticleSpecies *species=nullptr, bool periodicInU=false, bool periodicInV=false)
	Constructor creating parallelogram shaped mesh with a given resolution in u- and v-direction. More...

	~TriangleMeshWall () override=default
	Destructor. More...

TriangleMeshWall &	operator= (const TriangleMeshWall &other)
	Copy assignment operator. More...

TriangleMeshWall *	copy () const override
	Wall copy method. More...

void	read (std::istream &is) override
	Reads a TriangleMeshWall from an input stream, for example a restart file. More...

void	write (std::ostream &os) const override
	Writes a TriangleMeshWall to an output stream, for example a restart file. More...

std::string	getName () const override
	Returns the name of the object. More...

void	set (const std::vector< Vec3D > &points, const std::vector< std::array< unsigned, 3 >> &cells)
	Set function creating triangles. More...

bool	getDistanceAndNormal (const BaseParticle &p, Mdouble &distance, Vec3D &normal_return) const override
	Checks if a collision is happening with any of the TriangleWalls. NOTE: this does not handle actual interactions, but can only be used to know IF one (of possible many) interaction occurs. More...

BaseInteraction *	getInteractionWith (BaseParticle p, unsigned timeStamp, InteractionHandler interactionHandler) override
	Gets the interaction between a given BaseParticle and all TriangleWalls in this mesh at a given time. In case of multiple contacts, chooses the one with greatest overlap. More...

void	resetForceTorque (int numberOfOMPthreads) override

void	writeVTK (VTKContainer &vtk) const override

void	setSpecies (const ParticleSpecies *species)

void	moveVertex (unsigned index, const Vec3D &dP)
	Updates a vertex by a given change in position. More...

void	removeTriangle (unsigned index, bool removeFreeVertex=true)
	Removes a single triangle from the mesh. More...

void	refineTriangle (unsigned index, unsigned numberOfTimes=1)
	Makes a really basic refinement by adding a vertex in the middle of the triangle to create 3 new ones. Note: Multiple refinements will definitely NOT create a nice mesh. More...

void	setPeriodicCompanions (const std::vector< std::pair< unsigned, unsigned >> &periodicCompanions)
	Sets the vector with pairs of indices of vertices which lie on a periodic boundary and are each others 'companion'. E.g. when moving one vertex, the other is also moved the same amount. A vertex can have multiple companions (when lying on multiple periodic boundaries) and those should be in the vector as multiple pairs. More...

void	moveVerticesToMatchVolume (std::vector< Vec3D > displacements, Mdouble targetVolume, int maxNumRecursiveCalls=15)
	Moves all vertices by given displacements and corrects to match the change in volume with the target volume. The final displacements will be proportional to the initial ones, but their actual values will have change. More...

Mdouble	getVolumeTetrahedron (const Vec3D &a, const Vec3D &b, const Vec3D &c, const Vec3D &d)
	Calculates the volume of a tetrahedron formed by 4 vertices. More...

void	addToMesh (TriangleMeshWall mesh)
	Adds a mesh to this mesh. When vertices share a position, only the one in the current mesh is kept and both meshes are then "connected" at that point. More...

void	createParallelogramMesh (const Vec3D &P0, const Vec3D &P1, const Vec3D &P2, Mdouble resolutionU, Mdouble resolutionV, bool periodicInU=false, bool periodicInV=false)
	Creates a parallelogram shaped mesh with a given resolution in u- and v-direction. More...

void	createFourPointMesh (const Vec3D &P0, const Vec3D &P1, const Vec3D &P2, const Vec3D &P3, int numSegmentsU, int numSegmentsV)
	Creates mesh consisting of four points, with linearly interpolated segments. The points therefore don't necessarily have to lie in plane. More...

bool	isLocal (Vec3D &min, Vec3D &max) const override

void	setPosition (const Vec3D &position) override
	Sets the position of this BaseInteractable. More...

void	setOrientation (const Quaternion &orientation) override
	Sets the orientation of this BaseInteractable. More...

void	move (const Vec3D &move) override
	Moves this BaseInteractable by adding an amount to the position. More...

void	rotate (const Vec3D &angularVelocity) override
	Rotates this BaseInteractable. More...

Public Member Functions inherited from BaseWall
	BaseWall ()
	Default constructor. More...

	BaseWall (const BaseWall &w)
	Copy constructor. More...

	~BaseWall () override
	Default destructor. More...

virtual bool	getDistanceNormalOverlap (const BaseParticle &P, Mdouble &distance, Vec3D &normal_return, Mdouble &overlap) const

virtual bool	getDistanceNormalOverlapSuperquadric (const SuperQuadricParticle &p, Mdouble &distance, Vec3D &normal_return, Mdouble &overlap) const

virtual Vec3D	getFurthestPointSuperQuadric (const Vec3D &normalBodyFixed, const Vec3D &axes, Mdouble eps1, Mdouble eps2) const

virtual void	setHandler (WallHandler *handler)
	A function which sets the WallHandler for this BaseWall. More...

WallHandler *	getHandler () const
	A function which returns the WallHandler that handles this BaseWall. More...

void	setIndSpecies (unsigned int indSpecies) override
	Define the species of this wall using the index of the species in the SpeciesHandler in this DPMBase. More...

void	setSpecies (const ParticleSpecies *species)
	Defines the species of the current wall. More...

bool	isFixed () const override

void	setForceControl (Vec3D forceGoal, Vec3D gainFactor, Vec3D baseVelocity={0, 0, 0})
	Slowly adjusts the force on a wall towards a specified goal, by adjusting (prescribing) the velocity of the wall. More...

bool	getLinePlaneIntersect (Vec3D &intersect, const Vec3D &p0, const Vec3D &p1, const Vec3D &n, const Vec3D &p)

bool	isInsideWallVTK (const Vec3D &point, const Vec3D &normal, const Vec3D &position) const

void	projectOntoWallVTK (Vec3D &point0, const Vec3D &point1, const Vec3D &normal, const Vec3D &position) const

void	intersectVTK (std::vector< Vec3D > &points, Vec3D normal, Vec3D position) const

virtual BaseInteraction *	getInteractionWithSuperQuad (SuperQuadricParticle p, unsigned timeStamp, InteractionHandler interactionHandler)

void	getVTK (std::vector< Vec3D > &points, std::vector< std::vector< double >> &triangleStrips)

const Vec3D	getAxis () const

virtual void	actionsOnRestart ()
	No implementation but can be overidden in its derived classes. More...

virtual void	actionsAfterParticleGhostUpdate ()
	No implementation but can be overidden in its derived classes. More...

virtual void	handleParticleAddition (unsigned int id, BaseParticle *p)
	Handles the addition of particles to the particleHandler. More...

virtual void	handleParticleRemoval (unsigned int id)
	Handles the addition of particles to the particleHandler. More...

virtual void	checkInteractions (InteractionHandler *interactionHandler, unsigned int timeStamp)
	Check if all interactions are valid. More...

bool	getVTKVisibility () const

void	setVTKVisibility (bool vtkVisibility)

void	addRenderedWall (BaseWall *w)

BaseWall *	getRenderedWall (size_t i) const

std::vector< BaseWall * >	getRenderedWalls () const

void	removeRenderedWalls ()

void	renderWall (VTKContainer &vtk)

void	addParticlesAtWall (unsigned numElements=50)

void	setVelocityControl (Vec3D forceGoal, Vec3D gainFactor, Vec3D baseVelocity)

virtual void	writeWallDetailsVTK (VTKData &data) const

virtual void	computeWear ()

Public Member Functions inherited from BaseInteractable
	BaseInteractable ()
	Default BaseInteractable constructor. More...

	BaseInteractable (const BaseInteractable &p)
	Copy constructor. More...

	~BaseInteractable () override
	Destructor, it simply destructs the BaseInteractable and all the objects it contains. More...

unsigned int	getIndSpecies () const
	Returns the index of the species associated with the interactable object. More...

const ParticleSpecies *	getSpecies () const
	Returns a pointer to the species of this BaseInteractable. More...

void	setSpecies (const ParticleSpecies *species)
	Sets the species of this BaseInteractable. More...

const Vec3D &	getForce () const
	Returns the force on this BaseInteractable. More...

const Vec3D &	getTorque () const
	Returns the torque on this BaseInteractable. More...

void	setForce (const Vec3D &force)
	Sets the force on this BaseInteractable. More...

void	setTorque (const Vec3D &torque)
	Sets the torque on this BaseInteractable. More...

void	addForce (const Vec3D &addForce)
	Adds an amount to the force on this BaseInteractable. More...

void	addTorque (const Vec3D &addTorque)
	Adds an amount to the torque on this BaseInteractable. More...

void	sumForceTorqueOMP ()

const Vec3D &	getPosition () const
	Returns the position of this BaseInteractable. More...

const Quaternion &	getOrientation () const
	Returns the orientation of this BaseInteractable. More...

void	setOrientationViaNormal (Vec3D normal)
	Sets the orientation of this BaseInteractable by defining the vector that results from the rotation of the (1,0,0) vector. More...

void	setOrientationViaEuler (Vec3D eulerAngle)
	Sets the orientation of this BaseInteractable by defining the euler angles. More...

const std::vector< BaseInteraction * > &	getInteractions () const
	Returns a list of interactions which belong to this interactable. More...

void	addInteraction (BaseInteraction *I)
	Adds an interaction to this BaseInteractable. More...

bool	removeInteraction (BaseInteraction *I)
	Removes an interaction from this BaseInteractable. More...

void	copyInteractionsForPeriodicParticles (const BaseInteractable &p)
	Copies interactions to this BaseInteractable whenever a periodic copy made. More...

void	setVelocity (const Vec3D &velocity)
	set the velocity of the BaseInteractable. More...

void	setAngularVelocity (const Vec3D &angularVelocity)
	set the angular velocity of the BaseInteractble. More...

void	addVelocity (const Vec3D &velocity)
	adds an increment to the velocity. More...

void	addAngularVelocity (const Vec3D &angularVelocity)
	add an increment to the angular velocity. More...

virtual const Vec3D &	getVelocity () const
	Returns the velocity of this interactable. More...

virtual const Vec3D &	getAngularVelocity () const
	Returns the angular velocity of this interactable. More...

void	setPrescribedPosition (const std::function< Vec3D(double)> &prescribedPosition)
	Allows the position of an infinite mass interactable to be prescribed. More...

void	applyPrescribedPosition (double time)
	Computes the position from the user defined prescribed position function. More...

void	setPrescribedVelocity (const std::function< Vec3D(double)> &prescribedVelocity)
	Allows the velocity of an infinite mass interactable to be prescribed. More...

void	applyPrescribedVelocity (double time)
	Computes the velocity from the user defined prescribed velocity function. More...

void	setPrescribedOrientation (const std::function< Quaternion(double)> &prescribedOrientation)
	Allows the orientation of the infinite mass interactbale to be prescribed. More...

void	applyPrescribedOrientation (double time)
	Computes the orientation from the user defined prescribed orientation function. More...

void	setPrescribedAngularVelocity (const std::function< Vec3D(double)> &prescribedAngularVelocity)
	Allows the angular velocity of the infinite mass interactable to be prescribed. More...

void	applyPrescribedAngularVelocity (double time)
	Computes the angular velocity from the user defined prescribed angular velocity. More...

virtual const Vec3D	getVelocityAtContact (const Vec3D &contact) const
	Returns the velocity at the contact point, use by many force laws. More...

void	integrateBeforeForceComputation (double time, double timeStep)
	This is part of integrate routine for objects with infinite mass. More...

void	integrateAfterForceComputation (double time, double timeStep)
	This is part of the integration routine for objects with infinite mass. More...

virtual Mdouble	getInvMass () const

virtual Mdouble	getCurvature (const Vec3D &labFixedCoordinates) const

virtual bool	isFaceContact (const Vec3D &normal) const

Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...

	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...

virtual	~BaseObject ()=default
	virtual destructor More...

virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...

void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...

void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...

unsigned int	getIndex () const
	Returns the index of the object in the handler. More...

unsigned int	getId () const
	Returns the unique identifier of any particular object. More...

void	setGroupId (unsigned groupId)

unsigned	getGroupId () const

Protected Attributes
std::vector< Triangle >	triangles_

std::vector< Vertex >	vertices_

Private Member Functions
std::vector< unsigned >	getPeriodicCompanions (unsigned index)
	Looks up the companions belonging to a vertex index, if it has any. More...

bool	isWithinBoundingBox (const Vec3D &position, Mdouble radius) const
	Checks whether or not a part of the particle is within the bounding box. More...

void	updateBoundingBox ()
	Sets the local and global bounding boxes. This method should be called any time a vertex is updated in lab frame. More...

void	updateBoundingBoxGlobal ()
	Sets the global bounding box, using the bounding box in lab frame. This method should be called when there are changes in global frame, but not in lab frame. E.g. when calling setPosition(). More...

int	getNumberOfSegmentsAndResolution (Mdouble length, Mdouble &resolution)
	Finds the number of segments and the resolution needed to perfectly fit a length. More...

void	addZigZagDiagonalCells (std::vector< std::array< unsigned, 3 >> &cells, int numU, int numV, int i, int j)
	Helper function that adds two cells (triangles) to the provided cells vector. Used by createParallelogramMesh and createFourPointMesh. More...

Private Attributes
std::vector< std::pair< unsigned, unsigned > >	periodicCompanions_

Vec3D	boundingBoxMin_
	Bounding box corners in lab frame and global frame. Used to speed up contact detection. HGrid uses the global frame min max. More...

Vec3D	boundingBoxMax_

Vec3D	boundingBoxMinGlobal_

Vec3D	boundingBoxMaxGlobal_

Additional Inherited Members
Static Public Member Functions inherited from BaseWall
static void	addToVTK (const std::vector< Vec3D > &points, VTKContainer &vtk)
	Takes the points provided and adds a triangle strip connecting these points to the vtk container. More...

Constructor & Destructor Documentation

◆ TriangleMeshWall() [1/4]

TriangleMeshWall::TriangleMeshWall ( )

default

Default constructor.

Referenced by copy().

◆ TriangleMeshWall() [2/4]

TriangleMeshWall::TriangleMeshWall ( const TriangleMeshWall & other )

Copy constructor.

Parameters

other The TriangleMeshWall that must be copied.

                                                                 : BaseWall(other)
 {
     triangles_ = other.triangles_;
     vertices_ = other.vertices_;
     periodicCompanions_ = other.periodicCompanions_;
     
     boundingBoxMin_ = other.boundingBoxMin_;
     boundingBoxMax_ = other.boundingBoxMax_;
     boundingBoxMinGlobal_ = other.boundingBoxMinGlobal_;
     boundingBoxMaxGlobal_ = other.boundingBoxMaxGlobal_;
 }

References boundingBoxMax_, boundingBoxMaxGlobal_, boundingBoxMin_, boundingBoxMinGlobal_, periodicCompanions_, triangles_, and vertices_.

◆ TriangleMeshWall() [3/4]

TriangleMeshWall::TriangleMeshWall	(	const std::vector< Vec3D > &	points,
		const std::vector< std::array< unsigned, 3 >> &	cells,
		const ParticleSpecies *	species = `nullptr`
	)

Constructor creating triangles.

Parameters

points	Vector of vertices
cells	Vector of cells, each cell holds three indices to the points vector
species

 {
     // Set the species of the main wall first, as the set function will use it.
     setSpecies(species);
     set(points, cells);
 }

References set(), and setSpecies().

◆ TriangleMeshWall() [4/4]

TriangleMeshWall::TriangleMeshWall	(	const Vec3D &	P0,
		const Vec3D &	P1,
		const Vec3D &	P,
		Mdouble	resolutionU,
		Mdouble	resolutionV,
		const ParticleSpecies *	species = `nullptr`,
		bool	periodicInU = `false`,
		bool	periodicInV = `false`
	)

Constructor creating parallelogram shaped mesh with a given resolution in u- and v-direction.

Parameters

P0,P1,P2	The three points, in clockwise order, forming the parallelogram (fourth point is implied).
resolutionU	Maximum length of a segment in u-direction.
resolutionV	Maximum length of a segment in v-direction.
species
periodicInU	Whether or not the first and last column of vertices lie in a periodic boundary and should be set as periodic companions.
periodicInV	Whether or not the first and last row of vertices lie in a periodic boundary and should be set as periodic companions.

 {
     // Set the species first, as it is used in other methods.
     setSpecies(species);
     createParallelogramMesh(P0, P1, P2, resolutionU, resolutionV, periodicInU, periodicInV);
 }

References createParallelogramMesh(), and setSpecies().

◆ ~TriangleMeshWall()

TriangleMeshWall::~TriangleMeshWall ( )

overridedefault

Destructor.

Member Function Documentation

◆ addToMesh()

void TriangleMeshWall::addToMesh ( TriangleMeshWall mesh )

Adds a mesh to this mesh. When vertices share a position, only the one in the current mesh is kept and both meshes are then "connected" at that point.

Parameters

mesh	Mesh to be added.

 {
     // All triangles are simply added to the triangles_ vector. When adding vertices, any triangle index of the added
     // mesh simply becomes: updated index = index + number of triangles originally in this mesh.
     // Similar for the vertices, however vertices which share their position with a vertex already in the mesh are
     // ignored. So when adding triangles, the vertex indices can sometimes reference to a vertex already in the mesh.
     // The easiest way to implement is to temporarily store the updated vertex indices, and to later assign them.
     
     // Remember the number of vertices and triangles originally in this mesh.
     const int numVertices = vertices_.size();
     const int numTriangles = triangles_.size();
     // For each of the added vertices, their updated vertex is temporarily stored in a vector.
     // This is the cleanest/easiest way to later update the vertex indices of each added triangle.
     std::vector<unsigned> updatedVertexIndices;
     updatedVertexIndices.reserve(mesh.vertices_.size());
     
     // Loop through the vertices to be added.
     for (Vertex& v : mesh.vertices_)
     {
         // The triangle indices can simply be updated.
         for (auto& p : v.triangleIndices)
             p.first += numTriangles;
         
         // Initialize updated vertex index as -1, to later check if it has been set or not.
         int index = -1;
         // Loop through original vertices and compare vertex positions.
         for (int i = 0; i < numVertices; i++)
         {
             if (v.position.isEqualTo(vertices_[i].position, std::numeric_limits<Mdouble>::epsilon()))
             {
                 // When vertices share position, update vertex index.
                 index = i;
                 break;
             }
         }
     
         // When the updated index is not set, the vertex is not in the mesh yet and should be added.
         if (index == -1)
         {
             index = vertices_.size();
             vertices_.push_back(v);
         }
         else
         {
             // The vertex is already in the mesh, add the triangle indices of the added mesh to it.
             for (auto& p : v.triangleIndices)
                 vertices_[index].triangleIndices.push_back(p);
         }
         
         // Store the updated index.
         updatedVertexIndices.push_back(index);
     }
  
     // Loop through the triangles to be added.
     for (Triangle& t : mesh.triangles_)
     {
         // Update the vertex indices.
         for (unsigned& idx : t.vertexIndices)
             idx = updatedVertexIndices[idx];
         triangles_.push_back(t);
     }
     
     updateBoundingBox();
 }

References constants::i, Vec3D::isEqualTo(), TriangleMeshWall::Vertex::position, TriangleMeshWall::Vertex::triangleIndices, triangles_, updateBoundingBox(), TriangleMeshWall::Triangle::vertexIndices, and vertices_.

◆ addZigZagDiagonalCells()

void TriangleMeshWall::addZigZagDiagonalCells	(	std::vector< std::array< unsigned, 3 >> &	cells,
		int	numU,
		int	numV,
		int	i,
		int	j
	)

private

Helper function that adds two cells (triangles) to the provided cells vector. Used by createParallelogramMesh and createFourPointMesh.

Parameters

cells	The vector to which the cells are added.
numU	The number of segments in u-direction.
numV	The number of segments in v-direction.
i	The cell index in u-direction.
j	The cell index in v-direction.

 {
     // Not in last row/column
     if (i < numU - 1 && j < numV - 1)
     {
         // Bottom left
         const unsigned baseIdx = i + j * numU;
  
         // Check moduli to create zigzag diagonals (both being odd or even)
         if ((i % 2 == 0) != (j % 2 == 0))
         {
             // Diagonal from bottom left to top right
             // Bottom left, top left, top right (clockwise)
             cells.push_back({baseIdx, baseIdx + numU, baseIdx + numU + 1});
             // Bottom left, top right, bottom right (clockwise)
             cells.push_back({baseIdx, baseIdx + numU + 1, baseIdx + 1});
         }
         else
         {
             // Diagonal from top left to bottom right
             // Bottom left, top left, bottom right (clockwise)
             cells.push_back({baseIdx, baseIdx + numU, baseIdx + 1});
             // Top left, top right, bottom right (clockwise)
             cells.push_back({baseIdx + numU, baseIdx + numU + 1, baseIdx + 1});
         }
     }
 }

References constants::i.

Referenced by createFourPointMesh(), and createParallelogramMesh().

◆ copy()

TriangleMeshWall * TriangleMeshWall::copy ( ) const

overridevirtual

Wall copy method.

Returns: Pointer to the copy.

Implements BaseWall.

Reimplemented in WearableTriangleMeshWall.

 {
     return new TriangleMeshWall(*this);
 }

References TriangleMeshWall().

Referenced by operator=().

◆ createFourPointMesh()

void TriangleMeshWall::createFourPointMesh	(	const Vec3D &	P0,
		const Vec3D &	P1,
		const Vec3D &	P2,
		const Vec3D &	P3,
		int	numSegmentsU,
		int	numSegmentsV
	)

Creates mesh consisting of four points, with linearly interpolated segments. The points therefore don't necessarily have to lie in plane.

Parameters

P0,P1,P2,P3	The four points, in clock-wise order.
numSegmentsU	Number of segments in u-direction.
numSegmentsV	Number of segments in v-direction.

 {
     // To get to a point in the mesh, all we need to do is to walk along the bottom edge and then walk up along the
     // linearly interpolated vector between the left and right edge. We step with a certain fraction of the length of
     // the vectors, dependent on the number of segments in that direction.
  
     // Bottom direction vector (u-direction)
     const Vec3D dirU = P3 - P0;
     // Left and right direction vector (v-direction)
     const Vec3D dirV0 = P1 - P0;
     const Vec3D dirV1 = P2 - P3;
     // Step size for linear interpolation between left and right direction vectors
     Vec3D deltaDirV = (dirV1 - dirV0) / numSegmentsU;
  
     // Number of points is 1 more than number of segments
     const int numU = numSegmentsU + 1;
     const int numV = numSegmentsV + 1;
  
     std::vector<Vec3D> points;
     std::vector<std::array<unsigned, 3>> cells;
  
     for (int j = 0; j < numV; j++)
     {
         for (int i = 0; i < numU; i++)
         {
             // Update direction vector in v-direction
             Vec3D dirV = dirV0 + i * deltaDirV;
             const Vec3D p = P0 + dirU * i / numSegmentsU + dirV * j / numSegmentsV;
             points.push_back(p);
             addZigZagDiagonalCells(cells, numU, numV, i, j);
         }
     }
  
     set(points, cells);
 }

References addZigZagDiagonalCells(), constants::i, and set().

◆ createParallelogramMesh()

void TriangleMeshWall::createParallelogramMesh	(	const Vec3D &	P0,
		const Vec3D &	P1,
		const Vec3D &	P2,
		Mdouble	resolutionU,
		Mdouble	resolutionV,
		bool	periodicInU = `false`,
		bool	periodicInV = `false`
	)

Creates a parallelogram shaped mesh with a given resolution in u- and v-direction.

Parameters

P0,P1,P2	The three points, in clockwise order, forming the parallelogram (fourth point is implied).
resolutionU	Maximum length of a segment in u-direction.
resolutionV	Maximum length of a segment in v-direction.
periodicInU	Whether or not the first and last column of vertices lie in a periodic boundary and should be set as periodic companions.
periodicInV	Whether or not the first and last row of vertices lie in a periodic boundary and should be set as periodic companions.

 {
     // Length of the sides of the parallelogram
     const Mdouble lengthU = (P2 - P0).getLength();
     const Mdouble lengthV = (P1 - P0).getLength();
     // Direction vectors of the parallelogram sides
     const Vec3D dirU = (P2 - P0) / lengthU;
     const Vec3D dirV = (P1 - P0) / lengthV;
  
     // Number of points is 1 more than number of segments
     const int numU = getNumberOfSegmentsAndResolution(lengthU, resolutionU) + 1;
     const int numV = getNumberOfSegmentsAndResolution(lengthV, resolutionV) + 1;
  
     std::vector<Vec3D> points;
     std::vector<std::array<unsigned, 3>> cells;
  
     for (int j = 0; j < numV; j++)
     {
         for (int i = 0; i < numU; i++)
         {
             const Vec3D p = P0 + dirU * i * resolutionU + dirV * j * resolutionV;
             points.push_back(p);
             addZigZagDiagonalCells(cells, numU, numV, i, j);
         }
     }
  
     set(points, cells);
  
     // Set possible periodic companions for first/last row/column.
     std::vector<std::pair<unsigned, unsigned>> periodic;
     if (periodicInU)
     {
         // First/last column
         for (int j = 0; j < numV; j++)
             periodic.emplace_back(j * numU, (j+1) * numU - 1);
     }
     if (periodicInV)
     {
         // First/last row
         for (int i = 0; i < numU; i++)
             periodic.emplace_back(i, i + (numV-1) * numU);
     }
     if (periodicInU && periodicInV)
     {
         // Periodic in diagonals u/v
         periodic.emplace_back(0, numU * numV - 1);
         periodic.emplace_back(numU - 1, numU * (numV-1));
     }
     setPeriodicCompanions(periodic);
 }

References addZigZagDiagonalCells(), getNumberOfSegmentsAndResolution(), constants::i, set(), and setPeriodicCompanions().

Referenced by TriangleMeshWall().

◆ getDistanceAndNormal()

bool TriangleMeshWall::getDistanceAndNormal	(	const BaseParticle &	p,
		Mdouble &	distance,
		Vec3D &	normal_return
	)		const

overridevirtual

Checks if a collision is happening with any of the TriangleWalls. NOTE: this does not handle actual interactions, but can only be used to know IF one (of possible many) interaction occurs.

Parameters

p
distance
normal_return

Returns: Whether or not there is a collision.

Implements BaseWall.

 {
     // Input BaseParticle is constant, so copy the necessary properties and change to local coordinates.
     SphericalParticle pLocal;
     pLocal.setSpecies(p.getSpecies());
     pLocal.setRadius(p.getRadius());
     pLocal.setPosition(getOrientation().rotateBack(p.getPosition() - getPosition()));
     
     if (!isWithinBoundingBox(pLocal.getPosition(), pLocal.getWallInteractionRadius(this)))
         return false;
     
     for (const Triangle& t : triangles_)
     {
         if (t.wall.getDistanceAndNormal(pLocal, distance, normal_return))
             return true;
     }
     return false;
 }

References BaseInteractable::getOrientation(), BaseInteractable::getPosition(), BaseParticle::getRadius(), BaseInteractable::getSpecies(), BaseParticle::getWallInteractionRadius(), isWithinBoundingBox(), BaseInteractable::setPosition(), BaseParticle::setRadius(), BaseParticle::setSpecies(), and triangles_.

◆ getInteractionWith()

BaseInteraction * TriangleMeshWall::getInteractionWith	(	BaseParticle *	p,
		unsigned	timeStamp,
		InteractionHandler *	interactionHandler
	)

overridevirtual

Gets the interaction between a given BaseParticle and all TriangleWalls in this mesh at a given time. In case of multiple contacts, chooses the one with greatest overlap.

Parameters

p
timeStamp
interactionHandler

Returns

Note: Particle positions are rotated to lab frame, however the particle orientation itself is not considered, so most likely doesn't work properly for non-spherical particles.

Todo:: TW: I think this torque has the wrong sign

Reimplemented from BaseWall.

 {
     // In case of multiple contacts, we store the one with the maximum overlap and only calculate the forces for that interaction.
     // Since the BaseWall::getInteractionWith() automatically adds interactions to the handler, any interactions which
     // are not the one with greatest overlap should be removed from the handler.
     Mdouble maxOverlap = 0.0;
     BaseWall* maxWall = nullptr;
     
     // Change particle to local coordinates.
     //\todo How to handle orientation of non-spherical particles
     const Vec3D posOriginal = p->getPosition();
     p->setPosition(getOrientation().rotateBack(posOriginal - getPosition()));
     
     if (!isWithinBoundingBox(p->getPosition(), p->getWallInteractionRadius(this)))
     {
         p->setPosition(posOriginal);
         return nullptr;
     }
     
     // Loop through all triangles and find interactions and store the one with max overlap
     // (the main idea and the force calculations are literally copied from DPMBase::computeForcesDueToWalls)
     for (auto& t : triangles_)
     {
         // Checks if the particle is interacting with this triangle
         BaseInteraction* i = t.wall.getInteractionWith(p, timeStamp, interactionHandler);
         
         // When an interaction exists
         if (i != nullptr)
         {
             // When the overlap is greater than that of any previous interactions
             if (i->getOverlap() > maxOverlap)
             {
                 // Remove the previous maximum overlap interaction from the handler
                 if (maxWall != nullptr)
                 {
                     BaseInteraction* prevMaxI = interactionHandler->getInteraction(p, maxWall, timeStamp);
                     interactionHandler->removeObject(prevMaxI->getIndex());
                 }
                 
                 // Update the maximum overlap and store the interacting wall
                 maxOverlap = i->getOverlap();
                 maxWall = &t.wall;
             }
             else
             {
                 // Remove the last added interaction, as it is not the one with maximum overlap and should be discarded.
                 interactionHandler->removeObject(i->getIndex());
             }
         }
     }
     
     // Change particle back to its original coordinates, before doing any force calculations.
     p->setPosition(posOriginal);
     
     // When an interaction exists
     if (maxWall != nullptr)
     {
         // The interaction with maximum overlap
         BaseInteraction* i = interactionHandler->getInteraction(p, maxWall, timeStamp);
         // The TriangleWall which with the interaction occurred
         BaseInteractable* w = maxWall;
         
         // Rotate normal and change contact point to global coordinates
         i->setNormal(getOrientation().rotate(i->getNormal()));
         i->setContactPoint(getOrientation().rotate(i->getContactPoint()) + getPosition());
         
         // Transform TriangleWall position from local to global coordinates. (Needed for torque calculations etc.)
         const Vec3D wPosOriginal = w->getPosition();
         w->setPosition(getOrientation().rotateBack(w->getPosition()) + getPosition());
         // Add the mesh velocities to the TriangleWall velocities. Needed in the force calculations (relative velocity etc.).
         w->addVelocity(getVelocity());
         w->addAngularVelocity(getAngularVelocity());
         // At the moment the TriangleWalls in the mesh always have position, velocity and angular velocities equal to zero.
         // In case of future changes, however, they are treated as if they do have an actual value and therefore at the
         // end are also reset to those original values.
         
         //...calculates the forces between the two objects...
         i->computeForce();
         
         //...and applies them to each of the two objects (wall and particle).
         p->addForce(i->getForce());
         w->addForce(-i->getForce());
         
         //If the rotation flag is on, also applies the relevant torques (getRotation() returns a boolean).
         if (getHandler()->getDPMBase()->getRotation())
         {
             p->addTorque(i->getTorque() - Vec3D::cross(p->getPosition() - i->getContactPoint(), i->getForce()));
             w->addTorque(-i->getTorque() + Vec3D::cross(w->getPosition() - i->getContactPoint(), i->getForce()));
         }
         
         // Set the TriangleWall position and velocities back to their original (local) values.
         w->setPosition(wPosOriginal);
         w->addVelocity(-getVelocity());
         w->addAngularVelocity(-getAngularVelocity());
     }
     
     // Return no interaction for the main wall itself.
     return nullptr;
 }

References BaseInteractable::addAngularVelocity(), BaseInteractable::addForce(), BaseInteractable::addTorque(), BaseInteractable::addVelocity(), Vec3D::cross(), BaseInteractable::getAngularVelocity(), BaseWall::getHandler(), BaseObject::getIndex(), InteractionHandler::getInteraction(), BaseInteractable::getOrientation(), BaseInteractable::getPosition(), BaseInteractable::getVelocity(), BaseParticle::getWallInteractionRadius(), constants::i, isWithinBoundingBox(), BaseHandler< T >::removeObject(), rotate(), BaseInteractable::setPosition(), and triangles_.

◆ getName()

std::string TriangleMeshWall::getName ( ) const

overridevirtual

Returns the name of the object.

Returns: "TriangleMeshWall"

Implements BaseObject.

Reimplemented in WearableTriangleMeshWall.

 {
     return "TriangleMeshWall";
 }

◆ getNumberOfSegmentsAndResolution()

int TriangleMeshWall::getNumberOfSegmentsAndResolution	(	Mdouble	length,
		Mdouble &	resolution
	)

private

Finds the number of segments and the resolution needed to perfectly fit a length.

Parameters

length	Total length
resolution	Maximum length of a segment, will be made smaller when needed.

Returns: Resulting number of segments.

 {
     // Round up to get a whole number of segments, then update the resolution (might remain unchanged).
     double num = std::ceil(length / resolution);
     resolution = length / num;
     return static_cast<int>(num);
 }

Referenced by createParallelogramMesh().

◆ getPeriodicCompanions()

std::vector< unsigned > TriangleMeshWall::getPeriodicCompanions ( unsigned index )

private

Looks up the companions belonging to a vertex index, if it has any.

Parameters

index Index of the vertex to lookup the companions for.

Returns: Vector of vertex indices of the companions.

 {
     std::vector<unsigned> indices;
     
     // Loop through the companions, compare the index with both pair values and add the other to the return vector in case of a match.
     for (auto& p : periodicCompanions_)
     {
         if (p.first == index)
             indices.push_back(p.second);
         else if (p.second == index)
             indices.push_back(p.first);
     }
     
     return indices;
 }

References periodicCompanions_.

Referenced by moveVertex().

◆ getVolumeTetrahedron()

Mdouble TriangleMeshWall::getVolumeTetrahedron	(	const Vec3D &	a,
		const Vec3D &	b,
		const Vec3D &	c,
		const Vec3D &	d
	)

Calculates the volume of a tetrahedron formed by 4 vertices.

Returns: Volume of tetrahedron

 {
     return std::fabs(Vec3D::dot((a-d), Vec3D::cross((b-d), (c-d)))) / 6.0;
 }

References Vec3D::cross(), and Vec3D::dot().

Referenced by moveVerticesToMatchVolume().

◆ isLocal()

bool TriangleMeshWall::isLocal	(	Vec3D &	min,
		Vec3D &	max
	)		const

overridevirtual

if isLocal returns true and the DPM class derived from MercuryBase, the hGrid will be used to find wall-particle contacts, using min/max.

Reimplemented from BaseWall.

 {
     min = boundingBoxMinGlobal_;
     max = boundingBoxMaxGlobal_;
     return true;
 }

References boundingBoxMaxGlobal_, and boundingBoxMinGlobal_.

◆ isWithinBoundingBox()

bool TriangleMeshWall::isWithinBoundingBox	(	const Vec3D &	position,
		Mdouble	radius
	)		const

private

Checks whether or not a part of the particle is within the bounding box.

Parameters

position	Position of the particle
radius	Interaction radius of the particle

Returns: True when within the box

 {
     const Vec3D min = boundingBoxMin_ - Vec3D(radius, radius, radius);
     const Vec3D max = boundingBoxMax_ + Vec3D(radius, radius, radius);
     return position >= min && max >= position;
 }

References boundingBoxMax_, and boundingBoxMin_.

Referenced by getDistanceAndNormal(), and getInteractionWith().

◆ move()

void TriangleMeshWall::move ( const Vec3D & move )

overridevirtual

Moves this BaseInteractable by adding an amount to the position.

Moves (displaces) the interacable a given distance. Note, this just updates the position by the move.

Parameters

[in] move Reference to Vec3D which is the distance to move the interactable.

Reimplemented from BaseInteractable.

 {
     BaseWall::move(move);
     updateBoundingBoxGlobal();
 }

References BaseInteractable::move(), and updateBoundingBoxGlobal().

◆ moveVertex()

void TriangleMeshWall::moveVertex	(	unsigned	index,
		const Vec3D &	dP
	)

Updates a vertex by a given change in position.

Parameters

index	Index of vertex to move.
dP	Change in position.

 {
     // Update position of Vertex in vector.
     vertices_[index].position += dP;
     
     // Update each Triangle wall of the triangles who share this Vertex.
     for (auto& ti : vertices_[index].triangleIndices)
         triangles_[ti.first].wall.moveVertex(ti.second, dP);
     
     // Do the same for each of the possible companions of this index.
     for (unsigned idx : getPeriodicCompanions(index))
     {
         // Update position of Vertex in vector.
         vertices_[idx].position += dP;
     
         // Update each Triangle wall of the triangles who share this Vertex.
         for (auto& ti : vertices_[idx].triangleIndices)
             triangles_[ti.first].wall.moveVertex(ti.second, dP);
     }
     
     updateBoundingBox();
 }

References getPeriodicCompanions(), triangles_, updateBoundingBox(), and vertices_.

◆ moveVerticesToMatchVolume()

void TriangleMeshWall::moveVerticesToMatchVolume	(	std::vector< Vec3D >	displacements,
		Mdouble	targetVolume,
		int	maxNumRecursiveCalls = `15`
	)

Moves all vertices by given displacements and corrects to match the change in volume with the target volume. The final displacements will be proportional to the initial ones, but their actual values will have change.

Warning: This calculates absolute volume and might cause unexpected results when volume is both 'added' and 'removed'.

Parameters

displacements	Initial change in position for each vertex.
targetVolume	Volume that the change in volume must match.
maxNumRecursiveCalls	Maximum number of recursive calls allowed, in case certain tolerances are set too tight and infinite recursion occurs.

 {
     // Calculating the change in volume due to a moving triangle isn't analytically possible (not that I know of).
     // This is because when two vertices are moved, they don't necessarily lie in a plane with the original positions.
     // An approximation would be to split up the plane by picking one of the two diagonals, but which one to pick?
     // Luckily we are in a mesh and therefore the choice doesn't matter, as the neighbour will correct for any errors.
     // Only the edges of the mesh will then be an approximation, which is just something we have to live with.
     
     // The volume of the shape formed by the original and moved triangle can be calculated by splitting it up into 3
     // tetrahedrons. Each of these tetrahedrons is automatically formed when moving and updating the vertices one by one.
     // Therefore we simply loop through all the vertices in the mesh and for each of the triangles connected to it, we
     // calculate the volume of the tetrahedron formed by the 3 original vertices and the current updated vertex. The
     // latter is only actually updated after these volume calculations, so that they're not influenced by it. However
     // when this vertex is referenced in the remainder of the loop, the updated version is used, since that then forms
     // the second or third tetrahedron.
     
     // The total volume is kept track of and together with the target volume a ratio which is used to correct the vertex
     // displacements. A recursive call is then made with the corrected displacements. The recursion is stopped when the
     // ratio equals 1 and only then we actually know the displacements needed to get a change in volume matching the
     // target volume, which is then used to actually update the real vertices, i.e. the privately stored ones.
     
     if (targetVolume == 0.0)
         return;
  
     if (displacements.size() != vertices_.size())
     {
         logger(WARN, "Displacements vector must be equal in size as the number of vertices in the mesh.");
         return;
     }
     
     // In order to know if we are on the first run of this recursive method,
     // we store a static boolean and reset it once the recursion ends.
     static bool firstRecursiveCall = true;
     if (firstRecursiveCall)
     {
         firstRecursiveCall = false;
         
         // The vertex periodic companions are handled by adding the displacements to each other (only done once, on first run).
         // As one vertex can have multiple periodic companions, we first copy the displacements vector.
         // To prevent unnecessarily copying, however, we first check if there are any periodic companions.
         if (!periodicCompanions_.empty())
         {
             std::vector<Vec3D> disps = displacements;
             for (auto& p : periodicCompanions_)
             {
                 displacements[p.first] += disps[p.second];
                 displacements[p.second] += disps[p.first];
             }
         }
     }
     
     // Every call a clean copy of the original real vertices is made, so that they can be updated without affecting anything.
     std::vector<Vertex> vertices = vertices_;
     Mdouble totalVolume = 0.0;
     
     // Loop through vertices to displace them and calculate the change in volume for each triangle connected to it.
     for (int i = 0; i < vertices.size(); i++)
     {
         // Loop through each triangle connected to this vertex.
         for (auto& p : vertices[i].triangleIndices)
         {
             Triangle& t = triangles_[p.first];
             // Calculate the volume of the tetrahedron formed by each of the vertices of the triangle
             // (one of which is the current vertex) and the updated position of the current vertex.
             totalVolume += getVolumeTetrahedron(vertices[t.vertexIndices[0]].position,
                                                 vertices[t.vertexIndices[1]].position,
                                                 vertices[t.vertexIndices[2]].position,
                                                 vertices[i].position + displacements[i]);
         }
         
         // Only now actually update the current vertex position.
         vertices[i].position += displacements[i];
     }
     
     // Ratio between the target volume and actual volume
     Mdouble ratio = targetVolume / totalVolume;
  
     // Stop the recursive call when the ratio is equal to 1 (within certain tolerance).
     // Or when the ratio does not have a finite value (totalVolume turned out to be 0).
     Mdouble tol = 1.0e-6;
     if (mathsFunc::isEqual(ratio, 1.0, tol) || !std::isfinite(ratio) || maxNumRecursiveCalls == 0)
     {
         if (maxNumRecursiveCalls == 0)
             logger(WARN, "[TriangleMeshWall::moveVerticesToMatchVolume()] Maximum number of recursion calls reached for wall with id %.", getId());
  
         // Update the real vertices.
         int num = vertices_.size();
         for (int i = 0; i < num; i++)
             vertices_[i].position += displacements[i];
         
         // Update the real triangles wall.
         for (Triangle& t : triangles_)
             t.wall.moveVertices({ displacements[t.vertexIndices[0]], displacements[t.vertexIndices[1]], displacements[t.vertexIndices[2]] });
     
         updateBoundingBox();
         
         // Reset static boolean for the next time this function is first called.
         firstRecursiveCall = true;
         return;
     }
     
     // Multiply all displacements with the ratio.
     for (Vec3D& d : displacements)
         d *= ratio;
     // Recursive call.
     moveVerticesToMatchVolume(displacements, targetVolume, --maxNumRecursiveCalls);
 }

References BaseObject::getId(), getVolumeTetrahedron(), constants::i, mathsFunc::isEqual(), logger, periodicCompanions_, triangles_, updateBoundingBox(), TriangleMeshWall::Triangle::vertexIndices, vertices_, and WARN.

Referenced by WearableTriangleMeshWall::computeWear().

◆ operator=()

TriangleMeshWall & TriangleMeshWall::operator= ( const TriangleMeshWall & other )

Copy assignment operator.

Parameters

other The TriangleMeshWall that must be copied.

Returns

 {
     if (this == &other)
     {
         return *this;
     }
     return *(other.copy());
 }

References copy().

◆ read()

void TriangleMeshWall::read ( std::istream & is )

overridevirtual

Reads a TriangleMeshWall from an input stream, for example a restart file.

Reimplemented from BaseWall.

Reimplemented in WearableTriangleMeshWall.

 {
     BaseWall::read(is);
     
     std::string dummy;
     int num;
     is >> dummy >> num;
     
     std::vector<Vec3D> points(num);
     for (int i = 0; i < num; i++)
     {
         Vec3D p;
         is >> p;
         points[i] = p;
     }
     
     is >> dummy >> num;
     std::vector<std::array<unsigned, 3>> cells(num);
     for (int i = 0; i < num; i++)
     {
         std::array<unsigned, 3> c{};
         is >> c[0] >> c[1] >> c[2];
         cells[i] = c;
     }
     
     is >> dummy >> num;
     std::vector<std::pair<unsigned, unsigned>> periodicCompanions(num);
     for (int i = 0; i < num; i ++)
     {
         std::pair<unsigned, unsigned> p;
         is >> p.first >> p.second;
         periodicCompanions[i] = p;
     }
     
     set(points, cells);
     setPeriodicCompanions(periodicCompanions);
     
     updateBoundingBox();
 }

References constants::i, BaseWall::read(), set(), setPeriodicCompanions(), and updateBoundingBox().

Referenced by WearableTriangleMeshWall::read().

◆ refineTriangle()

void TriangleMeshWall::refineTriangle	(	unsigned	index,
		unsigned	numberOfTimes = `1`
	)

Makes a really basic refinement by adding a vertex in the middle of the triangle to create 3 new ones. Note: Multiple refinements will definitely NOT create a nice mesh.

Warning: For now can only be used in initial setup, i.e. when there are no interactions yet. Interactions have to be projected onto newly formed triangles, which is not yet implemented.

Parameters

index	Index of triangle to refine.
numberOfTimes	How many times to refine.

 {
     // A new vertex will be added in the middle of the triangle and 3 new triangles will be formed. The original triangle
     // will not be deleted, as erasing items from a vector can be slow. Instead its vertices positions and indices will
     // be updated to form one of the smaller triangles.
     // The local vertex indices are 0, 1, 2 and the newly added 3. The original triangle will go from 0, 1, 2 to 0, 1, 3.
     // The first new triangle will have indices 1, 2, 3, and the second 2, 0, 3.
     
     // (1)                                 (2)
     // _____________________________________
     // \\                                //
     //  \  \                          /  /
     //   \   \                     /    /
     //    \     \               /      /
     //     \       \          /       /
     //      \         \     /        /
     //       \          \ /         /
     //        \          |(3)      /
     //         \         |        /
     //          \        |       /
     //           \       |      /
     //            \      |     /
     //             \     |    /
     //              \    |   /
     //               \   |  /
     //                \  | /
     //                 \ |/
     //                  \/
     //                 (0)
     
     // Reserve space for 2 new triangles and 1 new vertex, otherwise references will be broken when adding to vectors.
     triangles_.reserve(triangles_.size() + 2);
     vertices_.reserve(vertices_.size() + 1);
     
     // The triangle to refine.
     Triangle& t = triangles_[index];
     
     // And its vertices.
     Vertex& v0 = vertices_[t.vertexIndices[0]];
     Vertex& v1 = vertices_[t.vertexIndices[1]];
     Vertex& v2 = vertices_[t.vertexIndices[2]];
     
     // Center of triangle is position for new vertex.
     const Vec3D p3 = (v0.position + v1.position + v2.position) / 3.0;
     vertices_.emplace_back(p3);
     const unsigned v3Index = vertices_.size() - 1;
     Vertex& v3 = vertices_[v3Index];
     
     // First new triangle.
     TriangleWall tw1;
     tw1.setVertices(v1.position, v2.position, v3.position);
     tw1.setSpecies(t.wall.getSpecies());
     Triangle t1(tw1, { t.vertexIndices[1], t.vertexIndices[2], v3Index });
     triangles_.push_back(t1);
     
     // Second new triangle.
     TriangleWall tw2;
     tw2.setVertices(v2.position, v0.position, v3.position);
     tw2.setSpecies(t.wall.getSpecies());
     Triangle t2(tw2, { t.vertexIndices[2], t.vertexIndices[0], v3Index });
     triangles_.push_back(t2);
     
     // Their indices for access in the triangles vector.
     const unsigned t2Index = triangles_.size() - 1;
     const unsigned t1Index = t2Index - 1;
     
     // Store the new triangle index and its local vertex index in the vertices.
     v0.triangleIndices.emplace_back(t2Index, 1);
     v1.triangleIndices.emplace_back(t1Index, 0);
     v2.triangleIndices.emplace_back(t1Index, 1);
     // The original triangle does not share vertex 2 anymore, so overwrite its index with that of the second new triangle.
     for (auto& p : v2.triangleIndices)
     {
         if (p.first == index)
         {
             p = std::pair<unsigned, unsigned>(t2Index, 0);
             break;
         }
     }
     
     // Store the triangles indices and local vertex indices in the newly added vertex.
     v3.triangleIndices.emplace_back(index, 2);
     v3.triangleIndices.emplace_back(t1Index, 2);
     v3.triangleIndices.emplace_back(t2Index, 2);
     
     // Overwrite the second vertex index of the original triangle with the newly added vertex.
     t.vertexIndices[2] = v3Index;
     // Update the original triangle vertex positions.
     t.wall.setVertices(v0.position, v1.position, v3.position);
     
     // Recursion, for multiple refinements.
     if (numberOfTimes > 1)
     {
         numberOfTimes--;
         // The newly added vertex shares all three new triangles, so remember their indices.
         const unsigned idx0 = v3.triangleIndices[0].first;
         const unsigned idx1 = v3.triangleIndices[1].first;
         const unsigned idx2 = v3.triangleIndices[2].first;
         // Then refine each of the new triangles.
         refineTriangle(idx0, numberOfTimes);
         refineTriangle(idx1, numberOfTimes);
         refineTriangle(idx2, numberOfTimes);
     }
 }

References BaseInteractable::getSpecies(), TriangleMeshWall::Vertex::position, BaseWall::setSpecies(), TriangleWall::setVertices(), TriangleMeshWall::Vertex::triangleIndices, triangles_, TriangleMeshWall::Triangle::vertexIndices, vertices_, and TriangleMeshWall::Triangle::wall.

◆ removeTriangle()

void TriangleMeshWall::removeTriangle	(	unsigned	index,
		bool	removeFreeVertex = `true`
	)

Removes a single triangle from the mesh.

Parameters

index	Index of triangle to remove.
removeFreeVertex	Removes a vertex when it has no more triangles attached to it.

 {
     // Remove any interactions the TriangleWall might have.
     // Otherwise later when in DPMBase interactionHandler.eraseOldInteractions(getNumberOfTimeSteps()) is called it
     // might cause crashes, since it might be trying to delete pointers which are already used for something else.
     for (BaseInteraction* i : triangles_[index].wall.getInteractions())
         i->removeFromHandler();
     
     // Swap to Triangle with the last Triangle in the vector and then simply pop_back. This is faster, cleaner and
     // simpler then using erase and having to update all other Triangle indices, since every index higher than the
     // removed one would have shifted one down. Now only the swapped Triangle index references have to be updated.
     const unsigned lastIndex = triangles_.size() - 1;
     Triangle triangleToRemove = triangles_[index];
     
     // Don't swap right way, since the swapped Triangle index references need to be updated, but since it's possible
     // that a free Vertex will be removed this might cause wrong index referencing.
     // So first remove the index reference to this Triangle, for each of its Vertices.
     for (unsigned vi : triangleToRemove.vertexIndices)
     {
         // Get the Triangle indices from this Vertex.
         auto& tis = vertices_[vi].triangleIndices;
         // Erase the index of the removed Triangle. This is only a short vector so erase is fine.
         // This will only remove one item, as it should only contain it once.
         tis.erase(std::remove_if(tis.begin(), tis.end(),[index](auto& p) { return p.first == index; }));
         
         // When no other Triangles are connected to this Vertex, it might be erased from the vector.
         if (removeFreeVertex && tis.empty())
         {
             // Removing a Vertex is done in a similar manner, by swapping and popping back.
             const unsigned lastIndexV = vertices_.size() - 1;
             Vertex vertexToRemove = vertices_[vi];
             vertices_[vi] = vertices_[lastIndexV];
             vertices_[lastIndexV] = vertexToRemove;
             vertices_.pop_back();
             
             // No Triangles with index references to the removed Vertex exist.
             // However, for every Triangle which is referencing the swapped Vertex, update the index with the removed index.
             for (auto& ti : vertices_[vi].triangleIndices)
                 for (unsigned& tvi : triangles_[ti.first].vertexIndices)
                     if (tvi == lastIndexV)
                     {
                         tvi = vi;
                         break;
                     }
     
             // If this vertex has any periodic companions, those should be removed from the vector.
             periodicCompanions_.erase(std::remove_if(periodicCompanions_.begin(), periodicCompanions_.end(),
                 [vi](auto& p) { return p.first == vi || p.second == vi; }), periodicCompanions_.end());
             // Also the swapped index should be updated with the removed index.
             for (auto& p : periodicCompanions_)
             {
                 if (p.first == lastIndexV)
                     p.first = vi;
                 else if (p.second == lastIndexV)
                     p.second = vi;
             }
         }
     }
     
     // Now swap the Triangles and pop back.
     triangles_[index] = triangles_[lastIndex];
     triangles_[lastIndex] = triangleToRemove;
     triangles_.pop_back();
     
     // For every Vertex which is referencing the swapped Triangle, update the index with the removed index.
     for (unsigned& vi : triangles_[index].vertexIndices)
         for (auto& ti : vertices_[vi].triangleIndices)
             if (ti.first == lastIndex)
             {
                 ti.first = index;
                 break;
             }
     
     updateBoundingBox();
 }

References constants::i, periodicCompanions_, triangles_, updateBoundingBox(), TriangleMeshWall::Triangle::vertexIndices, and vertices_.

◆ resetForceTorque()

void TriangleMeshWall::resetForceTorque ( int numberOfOMPthreads )

overridevirtual

Reimplemented from BaseInteractable.

 {
     BaseWall::resetForceTorque(numberOfOMPthreads);
     
     for (auto& t : triangles_)
         t.wall.resetForceTorque(numberOfOMPthreads);
 }

References BaseInteractable::resetForceTorque(), and triangles_.

◆ rotate()

void TriangleMeshWall::rotate ( const Vec3D & angularVelocityDt )

overridevirtual

Rotates this BaseInteractable.

Rotates the interacable a given solid angle. Note, this just updates the orientation by the angle.

This function has been declared virtual, so it can be overridden for IntersectionOfWalls.

Parameters

[in] angularVelocityDt Reference to Vec3D which is the solid angle through which the interactable is rotated.

Todo:: TW the move and rotate functions should only pass the time step, as teh velocity can be accessed directly by the object; this would simplify functions like Screw::rotate

Reimplemented from BaseInteractable.

 {
     BaseWall::rotate(angularVelocity);
     updateBoundingBoxGlobal();
 }

References BaseInteractable::rotate(), and updateBoundingBoxGlobal().

Referenced by getInteractionWith(), and writeVTK().

◆ set()

void TriangleMeshWall::set	(	const std::vector< Vec3D > &	points,
		const std::vector< std::array< unsigned, 3 >> &	cells
	)

Set function creating triangles.

Parameters

points	Vector of vertices
cells	Vector of cells, each cell holds three indices to the points vector

 {
     // The species for the triangles are the same as the main wall.
     // Note: when the species have not been set yet, this will be a nullptr,
     // so a check is done before actually setting the species for the triangles.
     auto species = getSpecies();
     
     // Clear mesh, as set function can be called multiple times to create different meshes. Useful when creating a
     // complicated mesh with the addToMesh() function.
     triangles_.clear();
     vertices_.clear();
     triangles_.reserve(cells.size());
     vertices_.reserve(points.size());
     
     // Add all the points as Vertex to the vector.
     for (auto& p : points)
         vertices_.emplace_back(p);
     
     for (auto& c : cells)
     {
         TriangleWall tw;
         // The position is the origin of the local coordinate system, which is always (0, 0, 0) (not getPosition()!).
         // This is needed in case the mesh has an angular velocity.
         tw.setVertices(points[c[0]], points[c[1]], points[c[2]], Vec3D(0.0, 0.0, 0.0));
         if (species != nullptr)
             tw.setSpecies(species);
         
         // Add as Triangle with TriangleWall and vertexIndices to the vector.
         triangles_.emplace_back(tw, c);
         
         // Add the Triangle index and the local vertex index to each of the Vertices.
         const unsigned tIndex = triangles_.size() - 1;
         vertices_[c[0]].triangleIndices.emplace_back(tIndex, 0);
         vertices_[c[1]].triangleIndices.emplace_back(tIndex, 1);
         vertices_[c[2]].triangleIndices.emplace_back(tIndex, 2);
     }
     
     updateBoundingBox();
 }

References BaseInteractable::getSpecies(), BaseWall::setSpecies(), TriangleWall::setVertices(), triangles_, updateBoundingBox(), and vertices_.

Referenced by createFourPointMesh(), createParallelogramMesh(), read(), and TriangleMeshWall().

◆ setOrientation()

void TriangleMeshWall::setOrientation ( const Quaternion & orientation )

overridevirtual

Sets the orientation of this BaseInteractable.

Interpretation depends on which interactable is being considered See also BaseInteractable::getOrientation.

Parameters

[in] orientation Reference to Vec3D storing the orientation of the particle.

Reimplemented from BaseInteractable.

 {
     BaseWall::setOrientation(orientation);
     updateBoundingBoxGlobal();
 }

References BaseInteractable::setOrientation(), and updateBoundingBoxGlobal().

◆ setPeriodicCompanions()

void TriangleMeshWall::setPeriodicCompanions ( const std::vector< std::pair< unsigned, unsigned >> & periodicCompanions )

Sets the vector with pairs of indices of vertices which lie on a periodic boundary and are each others 'companion'. E.g. when moving one vertex, the other is also moved the same amount. A vertex can have multiple companions (when lying on multiple periodic boundaries) and those should be in the vector as multiple pairs.

Parameters

periodicCompanions Vector of pairs containing the companions.

 {
     periodicCompanions_ = periodicCompanions;
 }

References periodicCompanions_.

Referenced by createParallelogramMesh(), and read().

◆ setPosition()

void TriangleMeshWall::setPosition ( const Vec3D & position )

overridevirtual

Sets the position of this BaseInteractable.

Interpretation depends on which interactable is being considered See also BaseInteractable::getPosistion.

Parameters

[in] position Reference to Vec3D storing the position of the particle.

Reimplemented from BaseInteractable.

 {
     BaseWall::setPosition(position);
     updateBoundingBoxGlobal();
 }

References BaseInteractable::setPosition(), and updateBoundingBoxGlobal().

◆ setSpecies()

void TriangleMeshWall::setSpecies ( const ParticleSpecies * species )

 {
     if (species == nullptr)
         return;
     BaseWall::setSpecies(species);
     for (auto& t : triangles_)
         t.wall.setSpecies(species);
 }

References BaseWall::setSpecies(), and triangles_.

Referenced by TriangleMeshWall().

◆ updateBoundingBox()

void TriangleMeshWall::updateBoundingBox ( )

private

Sets the local and global bounding boxes. This method should be called any time a vertex is updated in lab frame.

 {
     // Initialize min max.
     Vec3D min(constants::inf, constants::inf, constants::inf);
     Vec3D max(-constants::inf, -constants::inf, -constants::inf);
     
     // Loop through vertices and store min max positions.
     for (const Vertex& v : vertices_)
     {
         const Vec3D& pos = v.position;
         min = Vec3D::min(min, pos);
         max = Vec3D::max(max, pos);
     }
     
     boundingBoxMin_ = min;
     boundingBoxMax_ = max;
     
     updateBoundingBoxGlobal();
 }

References boundingBoxMax_, boundingBoxMin_, constants::inf, Vec3D::max(), Vec3D::min(), updateBoundingBoxGlobal(), and vertices_.

Referenced by addToMesh(), moveVertex(), moveVerticesToMatchVolume(), read(), removeTriangle(), and set().

◆ updateBoundingBoxGlobal()

void TriangleMeshWall::updateBoundingBoxGlobal ( )

private

Sets the global bounding box, using the bounding box in lab frame. This method should be called when there are changes in global frame, but not in lab frame. E.g. when calling setPosition().

 {
     // This basically is putting a bounding box around the rotated and translated lab frame bounding box.
     
     // All corners of the lab frame bounding box. Using min max for clarity.
     Vec3D min = boundingBoxMin_, max = boundingBoxMax_;
     Vec3D v0 = Vec3D(min.X, min.Y, min.Z);
     Vec3D v1 = Vec3D(min.X, min.Y, max.Z);
     Vec3D v2 = Vec3D(max.X, min.Y, max.Z);
     Vec3D v3 = Vec3D(max.X, min.Y, min.Z);
     Vec3D v4 = Vec3D(min.X, max.Y, min.Z);
     Vec3D v5 = Vec3D(min.X, max.Y, max.Z);
     Vec3D v6 = Vec3D(max.X, max.Y, max.Z);
     Vec3D v7 = Vec3D(max.X, max.Y, min.Z);
     
     // Store in array so we can do a auto loop by reference.
     std::array<Vec3D, 8> corners = { v0, v1, v2, v3, v4, v5, v6, v7 };
     
     // Reinitialize min max to use in loop.
     min = Vec3D(constants::inf, constants::inf, constants::inf);
     max = Vec3D(-constants::inf, -constants::inf, -constants::inf);
     
     // Loop through corners, rotate and translate them to global frame, get global min max position.
     for (Vec3D& pos : corners)
     {
         getOrientation().rotate(pos);
         pos += getPosition();
         min = Vec3D::min(min, pos);
         max = Vec3D::max(max, pos);
     }
     
     boundingBoxMinGlobal_ = min;
     boundingBoxMaxGlobal_ = max;
 }

References boundingBoxMax_, boundingBoxMaxGlobal_, boundingBoxMin_, boundingBoxMinGlobal_, BaseInteractable::getOrientation(), BaseInteractable::getPosition(), constants::inf, Vec3D::max(), Vec3D::min(), Quaternion::rotate(), Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by move(), rotate(), setOrientation(), setPosition(), and updateBoundingBox().

◆ write()

void TriangleMeshWall::write ( std::ostream & os ) const

overridevirtual

Writes a TriangleMeshWall to an output stream, for example a restart file.

Reimplemented from BaseWall.

Reimplemented in WearableTriangleMeshWall.

 {
     BaseWall::write(os);
     
     os << " points " << vertices_.size();
     for (const Vertex& v : vertices_)
         os << ' ' << v.position;
     os << " cells " << triangles_.size();
     for (const Triangle& t : triangles_)
         os << ' ' << t.vertexIndices[0] << ' ' << t.vertexIndices[1] << ' ' << t.vertexIndices[2];
     os << " periodicCompanions " << periodicCompanions_.size();
     for (auto& p : periodicCompanions_)
         os << ' ' << p.first << ' ' << p.second;
 }

References periodicCompanions_, triangles_, vertices_, and BaseWall::write().

Referenced by WearableTriangleMeshWall::write().

◆ writeVTK()

void TriangleMeshWall::writeVTK ( VTKContainer & vtk ) const

overridevirtual

adds extra information to the points and triangleStrips vectors needed to plot the wall in vtk format

Parameters

points	Coordinates of the vertices of the triangulated surfaces (in the VTK file this is called POINTS)
triangleStrips	Indices of three vertices forming one triangulated surface (in the VTK file this is called CELL)

Reimplemented from BaseWall.

 {
     const unsigned long s = vtk.points.size();
  
     for (auto& v : vertices_)
     {
         vtk.points.push_back(getOrientation().rotate(v.position) + getPosition());
     }
     
     for (auto& t : triangles_)
     {
         vtk.triangleStrips.push_back({ static_cast<double>(s + t.vertexIndices[0]),
                                        static_cast<double>(s + t.vertexIndices[1]),
                                        static_cast<double>(s + t.vertexIndices[2]) });
     }
 }

References BaseInteractable::getOrientation(), BaseInteractable::getPosition(), VTKContainer::points, rotate(), triangles_, VTKContainer::triangleStrips, and vertices_.

Member Data Documentation

◆ boundingBoxMax_

Vec3D TriangleMeshWall::boundingBoxMax_

private

Referenced by isWithinBoundingBox(), TriangleMeshWall(), updateBoundingBox(), and updateBoundingBoxGlobal().

◆ boundingBoxMaxGlobal_

Vec3D TriangleMeshWall::boundingBoxMaxGlobal_

private

Referenced by isLocal(), TriangleMeshWall(), and updateBoundingBoxGlobal().

◆ boundingBoxMin_

Vec3D TriangleMeshWall::boundingBoxMin_

private

Bounding box corners in lab frame and global frame. Used to speed up contact detection. HGrid uses the global frame min max.

Referenced by isWithinBoundingBox(), TriangleMeshWall(), updateBoundingBox(), and updateBoundingBoxGlobal().

◆ boundingBoxMinGlobal_

Vec3D TriangleMeshWall::boundingBoxMinGlobal_

private

Referenced by isLocal(), TriangleMeshWall(), and updateBoundingBoxGlobal().

◆ periodicCompanions_

std::vector<std::pair<unsigned, unsigned> > TriangleMeshWall::periodicCompanions_

private

Referenced by getPeriodicCompanions(), moveVerticesToMatchVolume(), removeTriangle(), setPeriodicCompanions(), TriangleMeshWall(), and write().

◆ triangles_

std::vector<Triangle> TriangleMeshWall::triangles_

protected

Referenced by addToMesh(), WearableTriangleMeshWall::computeWear(), getDistanceAndNormal(), getInteractionWith(), moveVertex(), moveVerticesToMatchVolume(), refineTriangle(), removeTriangle(), resetForceTorque(), set(), setSpecies(), TriangleMeshWall(), write(), and writeVTK().

◆ vertices_

std::vector<Vertex> TriangleMeshWall::vertices_

protected

Referenced by addToMesh(), WearableTriangleMeshWall::computeWear(), moveVertex(), moveVerticesToMatchVolume(), refineTriangle(), removeTriangle(), set(), WearableTriangleMeshWall::storeDebris(), TriangleMeshWall(), updateBoundingBox(), write(), and writeVTK().

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

Classes

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ TriangleMeshWall() [1/4]

◆ TriangleMeshWall() [2/4]

◆ TriangleMeshWall() [3/4]

◆ TriangleMeshWall() [4/4]

◆ ~TriangleMeshWall()

Member Function Documentation

◆ addToMesh()

◆ addZigZagDiagonalCells()

◆ copy()

◆ createFourPointMesh()

◆ createParallelogramMesh()

◆ getDistanceAndNormal()

◆ getInteractionWith()

◆ getName()

◆ getNumberOfSegmentsAndResolution()

◆ getPeriodicCompanions()

◆ getVolumeTetrahedron()

◆ isLocal()

◆ isWithinBoundingBox()

◆ move()

◆ moveVertex()

◆ moveVerticesToMatchVolume()

◆ operator=()

◆ read()

◆ refineTriangle()

◆ removeTriangle()

◆ resetForceTorque()

◆ rotate()

◆ set()

◆ setOrientation()

◆ setPeriodicCompanions()

◆ setPosition()

◆ setSpecies()

◆ updateBoundingBox()

◆ updateBoundingBoxGlobal()

◆ write()

◆ writeVTK()

Member Data Documentation

◆ boundingBoxMax_

◆ boundingBoxMaxGlobal_

◆ boundingBoxMin_

◆ boundingBoxMinGlobal_

◆ periodicCompanions_

◆ triangles_

◆ vertices_