Defines the basic properties that a interactable object can have. More...

#include <BaseInteractable.h>

Inheritance diagram for BaseInteractable:

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

void	read (std::istream &is) override
	Reads a BaseInteractable from an input stream. More...

void	write (std::ostream &os) const override
	Write a BaseInteractable to an output stream. More...

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

virtual void	setIndSpecies (unsigned int indSpecies)
	Sets the index of the Species of this BaseInteractable. 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 BaseInteraction *	getInteractionWith (BaseParticle P, unsigned timeStamp, InteractionHandler interactionHandler)=0
	Returns the interaction between this object and a given BaseParticle. 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 bool	isFixed () const =0

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

Private Attributes
std::function< Vec3D(double)>	prescribedPosition_

std::function< Vec3D(double)>	prescribedVelocity_

std::function< Quaternion(double)>	prescribedOrientation_

std::function< Vec3D(double)>	prescribedAngularVelocity_

Vec3D	position_

Quaternion	orientation_

Vec3D	angularVelocity_

Vec3D	force_

Vec3D	torque_

std::vector< Vec3D >	forceOMP_

std::vector< Vec3D >	torqueOMP_

const ParticleSpecies *	species_

unsigned int	indSpecies_

Vec3D	velocity_

std::vector< BaseInteraction * >	interactions_

Detailed Description

Defines the basic properties that a interactable object can have.

Inherits from class BaseObject (public) Also it includes a lot of code to deal with interactable objects that have a prescibed motion. Most of the code in here is MercuryDPM internal. The only place an user will interface with this code is for setting the lambda functions that prescribe the motion of infinite mass particles.

Todo:: Check prescribed objects have infinite mass.

Constructor & Destructor Documentation

◆ BaseInteractable() [1/2]

BaseInteractable::BaseInteractable ( )

Default BaseInteractable constructor.

Simply creates an empty BaseInteractable, with all vectors relating to the positions and motions of the current object initialised to zero and all pointers to null.

Note that the function also sets the species index (indSpecies_) to zero by default, so any objects created will, by default, possess the properties associated with species 0.

                                    :
         BaseObject()
 {
     //setting all vectors to zero
     position_.setZero();
     orientation_.setUnity();
     velocity_.setZero();
     angularVelocity_.setZero();
     force_.setZero();
     torque_.setZero();
     //setting the default species to species 0
     indSpecies_ = 0;
     //setting all relevant pointers to nullptr
     species_ = nullptr;
     prescribedPosition_ = nullptr;
     prescribedVelocity_ = nullptr;
     prescribedOrientation_ = nullptr;
     prescribedAngularVelocity_ = nullptr;
     logger(DEBUG, "BaseInteractable::BaseInteractable() finished");
 }

References angularVelocity_, DEBUG, force_, indSpecies_, logger, orientation_, position_, prescribedAngularVelocity_, prescribedOrientation_, prescribedPosition_, prescribedVelocity_, Quaternion::setUnity(), Vec3D::setZero(), species_, torque_, and velocity_.

◆ BaseInteractable() [2/2]

BaseInteractable::BaseInteractable ( const BaseInteractable & p )

Copy constructor.

Copies an existing BaseInteractable, p, and (almost) all objects it contains.

Note, that the interactions are not copied as these often require extra work. Rather, the interactions list is simply emptied using the standard C++ clear function, destroying all contents and leaving the interactions_ vector with a size of zero.

All the other properties are copied normally.

Please use this copy with care.

         : BaseObject(p)
 {
     interactions_.clear();
     position_ = p.position_;
     orientation_ = p.orientation_;
     velocity_ = p.velocity_;
     angularVelocity_ = p.angularVelocity_;
     force_ = p.force_;
     torque_ = p.torque_;
     species_ = p.species_;
     indSpecies_ = p.indSpecies_;
     prescribedPosition_ = p.prescribedPosition_;
     prescribedVelocity_ = p.prescribedVelocity_;
     prescribedOrientation_ = p.prescribedOrientation_;
     prescribedAngularVelocity_ = p.prescribedAngularVelocity_;
     logger(DEBUG, "BaseInteractable::BaseInteractable(const BaseInteractable &p finished");
 }

References angularVelocity_, DEBUG, force_, indSpecies_, interactions_, logger, orientation_, p, position_, prescribedAngularVelocity_, prescribedOrientation_, prescribedPosition_, prescribedVelocity_, species_, torque_, and velocity_.

◆ ~BaseInteractable()

BaseInteractable::~BaseInteractable ( )

override

Destructor, it simply destructs the BaseInteractable and all the objects it contains.

Removes all the interactions from the interactable.

 {
     logger(VERBOSE, "Deleting BaseInteractable with index= % and id = %, size = %", getIndex(), getId(),
            interactions_.size());
     while (!interactions_.empty())
     {
         interactions_.front()->removeFromHandler();
     }
     logger(DEBUG, "BaseInteractable::~BaseInteractable() finished");
 }

References DEBUG, BaseObject::getId(), BaseObject::getIndex(), interactions_, logger, and VERBOSE.

Member Function Documentation

◆ addAngularVelocity()

void BaseInteractable::addAngularVelocity ( const Vec3D & angularVelocity )

add an increment to the angular velocity.

See also BaseInteractable::setAngularVelocity

Parameters

[in] angularVelocity increment which to increase the angularVelocity by.

 {
     angularVelocity_ += angularVelocity;
 }

References angularVelocity_.

Referenced by BaseParticle::angularAccelerate().

◆ addForce()

void BaseInteractable::addForce ( const Vec3D & addForce )

Adds an amount to the force on this BaseInteractable.

Incremental version of BaseInteractable::setForce. Also see BaseInteraction::setForce for were this is used.

Parameters

[in] addForce Vec3D incremental force which is added to the total force of the interactable.

 {
     if (OMP_THREAD_NUM==0) {
         force_ += addForce;
     } else {
         forceOMP_[OMP_THREAD_NUM-1] += addForce;
     }
 }

References force_, forceOMP_, and OMP_THREAD_NUM.

Referenced by MeshTriangle::checkInteractions(), SingleParticleSegregation::computeAdditionalForces(), DPMBase::computeExternalForces(), Contact::computeExternalForces(), VolumeCoupling::computeExternalForces(), DPMBase::computeForcesDueToWalls(), DPMBase::computeInternalForce(), ChuteWithPeriodicInflow::computeInternalForces(), and BaseWall::getInteractionWith().

◆ addInteraction()

void BaseInteractable::addInteraction ( BaseInteraction * I )

Adds an interaction to this BaseInteractable.

Added a new interactions to the current interactable.

Parameters

[in] I Pointer to the new interaction which is to be added to the list of interactions of this interactable.

 {
     interactions_.push_back(I);
 }

References I, and interactions_.

Referenced by BaseInteraction::importI(), BaseInteraction::importP(), BaseInteraction::setI(), and BaseInteraction::setP().

◆ addTorque()

void BaseInteractable::addTorque ( const Vec3D & addTorque )

Adds an amount to the torque on this BaseInteractable.

Incremental version of BaseInteractable::setTorque. Also see BaseInteraction::setTorque for were this is used.

Parameters

[in] addTorque Vec3D incremental force which is added to the total torque of the interactable.

 {
     if (OMP_THREAD_NUM==0) {
         torque_ += addTorque;
     } else {
         torqueOMP_[OMP_THREAD_NUM-1] += addTorque;
     }
 }

References OMP_THREAD_NUM, torque_, and torqueOMP_.

Referenced by MeshTriangle::checkInteractions(), DPMBase::computeForcesDueToWalls(), DPMBase::computeInternalForce(), ChuteWithPeriodicInflow::computeInternalForces(), and BaseWall::getInteractionWith().

◆ addVelocity()

void BaseInteractable::addVelocity ( const Vec3D & velocity )

inline

adds an increment to the velocity.

◆ applyPrescribedAngularVelocity()

void BaseInteractable::applyPrescribedAngularVelocity ( double time )

Computes the angular velocity from the user defined prescribed angular velocity.

This calls the prescribedAngularVelocity function if one has been defined. See also BaseInteractable::setPrescribedAngularVelocity

Parameters

[in] time double which is the current time of the simulation.

 {
     if (prescribedAngularVelocity_)
     {
         setAngularVelocity(prescribedAngularVelocity_(time));
     }
 }

References prescribedAngularVelocity_, and setAngularVelocity().

Referenced by integrateAfterForceComputation(), and integrateBeforeForceComputation().

◆ applyPrescribedOrientation()

void BaseInteractable::applyPrescribedOrientation ( double time )

Computes the orientation from the user defined prescribed orientation function.

This calls the prescribedOrientation function if one has been defined. See also BaseInteractable::setPrescribedOrientation

Parameters

[in] time double which is the current time of the simulation.

 {
     if (prescribedOrientation_)
     {
         setOrientation(prescribedOrientation_(time));
     }
 }

References prescribedOrientation_, and setOrientation().

Referenced by integrateBeforeForceComputation().

◆ applyPrescribedPosition()

void BaseInteractable::applyPrescribedPosition ( double time )

Computes the position from the user defined prescribed position function.

This calls the prescribedPosition function if one has been defined. See also BaseInteractable::setPrescribedPosition

Parameters

[in] time double which is the current time of the simulation.

 {
     if (prescribedPosition_)
     {
         setPosition(prescribedPosition_(time));
     }
 }

References prescribedPosition_, and setPosition().

Referenced by integrateBeforeForceComputation().

◆ applyPrescribedVelocity()

void BaseInteractable::applyPrescribedVelocity ( double time )

Computes the velocity from the user defined prescribed velocity function.

This calls the prescribedVeclocity function if one has been defined. See also BaseInteractable::setPrescribedVelocity

Parameters

[in] time double which is the current time of the simulation.

 {
     if (prescribedVelocity_)
     {
         setVelocity(prescribedVelocity_(time));
     }
 }

References prescribedVelocity_, and setVelocity().

Referenced by integrateAfterForceComputation(), and integrateBeforeForceComputation().

◆ copyInteractionsForPeriodicParticles()

void BaseInteractable::copyInteractionsForPeriodicParticles ( const BaseInteractable & pOriginal )

Copies interactions to this BaseInteractable whenever a periodic copy made.

This loops over all interactions of periodic (particle) and calls copySwitchPointer, which copies the interactions.

Parameters

[in] pOriginal Reference to the BaseInteractable which is to be copied to create the ghost particles.

 {
     for (BaseInteraction* interaction : pOriginal.interactions_)
     {
         //So here this is the ghost and it is the interaction of the ghost/
         interaction->copySwitchPointer(&pOriginal, this);
     }
 }

References BaseInteraction::copySwitchPointer(), and interactions_.

Referenced by ConstantMassFlowMaserBoundary::createGhostCopy(), SubcriticalMaserBoundary::createGhostCopy(), PeriodicBoundary::createGhostParticle(), TimeDependentPeriodicBoundary::createGhostParticle(), LeesEdwardsBoundary::createHorizontalPeriodicParticle(), ShearBoxBoundary::createHorizontalPeriodicParticle(), AngledPeriodicBoundary::createPeriodicParticle(), LeesEdwardsBoundary::createVerticalPeriodicParticle(), and ShearBoxBoundary::createVerticalPeriodicParticle().

◆ getAngularVelocity()

const Vec3D & BaseInteractable::getAngularVelocity ( ) const

virtual

Returns the angular velocity of this interactable.

Returns the angular velocity of the BaseInteractbale. Note, this is the same for all BaseInteractables; it is the direction the object is moving in.

Returns: Vec3D reference which contains the current angular velocity of the current BaseInteractable.

 {
     return angularVelocity_;
 }

References angularVelocity_.

Referenced by MarbleRun::actionsAfterTimeStep(), NautaMixer::addScrew(), ClumpParticle::angularAccelerateClumpIterative(), compareParticles(), ChuteWithPeriodicInflow::computeInternalForces(), copyVelocityFrom(), BaseParticle::getAngularMomentum(), HorizontalBaseScrew::getDistanceAndNormal(), SimpleDrumSuperquadrics::getDistanceAndNormal(), TriangleMeshWall::getInteractionWith(), ParticleParticleCollision::getRelativeVelocity(), WallParticleCollision::getRelativeVelocity(), BaseParticle::getRotationalEnergy(), ClumpParticle::getRotationalEnergy(), getVelocityAtContact(), integrateBeforeForceComputation(), BaseParticle::integrateBeforeForceComputation(), ClumpParticle::integrateBeforeForceComputation(), main(), ChuteWithPeriodicInflow::outputXBallsDataParticlee(), ClumpParticle::updateExtraQuantities(), PeriodicBoundaryHandler::updateParticles(), ClumpParticle::updatePebblesVelPos(), and HorizontalBaseScrew::writeVTK().

◆ getCurvature()

virtual Mdouble BaseInteractable::getCurvature ( const Vec3D & labFixedCoordinates ) const

inlinevirtual

returns the inverse radius, or curvature, of the surface. This value is zero for walls and gets overridden for particles that have finite radius

Todo:: should be wall-type dependent

Reimplemented in BaseParticle, and SuperQuadricParticle.

394 { return 0.0; }

Referenced by BaseInteraction::getEffectiveRadius(), and BaseInteraction::getOverlapVolume().

◆ getForce()

const Vec3D& BaseInteractable::getForce ( ) const

inline

Returns the force on this BaseInteractable.

Return the current force being to the BaseInteractable. Note, the code works by first computing the forces of each interaction and then it loops over all BaseInteracables applying forces to them from the interactions they are involved in.

Returns: const Vec3D reference that is the total force applied to this interactable.

106 { return force_; }

References force_.

Referenced by T_protectiveWall::actionsAfterTimeStep(), ClosedCSCWalls::actionsAfterTimeStep(), MercuryProblem::actionsAfterTimeStep(), protectiveWall::actionsAfterTimeStep(), Slide::actionsBeforeTimeStep(), SphericalIndenter::getForceOnIndenter(), BaseParticle::integrateAfterForceComputation(), ClumpParticle::integrateAfterForceComputation(), BaseParticle::integrateBeforeForceComputation(), ClumpParticle::integrateBeforeForceComputation(), BaseWall::setForceControl(), BaseWall::setVelocityControl(), ClumpParticle::updateExtraQuantities(), and Slide::writeEneTimeStep().

◆ getIndSpecies()

unsigned int BaseInteractable::getIndSpecies ( ) const

inline

Returns the index of the species associated with the interactable object.

Returns: Unsigned int which is the unique index of the species

68 { return indSpecies_; }

References indSpecies_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), ChuteWithPeriodicInflow::computeInternalForces(), FlowRule::create_inflow_particle(), ChuteWithPeriodicInflow::integrateBeforeForceComputation(), ChuteWithPeriodicInflow::outputXBallsDataParticlee(), ChuteWithPeriodicInflow::printTime(), ParticleHandler::readAndCreateObject(), WallHandler::readAndCreateObject(), BaseParticle::setHandler(), BaseWall::setHandler(), and BaseWall::setIndSpecies().

◆ getInteractions()

const std::vector<BaseInteraction*>& BaseInteractable::getInteractions ( ) const

inline

Returns a list of interactions which belong to this interactable.

Returns: An list of pointers to all the interactions which this interacable is involved in.

257 { return interactions_; }

References interactions_.

Referenced by SilbertPeriodic::add_flow_particles(), MeshTriangle::checkInteractions(), WearableNurbsWall::computeWear(), WearableTriangulatedWall::computeWear(), PeriodicBoundaryHandler::findNewInteractions(), and DPMBase::removeDuplicatePeriodicParticles().

◆ getInteractionWith()

virtual BaseInteraction* BaseInteractable::getInteractionWith	(	BaseParticle *	P,
		unsigned	timeStamp,
		InteractionHandler *	interactionHandler
	)

pure virtual

Returns the interaction between this object and a given BaseParticle.

Todo:

TW make sure this function sets normal, distance, overlap, contact point

AT why is this a BaseParticle and not a BaseInteratable.

Implemented in VChute, TriangulatedWall, TriangleMeshWall, SineWall, RestrictedWall, ParabolaChute, MeshTriangle, Combtooth, BaseWall, ArcWall, SuperQuadricParticle, and BaseParticle.

◆ getInvMass()

virtual Mdouble BaseInteractable::getInvMass ( ) const

inlinevirtual

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

Reimplemented in MeshTriangle, and BaseParticle.

388 { return 0.0; }

Referenced by BaseInteraction::getEffectiveMass().

◆ getOrientation()

const Quaternion& BaseInteractable::getOrientation ( ) const

inline

Returns the orientation of this BaseInteractable.

Returns the reference to a Vec3D which contains the orientation of the interactionable. Please note the interpretation of this depends on which interactable. Please see derived objects for details.

Returns: Returns a reference to a Vec3D returns the position of the interactable.

210 { return orientation_; }

References orientation_.

◆ getPosition()

const Vec3D& BaseInteractable::getPosition ( ) const

inline

Returns the position of this BaseInteractable.

Returns the reference to a Vec3D which contains the position of the interactionable. Please note the interpretation of this depends on which interactable. For particles this is the centre of the particle; where for walls it is one point of the wall given \(r.n=p\)

Returns: Returns a reference to a Vec3D returns the position of the interactable.

198 { return position_; }

References position_.

◆ getSpecies()

const ParticleSpecies* BaseInteractable::getSpecies ( ) const

inline

Returns a pointer to the species of this BaseInteractable.

This function return a ParticleSpecies* for the current interacable. Please note, this is a ParticleSpecies; not, a BaseSpecies as interactables must have physically properties as well.

Returns: constant ParticleSpecies* pointer to the species storing the physical properties of this interactable.

     {
         return species_;
     }

References species_.

Referenced by ClumpParticle::actionsAfterAddObject(), IntersectionOfWalls::addObject(), NautaMixer::addScrew(), FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), InsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), ChargedBondedInteraction::computeAdhesionForce(), CurvyChute::createBottom(), NurbsWall::getDistanceAndNormal(), Screw::getDistanceAndNormal(), IntersectionOfWalls::getDistanceAndNormal(), ChargedBondedInteraction::getElasticEnergy(), BaseParticle::getInfo(), BaseParticle::getInteractionDistance(), SuperQuadricParticle::getInteractionRadius(), BaseParticle::getMaxInteractionRadius(), BasicIntersectionOfWalls::getVTK(), BasicUnionOfWalls::getVTK(), RestrictedWall::set(), TriangleMeshWall::set(), SuperQuadricParticle::setAxes(), SuperQuadricParticle::setExponents(), SuperQuadricParticle::setInertia(), BaseParticle::setRadius(), WallParticleCollision::setupInitialConditions(), BaseParticle::unfix(), and BaseInteraction::writeInteraction().

◆ getTorque()

const Vec3D& BaseInteractable::getTorque ( ) const

inline

Returns the torque on this BaseInteractable.

Return the current torque being to the BaseInteractable. Note, the code works by first computing the forces of each interaction and then it loops over all BaseInteracables applying forces to them from the interactions they are involved in.

Returns: const Vec3D reference that is the total force applied to this interactable.

118 { return torque_; }

References torque_.

Referenced by ClumpParticle::angularAccelerateClumpIterative(), BaseParticle::integrateAfterForceComputation(), BaseParticle::integrateBeforeForceComputation(), and ClumpParticle::updateExtraQuantities().

◆ getVelocity()

const Vec3D & BaseInteractable::getVelocity ( ) const

virtual

Returns the velocity of this interactable.

Returns the velocity of the BaseInteractbale. Note, this is the same for all BaseInteractables; it is the direction the object is moving in.

Returns: Vec3D reference which contains the current velocity of the current BaseInteractable.

 {
     return velocity_;
 }

References velocity_.

Referenced by HertzianBSHPInteractionTwoParticleElasticCollision::actionsAfterSolve(), SphericalSuperQuadricCollision::actionsAfterSolve(), SpeciesTest::actionsAfterSolve(), ClosedCSCRestart::actionsAfterTimeStep(), ClosedCSCRun::actionsAfterTimeStep(), ClosedCSCWalls::actionsAfterTimeStep(), SphericalIndenter::actionsAfterTimeStep(), BouncingSuperQuadric::actionsAfterTimeStep(), LawinenBox::actionsBeforeTimeStep(), Slide::actionsBeforeTimeStep(), FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), InsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), ChuteWithContraction::ChuteWithContraction(), compareParticles(), DPMBase::computeExternalForces(), ChuteWithPeriodicInflow::computeInternalForces(), ClosedCSCWalls::continueSolve(), copyVelocityFrom(), BaseParticle::getAngularMomentum(), SphericalIndenter::getIndenterVelocity(), TriangleMeshWall::getInteractionWith(), BaseParticle::getKineticEnergy(), ClumpParticle::getKineticEnergy(), BaseParticle::getMomentum(), ParticleParticleCollision::getRelativeVelocity(), WallParticleCollision::getRelativeVelocity(), getVelocityAtContact(), ClumpParticle::integrateAfterForceComputation(), integrateBeforeForceComputation(), BaseParticle::integrateBeforeForceComputation(), ClumpParticle::integrateBeforeForceComputation(), main(), InfiniteWallWithHole::move_time(), SphericalIndenter::outputXBallsData(), ChuteWithPeriodicInflow::outputXBallsDataParticlee(), LawinenBox::printTime(), ClosedCSCRestart::printTime(), ClosedCSCRun::printTime(), ClosedCSCWalls::printTime(), ChuteWithPeriodicInflow::printTime(), ContactDetectionNormalSpheresTest::test(), HertzContactRestitutionUnitTest::test(), PeriodicBoundaryHandler::updateParticles(), ClumpParticle::updatePebblesVelPos(), and MeshTriangle::updateVerticesFromParticles().

◆ getVelocityAtContact()

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

virtual

Returns the velocity at the contact point, use by many force laws.

Reimplemented in MeshTriangle.

 {
     return getVelocity() - Vec3D::cross(contact - getPosition(), getAngularVelocity());
 }

References Vec3D::cross(), getAngularVelocity(), getPosition(), and getVelocity().

◆ integrateAfterForceComputation()

void BaseInteractable::integrateAfterForceComputation	(	double	time,
		double	timeStep
	)

This is part of the integration routine for objects with infinite mass.

This is the last part of time integration for interactable objects which have an infinite mass.

Parameters

[in]	time	double which is the current simulation time
[in]	timeStep	double which is the current delta time of the simulation i.e. the size of each time step.

 {
     if (prescribedPosition_)
     {
         if (prescribedVelocity_)
         {
             applyPrescribedVelocity(time + timeStep);
         }
         else
         {
             setVelocity((prescribedPosition_(time + 1.1 * timeStep) - prescribedPosition_(time + 0.9 * timeStep)) /
                         (0.2 * timeStep));
         }
     }
     else
     {
         if (prescribedVelocity_)
         {
             applyPrescribedVelocity(time + 0.5 * timeStep);
         }
     }
     if (prescribedOrientation_)
     {
         if (prescribedAngularVelocity_)
         {
             applyPrescribedAngularVelocity(time + timeStep);
         }
         else
         {
             setAngularVelocity(getOrientation().applyCInverse(
                     (prescribedOrientation_(time + 1.1 * timeStep) - prescribedOrientation_(time + 0.9 * timeStep)) /
                     (0.2 * timeStep)
             ));
         }
     }
     else
     {
         if (prescribedAngularVelocity_)
         {
             applyPrescribedAngularVelocity(time + 0.5 * timeStep);
         }
     }
 }

References applyPrescribedAngularVelocity(), applyPrescribedVelocity(), getOrientation(), prescribedAngularVelocity_, prescribedOrientation_, prescribedPosition_, prescribedVelocity_, setAngularVelocity(), and setVelocity().

Referenced by BaseParticle::integrateAfterForceComputation(), and ClumpParticle::integrateAfterForceComputation().

◆ integrateBeforeForceComputation()

void BaseInteractable::integrateBeforeForceComputation	(	double	time,
		double	timeStep
	)

This is part of integrate routine for objects with infinite mass.

This does not first part of verlet integration but for objects with an infinite mass i.e. there motion is prescribed and not calculated from the applied forces. First it deals with the translation degrees of freedom and then secondly if deals with the angular degrees of freedom. Note, in both cases if the user has prescribed both positions and velocity these are used. If only only position is prescribed the velocity is computed from a finite difference. If only the velocity is prescribed the position is computed from integrating the velocity.

In the weird case they neither is set. The objects computed velocity is used to update its position.

Parameters

[in]	time	double which is the current simulation time
[in]	timeStep	double which is the current delta time of the simulation i.e. the size of each time step.

 {
     if (prescribedPosition_)
     {
         if (prescribedVelocity_)
         {
             //Both the velocity and position are defined; as we are using leap
             //frog method so the velocity is evaluated half a time later.
             applyPrescribedPosition(time + timeStep);
             applyPrescribedVelocity(time + 0.5 * timeStep);
         }
         else
         {
             //Only the position is defined.
             //Velocity is evaluated from a finite different of the Position
             //Note, we use 0.5 +- 0.1 timeStep for the velocity eval.
             applyPrescribedPosition(time + timeStep);
             setVelocity((prescribedPosition_(time + 0.6 * timeStep) - prescribedPosition_(time + 0.4 * timeStep)) /
                         (0.2 * timeStep));
         }
     }
     else
     {
         if (prescribedVelocity_)
         {
             //Only the velocity is set. The position is calculated from the
             //the integral of velocity.
             applyPrescribedVelocity(time + 0.5 * timeStep);
             move(getVelocity() * timeStep);
         }
         else
         {
             //Neither is set move based on the computed velocity of the object.
             move(getVelocity() * timeStep);
         }
     }
     if (prescribedOrientation_)
     {
         if (prescribedAngularVelocity_)
         {
             applyPrescribedOrientation(time + timeStep);
             applyPrescribedAngularVelocity(time + 0.5 * timeStep);
         }
         else
         {
             applyPrescribedOrientation(time + timeStep);
             setAngularVelocity(getOrientation().applyCInverse(
                     (prescribedOrientation_(time + 0.6 * timeStep) - prescribedOrientation_(time + 0.4 * timeStep)) /
                     (0.2 * timeStep)
             ));
         }
     }
     else
     {
         if (prescribedAngularVelocity_)
         {
             applyPrescribedAngularVelocity(time + 0.5 * timeStep);
             rotate(getAngularVelocity() * timeStep);
         }
         else
         {
             rotate(getAngularVelocity() * timeStep);
         }
     }
 }

References applyPrescribedAngularVelocity(), applyPrescribedOrientation(), applyPrescribedPosition(), applyPrescribedVelocity(), getAngularVelocity(), getOrientation(), getVelocity(), move(), prescribedAngularVelocity_, prescribedOrientation_, prescribedPosition_, prescribedVelocity_, rotate(), setAngularVelocity(), and setVelocity().

Referenced by BaseParticle::integrateBeforeForceComputation(), and ClumpParticle::integrateBeforeForceComputation().

◆ isFaceContact()

virtual bool BaseInteractable::isFaceContact ( const Vec3D & normal ) const

inlinevirtual

Reimplemented in TriangleWall.

396 {return true;}

◆ isFixed()

virtual bool BaseInteractable::isFixed ( ) const

pure virtual

used to distinguish particles which belong to the flow and fixed particles/walls

Implemented in BaseWall, and BaseParticle.

◆ move()

void BaseInteractable::move ( const Vec3D & move )

virtual

Moves this BaseInteractable by adding an amount to the position.

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

Parameters

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

Reimplemented in TriangulatedWall, TriangleWall, TriangleMeshWall, and MeshTriangle.

 {
     position_ += move;
 }

References position_.

Referenced by SphericalIndenter::actionsAfterTimeStep(), ChuteWithPeriodicInflow::AddContinuingBottom(), ConstantMassFlowMaserBoundary::checkBoundaryAfterParticleMoved(), ChuteWithContraction::ChuteWithContraction(), ChuteWithPeriodicInflowAndContinuingBottom::ChuteWithPeriodicInflowAndContinuingBottom(), ChuteWithPeriodicInflowAndContraction::ChuteWithPeriodicInflowAndContraction(), ChuteWithPeriodicInflowAndVariableBottom::ChuteWithPeriodicInflowAndVariableBottom(), ContractionWithPeriodicInflow::ContractionWithPeriodicInflow(), ConstantMassFlowMaserBoundary::createPeriodicParticle(), ChuteWithPeriodicInflow::ExtendInWidth(), integrateBeforeForceComputation(), BaseParticle::integrateBeforeForceComputation(), ClumpParticle::integrateBeforeForceComputation(), MeshTriangle::move(), TriangleMeshWall::move(), TriangleWall::move(), TriangulatedWall::move(), and ScalingTestRun::setupInitialConditions().

◆ read()

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

overridevirtual

Reads a BaseInteractable from an input stream.

BaseInteacatable read functions. Reads in all the information about an interacatable. Note, this can be from any istream but would normally be a file See also BaseInteractable::write

Parameters

[in] is std::istream to which the information is read from.

Implements BaseObject.

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, BaseWall, ArcWall, SuperQuadricParticle, ClumpParticle, BaseParticle, SimpleDrumSuperquadrics, ScrewsymmetricIntersectionOfWalls, HorizontalBaseScrew, and AxisymmetricIntersectionOfWalls.

 {
     BaseObject::read(is);
     std::string dummy;
     is >> dummy >> indSpecies_;
     is >> dummy >> position_;
     is >> dummy;
     //this if-statement is added to read Kasper van der Vaart's data files, which contain an additional variable named positionAbsolute
     if (dummy == "positionAbsolute")
     {
         is >> dummy >> dummy >> dummy >> dummy;
     }
     is >> orientation_;
     is >> dummy >> velocity_;
     is >> dummy >> angularVelocity_;
     is >> dummy;
     if (dummy == "0")
         is >> dummy;
     is >> force_;
     is >> dummy >> torque_;
 }

References angularVelocity_, force_, indSpecies_, orientation_, position_, BaseObject::read(), oomph::Global_string_for_annotation::string(), torque_, and velocity_.

Referenced by BaseParticle::read(), and BaseWall::read().

◆ removeInteraction()

bool BaseInteractable::removeInteraction ( BaseInteraction * I )

Removes an interaction from this BaseInteractable.

Removes a given interaction form the list of interactions belonging to the current interacable. This functions returns true to the interaction was found and returns false if the given interaction did not exist and the interaction was not removed. Note that this cannot be done with a range-based for, since we need the iterator to erase the interaction.

Parameters

[in] I BaseInteraction pointer which is the interaction to be removed.

Returns: bool True if the interaction was found and removed; false if the interaction did not exist for that interactable.

 {
     for (std::vector<BaseInteraction*>::iterator it = interactions_.begin(); it != interactions_.end(); ++it)
     {
         if (I == (*it))
         {
             interactions_.erase(it);
             return true;
         }
     }
     logger(WARN, "Error in BaseInteractable::removeInteraction: Interaction could not be removed");
     return false;
 }

References I, interactions_, logger, and WARN.

Referenced by BaseInteraction::importI(), BaseInteraction::importP(), BaseInteraction::setI(), BaseInteraction::setP(), and BaseInteraction::~BaseInteraction().

◆ resetForceTorque()

void BaseInteractable::resetForceTorque ( int numberOfOMPthreads )

virtual

Reimplemented in TriangleMeshWall.

 {
     #ifdef MERCURYDPM_USE_OMP
     forceOMP_.resize(numberOfOMPthreads-1);
     torqueOMP_.resize(numberOfOMPthreads-1);
     for (auto& force : forceOMP_)
     {
         force.setZero();
     }
     
     for (auto& torque : torqueOMP_)
     {
         torque.setZero();
     }
     #endif
     
     force_.setZero();
     torque_.setZero();
 }

References force_, forceOMP_, Vec3D::setZero(), torque_, and torqueOMP_.

Referenced by SphericalIndenter::actionsBeforeTimeStep(), DPMBase::computeAllForces(), and TriangleMeshWall::resetForceTorque().

◆ rotate()

void BaseInteractable::rotate ( const Vec3D & angularVelocityDt )

virtual

Rotates this BaseInteractable.

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

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

Parameters

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

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

Reimplemented in Screw, TriangleWall, TriangleMeshWall, and MeshTriangle.

 {
     //if (!angularVelocityDt.isZero()) {
     orientation_.updateAngularDisplacement(angularVelocityDt);
     //}
 }

References orientation_, and Quaternion::updateAngularDisplacement().

Referenced by VerticalMixerStraightBlades::addBlades(), VerticalMixerAngledBlades::addBlades(), VerticalMixerAngledBlades::addPrettyBlades(), integrateBeforeForceComputation(), BaseParticle::integrateBeforeForceComputation(), ClumpParticle::integrateBeforeForceComputation(), MeshTriangle::rotate(), TriangleMeshWall::rotate(), TriangleWall::rotate(), and Screw::rotate().

◆ setAngularVelocity()

void BaseInteractable::setAngularVelocity ( const Vec3D & angularVelocity )

set the angular velocity of the BaseInteractble.

See also BaseInteractable::getAngularVelocity

Parameters

[in] angularVelocity Vec3D which is the angularVelocity of the interactable.

 {
     angularVelocity_ = angularVelocity;
 }

References angularVelocity_.

◆ setForce()

void BaseInteractable::setForce ( const Vec3D & force )

inline

Sets the force on this BaseInteractable.

This sets the force being applied to this interactable. Note, first the code computes all forces in the interactions and then loops over all interactable objects applying the forces from the interactions to the interactables involved in the interaction.

Parameters

[in] force Vec3D which is the force to be applied.

129 { force_ = force; }

References force_.

Referenced by SmoothChute::actionsBeforeTimeStep().

◆ setIndSpecies()

virtual void BaseInteractable::setIndSpecies ( unsigned int indSpecies )

inlinevirtual

Sets the index of the Species of this BaseInteractable.

This set the species associated with this interactable. This function should not be used and BaseInteractable::setSpecies should be used instead. See also BaseInteractable::setSpecies

Reimplemented in BaseWall, and BaseParticle.

78 { indSpecies_ = indSpecies; }

References indSpecies_.

Referenced by BaseParticle::oldRead(), BaseParticle::setIndSpecies(), and BaseWall::setIndSpecies().

◆ setOrientation()

virtual void BaseInteractable::setOrientation ( const Quaternion & orientation )

inlinevirtual

Sets the orientation of this BaseInteractable.

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

Parameters

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

Reimplemented in TriangleWall, and TriangleMeshWall.

240 { orientation_ = orientation; }

References orientation_.

Referenced by applyPrescribedOrientation(), SuperQuadricParticle::getContactPointPlanB(), BaseParticle::oldRead(), InfiniteWall::oldRead(), TriangleMeshWall::setOrientation(), TriangleWall::setOrientation(), T_protectiveWall::setupInitialConditions(), ParticleParticleCollision::setupInitialConditions(), WallParticleCollision::setupInitialConditions(), protectiveWall::setupInitialConditions(), ChuteBottom::setupInitialConditions(), TriangleWall::setVertices(), MeshTriangle::setVertices(), PeriodicBoundaryHandler::updateParticles(), and ClumpParticle::updatePebblesVelPos().

◆ setOrientationViaEuler()

void BaseInteractable::setOrientationViaEuler ( Vec3D eulerAngle )

Sets the orientation of this BaseInteractable by defining the euler angles.

 {
     orientation_.setEuler(eulerAngle);
 }

References orientation_, and Quaternion::setEuler().

◆ setOrientationViaNormal()

void BaseInteractable::setOrientationViaNormal ( Vec3D normal )

Sets the orientation of this BaseInteractable by defining the vector that results from the rotation of the (1,0,0) vector.

Sets the orientation of the interactable. interpretation depends on which interactable is being considered See also BaseInteractable::getOrientation.

Parameters

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

 {
     orientation_.setOrientationViaNormal(normal);
 }

References WallFunction::normal(), orientation_, and Quaternion::setOrientationViaNormal().

Referenced by AxisymmetricIntersectionOfWalls::AxisymmetricIntersectionOfWalls(), HorizontalBaseScrew::HorizontalBaseScrew(), main(), Screw::Screw(), ScrewsymmetricIntersectionOfWalls::ScrewsymmetricIntersectionOfWalls(), AxisymmetricIntersectionOfWalls::setAxis(), HorizontalBaseScrew::setAxis(), ScrewsymmetricIntersectionOfWalls::setAxis(), SimpleDrumSuperquadrics::setAxis(), InfiniteWall::setNormal(), MinimalExampleDrum::setupInitialConditions(), EllipsoidsBouncingOnWallDemo::setupInitialConditions(), GranularCollapse::setupInitialConditions(), ContactDetectionWithWallTester::setupParticleAndWall(), ContactDetectionTester::setupParticles(), ContactDetectionTester::testEllipsoidsContact(), ContactDetectionWithWallTester::testEllipsoidsContact(), ContactDetectionTester::testSpheresContact(), and ContactDetectionWithWallTester::testSpheresContact().

◆ setPosition()

virtual void BaseInteractable::setPosition ( const Vec3D & position )

inlinevirtual

Sets the position of this BaseInteractable.

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

Parameters

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

Reimplemented in TriangleWall, and TriangleMeshWall.

219 { position_ = position; }

References position_.

◆ setPrescribedAngularVelocity()

void BaseInteractable::setPrescribedAngularVelocity ( const std::function< Vec3D(double)> & prescribedAngularVelocity )

Allows the angular velocity of the infinite mass interactable to be prescribed.

 {
     prescribedAngularVelocity_ = prescribedAngularVelocity;
 }

References prescribedAngularVelocity_.

◆ setPrescribedOrientation()

void BaseInteractable::setPrescribedOrientation ( const std::function< Quaternion(double)> & prescribedOrientation )

Allows the orientation of the infinite mass interactbale to be prescribed.

This is similar to the BaseInteractable::setPrescribedPosition and
works the same way. See BaseInteractable::setPrescibedPosition and BaseInteractable::setPrescribedVelocity for more details how it works. Note, the rate of change of the orientation can also be set using the function BaseInteractable::setPrescribedAngularVelocity.

Parameters

[in] prescribedOrientation std::function which is the lambda function and takes a double the time and returns a Vec 3D which is the orientation of the interactable for that time.

 {
     prescribedOrientation_ = prescribedOrientation;
 }

References prescribedOrientation_.

◆ setPrescribedPosition()

void BaseInteractable::setPrescribedPosition ( const std::function< Vec3D(double)> & prescribedPosition )

Allows the position of an infinite mass interactable to be prescribed.

This functions is used to give an interactable a prescribed motion, which is defined by a std::function. This is the new moving walls interface. A demo of the use would be: setPrescribedPosition([this] (double time) { return Vec3D(getXMin(),0.0,shaker_amp * std::sin(t * 2.0 * shaker_freq * constants::pi)); } ); This example moves the wall sinusoidally with time.

Parameters

[in] prescribedPosition std::function which is the lambda function and takes a double the time and returns a Vec 3D which is the position of the interactable for that time. See also BaseInteractable::setPrescribedVelocity for more information.

 {
     prescribedPosition_ = prescribedPosition;
 }

References prescribedPosition_.

Referenced by Binary::setupInitialConditions(), my_problem::setupInitialConditions(), ExtremeOverlapWithWallsUnitTest::setupInitialConditions(), MovingWallPrescribedPosition::setupInitialConditions(), MovingWallPrescribedPositionPrescribedVelocity::setupInitialConditions(), MovingWallTangentialPrescribedPosition::setupInitialConditions(), MovingWallTangentialPrescribedPositionPrescribedVelocity::setupInitialConditions(), and SCoupling< M, O >::updateTriangleWall().

◆ setPrescribedVelocity()

void BaseInteractable::setPrescribedVelocity ( const std::function< Vec3D(double)> & prescribedVelocity )

Allows the velocity of an infinite mass interactable to be prescribed.

In a similar manner to BaseInteractable::setPrescribedPosition this sets the velocity of the BaseInteactable. See also BaseInteractable::setPrescribedPosition Note, it is valid to set both the velocity and the position. No checking if these are consist is done at all. If you only set one of these function the other is automatically calculated using a by numerically differentiating or integrating the functions will is prescribed.

Parameters

[in] prescribedVelocity std::function which is the lambda function and takes a double the time and returns a Vec 3D which is the velocity of the intertable for that time.

 {
     prescribedVelocity_ = prescribedVelocity;
 }

References prescribedVelocity_.

Referenced by ParticleBeam::ParticleBeam(), BaseWall::setForceControl(), MovingWallPrescribedVelocity::setupInitialConditions(), MovingWallPrescribedPositionPrescribedVelocity::setupInitialConditions(), MovingWallTangentialPrescribedVelocity::setupInitialConditions(), MovingWallTangentialPrescribedPositionPrescribedVelocity::setupInitialConditions(), BaseWall::setVelocityControl(), and SCoupling< M, O >::updateTriangleWall().

◆ setSpecies()

void BaseInteractable::setSpecies ( const ParticleSpecies * species )

Sets the species of this BaseInteractable.

This function sets the species associated with this interactable object. Again this must be a ParticleSpecies. Note, it also automatically sets the index on the indSpecies_ by working up the correct index. However, index should be carefully used

Parameters

[in] species ParticleSpcies pointer which is species holding the physical properties.

 {
     logger.assert_debug(species->getHandler() != nullptr && species->getHandler()->getObject(species->getIndex())==species, "Error: Species is not part of any handler yet");
     species_ = species;
     indSpecies_ = species->getIndex();
 }

References BaseSpecies::getHandler(), BaseObject::getIndex(), BaseHandler< T >::getObject(), indSpecies_, logger, and species_.

Referenced by BaseParticle::setSpecies(), and BaseWall::setSpecies().

◆ setTorque()

void BaseInteractable::setTorque ( const Vec3D & torque )

inline

Sets the torque on this BaseInteractable.

This sets the torque being applied to this interactable. Note, first the code computes all force/torques in the interactions and then loops over all interactable objects applying the torques from the interactions to the interactables involved in the interaction.

Parameters

[in] torque Vec3D which is the force to be applied.

141 { torque_ = torque; }

References torque_.

Referenced by ChangingTOIParticle::actionsAfterTimeStep(), and SmoothChute::actionsBeforeTimeStep().

◆ setVelocity()

void BaseInteractable::setVelocity ( const Vec3D & velocity )

set the velocity of the BaseInteractable.

◆ sumForceTorqueOMP()

void BaseInteractable::sumForceTorqueOMP ( )

 {
     #ifdef MERCURYDPM_USE_OMP
     for (const auto force : forceOMP_)
     {
         force_ += force;
     }
     
     for (const auto torque : torqueOMP_)
     {
         torque_ += torque;
     }
     #endif
 }

References force_, forceOMP_, torque_, and torqueOMP_.

Referenced by SphericalIndenter::actionsAfterTimeStep(), and DPMBase::computeAllForces().

◆ write()

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

overridevirtual

Write a BaseInteractable to an output stream.

Parameters

[in] os The output stream to which the BaseInteractable is written.

BaseInteractable write function. Writes out all the information required to recreate this interactable. To write this interactable to the screen call write(std::cout). See also BaseInteractable::read

Parameters

[in] os std::ostream to which the information is written. Note, is any ostream is can be file or screen.

Todo:: take the zero out

Implements BaseObject.

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

 {
     BaseObject::write(os);
     os << " indSpecies " << indSpecies_
        << " position " << position_
        << " orientation " << orientation_
        //<< " axis " << orientation_.getAxis()
        << " velocity " << velocity_
        << " angularVelocity " << angularVelocity_ 
        << " force " << force_
        << " torque " << torque_;
 }

References angularVelocity_, force_, indSpecies_, orientation_, position_, torque_, velocity_, and BaseObject::write().

Referenced by BaseParticle::write(), and BaseWall::write().

Member Data Documentation

◆ angularVelocity_

Vec3D BaseInteractable::angularVelocity_

private

Store the angular velocity of the interactable.

Referenced by addAngularVelocity(), BaseInteractable(), getAngularVelocity(), read(), setAngularVelocity(), and write().

◆ force_

Vec3D BaseInteractable::force_

private

Stores the force applied to the interactable.

Referenced by addForce(), BaseInteractable(), getForce(), read(), resetForceTorque(), setForce(), sumForceTorqueOMP(), and write().

◆ forceOMP_

std::vector<Vec3D> BaseInteractable::forceOMP_

private

Referenced by addForce(), resetForceTorque(), and sumForceTorqueOMP().

◆ indSpecies_

unsigned int BaseInteractable::indSpecies_

private

Stores the index on the species associated with this interactable.

Referenced by BaseInteractable(), getIndSpecies(), read(), setIndSpecies(), setSpecies(), and write().

◆ interactions_

std::vector<BaseInteraction*> BaseInteractable::interactions_

private

List of interactions this interactable is involved with.

Referenced by addInteraction(), BaseInteractable(), copyInteractionsForPeriodicParticles(), getInteractions(), removeInteraction(), and ~BaseInteractable().

◆ orientation_

Quaternion BaseInteractable::orientation_

private

Stores the orientation of the interactable. Exactly what is stored depends on the type of interatable

Referenced by BaseInteractable(), getOrientation(), read(), rotate(), setOrientation(), setOrientationViaEuler(), setOrientationViaNormal(), and write().

◆ position_

Vec3D BaseInteractable::position_

private

Stores the position of the interactable. Exactly what is stored depends on the type of interactable.

Referenced by BaseInteractable(), getPosition(), move(), read(), setPosition(), and write().

◆ prescribedAngularVelocity_

std::function<Vec3D(double)> BaseInteractable::prescribedAngularVelocity_

private

User defined functions which if set describes the angular velocity of the interactable.

Referenced by applyPrescribedAngularVelocity(), BaseInteractable(), integrateAfterForceComputation(), integrateBeforeForceComputation(), and setPrescribedAngularVelocity().

◆ prescribedOrientation_

std::function<Quaternion(double)> BaseInteractable::prescribedOrientation_

private

User defined function which if set describes the orientation of the interactable

Referenced by applyPrescribedOrientation(), BaseInteractable(), integrateAfterForceComputation(), integrateBeforeForceComputation(), and setPrescribedOrientation().

◆ prescribedPosition_

std::function<Vec3D(double)> BaseInteractable::prescribedPosition_

private

User defined function which if set describes the position of the interactable

Referenced by applyPrescribedPosition(), BaseInteractable(), integrateAfterForceComputation(), integrateBeforeForceComputation(), and setPrescribedPosition().

◆ prescribedVelocity_

std::function<Vec3D(double)> BaseInteractable::prescribedVelocity_

private

User defined function which if set describes the velocity of the interactable.

Referenced by applyPrescribedVelocity(), BaseInteractable(), integrateAfterForceComputation(), integrateBeforeForceComputation(), and setPrescribedVelocity().

◆ species_

const ParticleSpecies* BaseInteractable::species_

private

Point to the ParticlesSpecies which stores density and other material properties of the interactable.

Referenced by BaseInteractable(), getSpecies(), and setSpecies().

◆ torque_

Vec3D BaseInteractable::torque_

private

Stores the torque applied to the interactable.

Referenced by addTorque(), BaseInteractable(), getTorque(), read(), resetForceTorque(), setTorque(), sumForceTorqueOMP(), and write().

◆ torqueOMP_

std::vector<Vec3D> BaseInteractable::torqueOMP_

private

See BaseInteractable::forceOMP_.

Referenced by addTorque(), resetForceTorque(), and sumForceTorqueOMP().

◆ velocity_

Vec3D BaseInteractable::velocity_

private

Stores the velocity of this interactable.

Referenced by addVelocity(), BaseInteractable(), getVelocity(), read(), setVelocity(), and write().

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BaseInteractable() [1/2]

◆ BaseInteractable() [2/2]

◆ ~BaseInteractable()

Member Function Documentation

◆ addAngularVelocity()

◆ addForce()

◆ addInteraction()

◆ addTorque()

◆ addVelocity()

◆ applyPrescribedAngularVelocity()

◆ applyPrescribedOrientation()

◆ applyPrescribedPosition()

◆ applyPrescribedVelocity()

◆ copyInteractionsForPeriodicParticles()

◆ getAngularVelocity()

◆ getCurvature()

◆ getForce()

◆ getIndSpecies()

◆ getInteractions()

◆ getInteractionWith()

◆ getInvMass()

◆ getOrientation()

◆ getPosition()

◆ getSpecies()

◆ getTorque()

◆ getVelocity()

◆ getVelocityAtContact()

◆ integrateAfterForceComputation()

◆ integrateBeforeForceComputation()

◆ isFaceContact()

◆ isFixed()

◆ move()

◆ read()

◆ removeInteraction()

◆ resetForceTorque()

◆ rotate()

◆ setAngularVelocity()

◆ setForce()

◆ setIndSpecies()

◆ setOrientation()

◆ setOrientationViaEuler()

◆ setOrientationViaNormal()

◆ setPosition()

◆ setPrescribedAngularVelocity()

◆ setPrescribedOrientation()

◆ setPrescribedPosition()

◆ setPrescribedVelocity()

◆ setSpecies()

◆ setTorque()

◆ setVelocity()

◆ sumForceTorqueOMP()

◆ write()

Member Data Documentation

◆ angularVelocity_

◆ force_

◆ forceOMP_

◆ indSpecies_

◆ interactions_

◆ orientation_

◆ position_

◆ prescribedAngularVelocity_

◆ prescribedOrientation_

◆ prescribedPosition_

◆ prescribedVelocity_

◆ species_

◆ torque_

◆ torqueOMP_

◆ velocity_