MeshTriangle implements a triangle whose vertex positions are defined by three particles. More...

#include <MeshTriangle.h>

Inheritance diagram for MeshTriangle:

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

	MeshTriangle (const MeshTriangle &other)=default
	Copy constructor. More...

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

MeshTriangle *	copy () const override
	Wall copy method. It calls the copy constructor of this Wall, useful for polymorphism. More...

std::string	getName () const override
	Returns the name of the object, here the string "MeshTriangle". More...

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

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

void	setVertices (Vec3D A, Vec3D B, Vec3D C)
	Sets member variables such that the wall represents a triangle with vertices A, B, C. More...

void	setVertices (Vec3D A, Vec3D B, Vec3D C, Vec3D position)
	Same as setVertices(A,B,C), but sets the position explicitly. The position is important when you rotate the wall, as the wall will be rotated around this position. More...

void	setVertexVelocities (Vec3D A, Vec3D B, Vec3D C)
	Sets the velocity of the vertex points. More...

std::array< Vec3D, 3 >	getVertices () const
	Returns an array of the vertex coordinates. More...

Vec3D	getFaceNormal () const
	Returns the face normal. More...

Mdouble	getArea () const
	Returns the area of the triangle. More...

void	move (const Vec3D &move) override

void	setVertexIds (unsigned int i, unsigned int j, unsigned int k)
	sets the ids of the vertex particles. Calls retrieveVertexParticles. More...

std::array< unsigned int, 3 >	getVertexIds () const
	Returns an array containing the ids of the vertex particles. More...

void	writeVTK (VTKContainer &vtk) const override

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

void	checkInteractions (InteractionHandler *interactionHandler, unsigned int timeStamp) override
	Checks, if the forces of all interctions should be applied. More...

bool	getDistanceAndNormal (const BaseParticle &p, Mdouble &distance, Vec3D &normal_return) const override
	Compute the distance from the wall for a given BaseParticle and return if there is a collision. If there is a collision, also return the normal vector. More...

bool	getDistanceNormalOverlapType (const BaseParticle &p, Mdouble &distance, Vec3D &normal, Mdouble &overlap, unsigned int &type) const

const Vec3D	getVelocityAtContact (const Vec3D &contact) const override
	Calculates the local velocity at a specified point. More...

const Vec3D	getBaricentricWeight (const Vec3D &contact) const
	Calculates the barycentric weight of a specified point. More...

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

bool	isLocal (Vec3D &min, Vec3D &max) const override
	Determines if the triangle is considered local. More...

bool	isInsideTriangle (const Vec3D &point) const
	Determines if a given point is within the triangle. More...

Mdouble	getInvMass () const override

void	setMass (Mdouble mass)

void	actionsOnRestart () override
	Actions executed on restart. More...

void	actionsAfterParticleGhostUpdate () override
	actionsPerformed after the position update of (ghost-) particles. More...

void	handleParticleRemoval (unsigned int id) override
	Handles the removal of particles to the particle Handler. More...

void	handleParticleAddition (unsigned int id, BaseParticle *p) override
	Handles the addition of particles to the particle Handler. More...

void	retrieveVertexParticles ()
	Tries to get pointers to all vertex particles from the handler. More...

void	checkActive ()
	Check if the triangle is considered active. More...

bool	getActive ()

void	setHandler (WallHandler *handler) override
	Set the handler. More...

void	applyPressure (Mdouble presure)
	Apply a force pointing in normal direction corresponding to the specified pressure. More...

void	applyForce (Vec3D force)
	Apply the given force to the triangle. 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

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

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

virtual void	resetForceTorque (int numberOfOMPthreads)

void	sumForceTorqueOMP ()

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

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

virtual void	setPosition (const Vec3D &position)
	Sets the position 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...

virtual void	setOrientation (const Quaternion &orientation)
	Sets the orientation of this BaseInteractable. 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...

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

Public Attributes
std::array< MeshTriangle *, 3 >	neighbor = {{nullptr}}

std::vector< std::vector< unsigned int > >	vertexNeighbors

Private Member Functions
void	updateVertexAndNormal ()
	Update vertexMin_, vertexMax_ and faceNormal_ for an updated position. More...

void	updateVerticesFromParticles ()
	Retrieve new positions from updated vertex particles. More...

Private Attributes
std::array< Vec3D, 3 >	vertex_

std::array< Vec3D, 3 >	vertexVelocity_

std::array< BaseParticle *, 3 >	vertexParticle_ = {{nullptr}}

Vec3D	vertexMin_

Vec3D	vertexMax_

std::array< Vec3D, 3 >	edgeNormal_

std::array< Vec3D, 3 >	edge_

std::array< unsigned int, 3 >	vertexIds_

std::array< double, 3 >	edgeLength_

Vec3D	faceNormal_

Mdouble	area_

Mdouble	invMass_ = 0.0

bool	isActive = 0

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

Detailed Description

MeshTriangle implements a triangle whose vertex positions are defined by three particles.

It tracks the movement of the specified particles and updates its own potition every timestep. If neighboring objects along the edges and vertices are known, their contacts will be taken into account to consider if particle contacts should produce a force. Calculated contact forces will be transferred to the certex particles.

A triangle may e.g. be constructed with the following code.

p0 = Vec3D(0, 0.1, 1);
p1 = Vec3D(0, 0.1, 0.9);
p2 = Vec3D(0, 0  , 1);
 
SphericalParticle p;
p.setSpecies(someSpecies);
p.setRadius(2e-2);
p.setVelocity(Vec3D(0.0, 0.0, 0.0));
p.setHandler(&particleHandler);
 
p.setPosition(p0);
unsigned int Id1 = particleHandler.copyAndAddObject(p)->getId();
p.setPosition(p1);
unsigned int Id2 = particleHandler.copyAndAddObject(p)->getId();
p.setPosition(p2);
unsigned int Id3 = particleHandler.copyAndAddObject(p)->getId();
 
MeshTriangle f;
f.setVertices(p0, p1, p2);
 
// Create all faces with their initial positions
f.setVertexIds(0, 1, 2);
f.setSpecies(someSpecies);
f.setMass(mass);
// Retrieve the correct positions from the particles
f.actionsAfterParticleGhostUpdate();

For a longer example, please have a look at the class Membrane.

Constructor & Destructor Documentation

◆ MeshTriangle() [1/2]

MeshTriangle::MeshTriangle ( )

default

Default constructor.

Referenced by copy().

◆ MeshTriangle() [2/2]

MeshTriangle::MeshTriangle ( const MeshTriangle & other )

default

Copy constructor.

◆ ~MeshTriangle()

MeshTriangle::~MeshTriangle ( )

overridedefault

Destructor.

Member Function Documentation

◆ actionsAfterParticleGhostUpdate()

void MeshTriangle::actionsAfterParticleGhostUpdate ( )

overridevirtual

actionsPerformed after the position update of (ghost-) particles.

After the particles get new positions, these need to be retrived to update the triangle.

Reimplemented from BaseWall.

 {
     updateVerticesFromParticles();
 }

References updateVerticesFromParticles().

◆ actionsOnRestart()

void MeshTriangle::actionsOnRestart ( )

overridevirtual

Actions executed on restart.

On restart, try to get all vertex particle pointers.

Reimplemented from BaseWall.

 {
     // Note this can not be done in the read sequence, as the particles are not yet available there
     retrieveVertexParticles();
 }

References retrieveVertexParticles().

◆ applyForce()

void MeshTriangle::applyForce ( Vec3D force )

Apply the given force to the triangle.

Parameters

[in] force

Applies a given force to the triangle, by splitting it between the vertex particles.

 {
     if (isActive)
     {
         force /= 3.0;
         for (unsigned int j=0; j<3; j++){
             vertexParticle_[j]->addForce(force);
         }
     }
     
 }

References isActive, j, and vertexParticle_.

◆ applyPressure()

void MeshTriangle::applyPressure ( Mdouble pressure )

Apply a force pointing in normal direction corresponding to the specified pressure.

Parameters

[in] pressure The pressure value in units of 1 Pa

Calculates the force acting on the triangle using the pressure and the triangles surface area. Applies the force to the vertex particles.

 {
     if (isActive)
     {
         // Area in Normaldirection
         // Calculate F = p*A/3.0
         // The division by 3.0 is to split the force evenly between the points
         Vec3D pressureForce = getArea()*pressure*getFaceNormal()/3.0;
         for (unsigned int j=0; j<3; j++){
             vertexParticle_[j]->addForce(pressureForce);
         }
     }
 }

References getArea(), getFaceNormal(), isActive, j, and vertexParticle_.

◆ checkActive()

void MeshTriangle::checkActive ( )

Check if the triangle is considered active.

Checks if the triangle is active. A triangle is considered active, if pointers to all references are known.

 {
     isActive = !(!vertexParticle_[0] || !vertexParticle_[1] || !vertexParticle_[2]);
 }

References isActive, and vertexParticle_.

Referenced by handleParticleAddition(), retrieveVertexParticles(), and updateVerticesFromParticles().

◆ checkInteractions()

void MeshTriangle::checkInteractions	(	InteractionHandler *	interactionHandler,
		unsigned int	timeStamp
	)

overridevirtual

Checks, if the forces of all interctions should be applied.

Parameters

[in]	interactionHandler	Pointer to InteractionHandler that contains all the interactions.
[in]	timeStamp	The time at which we want to look at the interactions.

Determine, if a contact os valid, i.e. that the forces due to this contact should be applied to both the particle in the wall. The evaluation is done by looking at the interaction a specific particle has with the current wall as well as neighboring walls. If a particle has multiple contacts, the selection criteria noted in doi:10.1002/nme.4487 are applied. Note: At this time this leads to issues when the particles are much bigger than the triangles.

Reimplemented from BaseWall.

 {
     unsigned j, id;
     // Iterate through the interactions and check if there is one with higher priority
     // Note: The id should already be taken into account when creating the interactions
     for (j = 0; j<getInteractions().size(); j++)
     {
         bool interactionValid = true;
         auto i = getInteractions()[j];
         if (i->getTimeStamp()!=timeStamp)
         {
             continue; // Old interactions are not needed
             logger(WARN, "Taking old interaction into account");
         }
         if (i->getMultiContactIdentifier()>3) // Vertex contact
         {
             id = i->getMultiContactIdentifier() - 4;
             
             for (auto triangleId : vertexNeighbors[id])
             {
                 // If a neighboring particle has a contact and a lower Id with
                 // the same particle, disregard this contact
                 if (triangleId<this->getId())
                 {
                     interactionValid = false;
                     break;
                 }
                 // logger(INFO, "id % %", id, getId());
                 auto k = getHandler()->getObjectById(triangleId);
                 auto interactionNeighbor = interactionHandler->getExistingInteraction(i->getP(), k);
                 if (interactionNeighbor && interactionNeighbor->getTimeStamp()==timeStamp)
                 {
                     if (interactionNeighbor->getMultiContactIdentifier() <= 3)
                     {
                         // logger(INFO, "Found invalid vertex contact");
                         interactionValid = false;
                         break;
                     }
                 }
             }
         }
         else if (i->getMultiContactIdentifier()>0) // Edge contact
         {
             id = i->getMultiContactIdentifier() - 1;
             if (neighbor[id])
             {
                 // If a neighboring particle has at least an edge contact with
                 // the same particle and a lower Id, disregard this contact
                 if (neighbor[id]->getId()<this->getId())
                 {
                     // logger(INFO, "Found invalid Edge contact due to Id");
                     interactionValid = false;
                 } 
                 else
                 {
                     auto interactionNeighbor = interactionHandler->getExistingInteraction(i->getP(), neighbor[id]);
                     if (interactionNeighbor && interactionNeighbor->getTimeStamp()==timeStamp)
                     {
                         if (interactionNeighbor->getMultiContactIdentifier() == 0)
                         {
                             // logger(INFO, "Found invalid edge contact");
                             interactionValid = false;
                         }
                     }
                 }
             }
         }
  
         // Undo the interaction
         if (!interactionValid)
         {
             i->getP()->addForce(-i->getForce());
             this->addForce(i->getForce());
             if (getHandler()->getDPMBase()->getRotation())
             {
                 i->getP()->addTorque(-i->getTorque() + Vec3D::cross(i->getP()->getPosition() - i->getContactPoint(), i->getForce()));
                 this->addTorque(i->getTorque() - Vec3D::cross(this->getPosition() - i->getContactPoint(), i->getForce()));
             }
             i->setForce(Vec3D(0,0,0));
         }
         else
         {
             Vec3D weight = getBaricentricWeight(i->getContactPoint());
             
             // Contact seems valid, distribute its force to the edges
             Vec3D force = -i->getForce();
  
             for(unsigned k=0; k<3; k++)
             {   
                 vertexParticle_[k]->addForce(weight.getComponent(k)*force);
             }
         }
     }
 }

References BaseInteractable::addForce(), BaseInteractable::addTorque(), Vec3D::cross(), getBaricentricWeight(), Vec3D::getComponent(), InteractionHandler::getExistingInteraction(), BaseWall::getHandler(), BaseObject::getId(), BaseInteractable::getInteractions(), BaseHandler< T >::getObjectById(), i, j, k, logger, neighbor, vertexNeighbors, vertexParticle_, and WARN.

◆ copy()

MeshTriangle* MeshTriangle::copy ( ) const

inlineoverridevirtual

Wall copy method. It calls the copy constructor of this Wall, useful for polymorphism.

Implements BaseWall.

77 { return new MeshTriangle(*this); }

MeshTriangle::MeshTriangle

MeshTriangle()=default

Default constructor.

References MeshTriangle().

◆ getActive()

bool MeshTriangle::getActive ( )

inline

215 { return isActive; }

References isActive.

◆ getArea()

Mdouble MeshTriangle::getArea ( ) const

inline

Returns the area of the triangle.

126 {return area_;}

MeshTriangle::area_

Mdouble area_

Definition: MeshTriangle.h:283

References area_.

Referenced by applyPressure().

◆ getBaricentricWeight()

const Vec3D MeshTriangle::getBaricentricWeight ( const Vec3D & contact ) const

Calculates the barycentric weight of a specified point.

Parameters

[in] contact The point, at which the weights should be calculated.

Returns: A Vec3D giving the weights. (x is the weight of corner 0,...)

Calculates baricentric weight of a given point in the triangle

 {
     Vec3D m;
     // The area of a triangle is
     // Taken from https://gamedev.stackexchange.com/questions/23743/whats-the-most-efficient-way-to-find-barycentric-coordinates
     // Mdouble areaABC = Vec3D::dot( getFaceNormal(), Vec3D::cross(vertex_[1]-vertex_[0], vertex_[2]-vertex_[0] )  ) ;
     // logger.assert_always(std::fabs(areaABC-area_*2)<1e-8, "OOPS, triangle area calculared wrong % %", areaABC, area_*2);
     Mdouble areaPBC = 0.5*Vec3D::dot( getFaceNormal(), Vec3D::cross(vertex_[1]-contact, vertex_[2]-contact )  ) ;
     Mdouble areaPCA = 0.5*Vec3D::dot( getFaceNormal(), Vec3D::cross(vertex_[2]-contact, vertex_[0]-contact )  ) ;
  
     m.X = areaPBC / area_ ; // alpha
     m.Y = areaPCA / area_ ; // beta
     m.Z = 1.0f - m.X - m.Y ; // gamma
     return m;
 }

References area_, Vec3D::cross(), Vec3D::dot(), getFaceNormal(), m, and vertex_.

Referenced by checkInteractions(), getVelocityAtContact(), and isInsideTriangle().

◆ getDistanceAndNormal()

bool MeshTriangle::getDistanceAndNormal	(	const BaseParticle &	p,
		Mdouble &	distance,
		Vec3D &	normal
	)		const

overridevirtual

Compute the distance from the wall for a given BaseParticle and return if there is a collision. If there is a collision, also return the normal vector.

Parameters

[in]	p	BaseParticle we want to calculate the distance and whether it collided of.
[out]	distance	The distance of the BaseParticle to this wall.
[out]	normal_return	If there was a collision, the normal vector to this wall will be placed here.

Returns: A boolean which says whether or not there was a collision.

This function computes whether or not there is a collision between a given BaseParticle and this MeshTriangle. If there is a collision, this function also computes the distance between the BaseParticle and MeshTriangle and the normal of the MeshTriangle at the intersection point. It does this by calling MeshTriangle::getDistanceNormalOverlapType. Since this function should be called before calculating any Particle-Wall interactions, it can also be used to set the normal vector in case of curved walls.

Implements BaseWall.

 {
     if (!isActive) return false;
     Mdouble overlap;
     unsigned int type;
     return getDistanceNormalOverlapType(p, distance, normal, overlap, type);
 }

References getDistanceNormalOverlapType(), isActive, WallFunction::normal(), p, and compute_granudrum_aor::type.

◆ getDistanceNormalOverlapType()

bool MeshTriangle::getDistanceNormalOverlapType	(	const BaseParticle &	p,
		Mdouble &	distance,
		Vec3D &	normal,
		Mdouble &	overlap,
		unsigned int &	type
	)		const

Parameters

[in]	p	BaseParticle we want to calculate the distance and whether it collided of.
[out]	distance	The distance of the BaseParticle to this wall.
[out]	normal_return	If there was a collision, the normal vector to this wall will be placed here.
[out]	overlap_return	If there was a collision, the overlap will be placed here.
[out]	type_return	If there was a collision, the contact type will be placed here.

Returns: A boolean which says whether or not there was a collision.

This function computes whether or not there is a collision between a given BaseParticle and this MeshTriangle. If there is a collision, this function also computes the distance between the BaseParticle and MeshTriangle and the normal of the MeshTriangle at the intersection point as well as the contact overlap and type. The type is set to the following: 0: face contact 1, 2, 3: contact with type-1th edge 4, 5, 6; contact with the type-4th vertex

 {
     if (!isActive) return false;
     
     // TODO: Note that this if may lead to contacts beeing ignored in md->checkParticleForInteraction because unadded
     // particles have the Id 0, which might indeed be the Id of a node particle
     if ( std::find(vertexIds_.begin(), vertexIds_.end(), p.getId()) != vertexIds_.end() )
     {
         // Do not detect any contact between particles that correspond to the walls nodes
         return false;
     }
     
     const Vec3D position = p.getPosition(); // note: no transfer to lab coordinates
     const Mdouble distanceMax = p.getWallInteractionRadius(this);
  
     // compute distance from face
     // get distance from particle position to the face
     const Mdouble signedDistance = Vec3D::dot(position-vertex_[0], faceNormal_);
     distance = std::abs(signedDistance);
  
     // check if any contact is possible
     if (distance >= distanceMax) return false;
  
     // compute distance from edges
     const std::array<Vec3D,3> edgeBranch {position - vertex_[0], position - vertex_[1], position - vertex_[2]};
     const std::array<double,3> edgeDistance {Vec3D::dot(edgeBranch[0], edgeNormal_[0]), Vec3D::dot(edgeBranch[1], edgeNormal_[1]), Vec3D::dot(edgeBranch[2], edgeNormal_[2])};
  
     // find edge with largest distance (this will be the edge if there is a edge contact)
     const size_t id = (edgeDistance[1] > edgeDistance[2]) ?
             (edgeDistance[0] > edgeDistance[1] ? 0 : 1) : (edgeDistance[0] > edgeDistance[2] ? 0 : 2);
  
     // check if there will be contact
     if (edgeDistance[id] > distanceMax) return false;
  
     // determine if it is a face contact
     const Vec3D posProjected = position - signedDistance * faceNormal_;
     if (edgeDistance[id] <= 0 && isInsideTriangle(posProjected)){
         normal = (signedDistance >= 0) ? -faceNormal_ : faceNormal_;
         overlap = p.getRadius() - distance;
         type=0; // Face contact
         return true;
     }
  
     // Then the neighbor will handle this interaction
     // determine if it is an edge or vertex contact
     const double positionAlongEdge = Vec3D::dot(edgeBranch[id], edge_[id]);
     if (positionAlongEdge <= 0) {
         //possible contact with left vertex
         distance = edgeBranch[id].getLength();
         if (distance > distanceMax) return false;
         // check vertex ids
         normal = edgeBranch[id] / -distance;
         type = 4 + id; // Vertex contact
     } else if (positionAlongEdge >= edgeLength_[id]) {
         //contact with right vertex
         const size_t idRight = (id + 1) % 3;
         distance = edgeBranch[idRight].getLength();
         if (distance > distanceMax) return false;
         // check vertex ids
         type = 4 + idRight; // Vertex contact
         normal = edgeBranch[idRight] / -distance;
  
     } else {
         // edge contact
         normal = edge_[id] * positionAlongEdge - edgeBranch[id];
         distance = normal.getLength();
         if (distance > distanceMax) return false;
         normal /= distance;
         type = 1 + id;
     }
  
     overlap = p.getRadius() - distance;
     return true;
 }

References abs(), Vec3D::dot(), edge_, edgeLength_, edgeNormal_, faceNormal_, isActive, isInsideTriangle(), WallFunction::normal(), p, compute_granudrum_aor::type, vertex_, and vertexIds_.

Referenced by getDistanceAndNormal(), and getInteractionWith().

◆ getFaceNormal()

Vec3D MeshTriangle::getFaceNormal ( ) const

inline

Returns the face normal.

121 {return faceNormal_;}

References faceNormal_.

Referenced by applyPressure(), and getBaricentricWeight().

◆ getInteractionWith()

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

overridevirtual

Parameters

[in]	p	Pointer to the BaseParticle which we want to check the interaction for.
[in]	timeStamp	The time at which we want to look at the interaction.
[in]	interactionHandler	A pointer to the InteractionHandler in which the interaction can be found.

Returns: A pointer to the BaseInteraction that happened between this BaseWall and the BaseParticle at the timeStamp.

It is determined, if there is any contact between the particle and the triangular wall. If a contact exists, all neccesary quantities are determined and set. This includes the contact type is determined (corner, edge or face contact, see laos doi:10.1002/nme.4487) and set with setMultiContactIdentifier.

Todo:

Reimplemented from BaseWall.

 {
     if (!isActive) return nullptr;
     
     // TODO: Note that this if may lead to contacts beeing ignored in md->checkParticleForInteraction because unadded
     // particles have the Id 0, which might indeed be the Id of an node particle
     if ( std::find(vertexIds_.begin(), vertexIds_.end(), p->getId()) != vertexIds_.end() )
     {
         // Do not detect any contact between particles that correspond to the walls nodes
         return nullptr;
     }
     
     Mdouble distance;
     Vec3D normal;
     Mdouble overlap;
     unsigned int type;
  
     if (!(p->isSphericalParticle()))
     {
         logger(ERROR, "MeshTriangle::getInteractionWith not implemented for particles of type %", p->getName());
     }
  
     if (getDistanceNormalOverlapType(*p, distance, normal, overlap, type))
     {
         // look for an existing interaction, or create a new one
         BaseInteraction *c = nullptr;
         if (getGroupId() > 0 && p->getInteractions().size() > 0)
         {
             // Do not care for the result in that case.
             return BaseWall::getInteractionWith(p, timeStamp, interactionHandler);
         }
  
         // look for an existing interaction, or create a new one
         c = interactionHandler->getInteraction(p, this, timeStamp);
  
         c->setNormal(-normal);
         c->setDistance(distance);
         c->setOverlap(overlap);
         c->setMultiContactIdentifier(type);
         c->setWallInteraction(1);
  
         c->setContactPoint(p->getPosition() - (p->getRadius() - 0.5 * c->getOverlap()) * c->getNormal());
  
         logger(DEBUG, "Particle contact with wall at %", c->getContactPoint());
         return c;
     }
     return nullptr;
 }

References calibrate::c, DEBUG, ERROR, getDistanceNormalOverlapType(), BaseObject::getGroupId(), InteractionHandler::getInteraction(), BaseWall::getInteractionWith(), isActive, logger, WallFunction::normal(), p, compute_granudrum_aor::type, and vertexIds_.

◆ getInvMass()

Mdouble MeshTriangle::getInvMass ( ) const

overridevirtual

returns the inverse mass. This value is zero for walls and gets overridden for particles that have finite mass

Reimplemented from BaseInteractable.

 {
     return invMass_;
 }

References invMass_.

◆ getName()

std::string MeshTriangle::getName ( ) const

inlineoverridevirtual

Returns the name of the object, here the string "MeshTriangle".

Implements BaseObject.

83 { return "MeshTriangle"; }

◆ getVelocityAtContact()

const Vec3D MeshTriangle::getVelocityAtContact ( const Vec3D & contact ) const

overridevirtual

Calculates the local velocity at a specified point.

Parameters

[in] contact The point, at which the velocity should be determined.

Returns: A Vec3D giving the calculated velocity.

Calculates the velocity at the contact position by interpolating the velocity of the triangle nodes using barycentric coordinates.

Reimplemented from BaseInteractable.

 {
     Vec3D m = getBaricentricWeight(contact);
     return m.x()*vertexVelocity_[0] + m.y()*vertexVelocity_[1] + m.z()*vertexVelocity_[2];
 };

References getBaricentricWeight(), m, and vertexVelocity_.

◆ getVertexIds()

std::array<unsigned int, 3> MeshTriangle::getVertexIds ( ) const

inline

Returns an array containing the ids of the vertex particles.

139 { return vertexIds_; }

References vertexIds_.

◆ getVertices()

std::array<Vec3D,3> MeshTriangle::getVertices ( ) const

inline

Returns an array of the vertex coordinates.

116 {return vertex_;}

References vertex_.

◆ handleParticleAddition()

void MeshTriangle::handleParticleAddition	(	unsigned int	id,
		BaseParticle *	p
	)

overridevirtual

Handles the addition of particles to the particle Handler.

Parameters

[in]	id	The id of the added particle
[in]	p	Pointer to the particle

If thie given id is equal to one of the vertex Particles, the reference is added. If this added particle makes the triangle active, the vertex positions are uodated using updateVerticesFromParticles().

Reimplemented from BaseWall.

 {
     unsigned int i;
     for (i=0; i<3; i++)
     {
         if (vertexIds_[i] == id)
         {
             vertexParticle_[i] = p;
             checkActive();
             updateVerticesFromParticles();
         }
     }
 }

References checkActive(), i, p, updateVerticesFromParticles(), vertexIds_, and vertexParticle_.

◆ handleParticleRemoval()

void MeshTriangle::handleParticleRemoval ( unsigned int id )

overridevirtual

Handles the removal of particles to the particle Handler.

Parameters

[in] id The id of the removed particle

If the given id is equal to one of the vertexParticles, the reference to that particle is removed and the triangle is set inactive

Reimplemented from BaseWall.

 {
     unsigned int i;
     for (i=0; i<3; i++)
     {
         if (vertexIds_[i] == id)
         {
             vertexParticle_[i] = nullptr;
             isActive = false;
         }
     }
 }

References i, isActive, vertexIds_, and vertexParticle_.

◆ isInsideTriangle()

bool MeshTriangle::isInsideTriangle ( const Vec3D & point ) const

Determines if a given point is within the triangle.

Parameters

[in] point Position to check

Returns: boolean specifying if point is within the triangle

 {
     Vec3D weights = getBaricentricWeight(point);
     
     Mdouble eps = 1e-12;
     return ((1-eps) > weights.X > eps && (1-eps) > weights.Y > eps && (1-eps) > weights.Z > eps) && ((1-eps) > weights.X+weights.Y > eps && (1-eps) > weights.Y+weights.Z > eps && (1-eps) > weights.Z+weights.X > eps);
     // return ((1-eps) > s0 > eps && (1-eps) > s1 > eps && (1-eps) > s2 > eps) && ((1-eps) > s0+s1 > eps && (1-eps) > s1+s2 > eps && (1-eps) > s2+s0 > eps);
     
 }

References e(), CRBond_Bessel::eps, getBaricentricWeight(), and calibrate::weights.

Referenced by getDistanceNormalOverlapType().

◆ isLocal()

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

overridevirtual

Determines if the triangle is considered local.

Parameters

[out]	min	the minimum of the triangle in all directions.
[out]	max	the maximum of the triangle in all directions

Returns: true The triangle is local

Reimplemented from BaseWall.

 {
     min = vertexMin_;
     max = vertexMax_;
     return true;
 }

References max, min, vertexMax_, and vertexMin_.

◆ move()

void MeshTriangle::move ( const Vec3D & move )

overridevirtual

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.

 {
     BaseInteractable::move(move);
     updateVertexAndNormal();
 }

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

◆ read()

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

overridevirtual

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

Parameters

[in] is The input stream from which the MeshTriangle is read, usually a restart file.

Reimplemented from BaseWall.

 {
     BaseWall::read(is);
     
     unsigned int i, j, s1, s2, Id;
     std::string dummy;
     
     is >> dummy >> s1;
     vertexNeighbors.reserve(s1);
     for (i=0; i<s1; i++)
     {
         is >> dummy >> s2;
         std::vector<unsigned int> vN;
         vN.reserve(s2);
         
         for (j=0; j<s2; j++)
         {
             is >> Id;
             vN.push_back(Id);
         }
         vertexNeighbors.push_back(vN);
         
     }
     
     
     
     is >> dummy;
     for (int i = 0; i < 3; i++)
     {
         is >> vertex_[i];
     }
     is >> dummy;
     for (int i = 0; i < 3; i++)
     {
         is >> vertexIds_[i];
     }
     
     is >> dummy >> invMass_;
     is >> dummy >> isActive;
     
     // updateVerticesFromParticles();
 }

References i, invMass_, isActive, j, BaseWall::read(), oomph::Global_string_for_annotation::string(), vertex_, vertexIds_, and vertexNeighbors.

◆ retrieveVertexParticles()

void MeshTriangle::retrieveVertexParticles ( )

Tries to get pointers to all vertex particles from the handler.

Tries to get the pointer to the vertex particles from the particleHandler. Afterwards it checks if the triangle is active and updates the vertex positions.

 {
     if (getHandler())
     {
         unsigned int i;
         for (i=0; i<3; i++)
         {
             vertexParticle_[i] = getHandler()->getDPMBase()->particleHandler.getObjectById(vertexIds_[i]);
         }
         checkActive();
         updateVerticesFromParticles();
     }
 }

References checkActive(), BaseHandler< T >::getDPMBase(), BaseWall::getHandler(), BaseHandler< T >::getObjectById(), i, DPMBase::particleHandler, updateVerticesFromParticles(), vertexIds_, and vertexParticle_.

Referenced by actionsOnRestart(), setHandler(), and setVertexIds().

◆ rotate()

void MeshTriangle::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.

 {
     if (!angularVelocityDt.isZero())
     {
         BaseInteractable::rotate(angularVelocityDt);
         updateVertexAndNormal();
     }
 }

References Vec3D::isZero(), BaseInteractable::rotate(), and updateVertexAndNormal().

◆ setHandler()

void MeshTriangle::setHandler ( WallHandler * handler )

overridevirtual

Set the handler.

Parameters

[in] handler Pointer to the wallHandler.

Sets the wall handler and calls retrieveVertexParticles

Reimplemented from BaseWall.

 {
     BaseWall::setHandler(handler);
     
     if (handler->getDPMBase()->particleHandler.getNumberOfObjects()==0)
     {
         // Without this, restart does not work
         return;
     }
  
     retrieveVertexParticles();
 }

References BaseHandler< T >::getDPMBase(), ParticleHandler::getNumberOfObjects(), DPMBase::particleHandler, retrieveVertexParticles(), and BaseWall::setHandler().

◆ setMass()

void MeshTriangle::setMass ( Mdouble mass )

Parameters

[in] mass Value of the mass assigned to the triangle.

The mass is neccesary for contact force determination. If not given, infinite mass is assumed.

 {
     logger.assert_always(mass > 0.0,
                         "Error in MeshTriangle::setMass, the given mass to be set must be positive.");
     invMass_ = 1.0 / mass;
  
 }

References invMass_, and logger.

◆ setVertexIds()

void MeshTriangle::setVertexIds	(	unsigned int	i,
		unsigned int	j,
		unsigned int	k
	)

sets the ids of the vertex particles. Calls retrieveVertexParticles.

Parameters

[in] i,j,k The ids of the particles representing the corners.

 {
     vertexIds_[0] = i;
     vertexIds_[1] = j;
     vertexIds_[2] = k;
     retrieveVertexParticles();
 }

References i, j, k, retrieveVertexParticles(), and vertexIds_.

◆ setVertexVelocities()

void MeshTriangle::setVertexVelocities	(	Vec3D	A,
		Vec3D	B,
		Vec3D	C
	)

Sets the velocity of the vertex points.

 {
     vertexVelocity_[0] = A;
     vertexVelocity_[1] = B;
     vertexVelocity_[2] = C;
 }

References vertexVelocity_.

Referenced by updateVerticesFromParticles().

◆ setVertices() [1/2]

void MeshTriangle::setVertices	(	Vec3D	A,
		Vec3D	B,
		Vec3D	C
	)

Sets member variables such that the wall represents a triangle with vertices A, B, C.

position_ is set to the center of mass of the wall
updateVertexAndNormal is called to set the remaining variables

 {
     setVertices(A, B, C, (A + B + C) / 3);
 }

Referenced by updateVerticesFromParticles().

◆ setVertices() [2/2]

void MeshTriangle::setVertices	(	Vec3D	A,
		Vec3D	B,
		Vec3D	C,
		Vec3D	position
	)

Same as setVertices(A,B,C), but sets the position explicitly. The position is important when you rotate the wall, as the wall will be rotated around this position.

 {
     setPosition(position);
     setOrientation({1, 0, 0, 0});
     vertex_[0] = A;
     vertex_[1] = B;
     vertex_[2] = C;
     updateVertexAndNormal();
 }

References BaseInteractable::setOrientation(), BaseInteractable::setPosition(), updateVertexAndNormal(), and vertex_.

◆ updateVertexAndNormal()

void MeshTriangle::updateVertexAndNormal ( )

private

Update vertexMin_, vertexMax_ and faceNormal_ for an updated position.

This function should be called after setting either position_ or vertexInLabFrame_.

vertex is set to the vertex position in the real coordinate system (rotated and shifted)
vertexMin_/vertexMax_ is set to define a bounding box around the wall (for contact detection)
edge_, edgeNormal_ and faceNormal_ is updated (stored for quick computation of contact point)

 {
     vertexMin_ = Vec3D::min(Vec3D::min(vertex_[0], vertex_[1]), vertex_[2]);
     vertexMax_ = Vec3D::max(Vec3D::max(vertex_[0], vertex_[1]), vertex_[2]);
  
     edge_ = {vertex_[1] - vertex_[0], vertex_[2] - vertex_[1], vertex_[0] - vertex_[2]};
     faceNormal_ = Vec3D::cross(edge_[0], edge_[1]);
     area_ = 0.5*faceNormal_.getLength();
     logger.assert_always(0.5*sqrt(Vec3D::cross(vertex_[1] - vertex_[0], vertex_[2] - vertex_[1]).getLengthSquared())==area_, "OOPS, face area wrong");
     
     faceNormal_.normalise();
  
     for (int i = 0; i < 3; i++)
     {
         edgeNormal_[i] = Vec3D::cross(edge_[i], faceNormal_);
         edgeLength_[i] = edge_[i].getLength();
         edge_[i] /= edgeLength_[i];
         edgeNormal_[i].normalise();
     }
     //logger(INFO,"vertex %,%,% edge %,%,% face %",vertex_[0],vertex_[1],vertex_[2],edgeNormal_[0],edgeNormal_[1],edgeNormal_[2],faceNormal_);
 }

References area_, Vec3D::cross(), edge_, edgeLength_, edgeNormal_, faceNormal_, Vec3D::getLength(), i, logger, Vec3D::max(), Vec3D::min(), Vec3D::normalise(), sqrt(), vertex_, vertexMax_, and vertexMin_.

Referenced by move(), rotate(), and setVertices().

◆ updateVerticesFromParticles()

void MeshTriangle::updateVerticesFromParticles ( )

private

Retrieve new positions from updated vertex particles.

Update the triangle position and velocity based on the vertex particles, if the triangle is active.

 {
     // Need to get references to the particles
     checkActive();
     if (!isActive) return;
     
     setVertices(vertexParticle_[0]->getPosition(), vertexParticle_[1]->getPosition(), vertexParticle_[2]->getPosition());
     setVertexVelocities(vertexParticle_[0]->getVelocity(), vertexParticle_[1]->getVelocity(), vertexParticle_[2]->getVelocity());
 }

References checkActive(), BaseInteractable::getPosition(), BaseInteractable::getVelocity(), isActive, setVertexVelocities(), setVertices(), and vertexParticle_.

Referenced by actionsAfterParticleGhostUpdate(), handleParticleAddition(), and retrieveVertexParticles().

◆ write()

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

overridevirtual

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

Parameters

[in] os The output stream where the MeshTriangle must be written to, usually a restart file.

Reimplemented from BaseWall.

 {
     BaseWall::write(os);
     unsigned int i, j, s1, s2;
     s1 = vertexNeighbors.size();
     os << " vertexNeighbors " << s1;
     for (i=0; i<s1; i++)
     {
         s2 = vertexNeighbors[i].size();
         os << " vertexNeighborsElements " << s2;
         for (j=0; j<s2; j++)
         {
             os << " " << vertexNeighbors[i][j];            
         }
     }
     
     os << " vertex ";
     for (int i = 0; i < 3; i++)
     {
         os << ' ' << vertex_[i];
     }
     os << " edgeParticleIds ";
     for (int i = 0; i < 3; i++)
     {
         os << ' ' << vertexIds_[i];
     }
     
     os << " invMass " << invMass_;
     
     os << " isActive " << isActive;
     
     // Note: need not to write faceNormal_ and area_, as these are recalculated
     // on read.
 }

References i, invMass_, isActive, j, vertex_, vertexIds_, vertexNeighbors, and BaseWall::write().

◆ writeVTK()

void MeshTriangle::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.

 {
     if (!isActive) return;
     
     const unsigned long s = vtk.points.size();
     for (auto v : vertex_)
     {
         vtk.points.push_back(v);
     }
     std::vector<double> cell;
     cell.reserve(3);
     cell.push_back(s);
     cell.push_back(s + 1);
     cell.push_back(s + 2);
     
     vtk.triangleStrips.push_back(cell);
 }

References isActive, VTKContainer::points, s, VTKContainer::triangleStrips, v, and vertex_.

Member Data Documentation

◆ area_

Mdouble MeshTriangle::area_

private

Referenced by getArea(), getBaricentricWeight(), and updateVertexAndNormal().

◆ edge_

std::array<Vec3D, 3> MeshTriangle::edge_

private

Referenced by getDistanceNormalOverlapType(), and updateVertexAndNormal().

◆ edgeLength_

std::array<double, 3> MeshTriangle::edgeLength_

private

Referenced by getDistanceNormalOverlapType(), and updateVertexAndNormal().

◆ edgeNormal_

std::array<Vec3D, 3> MeshTriangle::edgeNormal_

private

stores the wall normal n in n.x=p

Referenced by getDistanceNormalOverlapType(), and updateVertexAndNormal().

◆ faceNormal_

Vec3D MeshTriangle::faceNormal_

private

stores the face normal, not rotated into the lab frame; thus, if the wall rotates, this normal has to be rotated as well

Referenced by getDistanceNormalOverlapType(), getFaceNormal(), and updateVertexAndNormal().

◆ invMass_

Mdouble MeshTriangle::invMass_ = 0.0

private

Referenced by getInvMass(), read(), setMass(), and write().

◆ isActive

bool MeshTriangle::isActive = 0

private

Referenced by applyForce(), applyPressure(), checkActive(), getActive(), getDistanceAndNormal(), getDistanceNormalOverlapType(), getInteractionWith(), handleParticleRemoval(), read(), updateVerticesFromParticles(), write(), and writeVTK().

◆ neighbor

std::array<MeshTriangle*, 3> MeshTriangle::neighbor = {{nullptr}}

stores references to the neighbors along the edges.

Referenced by checkInteractions().

◆ vertex_

std::array<Vec3D, 3> MeshTriangle::vertex_

private

stores the position of the vertices relative to the position of the wall but not rotated into the lab frame; thus, if the wall rotates, these vertices have to be rotated as well

Referenced by getBaricentricWeight(), getDistanceNormalOverlapType(), getVertices(), read(), setVertices(), updateVertexAndNormal(), write(), and writeVTK().

◆ vertexIds_

std::array<unsigned int, 3> MeshTriangle::vertexIds_

private

Referenced by getDistanceNormalOverlapType(), getInteractionWith(), getVertexIds(), handleParticleAddition(), handleParticleRemoval(), read(), retrieveVertexParticles(), setVertexIds(), and write().

◆ vertexMax_

Vec3D MeshTriangle::vertexMax_

private

Referenced by isLocal(), and updateVertexAndNormal().

◆ vertexMin_

Vec3D MeshTriangle::vertexMin_

private

stores the min and max coordinate values of the vertices (needed for hGrid)

Referenced by isLocal(), and updateVertexAndNormal().

◆ vertexNeighbors

std::vector<std::vector<unsigned int> > MeshTriangle::vertexNeighbors

stores references to the neighbors on corners.

Referenced by checkInteractions(), read(), and write().

◆ vertexParticle_

std::array<BaseParticle*, 3> MeshTriangle::vertexParticle_ = {{nullptr}}

private

Referenced by applyForce(), applyPressure(), checkActive(), checkInteractions(), handleParticleAddition(), handleParticleRemoval(), retrieveVertexParticles(), and updateVerticesFromParticles().

◆ vertexVelocity_

std::array<Vec3D, 3> MeshTriangle::vertexVelocity_

private

Referenced by getVelocityAtContact(), and setVertexVelocities().

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

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MeshTriangle() [1/2]

◆ MeshTriangle() [2/2]

◆ ~MeshTriangle()

Member Function Documentation

◆ actionsAfterParticleGhostUpdate()

◆ actionsOnRestart()

◆ applyForce()

◆ applyPressure()

◆ checkActive()

◆ checkInteractions()

◆ copy()

◆ getActive()

◆ getArea()

◆ getBaricentricWeight()

◆ getDistanceAndNormal()

◆ getDistanceNormalOverlapType()

◆ getFaceNormal()

◆ getInteractionWith()

◆ getInvMass()

◆ getName()

◆ getVelocityAtContact()

◆ getVertexIds()

◆ getVertices()

◆ handleParticleAddition()

◆ handleParticleRemoval()

◆ isInsideTriangle()

◆ isLocal()

◆ move()

◆ read()

◆ retrieveVertexParticles()

◆ rotate()

◆ setHandler()

◆ setMass()

◆ setVertexIds()

◆ setVertexVelocities()

◆ setVertices() [1/2]

◆ setVertices() [2/2]

◆ updateVertexAndNormal()

◆ updateVerticesFromParticles()

◆ write()

◆ writeVTK()

Member Data Documentation

◆ area_

◆ edge_

◆ edgeLength_

◆ edgeNormal_

◆ faceNormal_

◆ invMass_

◆ isActive

◆ neighbor

◆ vertex_

◆ vertexIds_

◆ vertexMax_

◆ vertexMin_

◆ vertexNeighbors

◆ vertexParticle_

◆ vertexVelocity_