TriangulatedWall::Face Struct Reference

Struct used to store the properties of a face needed for contact detection. More...

#include <TriangulatedWall.h>

Public Member Functions
Mdouble	getDistance (const Vec3D &otherPosition) const
	computes the signed distance to the face in normal direction More...
bool	getDistanceAndNormal (const BaseParticle &p, Mdouble &distance, Vec3D &normal_return) const
	Returns true if contact with the face exists, false if not. If contact exists, then the distance and normal is returned as well. More...

Public Attributes
std::array< Vec3D *, 3 >	vertex
	defines the three vertices (anticlockwise direction around the normal) More...
std::array< Face *, 3 >	neighbor = {{nullptr}}
	For each edge, stores the neighboring face (nullptr if none) More...
std::array< Vec3D, 3 >	edgeNormal
	For each edge, stores the vector normal to the face normal and the edge direction (vector between the vertices). More...
Vec3D	normal
	face normal (vertices are ordered anticlockwise direction around the normal) More...

Detailed Description

Struct used to store the properties of a face needed for contact detection.

Definition at line 59 of file TriangulatedWall.h.

Member Function Documentation

Mdouble TriangulatedWall::Face::getDistance

(

const Vec3D &

otherPosition

)

const

computes the signed distance to the face in normal direction

Definition at line 318 of file TriangulatedWall.cc.

References Vec3D::dot(), normal, and vertex.

{
    return Vec3D::dot(*vertex[0] - otherPosition, normal);
}

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

Returns true if contact with the face exists, false if not. If contact exists, then the distance and normal is returned as well.

check if there is contact with the face, determine if contact is with face, edge, vertex, return distance and normal; only return edge, vertex contact if neighbor face pointer is higher to avoid doubles

Todo:

make the triangle work from both sides

Definition at line 327 of file TriangulatedWall.cc.

References Vec3D::dot(), Vec3D::getLength(), Vec3D::getLengthSquared(), BaseInteractable::getPosition(), and BaseParticle::getWallInteractionRadius().

{
    //check if particle overlaps
    distance = getDistance(p.getPosition());
    //return if distance is large, or particle has too much overlap
    Mdouble interactionRadius = p.getWallInteractionRadius();
    if (fabs(distance) >= interactionRadius)
        return false;

    //Contact radius squared
    Mdouble allowedDistanceSquared = interactionRadius*interactionRadius-distance*distance;
    int touchingEdge = -1;
    Vec3D* touchingVertex = nullptr;
    //loop through edges to find out if there is a contact with face, edge, vertex, or neither.
    for (unsigned i=0; i<3; i++)
    {
        //distance from the edge
        Mdouble edgeDistance = Vec3D::dot(edgeNormal[i], *vertex[i] - p.getPosition());
        if (edgeDistance<=0) //if in contact with the face
            continue;
        if (edgeDistance * edgeDistance >= allowedDistanceSquared) //if not in contact with anything
            return false;
        //this point is only reached if in contact, but not with the face
        //if edge is convex, treat as face, not edge contact
        bool convex = (neighbor[i] && ((neighbor[i]->getDistance(p.getPosition())<0)?(Vec3D::dot(neighbor[i]->normal,edgeNormal[i])>1e-12):(Vec3D::dot(neighbor[i]->normal,edgeNormal[i])<-1e-12)));
        if (touchingEdge==-1) {
            //edge or vertex contact (depending if more edges are found)
            touchingEdge = i;
        } else {
            //vertex contact
            touchingVertex = vertex[(i==2 && touchingEdge==0)?0:i];
        }
        //if (!convex) continue;
        //do not compute if neighbor exists and has lower index or face contact.
        if (neighbor[i] > this){ //if neighbor has higher index
            if (neighbor[i]->neighbor[0]==this) {
                edgeDistance = Vec3D::dot(neighbor[i]->edgeNormal[0], *vertex[i] - p.getPosition());
            } else if (neighbor[i]->neighbor[1]==this) {
                edgeDistance = Vec3D::dot(neighbor[i]->edgeNormal[1], *vertex[i] - p.getPosition());
            } else { //if (neighbor[i]->neighbor[2]==this)
                edgeDistance = Vec3D::dot(neighbor[i]->edgeNormal[2], *vertex[i] - p.getPosition());
            }
            if (edgeDistance<=0  && !convex) //if neighbor has face contact, ignore the edge contact
                return false;
        } else if (neighbor[i] && !convex) {
            return false;
        }
    }


    //check if convex neighbours are overlapping as well
    if (touchingVertex) { //vertex contact
        normal_return = *touchingVertex -p.getPosition();
        distance = Vec3D::getLength(normal_return);
        normal_return /= distance;
        //return false;
        //logger(INFO,"vertex contact");
    } else if (touchingEdge==-1) { //face contact
        if (distance>=0) { // front face contact
            normal_return = normal;
        } else { // back face contact
            normal_return = -normal;
            distance = -distance;
        }
        //return false;
        //logger(INFO,"face contact");
    } else { //edge contact
        Vec3D VP = *vertex[touchingEdge] - p.getPosition();
        Vec3D VW = *vertex[touchingEdge] - *vertex[(touchingEdge==2)?0:(touchingEdge+1)];
        normal_return = VP - Vec3D::dot(VP, VW)/Vec3D::getLengthSquared(VW)*VW;
        distance = Vec3D::getLength(normal_return);
        normal_return /= distance;
        //return false;
        //logger(INFO,"edge contact at c=% p=% d=% n=%",p.getPosition() + distance * normal_return,p.getPosition(), distance, normal_return);
    }
    return true;
}

Member Data Documentation

std::array<Vec3D,3> TriangulatedWall::Face::edgeNormal

For each edge, stores the vector normal to the face normal and the edge direction (vector between the vertices).

Definition at line 66 of file TriangulatedWall.h.

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

For each edge, stores the neighboring face (nullptr if none)

Definition at line 64 of file TriangulatedWall.h.

Vec3D TriangulatedWall::Face::normal

face normal (vertices are ordered anticlockwise direction around the normal)

Definition at line 68 of file TriangulatedWall.h.

Referenced by getDistance().

std::array<Vec3D*,3> TriangulatedWall::Face::vertex

defines the three vertices (anticlockwise direction around the normal)

Definition at line 62 of file TriangulatedWall.h.

Referenced by getDistance(), and TriangulatedWall::readVTK().

---

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

• Walls/TriangulatedWall.h
• Walls/TriangulatedWall.cc