A IntersectionOfWalls is convex polygon defined as an intersection of InfiniteWall's. More...

#include <IntersectionOfWalls.h>

Inheritance diagram for IntersectionOfWalls:

Classes
struct	normalAndPosition

Public Member Functions
	IntersectionOfWalls ()
	Default constructor. More...

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

	IntersectionOfWalls (const std::vector< normalAndPosition > &walls, const ParticleSpecies *species)
	Constructor setting values. More...

	~IntersectionOfWalls () override
	Destructor. More...

IntersectionOfWalls &	operator= (const IntersectionOfWalls &other)

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

void	clear ()
	Removes all parts of the walls. More...

void	setSpecies (const ParticleSpecies *species)
	sets species of subwalls as well More...

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

unsigned int	getNumberOfObjects ()
	Returns the number of objects. More...

void	addObject (Vec3D normal, Vec3D point)
	Adds a wall to the set of infinite walls, given a normal vector pointing into the wall (i.e. out of the simulation domain), going through the point, so that normalx=normalpoint. More...

void	addObject (Quaternion orientation, Vec3D position)

void	add3PointObject (Vec3D PointA, Vec3D PointB, Vec3D PointC)

void	setPointsAndLines (unsigned int n)

void	addTetraSTL (Vec3D PointA, Vec3D PointB, Vec3D PointC, Vec3D WallNormal, Mdouble Thickness, int wallidentifier)
	constructs a tetrahedron for an STL file input More...

void	addTetra (const Vec3D &PointA, const Vec3D &PointB, const Vec3D &PointC, Mdouble &Thickness)
	constructs a tetrahedron from 3 input coordinates More...

void	addPlate (const Vec3D &PointA, const Vec3D &PointB, const Vec3D &PointC, const Vec3D &WallNormal, const Mdouble &Thickness, int wallidentifier)

MERCURYDPM_DEPRECATED void	addObject (Vec3D normal, Mdouble position)
	Adds a wall to the set of finite walls, given an normal vector pointing into the wall (i.e. out of the flow domain), to give a plane defined by normal*x=position. More...

void	createOpenPrism (std::vector< Vec3D > points, Vec3D prismAxis)
	Creates an open prism which is a polygon between the points, except the first and last point, and extends infinitely in the PrismAxis direction. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly. More...

void	createPrism (std::vector< Vec3D > points, Vec3D prismAxis)
	Creates an open prism which is a polygon between the points and extends infinitely in the PrismAxis direction. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly. More...

void	createOpenPrism (std::vector< Vec3D > points)
	Creates an open prism which is a polygon between the points, except the first and last point, and extends infinitely in the direction perpendicular to the first and second wall. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly. More...

void	createPrism (std::vector< Vec3D > points)
	Creates an open prism which is a polygon between the points and extends infinitely in the direction perpendicular to the first and second wall. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly. 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	getDistanceAndNormal (const Vec3D &position, Mdouble wallInteractionRadius, Mdouble &distance, Vec3D &normal_return) const
	Compute the distance from the wall for a given BaseParticle and return if there is an interaction. If there is an interaction, also return the normal vector. More...

void	read (std::istream &is) override
	Move the IntersectionOfWalls to a new position, which is a Vec3D from the old position. More...

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

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

void	writeVTK (VTKContainer &vtk) const override

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

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

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

BaseInteraction *	getInteractionWith (BaseParticle p, unsigned timeStamp, InteractionHandler interactionHandler) override
	Returns the interaction between this wall and a given particle, nullptr if there is no interaction. More...

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

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

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

virtual void	rotate (const Vec3D &angularVelocityDt)
	Rotates 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...

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< InfiniteWall >	wallObjects_
	The wall "segments"/directions that together make up the finite wall. More...

std::vector< Vec3D >	C_
	A vector that stores the intersection point of three different InfiniteWall. More...

Private Attributes
std::vector< Vec3D >	A_
	A vector that stores a point for each intersecting line between two different InfiniteWall. More...

std::vector< Vec3D >	AB_
	A vector that stores the direction of the intersecting lines between two different InfiniteWall. More...

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

A IntersectionOfWalls is convex polygon defined as an intersection of InfiniteWall's.

It can be defined as the intersection of a set of InfiniteWall's, defined by the normal vector into the wall and a point on the wall. For example, the following gives a cube |x|<1 and |y|<1:

IntersectionOfWalls w;
//for each wall, specify a normal and position vector
w.addObject(Vec3D(-1, 0, 0),Vec3D(1, 0, 0));
w.addObject(Vec3D(1, 0, 0),Vec3D(0, 0, 0));
w.addObject(Vec3D(0, -1, 0),Vec3D(0, 1, 0));
w.addObject(Vec3D(0, 1, 0),Vec3D(0, 0, 0));
wallHandler.copyAndAddObject(w);

A particle of radius *r* and position *x* touches an InfiniteWall with normal *n* and position *p* if \(p-n\cdot x\leq r\) (note 'touching particles' also includes particles that are completely enclosed inside the wall). A particle touches an IntersectionOfWalls if it touches all InfiniteWall objects (shown in the image below).

For a demonstration on how to use this class, see T8: Motion of a particle in a box with an obstacle and Flow through a 3D hourglass/silo (shown in the image below).

Constructor & Destructor Documentation

◆ IntersectionOfWalls() [1/3]

IntersectionOfWalls::IntersectionOfWalls ( )

Default constructor.

 {
     logger(DEBUG, "IntersectionOfWalls() constructed.");
 }

References DEBUG, and logger.

Referenced by copy().

◆ IntersectionOfWalls() [2/3]

IntersectionOfWalls::IntersectionOfWalls ( const IntersectionOfWalls & other )

Copy constructor.

Parameters

[in] other The IntersectionOfWalls that must be copied.

         : BaseWall(other)
 {
     wallObjects_ = other.wallObjects_;
     for (auto& wall : wallObjects_)
     {
         if (getHandler() != nullptr)
             wall.setHandler(getHandler());
     }
     A_ = other.A_;
     AB_ = other.AB_;
     C_ = other.C_;
     logger(DEBUG, "IntersectionOfWalls(IntersectionOfWalls&) constructed.");
 }

References A_, AB_, C_, DEBUG, BaseWall::getHandler(), logger, and wallObjects_.

◆ IntersectionOfWalls() [3/3]

IntersectionOfWalls::IntersectionOfWalls	(	const std::vector< normalAndPosition > &	walls,
		const ParticleSpecies *	species
	)

Constructor setting values.

 {
     setSpecies(species);
     for (auto wall : walls)
     {
         addObject(wall.normal, wall.position);
     }
 }

References addObject(), and setSpecies().

◆ ~IntersectionOfWalls()

IntersectionOfWalls::~IntersectionOfWalls ( )

override

Destructor.

 {
     logger(DEBUG, "~IntersectionOfWalls() has been called.");
 }

References DEBUG, and logger.

Member Function Documentation

◆ add3PointObject()

void IntersectionOfWalls::add3PointObject	(	Vec3D	PointA,
		Vec3D	PointB,
		Vec3D	PointC
	)

Parameters

PointA	first coordinate plane passes through;
PointB	second coordinate plane passes through;
PointC	third coordinate plane passes through;

calls the IntersectionOfWalls::addObject(normal, point) by calculating the normal from these three coordinates

 {
     Vec3D SubtB = PointA - PointB;
     Vec3D SubtC = PointA - PointC;
     
     Vec3D WallNormal = Vec3D::cross(SubtB, SubtC);
     //Check if walls coordinates  inline, if true Do not build wall and give error message.
     if (WallNormal.getLengthSquared() == 0.0)
     {
         logger(ERROR,
                "Error Building IntersectionOfWalls::add3PointObject out of 3 coordinates. Coordinates are in line, Wall not constructed.");
     }
     else
     {
         addObject(WallNormal, PointA);
     }
     
 }

References addObject(), Vec3D::cross(), ERROR, Vec3D::getLengthSquared(), and logger.

Referenced by addPlate(), addTetra(), and addTetraSTL().

◆ addObject() [1/3]

void IntersectionOfWalls::addObject	(	Quaternion	orientation,
		Vec3D	position
	)

Parameters

[in]	normal	The normal to this wallObject.
[in]	position	One of the points of the wallObject.

Adds a wall to the set of finite walls, given an outward unit normal vector s.t. normal*x=normal*point for all x of the wallObject. First make the InfiniteWall, then compute all intersections, which are then stored in A_, AB_ and C_.

 {
     //n is the index of the new wall
     std::size_t n = wallObjects_.size();
     InfiniteWall w;
     if (getSpecies()) w.setSpecies(getSpecies());
     w.setOrientation(orientation);
     w.setPosition(position);
     wallObjects_.push_back(w);
     setPointsAndLines(n);
 }

References BaseInteractable::getSpecies(), n, setPointsAndLines(), w, and wallObjects_.

◆ addObject() [2/3]

void IntersectionOfWalls::addObject	(	Vec3D	normal,
		Mdouble	position
	)

Adds a wall to the set of finite walls, given an normal vector pointing into the wall (i.e. out of the flow domain), to give a plane defined by normal*x=position.

Deprecated:: Don't use this function, instead use the function addObject(Vec3D, Vec3D).

Parameters

[in]	normal	The normal to the wallObject.
[in]	position	The position of the wallObject in the direction of the normal vector.

 {
     //logger(WARN, "This function is deprecated, use IntersectionOfWalls::addObject(Vec3D, Vec3D) instead.");
     addObject(normal, position * normal);
 }

References addObject(), and WallFunction::normal().

◆ addObject() [3/3]

void IntersectionOfWalls::addObject	(	Vec3D	normal,
		Vec3D	point
	)

Adds a wall to the set of infinite walls, given a normal vector pointing into the wall (i.e. out of the simulation domain), going through the point, so that normal*x=normal*point.

Parameters

[in]	normal	The normal to this wallObject.
[in]	point	One of the points of the wallObject.

Adds a wall to the set of finite walls, given an outward unit normal vector s.t. normal*x=normal*point for all x of the wallObject. First make the InfiniteWall, then compute all intersections, which are then stored in A_, AB_ and C_.

 {
     normal.normalise();
     
     //n is the index of the new wall
     std::size_t n = wallObjects_.size();
     InfiniteWall w;
     if (getSpecies()) w.setSpecies(getSpecies());
     w.set(normal, point);
     wallObjects_.push_back(w);
     setPointsAndLines(n);
 }

References BaseInteractable::getSpecies(), n, WallFunction::normal(), setPointsAndLines(), w, and wallObjects_.

◆ addPlate()

void IntersectionOfWalls::addPlate	(	const Vec3D &	PointA,
		const Vec3D &	PointB,
		const Vec3D &	PointC,
		const Vec3D &	WallNormal,
		const Mdouble &	Thickness,
		int	wallidentifier
	)

 {
     
     //Check if walls coordinates  inline, if true Do not build wall and give error message. But keep continuing
     if (WallNormal.getLengthSquared() == 0.0)
     {
         logger(WARN, "Error Building Plate number % out of 3 coordinates. Coordinates are in line, Wall not "
                      "constructed.", wallidentifier);
     }
     else
     {
         Vec3D PointAT = PointA - WallNormal * Thickness;
         Vec3D PointBT = PointB - WallNormal * Thickness;
         Vec3D PointCT = PointC - WallNormal * Thickness;
         
         //generate the base wall first through the input coordinates
         add3PointObject(PointC, PointB, PointA);
         
         //add sidewalls
         add3PointObject(PointA, PointB, PointAT);
         add3PointObject(PointB, PointC, PointBT);
         add3PointObject(PointC, PointA, PointCT);
         
         
         //add opposite wall
         add3PointObject(PointAT, PointBT, PointCT);
         
         
     }
     
     
 }

References add3PointObject(), Vec3D::getLengthSquared(), logger, and WARN.

◆ addTetra()

void IntersectionOfWalls::addTetra	(	const Vec3D &	PointA,
		const Vec3D &	PointB,
		const Vec3D &	PointC,
		Mdouble &	Thickness
	)

constructs a tetrahedron from 3 input coordinates

Parameters

PointA	first coordinate plane passes through;
PointB	second coordinate plane passes through;
PointC	third coordinate plane passes through;
Thickness	the height of the apex

constructs a tethrahedron with the apex in the direction according to the right hand rule

 {
     
     //generate other coordinate by finding the centre and shift it the distance thickness in the normal direction
     //calculate normal
     Vec3D SubtB = PointA - PointB;
     Vec3D SubtC = PointA - PointC;
     
     Vec3D WallNormal = Vec3D::cross(SubtB, SubtC);
     
     //Check if walls coordinates  inline, if true Do not build wall and give error message.
     if (WallNormal.getLengthSquared() == 0.0)
     {
         logger(ERROR,
                "Error Building IntersectionOfWalls::addTetra out of 3 coordinates. "
                "Coordinates are in line, Wall not constructed.");
     }
     else
     {
         //calculate centroid
         Vec3D mid = (PointA + PointB + PointC) / 3.0;
         //shift centroid in normal direction
         Vec3D midT = mid + WallNormal * Thickness;
         //generate the base wall first through the input coordinates
         add3PointObject(PointC, PointB, PointA);
         
         //add sidewalls
         add3PointObject(PointA, midT, PointB);
         add3PointObject(PointB, midT, PointC);
         add3PointObject(PointC, midT, PointA);
     }
 }

References add3PointObject(), Vec3D::cross(), ERROR, Vec3D::getLengthSquared(), and logger.

◆ addTetraSTL()

void IntersectionOfWalls::addTetraSTL	(	Vec3D	PointA,
		Vec3D	PointB,
		Vec3D	PointC,
		Vec3D	WallNormal,
		Mdouble	Thickness,
		int	wallidentifier
	)

constructs a tetrahedron for an STL file input

Parameters

PointA	first coordinate plane passes through;
PointB	second coordinate plane passes through;
PointC	third coordinate plane passes through;
WallNormal	the normal of the wal of the plane, Please note that the Wallnormal input is defined inverse to other Mercury functions Due to the usage of this function for reading in STL files
Thickness	the height of the apex
wallidentifier	to identify which wall does not get constructed for bug finding in STL files

constructs a tethrahedron with the apex in minus normal direction.

 {
     //Check if wall coordinates  inline, if true Do not build wall and give error message. But keep continuing
     if (WallNormal.getLengthSquared() == 0.0)
     {
         logger(WARN, "Error Building Plate number % out of 3 coordinates. Coordinates are in line, Wall not "
                      "constructed", wallidentifier);
     }
     else
     {
         //do a check whether the normal follows the RHR (Right Hand Rule) or not
         //todo: Bert Use this check a lot, possibly make a function of this
         Vec3D SubtB = PointA - PointB;
         Vec3D SubtC = PointA - PointC;
         
         Vec3D WallNormalRHR = Vec3D::cross(SubtB, SubtC);
         
         //normalise for easy check
         WallNormalRHR.normalise();
         WallNormal.normalise();
         
         //if RHRchecl is 1, wall normal and RHR normal are in same direction, if -1 theyre not, then point B and C need to be swapped
         Mdouble RHRcheck = Vec3D::dot(WallNormalRHR, WallNormal);
         //todo: Bert Officially need to check for other answers than 1, however, it will either be -1 or 1 in ideal case
         
         if (RHRcheck == 1)
         {
             //calculate centroid
             Vec3D mid = (PointA + PointB + PointC) / 3.0;
             //shift centroid in normal direction
             //mental note: if Same direction as STL normal it should be subtracted to go IN the wall
             Vec3D midT = mid - WallNormalRHR * Thickness;
             //generate the base wall first through the input coordinates
             add3PointObject(PointA, PointC, PointB);
             
             //add sidewalls
             add3PointObject(PointA, midT, PointC);
             add3PointObject(PointC, midT, PointB);
             add3PointObject(PointB, midT, PointA);
         }
         else
         {
             //calculate centroid
             Vec3D mid = (PointA + PointB + PointC) / 3.0;
             //shift centroid in normal direction
             //mental note: if opposite direction as STL normal it should be added to go IN the wall
             Vec3D midT = mid + WallNormalRHR * Thickness;
             //generate the base wall first through the input coordinates
             add3PointObject(PointA, PointB, PointC);
             
             //add sidewalls
             add3PointObject(PointA, midT, PointB);
             add3PointObject(PointB, midT, PointC);
             add3PointObject(PointC, midT, PointA);
         }
         
     }
 }

References add3PointObject(), Vec3D::cross(), Vec3D::dot(), Vec3D::getLengthSquared(), logger, Vec3D::normalise(), and WARN.

◆ clear()

void IntersectionOfWalls::clear ( )

Removes all parts of the walls.

 {
     wallObjects_.clear();
     A_.clear();
     AB_.clear();
     C_.clear();
     removeRenderedWalls();
 }

References A_, AB_, C_, BaseWall::removeRenderedWalls(), and wallObjects_.

Referenced by createOpenPrism().

◆ copy()

IntersectionOfWalls * IntersectionOfWalls::copy ( ) const

overridevirtual

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

Returns: pointer to a IntersectionOfWalls object allocated using new.

Implements BaseWall.

Reimplemented in ScrewsymmetricIntersectionOfWalls.

 {
     return new IntersectionOfWalls(*this);
 }

References IntersectionOfWalls().

Referenced by operator=().

◆ createOpenPrism() [1/2]

void IntersectionOfWalls::createOpenPrism ( std::vector< Vec3D > points )

Creates an open prism which is a polygon between the points, except the first and last point, and extends infinitely in the direction perpendicular to the first and second wall. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly.

Parameters

[in] points A vector of 3D-vectors which contains the points between which the polygon is drawn.

Create an open prism which is a polygon with no connection between the first and last point, and extending infinitely in the direction perpendicular to the first and second wall. Do this by first computing in which direction the wall must be extended infinitely, then call createOpenPrism(points, prismAxis).

 {
     Vec3D prismAxis = Vec3D::cross(
             Vec3D::getUnitVector(points[1] - points[0]),
             Vec3D::getUnitVector(points[2] - points[0]));
     createOpenPrism(points, prismAxis);
 }

References createOpenPrism(), Vec3D::cross(), and Vec3D::getUnitVector().

◆ createOpenPrism() [2/2]

void IntersectionOfWalls::createOpenPrism	(	std::vector< Vec3D >	points,
		Vec3D	prismAxis
	)

Creates an open prism which is a polygon between the points, except the first and last point, and extends infinitely in the PrismAxis direction. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly.

Parameters

[in]	points	A vector of 3D-vectors which contains the points between which the polygon is drawn.
[in]	prismAxis	A 3D-vector which represents the direction in which the prism is extended infinitely.

Create an open prism which is a polygon with no connection between the first and last point, and extending infinitely in the other direction, which is defined as PrismAxis. Do this by adding the walls between the consecutive points one by one.

 {
     clear();
     //note: use i+1 < points.size() instead of i < points.size()-1, otherwise it creates havoc if point has zero entries.
     for (unsigned int i = 0; i + 1 < points.size(); i++)
         addObject(Vec3D::cross(points[i] - points[i + 1], prismAxis), points[i]);
 }

References addObject(), clear(), Vec3D::cross(), and i.

Referenced by VerticalMixerStraightBlades::addBlades(), VerticalMixerAngledBlades::addBlades(), createOpenPrism(), createPrism(), HourGlass2D::setupInitialConditions(), HourGlass::setupInitialConditions(), Tutorial11::setupInitialConditions(), and MovingIntersectionOfWallsUnitTest_Basic::setupInitialConditions().

◆ createPrism() [1/2]

void IntersectionOfWalls::createPrism ( std::vector< Vec3D > points )

Creates an open prism which is a polygon between the points and extends infinitely in the direction perpendicular to the first and second wall. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly.

Parameters

[in] points A vector of 3D-vectors which contains the points between which the polygon is drawn.

Create an open prism which is a polygon, and extending infinitely in the direction perpendicular to the first and second wall. Do this by first computing in which direction the wall must be extended infinitely, then call createOpenPrism(points, prismAxis).

 {
     Vec3D prismAxis = Vec3D::cross(
             Vec3D::getUnitVector(points[1] - points[0]),
             Vec3D::getUnitVector(points[2] - points[0]));
     createPrism(points, prismAxis);
 }

References createPrism(), Vec3D::cross(), and Vec3D::getUnitVector().

◆ createPrism() [2/2]

void IntersectionOfWalls::createPrism	(	std::vector< Vec3D >	points,
		Vec3D	prismAxis
	)

Creates an open prism which is a polygon between the points and extends infinitely in the PrismAxis direction. Note that if you view from inside of your geometry, the shape formed by points has to be convex, otherwise it will not create the wall correctly.

Parameters

[in]	points	A vector of 3D-vectors which contains the points between which the polygon is drawn.
[in]	prismAxis	A 3D-vector which represents the direction in which the prism is extended infinitely.

Create an open prism which is a polygon and extending infinitely in the other direction, which is defined as PrismAxis. Do this by first creating an open prism and then connect the last and the first point.

 {
     createOpenPrism(points, prismAxis);
     addObject(Vec3D::cross(points.back() - points.front(), prismAxis), points.front());
 }

References addObject(), createOpenPrism(), and Vec3D::cross().

Referenced by VerticalMixerAngledBlades::addPrettyBlades(), createPrism(), and Tutorial12::setupInitialConditions().

◆ getDistanceAndNormal() [1/2]

bool IntersectionOfWalls::getDistanceAndNormal	(	const BaseParticle &	p,
		Mdouble &	distance,
		Vec3D &	normal_return
	)		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 IntersectionOfWalls. If there is a collision, this function also computes the distance between the BaseParticle and IntersectionOfWalls and the normal of the IntersectionOfWalls at the intersection point. It does this by calling IntersectionOfWalls::getDistanceAndNormal(const Vec3D& , Mdouble , Mdouble&, Vec3D&) const. 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.

Todo:: do this for all walls

Implements BaseWall.

Reimplemented in ScrewsymmetricIntersectionOfWalls.

 {
     //transform coordinates into position-orientation frame
     Vec3D position = p.getPosition() - getPosition();
     getOrientation().rotateBack(position);
     BaseSpecies* s = getHandler()->getDPMBase()->speciesHandler.getMixedObject(p.getSpecies(), getSpecies());
     if (getDistanceAndNormal(position, p.getRadius() + s->getInteractionDistance(), distance, normal_return))
     {
         getOrientation().rotate(normal_return);
         return true;
     }
     else
     {
         return false;
     }
 }

References BaseHandler< T >::getDPMBase(), BaseWall::getHandler(), SpeciesHandler::getMixedObject(), BaseInteractable::getOrientation(), BaseInteractable::getPosition(), BaseInteractable::getSpecies(), p, Quaternion::rotate(), Quaternion::rotateBack(), s, and DPMBase::speciesHandler.

Referenced by AxisymmetricIntersectionOfWalls::getDistanceAndNormal(), HorizontalBaseScrew::getDistanceAndNormal(), and ScrewsymmetricIntersectionOfWalls::getDistanceAndNormal().

◆ getDistanceAndNormal() [2/2]

bool IntersectionOfWalls::getDistanceAndNormal	(	const Vec3D &	position,
		Mdouble	wallInteractionRadius,
		Mdouble &	distance,
		Vec3D &	normal_return
	)		const

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

Parameters

[in]	position	The position of the object there is possible an interaction with.
[in]	wallInteractionRadius	The maximum distance between the IntersectionOfWalls and the input argument position for which there is an interaction.
[out]	distance	The distance of the object at position to this wall.
[out]	normal_return	If there was an interaction, the normal vector to this wall will be placed here.

Returns: A boolean which says whether or not there was an interaction.

This function computes whether a particle at the given position (position) and radius (wallInteractionRadius) overlaps with the IntersectionOfWalls.

First, the distances to each InfiniteWall is computed, and the three walls with the largest distances (smallest overlaps) are identified (distance, distance2, distance3, id, id2, id3).
If the largest distance is bigger than the wallInteractionRadius, there is no contact. This, if any distance>wallInteractionRadius is detected we return false.
If the second-largest distance is bigger than the wallInteractionRadius, it is a face contact (contact with a single wall.
Otherwise, we need to determine if it is a edge or vertex contact. In the latter two cases, the function returns true, and the distance and normal vector is returned.

 {
     if (wallObjects_.empty())
     {
         logger(DEBUG, "Empty IntersectionOfWalls");
         return false;
     }
     
     distance = -1e20;
     Mdouble distance2 = -1e20;
     Mdouble distance3 = -1e20;
     Mdouble distanceCurrent;
     unsigned int id = 0;
     unsigned int id2 = 0;
     unsigned int id3 = 0;
     
     //For each wall we calculate the distance (distanceCurrent). To compute The walls with the minimal overlap
     //The object has to touch each wall  each wall (distanceCurrent) and keep the minimum distance (distance) and wall index (id
     for (unsigned int i = 0; i < wallObjects_.size(); i++)
     {
         // Calculate distance to each wall (distanceCurrent);
         distanceCurrent = wallObjects_[i].getDistance(position);
         // The object has to touch each wall (distanceCurrent >= wallInteractionRadius), otherwise return false (i.e. no contact)
         // This means that for each InfiniteWall in wallObjects_, the particle is either "inside"
         // the wall or touching it. If not, there is no interaction.
         if (distanceCurrent >= wallInteractionRadius)
         {
             return false;
         }
         // Find out which of the InfiniteWalls is interacting with the particle.
         // Keep the minimum distance (distance) and wall index (id)
         // and store up to two walls (id2, id3) and their distances (distance2, distance3),
         // if the possible contact point is near the intersection between id and id2 (and id3)
         if (distanceCurrent > distance)
         {
             if (distance > -wallInteractionRadius) //if distance was set previously
             {
                 if (distance2 > -wallInteractionRadius) //if distance2 was set previously
                 {
                     distance3 = distance2;
                     id3 = id2;
                 }
                 distance2 = distance;
                 id2 = id;
             }
             distance = distanceCurrent;
             id = i;
         }
         else if (distanceCurrent < -wallInteractionRadius)
         {
             continue;
         }
         else if (distanceCurrent > distance2)
         {
             if (distance2 > -wallInteractionRadius) //if distance2 was set previously
             {
                 distance3 = distance2;
                 id3 = id2;
             }
             distance2 = distanceCurrent;
             id2 = i;
         }
         else if (distanceCurrent > distance3)
         {
             distance3 = distanceCurrent;
             id3 = i;
         }
     }
     
     //If we are here, the closest wall is id;
     //if distance2>-P.Radius (and distance3>-P.Radius), the possible contact point
     // is near the intersection between id and id2 (and id3)
     if (distance2 > -wallInteractionRadius)
     {
         //D is the point on wall id closest to P
         Vec3D D = position + wallObjects_[id].getNormal() * distance;
         //If the distance of D to id2 is positive, the contact is with the intersection
         bool intersection_with_id2 = (wallObjects_[id2].getDistance(D) > 0.0);
         
         if (distance3 > -wallInteractionRadius && (wallObjects_[id3].getDistance(D) > 0.0))
         {
             //E is the point on wall id2 closest to P
             Vec3D E = position + wallObjects_[id2].getNormal() * distance2;
             //If the distance of D to id2 is positive, the contact is with the intersection
             bool intersection_with_id3 = (wallObjects_[id3].getDistance(E) > 0.0);
             
             if (intersection_with_id2)
             {
                 if (intersection_with_id3)
                 {
                     //possible contact is with intersection of id,id2,id3
                     //we know id2<id3
                     if (id2 > id3)
                     {
                         auto id = id2;
                         id2 = id3;
                         id3 = id;
                     }
                     unsigned int index =
                             (id < id2) ? ((id3 - 2) * (id3 - 1) * id3 / 6 + (id2 - 1) * id2 / 2 + id) :
                             (id < id3) ? ((id3 - 2) * (id3 - 1) * id3 / 6 + (id - 1) * id / 2 + id2) :
                             ((id - 2) * (id - 1) * id / 6 + (id3 - 1) * id3 / 2 + id2);
                     normal_return = position - C_[index];
                     distance = sqrt(normal_return.getLengthSquared());
                     if (distance <= wallInteractionRadius) //note what if nan?
                     {
                         normal_return /= -distance;
                         return true; //contact with id,id2,id3
                     }
                     else
                     {
                         if (distance == distance)
                             return false;
                     }
                 }
             }
             else
             {
                 intersection_with_id2 = true;
                 distance2 = distance3;
                 id2 = id3;
             }
         }
         
         if (intersection_with_id2)
         { //possible contact is with intersection of id,id2
             unsigned int index = (id > id2) ? ((id - 1) * id / 2 + id2) : ((id2 - 1) * id2 / 2 + id);
             Vec3D AC = position - A_[index];
             normal_return = AC - AB_[index] * Vec3D::dot(AC, AB_[index]);
             distance = sqrt(normal_return.getLengthSquared());
             if (distance <= wallInteractionRadius) //note what if nan?
             {
                 normal_return /= -distance;
                 return true; //contact with id,id2,id3
             }
             else
             {
                 if (distance == distance)
                     return false;
             }
         }
     }
     //contact is with id
     normal_return = wallObjects_[id].getNormal();
     return true;
 }

References A_, AB_, C_, D, DEBUG, Vec3D::dot(), Global_Physical_Variables::E, Vec3D::getLengthSquared(), i, logger, sqrt(), and wallObjects_.

◆ getName()

std::string IntersectionOfWalls::getName ( ) const

overridevirtual

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

Returns: The string "IntersectionOfWalls".

Implements BaseObject.

Reimplemented in ScrewsymmetricIntersectionOfWalls.

 {
     return "IntersectionOfWalls";
 }

◆ getNumberOfObjects()

unsigned int IntersectionOfWalls::getNumberOfObjects ( )

Returns the number of objects.

Suppose your simulation adds to an IntersectionOfWalls after a certain time or condition is met. Checking the number of objects is useful for checking if this has happened yet, when restarting.

 {
     return wallObjects_.size();
 }

References wallObjects_.

◆ operator=()

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

Copy assignment operator.

Parameters

[in] other The IntersectionOfWalls that must be copied.

 {
     logger(DEBUG, "IntersectionOfWalls::operator= called.");
     if (this == &other)
     {
         return *this;
     }
     return *(other.copy());
 }

References copy(), DEBUG, and logger.

◆ read()

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

overridevirtual

Move the IntersectionOfWalls to a new position, which is a Vec3D from the old position.

Todo:: currently the IntersectionOfWall is special for moving and rotating; should we remove that specialty?

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

 \param[in] move A reference to a Vec3D that denotes the direction and length
 it should be moved with.
 \details A function that moves the InterSectionOfWalls in a certain direction
 by both moving the walls and all intersections. Note that the directions of the
 intersections are not moved since they don't change when moving the IntersectionOfWalls
 as a whole.
 \todo We should use the position_ and orientation_ of the IntersectionOfWalls;
 that way, IntersectionOfWalls can be moved with the standard BaseInteractable::move function,
 getting rid of an anomaly in the code and removing the virtual from the move function. \author weinhartt
&zwj;/

void IntersectionOfWalls::move(const Vec3D& move) { BaseInteractable::move(move); for (Vec3D& a : A_) { a += move; } for (Vec3D& c : C_) { c += move; } for (InfiniteWall& o : wallObjects_) { o.move(move); } }

/*!

Parameters

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

Reimplemented from BaseWall.

Reimplemented in ScrewsymmetricIntersectionOfWalls.

 {
     BaseWall::read(is);
     std::string dummy;
     int n;
     is >> dummy >> n;
     
     Vec3D normal;
     Vec3D position;
     for (int i = 0; i < n; i++)
     {
         is >> dummy;
         if (dummy != "normal")
         {
             Quaternion orientation;
             is >> position >> dummy >> orientation;
             addObject(orientation, position);
         }
         else
         {
             is >> normal >> dummy >> position;
             addObject(normal, position);
         }
     }
 }

References addObject(), i, n, WallFunction::normal(), BaseWall::read(), and oomph::Global_string_for_annotation::string().

Referenced by AxisymmetricIntersectionOfWalls::read(), HorizontalBaseScrew::read(), and ScrewsymmetricIntersectionOfWalls::read().

◆ setHandler()

void IntersectionOfWalls::setHandler ( WallHandler * handler )

overridevirtual

A function which sets the WallHandler for this BaseWall.

Setting the WallHandler also sets the DPMBase and therefore the SpeciesHandler for the species. This wall's species pointer is updated to the new SpeciesHandler.

Parameters

[in] handler - A pointer to the WallHandler that we want to handle this wall.

Reimplemented from BaseWall.

 {
     BaseWall::setHandler(wallHandler);
     for (InfiniteWall& w : wallObjects_)
     {
         w.setHandler(wallHandler);
     }
 }

References BaseWall::setHandler(), w, and wallObjects_.

◆ setPointsAndLines()

void IntersectionOfWalls::setPointsAndLines ( unsigned int n )

 {
     // AB[n*(n-1)/2+m] is the direction of the intersecting line between walls m and n, m<n
     // A[n*(n-1)/2+m] is a point on the intersecting line between walls m and n, m<n
     // See http://www.netcomuk.co.uk/~jenolive/vect18d.html for finding the line where two planes meet
     AB_.resize(n * (n + 1) / 2); //0 + 1 + 2 + ... + indexNew, total number of walls you need
     A_.resize(n * (n + 1) / 2);
     for (std::size_t m = 0; m < n; m++)
     {
         std::size_t id = (n - 1) * n / 2 + m;
         //first we cross the wall normals and normalise to obtain AB
         AB_[id] = Vec3D::cross(wallObjects_[m].getNormal(), wallObjects_[n].getNormal());
         AB_[id] /= sqrt(AB_[id].getLengthSquared());
         //then we find a point A (using AB*x=0 as a third plane)
         Mdouble invdet = 1.0 / (+wallObjects_[n].getNormal().X *
                                 (wallObjects_[m].getNormal().Y * AB_[id].Z - AB_[id].Y * wallObjects_[m].getNormal().Z)
                                 - wallObjects_[n].getNormal().Y * (wallObjects_[m].getNormal().X * AB_[id].Z -
                                                                    wallObjects_[m].getNormal().Z * AB_[id].X)
                                 + wallObjects_[n].getNormal().Z * (wallObjects_[m].getNormal().X * AB_[id].Y -
                                                                    wallObjects_[m].getNormal().Y * AB_[id].X));
         
         A_[id] = Vec3D(+(wallObjects_[m].getNormal().Y * AB_[id].Z - AB_[id].Y * wallObjects_[m].getNormal().Z) *
                        Vec3D::dot(wallObjects_[n].getPosition(), wallObjects_[n].getNormal())
                        - (wallObjects_[n].getNormal().Y * AB_[id].Z - wallObjects_[n].getNormal().Z * AB_[id].Y) *
                          Vec3D::dot(wallObjects_[m].getPosition(), wallObjects_[m].getNormal())
                        + (wallObjects_[n].getNormal().Y * wallObjects_[m].getNormal().Z -
                           wallObjects_[n].getNormal().Z * wallObjects_[m].getNormal().Y) * 0.0,
                        -(wallObjects_[m].getNormal().X * AB_[id].Z - wallObjects_[m].getNormal().Z * AB_[id].X) *
                        Vec3D::dot(wallObjects_[n].getPosition(), wallObjects_[n].getNormal())
                        + (wallObjects_[n].getNormal().X * AB_[id].Z - wallObjects_[n].getNormal().Z * AB_[id].X) *
                          Vec3D::dot(wallObjects_[m].getPosition(), wallObjects_[m].getNormal())
                        - (wallObjects_[n].getNormal().X * wallObjects_[m].getNormal().Z -
                           wallObjects_[m].getNormal().X * wallObjects_[n].getNormal().Z) * 0.0,
                        +(wallObjects_[m].getNormal().X * AB_[id].Y - AB_[id].X * wallObjects_[m].getNormal().Y) *
                        Vec3D::dot(wallObjects_[n].getPosition(), wallObjects_[n].getNormal())
                        - (wallObjects_[n].getNormal().X * AB_[id].Y - AB_[id].X * wallObjects_[n].getNormal().Y) *
                          Vec3D::dot(wallObjects_[m].getPosition(), wallObjects_[m].getNormal())
                        + (wallObjects_[n].getNormal().X * wallObjects_[m].getNormal().Y -
                           wallObjects_[m].getNormal().X * wallObjects_[n].getNormal().Y) * 0.0) * invdet;
     }
     
     // C[(n-2)*(n-1)*n/6+(m-1)*m/2+l] is a point intersecting walls l, m and n, l<m<n
     C_.resize((n - 1) * n * (n + 1) / 6);
     for (std::size_t m = 0; m < n; m++)
     {
         for (std::size_t l = 0; l < m; l++)
         {
             std::size_t id = (n - 2) * (n - 1) * n / 6 + (m - 1) * m / 2 + l;
             Mdouble invdet = 1.0 / (+wallObjects_[n].getNormal().X *
                                     (wallObjects_[m].getNormal().Y * wallObjects_[l].getNormal().Z -
                                      wallObjects_[l].getNormal().Y * wallObjects_[m].getNormal().Z)
                                     - wallObjects_[n].getNormal().Y *
                                       (wallObjects_[m].getNormal().X * wallObjects_[l].getNormal().Z -
                                        wallObjects_[m].getNormal().Z * wallObjects_[l].getNormal().X)
                                     + wallObjects_[n].getNormal().Z *
                                       (wallObjects_[m].getNormal().X * wallObjects_[l].getNormal().Y -
                                        wallObjects_[m].getNormal().Y * wallObjects_[l].getNormal().X));
             C_[id] = Vec3D(+(wallObjects_[m].getNormal().Y * wallObjects_[l].getNormal().Z -
                              wallObjects_[l].getNormal().Y * wallObjects_[m].getNormal().Z) *
                            Vec3D::dot(wallObjects_[n].getPosition(), wallObjects_[n].getNormal())
                            - (wallObjects_[n].getNormal().Y * wallObjects_[l].getNormal().Z -
                               wallObjects_[n].getNormal().Z * wallObjects_[l].getNormal().Y) *
                              Vec3D::dot(wallObjects_[m].getPosition(), wallObjects_[m].getNormal())
                            + (wallObjects_[n].getNormal().Y * wallObjects_[m].getNormal().Z -
                               wallObjects_[n].getNormal().Z * wallObjects_[m].getNormal().Y) *
                              Vec3D::dot(wallObjects_[l].getPosition(), wallObjects_[l].getNormal()),
                            -(wallObjects_[m].getNormal().X * wallObjects_[l].getNormal().Z -
                              wallObjects_[m].getNormal().Z * wallObjects_[l].getNormal().X) *
                            Vec3D::dot(wallObjects_[n].getPosition(), wallObjects_[n].getNormal())
                            + (wallObjects_[n].getNormal().X * wallObjects_[l].getNormal().Z -
                               wallObjects_[n].getNormal().Z * wallObjects_[l].getNormal().X) *
                              Vec3D::dot(wallObjects_[m].getPosition(), wallObjects_[m].getNormal())
                            - (wallObjects_[n].getNormal().X * wallObjects_[m].getNormal().Z -
                               wallObjects_[m].getNormal().X * wallObjects_[n].getNormal().Z) *
                              Vec3D::dot(wallObjects_[l].getPosition(), wallObjects_[l].getNormal()),
                            +(wallObjects_[m].getNormal().X * wallObjects_[l].getNormal().Y -
                              wallObjects_[l].getNormal().X * wallObjects_[m].getNormal().Y) *
                            Vec3D::dot(wallObjects_[n].getPosition(), wallObjects_[n].getNormal())
                            - (wallObjects_[n].getNormal().X * wallObjects_[l].getNormal().Y -
                               wallObjects_[l].getNormal().X * wallObjects_[n].getNormal().Y) *
                              Vec3D::dot(wallObjects_[m].getPosition(), wallObjects_[m].getNormal())
                            + (wallObjects_[n].getNormal().X * wallObjects_[m].getNormal().Y -
                               wallObjects_[m].getNormal().X * wallObjects_[n].getNormal().Y) *
                              Vec3D::dot(wallObjects_[l].getPosition(), wallObjects_[l].getNormal())) * invdet;
         }
     }
     
     logger(VERBOSE, "%", *this);
     for (const InfiniteWall& w : wallObjects_)
         logger(VERBOSE, "wallObject %, %", w.getNormal(), w.getPosition());
     for (Vec3D v : A_)
         logger(VERBOSE, "A %", v);
     for (Vec3D v : AB_)
         logger(VERBOSE, "AB %", v);
     for (Vec3D v : C_)
         logger(VERBOSE, "C %", v);
 }

References A_, AB_, C_, Vec3D::cross(), Vec3D::dot(), BaseInteractable::getPosition(), logger, m, n, sqrt(), v, VERBOSE, w, wallObjects_, X, Y, and Z.

Referenced by addObject().

◆ setSpecies()

void IntersectionOfWalls::setSpecies ( const ParticleSpecies * species )

sets species of subwalls as well

 {
     BaseWall::setSpecies(species);
     for (auto wall : wallObjects_)
     {
         wall.setSpecies(species);
     }
 }

References BaseWall::setSpecies(), and wallObjects_.

◆ write()

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

overridevirtual

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

Parameters

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

Reimplemented from BaseWall.

Reimplemented in ScrewsymmetricIntersectionOfWalls.

 {
     BaseWall::write(os);
     os << " numIntersectionOfWalls " << wallObjects_.size();
     for (const auto& wallObject : wallObjects_)
     {
         os << " position " << wallObject.getPosition() << " orientation " << wallObject.getOrientation();
     }
 }

References wallObjects_, and BaseWall::write().

Referenced by AxisymmetricIntersectionOfWalls::write(), HorizontalBaseScrew::write(), and ScrewsymmetricIntersectionOfWalls::write().

◆ writeVTK()

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

Reimplemented in ScrewsymmetricIntersectionOfWalls.

 {
     Vec3D max = getHandler()->getDPMBase()->getMax()-getPosition();
     Vec3D min = getHandler()->getDPMBase()->getMin()-getPosition();
     for (auto wall = wallObjects_.begin(); wall != wallObjects_.end(); wall++)
     {
         std::vector<Vec3D> points;
         wall->createVTK(points, min, max);
         for (auto other = wallObjects_.begin(); other != wallObjects_.end(); other++)
         {
             if (other != wall)
             {
                 intersectVTK(points, -other->getNormal(), other->getPosition());
             }
         }
         //rotate into real frame
         for (auto& p : points)
         {
             getOrientation().rotate(p);
             p += getPosition();
         }
         wall->addToVTK(points, vtk);
     }
 }

References BaseHandler< T >::getDPMBase(), BaseWall::getHandler(), DPMBase::getMax(), DPMBase::getMin(), BaseInteractable::getOrientation(), BaseInteractable::getPosition(), BaseWall::intersectVTK(), max, min, p, Quaternion::rotate(), and wallObjects_.

Member Data Documentation

◆ A_

std::vector<Vec3D> IntersectionOfWalls::A_

private

A vector that stores a point for each intersecting line between two different InfiniteWall.

A[n*(n-1)/2+m] is a point on the intersecting line between walls m and n, m<n.

Referenced by clear(), getDistanceAndNormal(), IntersectionOfWalls(), and setPointsAndLines().

◆ AB_

std::vector<Vec3D> IntersectionOfWalls::AB_

private

A vector that stores the direction of the intersecting lines between two different InfiniteWall.

AB[n*(n-1)/2+m] is the direction of the intersecting line between walls m and n, m<n.

Referenced by clear(), getDistanceAndNormal(), IntersectionOfWalls(), and setPointsAndLines().

◆ C_

std::vector<Vec3D> IntersectionOfWalls::C_

protected

A vector that stores the intersection point of three different InfiniteWall.

C[(n-2)*(n-1)*n/6+(m-1)*m/2+l] is a point intersecting walls l, m and n, l<m<n

Referenced by clear(), getDistanceAndNormal(), IntersectionOfWalls(), and setPointsAndLines().

◆ wallObjects_

std::vector<InfiniteWall> IntersectionOfWalls::wallObjects_

protected

The wall "segments"/directions that together make up the finite wall.

An intersection of walls exists of a number of infinite walls that are cut of at the intersection points. These InfiniteWall are saved in this vector called iWObjects_.

Referenced by addObject(), clear(), getDistanceAndNormal(), getNumberOfObjects(), IntersectionOfWalls(), setHandler(), setPointsAndLines(), setSpecies(), write(), HorizontalBaseScrew::writeVTK(), writeVTK(), ScrewsymmetricIntersectionOfWalls::writeVTK(), and AxisymmetricIntersectionOfWalls::writeVTK().

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

Classes

Public Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ IntersectionOfWalls() [1/3]

◆ IntersectionOfWalls() [2/3]

◆ IntersectionOfWalls() [3/3]

◆ ~IntersectionOfWalls()

Member Function Documentation

◆ add3PointObject()

◆ addObject() [1/3]

◆ addObject() [2/3]

◆ addObject() [3/3]

◆ addPlate()

◆ addTetra()

◆ addTetraSTL()

◆ clear()

◆ copy()

◆ createOpenPrism() [1/2]

◆ createOpenPrism() [2/2]

◆ createPrism() [1/2]

◆ createPrism() [2/2]

◆ getDistanceAndNormal() [1/2]

◆ getDistanceAndNormal() [2/2]

◆ getName()

◆ getNumberOfObjects()

◆ operator=()

◆ read()

◆ setHandler()

◆ setPointsAndLines()

◆ setSpecies()

◆ write()

◆ writeVTK()

Member Data Documentation

◆ A_

◆ AB_

◆ C_

◆ wallObjects_