Basic class for walls. More...

#include <BaseWall.h>

Inheritance diagram for BaseWall:

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

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

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

virtual BaseWall *	copy () const =0
	Pure virtual function that can be overwritten in inherited classes in order to copy a BaseWall. More...

void	read (std::istream &is) override
	Function that reads a BaseWall from an input stream, usually a restart file. More...

void	write (std::ostream &os) const override
	Function that writes a BaseWall to an output stream, usually a restart file. More...

virtual bool	getDistanceAndNormal (const BaseParticle &P, Mdouble &distance, Vec3D &normal_return) const =0
	Pure virtual function that computes the distance of a BaseParticle to this wall and returns the normal of this wall if there is a collision. More...

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

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

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

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

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

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

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

bool	isFixed () const override

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

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)

virtual void	writeVTK (VTKContainer &vtk) const

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 std::string	getName () const =0
	A purely virtual function. 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

Static Public Member Functions
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...

Private Attributes
WallHandler *	handler_

bool	vtkVisibility_ = true

std::vector< BaseWall * >	renderedWalls_

Detailed Description

Basic class for walls.

Class from which all walls inherit. Please note the getVelocity can for some walls be dependent on which point on the wall is meant.

Constructor & Destructor Documentation

◆ BaseWall() [1/2]

BaseWall::BaseWall ( )

Default constructor.

Default constructor for the BaseWall class. Simply creates an empty BaseWall. Note that it also, by default, sets the handler to a null pointer - i.e. does not automatically assign the current object a given WallHandler.

 {
     handler_ = nullptr;
     logger(DEBUG, "BaseWall::BaseWall() finished");
 }

References DEBUG, handler_, and logger.

◆ BaseWall() [2/2]

BaseWall::BaseWall ( const BaseWall & w )

Copy constructor.

An existing wall (i.e. a BaseWall type object), w, is passed as an argument. A copy of this object is then created. The BaseWall class is relatively low-level, and this copy constructor simply acts to provide a pointer to the WallHandler belonging to w, i.e. assigning the new wall to the same handler as the original. (A derived class' copy constructor calls this, but does all of the other work.)

Parameters

[in] w - The existing BaseWall object to be copied.

         : BaseInteractable(w)
 {
     //sets the current handler to that belonging to the existing wall, w
     handler_ = w.handler_;
     renderedWalls_.reserve(w.renderedWalls_.capacity());
     vtkVisibility_ = w.vtkVisibility_;
     for (auto* const r : w.renderedWalls_)
         renderedWalls_.push_back(r->copy());
     logger(DEBUG, "BaseWall::BaseWall(const BaseWall &p) finished");
 }

References DEBUG, handler_, logger, UniformPSDSelfTest::r, renderedWalls_, vtkVisibility_, and w.

◆ ~BaseWall()

BaseWall::~BaseWall ( )

override

Default destructor.

Note that this is a virtual destructor, ensuring that derived classes can be deleted easily and safely.

 {
     logger(DEBUG, "BaseWall::~BaseWall() finished");
     removeRenderedWalls();
 }

References DEBUG, logger, and removeRenderedWalls().

Member Function Documentation

◆ actionsAfterParticleGhostUpdate()

virtual void BaseWall::actionsAfterParticleGhostUpdate ( )

inlinevirtual

No implementation but can be overidden in its derived classes.

This function is called by WallHandler::actionsAfterParticleGhostUpdate, which is called by DPMBase::computeOneTimeStep directly after the ghost particle update. It may be used to adjust wall properties based on the changed wall positions (for an example, look e.g. at MeshTriangle).

Reimplemented in MeshTriangle.

172 {}

◆ actionsOnRestart()

virtual void BaseWall::actionsOnRestart ( )

inlinevirtual

No implementation but can be overidden in its derived classes.

This function is called by DPMBase::solve, if the simulation is restarted.

Reimplemented in MeshTriangle.

163 {}

◆ addParticlesAtWall()

void BaseWall::addParticlesAtWall ( unsigned numElements = 50 )

 {
     auto& speciesHandler = getHandler()->getDPMBase()->speciesHandler;
     logger.assert_always(speciesHandler.getSize()>0,"addParticlesAtWall: You need to define at least one species");
  
     Vec3D max = getHandler()->getDPMBase()->getMax();
     Vec3D min = getHandler()->getDPMBase()->getMin();
     double h = Vec3D::min(max-min)/numElements;
     double r = 0.5*h;
  
     auto& particleHandler = getHandler()->getDPMBase()->particleHandler;
     double numParticles0 = particleHandler.getSize();
     SphericalParticle p;
     p.setSpecies(speciesHandler.getObject(0));
     Vec3D pos;
     for (pos.X = min.X; pos.X <= max.X; pos.X += h)
     for (pos.Y = min.Y; pos.Y <= max.Y; pos.Y += h)
     for (pos.Z = min.Z; pos.Z <= max.Z; pos.Z += h)
     {
         Vec3D normal;
         Mdouble distance;
         p.setRadius(2.0*r);
         p.setPosition(pos);
         //if touching the wall
         if (getDistanceAndNormal(p, distance, normal) && distance>=0)
         {
             p.setRadius(r);
             p.setPosition(pos+(distance-r)*normal);
             particleHandler.copyAndAddObject(p);
         }
     }
     logger(INFO,"Inserted % particles that touch wall %", particleHandler.getNumberOfObjects()-numParticles0, getIndex());
 }

References getDistanceAndNormal(), BaseHandler< T >::getDPMBase(), getHandler(), BaseObject::getIndex(), DPMBase::getMax(), DPMBase::getMin(), BaseHandler< T >::getSize(), INFO, logger, max, min, Vec3D::min(), WallFunction::normal(), p, DPMBase::particleHandler, UniformPSDSelfTest::r, DPMBase::speciesHandler, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by AxisymmetricWallSelfTest::setupInitialConditions().

◆ addRenderedWall()

void BaseWall::addRenderedWall ( BaseWall * w )

 {
     renderedWalls_.push_back(w);
 }

References renderedWalls_, and w.

◆ addToVTK()

void BaseWall::addToVTK	(	const std::vector< Vec3D > &	points,
		VTKContainer &	vtk
	)

static

Takes the points provided and adds a triangle strip connecting these points to the vtk container.

 {
     if (!points.empty())
     {
         //all all values in myPoints to points
         vtk.points.insert(vtk.points.end(), points.begin(), points.end());
         
         // create one cell object containing all indices of the added points (created a triangle strip connecting these points)
         std::vector<double> cell;
         cell.reserve(vtk.points.size() + 1);
         cell.push_back(vtk.points.size() - 1);
         for (unsigned i = vtk.points.size() - points.size(); i < vtk.points.size(); i++)
         {
             cell.push_back((double) i);
         }
         
         //add this triangle strip to the vtk file
         vtk.triangleStrips.push_back(cell);
     }
 }

References i, VTKContainer::points, and VTKContainer::triangleStrips.

Referenced by LevelSetWall::createVTK(), and InfiniteWall::writeVTK().

◆ checkInteractions()

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

inlinevirtual

Check if all interactions are valid.

This function is called by DPMBase::computeAllForces. It may be used by a wall to check and modify interactions previously created during contact detection.

Reimplemented in MeshTriangle.

199 {}

◆ computeWear()

virtual void BaseWall::computeWear ( )

inlinevirtual

Reimplemented in WearableTriangulatedWall, WearableTriangleMeshWall, and WearableNurbsWall.

227 { };

◆ copy()

virtual BaseWall* BaseWall::copy ( ) const

pure virtual

Pure virtual function that can be overwritten in inherited classes in order to copy a BaseWall.

Returns: A pointer to the new BaseWall.

Implemented in WearableTriangulatedWall, WearableTriangleMeshWall, VChute, TriangulatedWall, TriangleWall, TriangleMeshWall, SphericalWall, SineWall, RestrictedWall, ParabolaChute, NurbsWall, MeshTriangle, LevelSetWall, IntersectionOfWalls, InfiniteWallWithHole, InfiniteWall, CylindricalWall, Combtooth, Coil, BasicUnionOfWalls, BasicIntersectionOfWalls, ArcWall, WearableNurbsWall, SimpleDrumSuperquadrics, ScrewsymmetricIntersectionOfWalls, Screw, HorizontalScrew, HorizontalBaseScrew, and AxisymmetricIntersectionOfWalls.

Referenced by BasicIntersectionOfWalls::add(), BasicUnionOfWalls::add(), and RestrictedWall::set().

◆ getAxis()

const Vec3D BaseWall::getAxis ( ) const

This functions returns a axis for a wall using it Quaternion descriptions. At the moment Quaternion are not implemented for a wall; so this is currently a workaround for the non-implementation Quaternion for the walls. In the future this functions will be replaced.

Returns: A Vec3D which is the axis of the wall

 {
     Quaternion Q = getOrientation();
     Vec3D axis;
     axis.X = Q.q1;
     axis.Y = Q.q2;
     axis.Z = Q.q3;
     return axis;
 }

References BaseInteractable::getOrientation(), Q, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by ScrewsymmetricIntersectionOfWalls::computeDeltaZ().

◆ getDistanceAndNormal()

virtual bool BaseWall::getDistanceAndNormal	(	const BaseParticle &	P,
		Mdouble &	distance,
		Vec3D &	normal_return
	)		const

pure virtual

Pure virtual function that computes the distance of a BaseParticle to this wall and returns the normal of this wall if there is a collision.

Beware, the distance and normal are output parameters, not return values!

Parameters

[in]	P	Reference to the BaseParticle we want to compute the distance to the BaseWall of.
[out]	distance	Distance of the BaseParticle to the BaseWall.
[out]	normal_return	The normal of the wall. Is only given if there is a collision.

Returns: A boolean which indicates if there is a collision between the BaseParticle and the wall.

Implemented in VChute, TriangulatedWall, TriangleWall, TriangleMeshWall, SphericalWall, SineWall, SimpleDrumSuperquadrics, RestrictedWall, ParabolaChute, MeshTriangle, LevelSetWall, IntersectionOfWalls, InfiniteWallWithHole, InfiniteWall, CylindricalWall, Combtooth, Coil, BasicUnionOfWalls, BasicIntersectionOfWalls, ScrewsymmetricIntersectionOfWalls, Screw, NurbsWall, HorizontalScrew, HorizontalBaseScrew, AxisymmetricIntersectionOfWalls, and ArcWall.

Referenced by addParticlesAtWall(), ChuteWithContraction::ChuteWithContraction(), ChuteWithPeriodicInflowAndContraction::ChuteWithPeriodicInflowAndContraction(), ContractionWithPeriodicInflow::ContractionWithPeriodicInflow(), Domain::findNewMPIInteractions(), RestrictedWall::getDistanceAndNormal(), and getDistanceNormalOverlap().

◆ getDistanceNormalOverlap()

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

virtual

 {
     if (P.isSphericalParticle())
     {
         bool isInContact = getDistanceAndNormal(P, distance, normal_return);
         overlap = P.getRadius() - distance;
         return isInContact;
     }
     else
     {
         auto superQuadric = dynamic_cast<const SuperQuadricParticle*>(&P);
         return getDistanceNormalOverlapSuperquadric(*superQuadric, distance, normal_return, overlap);
     }
 }

References getDistanceAndNormal(), getDistanceNormalOverlapSuperquadric(), and Global_Physical_Variables::P.

Referenced by getInteractionWith().

◆ getDistanceNormalOverlapSuperquadric()

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

virtual

Reimplemented in SimpleDrumSuperquadrics, and InfiniteWall.

 {
     logger(ERROR, "Generic wall-superquadric interactions not implemented yet.");
     return false;
 }

References ERROR, and logger.

Referenced by getDistanceNormalOverlap().

◆ getFurthestPointSuperQuadric()

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

virtual

Reimplemented in SimpleDrumSuperquadrics, and InfiniteWall.

 {
     logger(ERROR, "Generic wall-superquadric interactions not implemented yet.");
     return {};
 }

References ERROR, and logger.

Referenced by getInteractionWith().

◆ getHandler()

WallHandler * BaseWall::getHandler ( ) const

A function which returns the WallHandler that handles this BaseWall.

Returns: A pointer to the WallHandler that manages this BaseWall.

 {
     return handler_;
 }

References handler_.

Referenced by addParticlesAtWall(), MeshTriangle::checkInteractions(), WearableNurbsWall::computeWear(), WearableTriangleMeshWall::computeWear(), WearableTriangulatedWall::computeWear(), InfiniteWall::createVTK(), HorizontalBaseScrew::getDistanceAndNormal(), NurbsWall::getDistanceAndNormal(), Screw::getDistanceAndNormal(), IntersectionOfWalls::getDistanceAndNormal(), getInteractionWith(), TriangleMeshWall::getInteractionWith(), IntersectionOfWalls::IntersectionOfWalls(), read(), BasicIntersectionOfWalls::read(), BasicUnionOfWalls::read(), renderWall(), MeshTriangle::retrieveVertexParticles(), Screw::rotate(), setHandler(), setIndSpecies(), setSpecies(), AxisymmetricIntersectionOfWalls::writeVTK(), HorizontalBaseScrew::writeVTK(), IntersectionOfWalls::writeVTK(), and ScrewsymmetricIntersectionOfWalls::writeVTK().

◆ getInteractionWith()

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

overridevirtual

Returns the interaction between this wall and a given particle, nullptr if there is no interaction.

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.

Implements BaseInteractable.

Reimplemented in VChute, TriangulatedWall, TriangleMeshWall, SineWall, RestrictedWall, ParabolaChute, MeshTriangle, and Combtooth.

 {
     Mdouble distance;
     Vec3D normal;
     Mdouble overlap;
  
     if (getDistanceNormalOverlap(*p, distance, normal, overlap))
     {
         #ifdef MERCURYDPM_TRIANGLE_WALL_CORRECTION
         // look for an existing interaction, or create a new one
         BaseInteraction *c = nullptr;
         // This if-statement deals with groups of walls. If a particle has multiple contacts with a group of walls, and if the contact areas of these contacts overlap, then we keep only the biggest of the overlapping contacts.
         if (getGroupId() > 0 && p->getInteractions().size() > 0) {
             // if there is a contact with a group of walls, and if p had at least one previously detected contact (in the last timestep or the current)
             for (const auto i : p->getInteractions()) {
                 if (i->getI() == (BaseInteractable *) this) {
                     // if there is an existing interaction with this wall, keep it
                     i->setTimeStamp(timeStamp);
                     c = i;
                     break;
                 }
                 if (i->getI()->getGroupId() == getGroupId()) {
                     // update contact, otherwise the distance comparison iis not correct
                     // (note this is costly and we should replace this with a quicker algorithm if possible)
                     if (i->getTimeStamp() < timeStamp) {
                         double distance, overlap;
                         Vec3D normal;
                         static_cast<BaseWall*>(i->getI())->getDistanceNormalOverlap(*p, distance, normal, overlap);
                         i->setNormal(-normal);
                         i->setDistance(distance);
                         i->setOverlap(overlap);
                     }
                     // if another interaction with a wall of the same group is found
                     double proj = Vec3D::dot(-normal, i->getNormal());
                     // if the two contacts share a contact area, keep only the contact with the minimum distance
                     if (distance >= i->getDistance()) {
                         // if that other contact is closer to the particle than this one
                         if (proj * distance > (1.0-1e-12) * i->getDistance()) {
                             //if one contact point is in the contact area of the other point
                             //(I take the vector a=radius*n, project it onto the other normal ni: b=(a.ni)ni, and check that |a|>(r-delta_i), which is equivalent to checking whether position+a is a distance less than the contact radius from the normal vector ni )
                             //logger(INFO,"Ignoring contact with % because contact with % is closer",getId(),i->getI()->getId());
                             return nullptr;
                         }
                         //else, continue to compute this contact
                     } else {
                         // if this contact is closer to the particle than the other one
                         if (proj * i->getDistance() >= (1.0-1e-12) * distance) {
                             //if the other contact point is in the contact area of this point, replace the other contact with this one
                             i->setI(this);
                             c = i;
                             // if the contact force has already been computed (with the other wall), undo the force/torque computation
                             if (i->getTimeStamp() == timeStamp) {
                                 p->addForce(-i->getForce());
                                 this->addForce(i->getForce());
                                 if (getHandler()->getDPMBase()->getRotation()) {
                                     p->addTorque(-i->getTorque() + Vec3D::cross(p->getPosition() - i->getContactPoint(), i->getForce()));
                                     this->addTorque(i->getTorque() - Vec3D::cross(this->getPosition() - i->getContactPoint(), i->getForce()));
                                 }
                             }
                             i->setTimeStamp(timeStamp);
                             break;
                         }
                     }
                 }
             }
         }
         if (c == nullptr) {
             // look for an existing interaction, or create a new one
             c = interactionHandler->getInteraction(p, this, timeStamp);
         }
         #else
         BaseInteraction* c = interactionHandler->getInteraction(p, this, timeStamp);
         #endif
  
         c->setNormal(-normal);
         c->setDistance(distance);
         c->setOverlap(overlap);
         if (p->isSphericalParticle())
         {
             // Set the contact point half the overlap away from the wall.
             // This choice is made to be consistent with \ref BaseParticle::getInteractionWith
             // for the case of a collision with a particle of infinite radius.
             c->setContactPoint(p->getPosition() - (p->getRadius() - 0.5 * c->getOverlap()) * c->getNormal());
         }
         else
         {
             Vec3D normalBodyFixed = normal;
             p->getOrientation().rotateBack(normalBodyFixed);
             auto furthestPoint = getFurthestPointSuperQuadric(normalBodyFixed, p->getAxes(),
                                                               p->getExponentEps1(), p->getExponentEps2());
             Vec3D overlapBody = overlap * normalBodyFixed;
             Vec3D contactPoint = furthestPoint - overlapBody / 2;
             p->getOrientation().rotate(contactPoint);
             contactPoint += p->getPosition();
             c->setContactPoint(contactPoint);
         }
         logger(DEBUG, "Particle contact with wall at %", c->getContactPoint());
         return c;
     }
     return nullptr;
 }

References BaseInteractable::addForce(), BaseInteractable::addTorque(), calibrate::c, Vec3D::cross(), DEBUG, Vec3D::dot(), e(), getDistanceNormalOverlap(), getFurthestPointSuperQuadric(), BaseObject::getGroupId(), getHandler(), InteractionHandler::getInteraction(), i, logger, WallFunction::normal(), and p.

Referenced by MeshTriangle::getInteractionWith(), RestrictedWall::getInteractionWith(), GetDistanceAndNormalForTriangleWalls::setupInitialConditions(), ContactDetectionWithWallTester::testEllipsoidsContact(), and ContactDetectionWithWallTester::testSpheresContact().

◆ getInteractionWithSuperQuad()

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

virtual

Todo:: make it work with screw, coil and other weird walls

Reimplemented in SimpleDrumSuperquadrics.

 {
     logger(ERROR, "Generic wall-superquad interactions not implemented yet.");
     return nullptr;
 }

References ERROR, and logger.

Referenced by SimpleDrumSuperquadrics::getInteractionWithSuperQuad().

◆ getLinePlaneIntersect()

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

 {
     // t = (p-p0).n / (p1-p0).n
     //first compute the denominator
     Mdouble denominator = Vec3D::dot(p1 - p0, n);
     if (fabs(denominator) >= 1e-10)
     {
         Mdouble t = Vec3D::dot(p - p0, n) / denominator;
         if (t < 1 + 1e-12 && t > -1e-12)
             intersect = p0 + t * (p1 - p0);
         return true;
     }
     return false;
 }

References Vec3D::dot(), e(), boost::multiprecision::fabs(), n, p, p0, p1, and plotPSD::t.

◆ getRenderedWall()

BaseWall * BaseWall::getRenderedWall ( size_t i ) const

 {
     return renderedWalls_[i];
 }

References i, and renderedWalls_.

◆ getRenderedWalls()

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

 {
     return renderedWalls_;
 }

References renderedWalls_.

◆ getVTK()

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

inline

150 {}

◆ getVTKVisibility()

bool BaseWall::getVTKVisibility ( ) const

 {
     return vtkVisibility_;
 }

References vtkVisibility_.

Referenced by renderWall().

◆ handleParticleAddition()

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

inlinevirtual

Handles the addition of particles to the particleHandler.

This function is called by DPMBase::handleParticleAddition, whenever a particle is added to the particleHandler. It may be used to update stored pointers to particles

Parameters

[in]	id	The id of the removed particle.
[in]	p	A pointer to the particle.

Reimplemented in MeshTriangle.

182 {}

◆ handleParticleRemoval()

virtual void BaseWall::handleParticleRemoval ( unsigned int id )

inlinevirtual

Handles the addition of particles to the particleHandler.

This function is called by DPMBase::handleParticleRemoval whenever a (ghost-)particle is removed from the particleHandler. It may be used to update stored pointers to particles

Parameters

[in] id The id of the removed particle.

Reimplemented in MeshTriangle.

191 {}

◆ intersectVTK()

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

Intersects a of set VTK points representing a wall with a half-space defined by position and normal; This is used in createVTK to restrict the VTK points representing a wall to the inside of the domain.

Checks if a set of VTK points is inside a half-space defined by position and normal; all points outside the half-space are projected onto the half-space boundary. Thus, if the old set of points represented a wall object, the new set of points is represents the intersection of the wall with the half-space.

 {
     // find first point in Wall
     std::vector<Vec3D>::iterator firstIn = points.begin();
     for (; firstIn != points.end(); firstIn++)
     {
         //stop if points[first] is in domain
         if (isInsideWallVTK(*firstIn, normal, position))
         {
             break;
         }
     }
     
     //if all points are out of the wall
     if (firstIn == points.end())
     {
         logger(DEBUG, "BaseWall::intersectVTK: all points out of wall");
         return;
     }
     
     // find first point out of the wall after firstIn
     std::vector<Vec3D>::iterator firstOut = firstIn + 1;
     for (; firstOut != points.end(); firstOut++)
     {
         if (!isInsideWallVTK(*firstOut, normal, position))
         {
             break;
         }
     }
     
     //if all points are in the wall
     if (firstOut == points.end() && firstIn == points.begin())
     {
         logger(DEBUG, "BaseWall::intersectVTK: points completely in wall; removing points");
         points.clear();
         return;
     }
     
     //if the sequence starts with a point out of the wall
     //Several cases have to be distinguished, multiple points in the wall the last point in or out of the wall: ooiiioo, ooioo, ooiii, or ooi
     //In addition, we add the case iiioo and ioo
     if (firstIn != points.begin() || !isInsideWallVTK(points.back(), normal, position))
     {
         // remove unnessesary points in the wall 
         // ooiiioo -> ooiioo, ooiii -> ooii, iiioo -> iioo
         if (firstOut - firstIn > 2)
         {
             logger(DEBUG, "BaseWall::intersectVTK: remove unnessesary points in the wall");
             //necessary reset of firstOut, as erase invalidates iterators after erase point
             points.erase(firstIn + 1, firstOut - 1); //note: erase does not delete the last point
             firstOut = firstIn + 2;
         }
         
         // if there is only one point in the wall, make it two
         // ooioo -> ooiioo, ooi -> ooii
         if (firstOut == firstIn + 1)
         {
             logger(DEBUG, "BaseWall::intersectVTK: there is only one point in the wall, make it two");
             //necessary reset of firstIn, firstOut, as insert invalidates iterators
             unsigned in = firstIn - points.begin();
             points.insert(firstIn + 1, *firstIn);
             firstIn = points.begin() + in;//necessary, unless capacity is set right
             firstOut = firstIn + 2;
         }
         
         // three cases remain: ooiioo, ooii, iioo
         
         //move both points onto the surface of the wall
         if (firstIn != points.begin())
         {
             logger(DEBUG, "BaseWall::intersectVTK: move first point onto the surface of the wall");
             projectOntoWallVTK(*firstIn, *(firstIn - 1), normal, position);
         }
         else
         {
             logger(DEBUG,
                    "BaseWall::intersectVTK: move first point (at the beginning of the list) onto the surface of the wall");
             projectOntoWallVTK(points.front(), points.back(), normal, position);
         }
         
         if (firstOut != points.end())
         {
             logger(DEBUG, "BaseWall::intersectVTK: move second point onto the surface of the wall");
             projectOntoWallVTK(*(firstOut - 1), *firstOut, normal, position);
         }
         else
         {
             logger(DEBUG,
                    "BaseWall::intersectVTK: move second point (at the end of the list) onto the surface of the wall");
             projectOntoWallVTK(points.back(), points.front(), normal, position);
         }
         //if sequence starts and ends with a point in the wall: iiiooiii
     }
     else
     {
         logger(DEBUG, "BaseWall::intersectVTK: sequence starts and ends with a point in the wall");
         
         // find first point in wall after firstOut
         for (firstIn = firstOut + 1; firstIn != points.end(); firstIn++)
         {
             if (isInsideWallVTK(*firstIn, normal, position))
             {
                 break;
             }
         }
         
         // remove unnessesary points in the wall 
         // iiiooiii -> iooi
         points.erase(firstIn + 1, points.end());
         points.erase(points.begin(),
                      firstOut - 1); //note: erase does not delete the last point //note iterators are invalid now
         
         //move both points onto the surface of the wall: iooi
         projectOntoWallVTK(points.front(), *(points.begin() + 1), normal, position);
         projectOntoWallVTK(points.back(), *(points.end() - 2), normal, position);
     }
 }

References DEBUG, isInsideWallVTK(), logger, WallFunction::normal(), and projectOntoWallVTK().

Referenced by InfiniteWall::createVTK(), HorizontalBaseScrew::writeVTK(), IntersectionOfWalls::writeVTK(), ScrewsymmetricIntersectionOfWalls::writeVTK(), and AxisymmetricIntersectionOfWalls::writeVTK().

◆ isFixed()

bool BaseWall::isFixed ( ) const

overridevirtual

Sets all walls (unlike particles) to be inherently fixed - i.e. the bool "is fixed" will by definition return "true" when called for a wall (i.e. any BaseWall tyope object).

Implements BaseInteractable.

 {
     return true;
 }

◆ isInsideWallVTK()

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

Checks if point is in wall (if close to the wall, the point is assumed out of the wall)

 {
     return Vec3D::dot(position - point, normal) < -1e-12;
 }

References Vec3D::dot(), e(), and WallFunction::normal().

Referenced by intersectVTK().

◆ isLocal()

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

inlinevirtual

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

Reimplemented in TriangleWall, TriangleMeshWall, and MeshTriangle.

118 { return false; }

◆ projectOntoWallVTK()

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

Moves point0 onto the surface of the wallsuch that the direction of the edge from point0 to point1 is preserved.

intersectVTK = point[i] + t*(point[i-1]-point[i]) and (intersectVTK - position) normal_=0. => (position-point[i]-t(point[i-1]-point[i]))*normal_=0 t=(position-point[i]))*normal_ / (point[i-1]-point[i]))*normal_

 {
     Vec3D dPoint = point1 - point0;
     point0 += Vec3D::dot(position - point0, normal) / Vec3D::dot(dPoint, normal) * dPoint;
 }

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

Referenced by intersectVTK().

◆ read()

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

overridevirtual

Function that reads a BaseWall from an input stream, usually a restart file.

The BaseWall takes no more information than for a BaseInteractable. (A derived class' read method does most of the work.)

Parameters

[in] is - The input stream from which the BaseWall is read.

Reimplemented from BaseInteractable.

Reimplemented in WearableTriangulatedWall, WearableTriangleMeshWall, WearableNurbsWall, VChute, TriangulatedWall, TriangleWall, TriangleMeshWall, SphericalWall, SineWall, Screw, RestrictedWall, ParabolaChute, NurbsWall, MeshTriangle, LevelSetWall, IntersectionOfWalls, InfiniteWallWithHole, InfiniteWall, HorizontalScrew, CylindricalWall, Combtooth, Coil, BasicUnionOfWalls, BasicIntersectionOfWalls, SimpleDrumSuperquadrics, ScrewsymmetricIntersectionOfWalls, and HorizontalBaseScrew.

 {
     BaseInteractable::read(is);
     unsigned size;
     std::string type;
     if (helpers::isNext(is,"vtkVisibility")) {
         is >> vtkVisibility_;
     }
     if (helpers::isNext(is,"renderedWalls")) {
         is >> size;
         for (unsigned i = 0; i < size; i++)
         {
             is >> type;
             BaseWall* wall = getHandler()->createObject(type);
             wall->setHandler(getHandler());
             wall->read(is);
             renderedWalls_.push_back(wall);
             renderedWalls_.back()->setId(renderedWalls_.size());
         }
     }
 }

References WallHandler::createObject(), getHandler(), i, helpers::isNext(), BaseInteractable::read(), read(), renderedWalls_, setHandler(), size, oomph::Global_string_for_annotation::string(), compute_granudrum_aor::type, and vtkVisibility_.

Referenced by SimpleDrumSuperquadrics::read(), ArcWall::read(), read(), BasicIntersectionOfWalls::read(), BasicUnionOfWalls::read(), Coil::read(), Combtooth::read(), CylindricalWall::read(), HorizontalScrew::read(), InfiniteWall::read(), InfiniteWallWithHole::read(), IntersectionOfWalls::read(), LevelSetWall::read(), MeshTriangle::read(), NurbsWall::read(), RestrictedWall::read(), Screw::read(), SineWall::read(), SphericalWall::read(), TriangleMeshWall::read(), TriangleWall::read(), and VChute::read().

◆ removeRenderedWalls()

void BaseWall::removeRenderedWalls ( )

                                    {
     for (auto* const r : renderedWalls_)
         delete r;
     renderedWalls_.clear();
 }

References UniformPSDSelfTest::r, and renderedWalls_.

Referenced by IntersectionOfWalls::clear(), and ~BaseWall().

◆ renderWall()

void BaseWall::renderWall ( VTKContainer & vtk )

 {
     if (getVTKVisibility())
     {
         if (renderedWalls_.empty())
         {
             writeVTK(vtk);
         }
         else
         {
             const Mdouble time = getHandler()->getDPMBase()->getTime();
             const Mdouble timeStep = getHandler()->getDPMBase()->getTimeStep();
             const int saveCount = getHandler()->getDPMBase()->dataFile.getSaveCount();
             for (const auto& r: renderedWalls_)
             {
                 // First write...
                 r->writeVTK(vtk);
  
                 // Then update the position and orientation for time steps that were skipped.
                 // We have to use a loop, as doing it at once like so:
                 // r->integrateBeforeForceComputation(time - timeStep * (saveCount - 1), timeStep * saveCount);
                 // r->integrateAfterForceComputation(time - timeStep * (saveCount - 1), timeStep * saveCount);
                 // gives small deviations which add up quickly to give very different results.
                 for (int i = 0; i < saveCount; i++)
                 {
                     r->integrateBeforeForceComputation(time - timeStep * (saveCount - i - 1), timeStep);
                     r->integrateAfterForceComputation(time - timeStep * (saveCount - i - 1), timeStep);
                 }
             }
         }
     }
 }

References DPMBase::dataFile, BaseHandler< T >::getDPMBase(), getHandler(), File::getSaveCount(), DPMBase::getTime(), DPMBase::getTimeStep(), getVTKVisibility(), i, UniformPSDSelfTest::r, renderedWalls_, and writeVTK().

◆ setForceControl()

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

Parameters

[in]	forceGoal	- the desired force on the wall
[in]	gainFactor	- the rate at which the velocity of the wall should be adjusted
[in]	baseVelocity	- the velocity that the wall should travel at when the forceGoal is reached

                                                                                     {
     setPrescribedVelocity([this, forceGoal, gainFactor, baseVelocity] (double time){
         auto dForce = getForce()-forceGoal;
         return baseVelocity + gainFactor.multiplyElementwise(dForce);
     });
 }

References BaseInteractable::getForce(), Vec3D::multiplyElementwise(), and BaseInteractable::setPrescribedVelocity().

◆ setHandler()

void BaseWall::setHandler ( WallHandler * handler )

virtual

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 in IntersectionOfWalls, and MeshTriangle.

 {
     handler_ = handler;
     setSpecies(getHandler()->getDPMBase()->speciesHandler.getObject(getIndSpecies()));
 }

References getHandler(), BaseInteractable::getIndSpecies(), BaseHandler< T >::getObject(), handler_, and setSpecies().

Referenced by read(), BasicIntersectionOfWalls::read(), BasicUnionOfWalls::read(), WallHandler::readAndCreateObject(), MeshTriangle::setHandler(), IntersectionOfWalls::setHandler(), and setSpecies().

◆ setIndSpecies()

void BaseWall::setIndSpecies ( unsigned int indSpecies )

overridevirtual

Define the species of this wall using the index of the species in the SpeciesHandler in this DPMBase.

Deprecated:: TW: this function should be taken out and replaced by setSpecies

Parameters

[in] indSpecies The index of the species of this BaseWall in the SpeciesHandler.

Reimplemented from BaseInteractable.

 {
     if (handler_ != nullptr)
     {
         setSpecies(getHandler()->getDPMBase()->speciesHandler.getObject(getIndSpecies()));
     }
     else
     {
         BaseInteractable::setIndSpecies(indSpecies);
         logger(ERROR, "setIndSpecies called on a particle with no particle handler.\n"
                       "Therefore I can't request the given species from the species handler.\n"
                       " PartID = %", getId());
     }
 }

References ERROR, getHandler(), BaseObject::getId(), BaseInteractable::getIndSpecies(), BaseHandler< T >::getObject(), handler_, logger, BaseInteractable::setIndSpecies(), and setSpecies().

◆ setSpecies()

void BaseWall::setSpecies ( const ParticleSpecies * species )

Defines the species of the current wall.

Firstly, calls the "BaseInteractable" version of the setSpecies function (BaseInteractable::setSpecies()) which actually sets the species_ of the particle (i.e. provides a pointer to the ParticleSpecies which stores the relevant material properties which we wish to assign to out wall) as well as assigning the relevant species index (indSpecies_) as well as performing relevant error checks.

Secondly, sets a pointer to the relevant handler, which is needed to retrieve species information.

Parameters

[in] species - The pointer to the species whose properties we want to assign to the current wall - i.e. the species we want to "give" the wall.

Todo:: TW: this function should also check if the particle is the correct particle for the species type.

 {
     BaseInteractable::setSpecies(species);
     //Checks if the current wall currently belongs to a defined wallHandler...
     if (getHandler() == nullptr)
     {
         //and if not:
         //Creates a pointer to the handler to which the chosen species belongs
         SpeciesHandler* sH = species->getHandler();
         //Creates a pointer back to the DPMBase class
         DPMBase* dB = sH->getDPMBase();
         //If this is not a null pointer, assigns the current wall to the relevant wallHandler.
         if (dB != nullptr)
             setHandler(&dB->wallHandler);
     }
 }

References BaseHandler< T >::getDPMBase(), BaseSpecies::getHandler(), getHandler(), setHandler(), BaseInteractable::setSpecies(), and DPMBase::wallHandler.

◆ setVelocityControl()

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

                                                                                        {
     setPrescribedVelocity([this, forceGoal, gainFactor, baseVelocity] (double time){
         auto dForce = getForce()-forceGoal;
         return baseVelocity + gainFactor.multiplyElementwise(dForce);
     });
 }

References BaseInteractable::getForce(), Vec3D::multiplyElementwise(), and BaseInteractable::setPrescribedVelocity().

◆ setVTKVisibility()

void BaseWall::setVTKVisibility ( bool vtkVisibility )

 {
     vtkVisibility_ = vtkVisibility;
 }

References vtkVisibility_.

Referenced by main().

◆ write()

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

overridevirtual

Function that writes a BaseWall to an output stream, usually a restart file.

Reimplemented from BaseInteractable.

Reimplemented in WearableTriangulatedWall, WearableTriangleMeshWall, WearableNurbsWall, VChute, TriangulatedWall, TriangleWall, TriangleMeshWall, SphericalWall, SineWall, Screw, RestrictedWall, ParabolaChute, NurbsWall, MeshTriangle, IntersectionOfWalls, InfiniteWallWithHole, HorizontalScrew, CylindricalWall, Combtooth, Coil, BasicUnionOfWalls, BasicIntersectionOfWalls, SimpleDrumSuperquadrics, ScrewsymmetricIntersectionOfWalls, and HorizontalBaseScrew.

 {
     BaseInteractable::write(os);
     if (vtkVisibility_==false)
     {
         os << " vtkVisibility " << vtkVisibility_;
     }
     if (renderedWalls_.size()>0)
     {
         os << " renderedWalls " << renderedWalls_.size();
         for (auto w : renderedWalls_)
         {
             os << " ";
             w->write(os);
         }
     }
 }

References renderedWalls_, vtkVisibility_, w, and BaseInteractable::write().

Referenced by SimpleDrumSuperquadrics::write(), ArcWall::write(), BasicIntersectionOfWalls::write(), BasicUnionOfWalls::write(), Coil::write(), Combtooth::write(), CylindricalWall::write(), HorizontalScrew::write(), InfiniteWallWithHole::write(), IntersectionOfWalls::write(), MeshTriangle::write(), NurbsWall::write(), RestrictedWall::write(), Screw::write(), SineWall::write(), SphericalWall::write(), TriangleMeshWall::write(), TriangleWall::write(), and VChute::write().

◆ writeVTK()

void BaseWall::writeVTK ( VTKContainer & vtk ) const

virtual

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 in TriangulatedWall, TriangleWall, TriangleMeshWall, ScrewsymmetricIntersectionOfWalls, Screw, RestrictedWall, NurbsWall, MeshTriangle, LevelSetWall, IntersectionOfWalls, InfiniteWall, HorizontalScrew, HorizontalBaseScrew, BasicUnionOfWalls, and AxisymmetricIntersectionOfWalls.

 {
     logger(WARN, "Walls % of type % have no vtk writer defined", getIndex(), getName());
 }

References BaseObject::getIndex(), BaseObject::getName(), logger, and WARN.

Referenced by renderWall(), and RestrictedWall::writeVTK().

◆ writeWallDetailsVTK()

virtual void BaseWall::writeWallDetailsVTK ( VTKData & data ) const

inlinevirtual

Reimplemented in WearableNurbsWall, and NurbsWall.

225 { };

Member Data Documentation

◆ handler_

WallHandler* BaseWall::handler_

private

A pointer to the WallHandler that handles this BaseWall.

Referenced by BaseWall(), getHandler(), setHandler(), and setIndSpecies().

◆ renderedWalls_

std::vector<BaseWall*> BaseWall::renderedWalls_

private

A vector of walls that gets rendered instead of the actual wall

Referenced by addRenderedWall(), BaseWall(), getRenderedWall(), getRenderedWalls(), read(), removeRenderedWalls(), renderWall(), and write().

◆ vtkVisibility_

bool BaseWall::vtkVisibility_ = true

private

Referenced by BaseWall(), getVTKVisibility(), read(), setVTKVisibility(), and write().

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

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BaseWall() [1/2]

◆ BaseWall() [2/2]

◆ ~BaseWall()

Member Function Documentation

◆ actionsAfterParticleGhostUpdate()

◆ actionsOnRestart()

◆ addParticlesAtWall()

◆ addRenderedWall()

◆ addToVTK()

◆ checkInteractions()

◆ computeWear()

◆ copy()

◆ getAxis()

◆ getDistanceAndNormal()

◆ getDistanceNormalOverlap()

◆ getDistanceNormalOverlapSuperquadric()

◆ getFurthestPointSuperQuadric()

◆ getHandler()

◆ getInteractionWith()

◆ getInteractionWithSuperQuad()

◆ getLinePlaneIntersect()

◆ getRenderedWall()

◆ getRenderedWalls()

◆ getVTK()

◆ getVTKVisibility()

◆ handleParticleAddition()

◆ handleParticleRemoval()

◆ intersectVTK()

◆ isFixed()

◆ isInsideWallVTK()

◆ isLocal()

◆ projectOntoWallVTK()

◆ read()

◆ removeRenderedWalls()

◆ renderWall()

◆ setForceControl()

◆ setHandler()

◆ setIndSpecies()

◆ setSpecies()

◆ setVelocityControl()

◆ setVTKVisibility()

◆ write()

◆ writeVTK()

◆ writeWallDetailsVTK()

Member Data Documentation

◆ handler_

◆ renderedWalls_

◆ vtkVisibility_