#include <ClumpParticle.h>

Inheritance diagram for ClumpParticle:

Public Member Functions
	ClumpParticle ()
	Basic Particle constructor, creates a particle at (0,0,0) with radius, mass and inertia equal to 1. More...

	ClumpParticle (const ClumpParticle &p)
	Basic Particle constructor (copy-based) More...

	~ClumpParticle () override
	Destructor, needs to be implemented and checked to see if it is the largest or smallest particle currently in its particleHandler. More...

ClumpParticle *	copy () const override

void	write (std::ostream &os) const override
	Particle print function, which accepts an std::ostream as input. More...

void	read (std::istream &is) override
	Particle read function, which accepts an std::istream as input. More...

std::string	getName () const override

bool	isSphericalParticle () const override

void	computeMass (const ParticleSpecies &s) override
	Computes the particle's (inverse) mass and inertia. More...

void	setInitInertia (MatrixSymmetric3D inertia)

void	rotateTensorOfInertia ()

void	addPebble (Vec3D position, Mdouble radius)

void	setClump ()

void	setPrincipalDirections (Matrix3D directions)

void	setInitPrincipalDirections (Matrix3D directions)

Vec3D	getPrincipalDirections_e1 () const

Vec3D	getPrincipalDirections_e2 () const

Vec3D	getPrincipalDirections_e3 () const

Vec3D	getInitPrincipalDirections_e1 () const

Vec3D	getInitPrincipalDirections_e2 () const

Vec3D	getInitPrincipalDirections_e3 () const

Matrix3D	getRotationMatrix () const

int	NPebble () const

void	actionsAfterAddObject () override

void	updatePebblesVelPos ()

void	integrateBeforeForceComputation (double time, double timeStep) override

void	integrateAfterForceComputation (double time, double timeStep) override

void	angularAccelerateClumpIterative (double timeStep)

void	rotatePrincipalDirections (Vec3D rotation)

void	setPrincipalDirections_e1 (Vec3D e)

void	setPrincipalDirections_e2 (Vec3D e)

void	setPrincipalDirections_e3 (Vec3D e)

std::vector< Mdouble >	getPebbleRadius () const

void	setPebble (int kPebble, ClumpParticle *pPebble)

void	setClump (ClumpParticle *master)

void	setClumpMass (Mdouble mass)

void	setDamping (Mdouble damp)

Mdouble	getKineticEnergy () const override

Mdouble	getRotationalEnergy () const override
	Calculates the particle's rotational kinetic energy. More...

std::vector< Vec3D >	getPebblePositions ()

std::vector< Mdouble >	getPebbleRadii ()

bool	getDzhanibekovParticle ()

bool	getVerticallyOriented ()

void	setDzhanibekovParticle (bool d)

void	setVerticallyOriented (bool d)

unsigned	getNumberOfFieldsVTK () const override

std::string	getTypeVTK (unsigned i) const override

std::string	getNameVTK (unsigned i) const override

std::vector< Mdouble >	getFieldVTK (unsigned i) const override

void	updateExtraQuantities ()

Public Member Functions inherited from NonSphericalParticle
	NonSphericalParticle ()=default

	NonSphericalParticle (const NonSphericalParticle &p)=default

	NonSphericalParticle (const BaseParticle &p)
	Base class copy constructor. Creates a NonSphericalParticle particle from a BaseParticle. More...

	~NonSphericalParticle () override=default

bool	isSphericalParticle () const override

virtual Mdouble	getSurfaceArea () const override

Public Member Functions inherited from BaseParticle
	BaseParticle ()
	Basic Particle constructor, creates an Particle at (0,0,0) with radius, mass and inertia equal to 1. More...

	BaseParticle (const BaseParticle &p)
	Particle copy constructor, which accepts as input a reference to a Particle. It creates a copy of this Particle and all it's information. Usually it is better to use the copy() function for polymorphism. More...

	BaseParticle (const ParticleSpecies *s)

	~BaseParticle () override
	Particle destructor, needs to be implemented and checked if it removes tangential spring information. More...

virtual Mdouble	getVolume () const
	Get Particle volume function, which required a reference to the Species vector. It returns the volume of the Particle. More...

void	fixParticle ()
	Fix Particle function. It fixes a Particle by setting its inverse mass and inertia and velocities to zero. More...

bool	isFixed () const override
	Is fixed Particle function. It returns whether a Particle is fixed or not, by checking its inverse Mass. More...

bool	isMPIParticle () const
	Indicates if this particle is a ghost in the MPI domain. More...

void	setMPIParticle (bool flag)
	Flags the mpi particle status. More...

bool	isInMPIDomain ()
	Indicates if the particle is in the communication zone of the mpi domain. More...

void	setInMPIDomain (bool flag)
	Flags the status of the particle if wether it is in the communication zone or not. More...

bool	isInPeriodicDomain () const
	Indicates if the particle is in the periodic boundary communication zone. More...

void	setInPeriodicDomain (bool flag)
	Flags the status of the particle whether it is in the periodic communication zone or not. More...

bool	isPeriodicGhostParticle () const
	Indicates if this particle is a ghost in the periodic boundary. More...

void	setPeriodicGhostParticle (bool flag)
	Flags the status of the particle to be a ghost in periodic boundary or not. More...

bool	isMaserParticle () const
	Indicates if this particle belongs to the maser boundary. More...

void	setMaserParticle (bool flag)
	Flags the status of the particle if it belongs to the maser boundary or not. More...

void	setCommunicationComplexity (unsigned complexity)
	Set the communication complexity of the particle. More...

unsigned	getCommunicationComplexity ()
	Obtains the communication complexity of the particle. More...

void	setPeriodicComplexity (std::vector< int > complexity)
	Set the periodic communication complexity of the particle. More...

void	setPeriodicComplexity (int index, int value)
	Set the periodic communication complexity of the particle. More...

const std::vector< int > &	getPeriodicComplexity ()
	Obtains the periodic communication complexity of the particle. More...

void	setPreviousPeriodicComplexity (std::vector< int > complexity)
	Set the previous periodic communication complexity of the paritcle. More...

const std::vector< int > &	getPreviousPeriodicComplexity () const
	Sets the previous periodic communication complexity of the particle. More...

int	getPeriodicComplexity (int index)
	Gets the periodic communication complexity of a certain boundary. More...

void	unfix ()
	Unfix Particle function, which required a reference to the Species vector. It unfixes a Particle by computing the Particles mass and inertia. More...

virtual void	oldRead (std::istream &is)

virtual void	setInfo (Mdouble info)
	Sets some user-defined information about this object (by default, species ID). More...

virtual Mdouble	getInfo () const
	Returns some user-defined information about this object (by default, species ID). More...

void	setTimeStamp (unsigned timeStamp)

unsigned	getTimeStamp () const

void	printHGrid (std::ostream &os) const
	Adds particle's HGrid level and cell coordinates to an ostream. More...

unsigned int	getHGridLevel () const
	Returns particle's HGrid level. More...

BaseParticle *	getHGridNextObject () const
	Returns pointer to next object in particle's HGrid level & cell. More...

BaseParticle *	getHGridPrevObject () const
	Returns pointer to previous object in particle's HGrid level & cell. More...

int	getHGridX () const
	Returns particle's HGrid cell X-coordinate. More...

int	getHGridY () const
	Returns particle's HGrid cell Y-coordinate. More...

int	getHGridZ () const
	Returns particle's HGrid cell Z-coordinate. More...

MatrixSymmetric3D	getInvInertia () const
	Returns the inverse of the particle's inertia tensor. More...

Mdouble	getInvMass () const override
	Returns the inverse of the particle's mass. More...

Mdouble	getCurvature (const Vec3D &labFixedCoordinates) const override

Mdouble	getGravitationalEnergy () const
	Calculates the particle's gravitational energy. More...

Mdouble	getMass () const
	Returns the particle's mass. More...

Vec3D	getMomentum () const

MatrixSymmetric3D	getInertia () const

Vec3D	getAngularMomentum () const

BaseParticle *	getPeriodicFromParticle () const
	Returns the 'original' particle this one's a periodic copy of. More...

Mdouble	getRadius () const
	Returns the particle's radius. More...

Mdouble	getMaxInteractionRadius () const
	Returns the particle's interaction radius, which might be different from radius_ (e.g., when dealing with wet particles) More...

Mdouble	getInteractionDistance (const BaseInteractable *i) const
	Returns the interactionDistance_ of the mixed species of this particle and the particle or wall i. More...

Mdouble	getSumOfInteractionRadii (const BaseParticle *particle) const
	returns the sum of the radii plus the interactionDistance More...

Mdouble	getWallInteractionRadius (const BaseWall *wall) const
	returns the radius plus the interactionDistance More...

const Vec3D &	getPreviousPosition () const
	Returns the particle's position in the previous time step. More...

const Vec3D	getDisplacement2 (Mdouble xmin, Mdouble xmax, Mdouble ymin, Mdouble ymax, Mdouble zmin, Mdouble zmax, Mdouble t) const

virtual void	setInertia ()

void	setInertia (MatrixSymmetric3D inertia)
	Sets the particle's inertia_ (and adjusts invInertia_ accordingly) More...

void	setInverseInertia (MatrixSymmetric3D inverseInertia)
	Sets the particle's inertia_ (and adjusts invInertia_ accordingly) More...

void	setInfiniteInertia ()
	Sets the particle's inertia_ to 'infinite' (1e20) and its invInertia_ to 0. More...

void	setPeriodicFromParticle (BaseParticle *p)
	Assigns the pointer to the 'original' particle this one's a periodic copy of (used in periodic boundary condition implementations). More...

void	setHGridX (const int x)
	Sets the particle's HGrid cell X-coordinate. More...

void	setHGridY (const int y)
	Sets the particle's HGrid cell Y-coordinate. More...

void	setHGridZ (const int z)
	Sets the particle's HGrid cell Z-coordinate. More...

void	setHGridLevel (const unsigned int level)
	Sets the particle's HGrid level. More...

void	setHGridNextObject (BaseParticle *p)
	Sets the pointer to the next object in the particle's HGrid cell & level. More...

void	setHGridPrevObject (BaseParticle *p)
	Sets the pointer to the previous object in the particle's HGrid cell & level. More...

virtual void	setRadius (Mdouble radius)
	Sets the particle's radius_ (and adjusts the mass_ accordingly, based on the particle's species) More...

virtual Vec3D	getAxes () const
	Only ustilised in case of superquadric particles. Had to create a virtual function to allow function access in writeVTK function in the particle handler. More...

virtual Mdouble	getExponentEps1 () const
	Only ustilised in case of superquadric particles. Had to create a virtual function to allow function access in writeVTK function in the particle handler. More...

virtual Mdouble	getExponentEps2 () const
	Only ustilised in case of superquadric particles. Had to create a virtual function to allow function access in writeVTK function in the particle handler. More...

virtual void	setAxes (const Vec3D &axes)
	Only ustilised in case of superquadric particles. More...

virtual void	setExponents (const Mdouble &eps1, const Mdouble &eps2)
	Only ustilised in case of superquadric particles. More...

MERCURYDPM_DEPRECATED void	setMass (Mdouble mass)
	Sets the particle's mass. More...

void	setMassForP3Statistics (Mdouble mass)
	Sets the particle's mass This function should not be used, but is necessary to extend the CG toolbox to non-spherical particles. More...

void	setPreviousPosition (const Vec3D &pos)
	Sets the particle's position in the previous time step. More...

void	movePrevious (const Vec3D &posMove)
	Adds a vector to the particle's previousPosition_. More...

void	accelerate (const Vec3D &vel)
	Increases the particle's velocity_ by the given vector. More...

void	angularAccelerate (const Vec3D &angVel)
	Increases the particle's angularVelocity_ by the given vector. More...

void	setHandler (ParticleHandler *handler)
	Sets the pointer to the particle's ParticleHandler. More...

ParticleHandler *	getHandler () const
	Returns pointer to the particle's ParticleHandler. More...

BaseInteraction *	getInteractionWith (BaseParticle P, unsigned timeStamp, InteractionHandler interactionHandler) override
	Checks if particle is in interaction with given particle P, and if so, returns vector of pointer to the associated BaseInteraction object (else returns empty vector). More...

virtual bool	isInContactWith (const BaseParticle *P) const
	Get whether or not this particle is in contact with the given particle. More...

unsigned int	getParticleDimensions () const
	Returns the particle's dimensions (either 2 or 3). More...

MERCURYDPM_DEPRECATED void	setIndSpecies (unsigned int indSpecies) override

virtual void	setSpecies (const ParticleSpecies *species)

virtual void	actionsBeforeTimeStep ()

virtual void	actionsAfterTimeStep ()

const HGridCell &	getHGridCell () const

BaseParticle *	getClump () const

bool	isClump () const
	Checks if particle is a clump (container) More...

bool	isPebble () const
	Checks if particle is a pebble (belongs to a clump) More...

virtual Vec3D	getCenterOfMass ()

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 bool	isFaceContact (const Vec3D &normal) const

Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...

	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...

virtual	~BaseObject ()=default
	virtual destructor More...

virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...

void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...

void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...

unsigned int	getIndex () const
	Returns the index of the object in the handler. More...

unsigned int	getId () const
	Returns the unique identifier of any particular object. More...

void	setGroupId (unsigned groupId)

unsigned	getGroupId () const

Private Member Functions
MatrixSymmetric3D	MtoS (Matrix3D M)

Matrix3D	StoM (MatrixSymmetric3D M)

Matrix3D	transpose (Matrix3D M)

Private Attributes
int	nPebble_

bool	isDzhanibekovParticle_

bool	isVerticallyOriented_

Vec3D	angularAcceleration_

Mdouble	clumpMass_

Mdouble	viscousDamping_

MatrixSymmetric3D	clumpInertia_

MatrixSymmetric3D	clumpInitInertia_

std::vector< Vec3D >	pebblePos_

std::vector< Mdouble >	pebbleRadius_

Matrix3D	principalDirections_

Matrix3D	initPrincipalDirections_

std::vector< ClumpParticle * >	pebbleParticles_

Matrix3D	rotationMatrix_

Additional Inherited Members
Public Attributes inherited from BaseParticle
Mdouble	radius_

Mdouble	invMass_
	Particle radius_. More...

MatrixSymmetric3D	invInertia_
	Inverse Particle mass (for computation optimization) More...

BaseParticle *	clumpParticle_
	Function that updates necessary quantities of a clump particle after adding a pebble. More...

bool	isPebble_
	pointer to a clump particle (for a pebble) More...

bool	isClump_
	The particle is pebble. More...

Detailed Description

functional of rigid clumps in mercuryDPM

Constructor & Destructor Documentation

◆ ClumpParticle() [1/2]

ClumpParticle::ClumpParticle ( )

Basic Particle constructor, creates a particle at (0,0,0) with radius, mass and inertia equal to 1.

 {
     setRadius(1.0);
     nPebble_ = 0;
  
     clumpMass_ = 1.0;
     viscousDamping_ = 0.0;
     pebblePos_ = std::vector<Vec3D>(0);
  
     pebbleRadius_ = std::vector<Mdouble>(0);
     pebbleParticles_ = std::vector<ClumpParticle*>(0);
  
     principalDirections_ = Matrix3D(1, 0, 0, 0, 1, 0, 0, 0, 1);
     initPrincipalDirections_ = Matrix3D(1, 0, 0, 0, 1, 0, 0, 0, 1);
  
     clumpInertia_ = MatrixSymmetric3D(1, 0, 0, 1, 0, 1);
     clumpInitInertia_ = MatrixSymmetric3D(1, 0, 0, 1, 0, 1);
     rotationMatrix_ = Matrix3D(1, 0, 0, 0, 1, 0, 0, 0, 1);
     invInertia_= clumpInertia_.inverse();
  
     isPebble_ = false; //Assign false by default
     isClump_ = false; //Assign false by default
     clumpParticle_ = nullptr;
  
  
     isDzhanibekovParticle_ = false;
     isVerticallyOriented_ = false;
  
     logger(DEBUG, "Clump() created");
 }

References clumpInertia_, clumpInitInertia_, clumpMass_, BaseParticle::clumpParticle_, DEBUG, initPrincipalDirections_, MatrixSymmetric3D::inverse(), BaseParticle::invInertia_, BaseParticle::isClump_, isDzhanibekovParticle_, BaseParticle::isPebble_, isVerticallyOriented_, logger, nPebble_, pebbleParticles_, pebblePos_, pebbleRadius_, principalDirections_, rotationMatrix_, BaseParticle::setRadius(), and viscousDamping_.

Referenced by copy().

◆ ClumpParticle() [2/2]

ClumpParticle::ClumpParticle ( const ClumpParticle & p )

Basic Particle constructor (copy-based)

                                                   : NonSphericalParticle(p)
 {
     nPebble_ = p.nPebble_;
  
     clumpMass_ = p.clumpMass_;
     viscousDamping_ = p.viscousDamping_;
     pebblePos_ = p.pebblePos_;
     pebbleRadius_ = p.pebbleRadius_;
     pebbleParticles_ = p.pebbleParticles_;
     principalDirections_ = p.principalDirections_;
     initPrincipalDirections_ = p.initPrincipalDirections_;
     clumpInertia_ = p.clumpInertia_;
     clumpInitInertia_ = p.clumpInitInertia_;
     rotationMatrix_ = p.rotationMatrix_;
     invInertia_= clumpInertia_.inverse();
     isDzhanibekovParticle_ = p.isDzhanibekovParticle_;
     isVerticallyOriented_ = p.isVerticallyOriented_;
  
     for (int iPebble = 1; iPebble <= nPebble_; iPebble++) pebbleParticles_[iPebble - 1] = nullptr;
  
     // Pebble attributes
     isPebble_ = p.isPebble_;
     clumpParticle_ = p.clumpParticle_;
     // Clump attributes
     isClump_ = p.isClump_;
 }

References clumpInertia_, clumpInitInertia_, clumpMass_, BaseParticle::clumpParticle_, initPrincipalDirections_, MatrixSymmetric3D::inverse(), BaseParticle::invInertia_, BaseParticle::isClump_, isDzhanibekovParticle_, BaseParticle::isPebble_, isVerticallyOriented_, nPebble_, p, pebbleParticles_, pebblePos_, pebbleRadius_, principalDirections_, rotationMatrix_, and viscousDamping_.

◆ ~ClumpParticle()

ClumpParticle::~ClumpParticle ( )

overridedefault

Destructor, needs to be implemented and checked to see if it is the largest or smallest particle currently in its particleHandler.

Member Function Documentation

◆ actionsAfterAddObject()

void ClumpParticle::actionsAfterAddObject ( )

overridevirtual

Methods and attributes necessary for clumped particles

Reimplemented from BaseParticle.

 {
     //Only attribute features to clump particle.
     if (isPebble()) return;
     if (isClump())
     {
         ClumpParticle p0;   // Instance for the pebbles
         p0.setSpecies(getSpecies());
         p0.setClump(this);
  
         //Go through the number of pebbles
         for (int iPebble = 1; iPebble <= NPebble(); iPebble++)
         {
             //Set the radius of pebbles:
             p0.setRadius(getPebbleRadius()[iPebble - 1]);
             //Store the address of the pebble:
             setPebble(iPebble - 1, getHandler()->copyAndAddObject(p0));
         }
  
         //Update the pebble positions, velocities.
         updatePebblesVelPos();
     }
 }

References BaseParticle::getHandler(), getPebbleRadius(), BaseInteractable::getSpecies(), BaseParticle::isClump(), BaseParticle::isPebble(), NPebble(), p0, setPebble(), and updatePebblesVelPos().

◆ addPebble()

void ClumpParticle::addPebble	(	Vec3D	position,
		Mdouble	radius
	)

 {
     nPebble_++; //Counter of pebbles
     pebblePos_.push_back(position); //Store pebble positions
     pebbleRadius_.push_back(radius); //Store pebble radius
     pebbleParticles_.push_back(nullptr);//Store null pointer per pebble.
 //    isClump_ = true;
 }

References nPebble_, pebbleParticles_, pebblePos_, pebbleRadius_, and UniformPSDSelfTest::radius.

◆ angularAccelerateClumpIterative()

void ClumpParticle::angularAccelerateClumpIterative ( double timeStep )

 {
     Mdouble Ixx_ = getInertia().XX;
     Mdouble Iyy_ = getInertia().YY;
     Mdouble Izz_ = getInertia().ZZ;
     Mdouble Ixy_ = getInertia().XY;
     Mdouble Ixz_ = getInertia().XZ;
     Mdouble Iyz_ = getInertia().YZ;
  
     Vec3D M = getTorque() - viscousDamping_ * getAngularVelocity();
  
     Vec3D angularVelocity_0 = getAngularVelocity();
     Vec3D angularVelocity_n = angularVelocity_0;
     for (int n = 0; n<N_ITER; n++) //
     {
         Mdouble wx = angularVelocity_n.X;
         Mdouble wy = angularVelocity_n.Y;
         Mdouble wz = angularVelocity_n.Z;
  
         Vec3D W = Vec3D(wy*wz*(Izz_-Iyy_) - wz*wz*Iyz_ + wy*wy*Iyz_ + wx*wy*Ixz_ - wz*wx*Ixy_,
                         wz*wx*(Ixx_-Izz_) - wx*wx*Ixz_ + wz*wz*Ixz_ + wy*wz*Ixy_ - wx*wy*Iyz_,
                         wx*wy*(Iyy_-Ixx_) - wy*wy*Ixy_ + wx*wx*Ixy_ + wz*wx*Iyz_ - wy*wz*Ixz_);
  
         Vec3D angularAcceleration_n = invInertia_ * (M-W);
         angularAcceleration_ = angularAcceleration_n;
         angularAcceleration_ = angularAcceleration_n;
         angularVelocity_n = angularVelocity_0 + 0.5 * timeStep * angularAcceleration_n;
     }
  
     setAngularVelocity(angularVelocity_n);
 }

References angularAcceleration_, BaseInteractable::getAngularVelocity(), BaseParticle::getInertia(), BaseInteractable::getTorque(), BaseParticle::invInertia_, n, N_ITER, BaseInteractable::setAngularVelocity(), viscousDamping_, oomph::QuadTreeNames::W, Vec3D::X, MatrixSymmetric3D::XX, MatrixSymmetric3D::XY, MatrixSymmetric3D::XZ, Vec3D::Y, MatrixSymmetric3D::YY, MatrixSymmetric3D::YZ, Vec3D::Z, and MatrixSymmetric3D::ZZ.

Referenced by integrateAfterForceComputation(), and integrateBeforeForceComputation().

◆ computeMass()

void ClumpParticle::computeMass ( const ParticleSpecies & s )

overridevirtual

Computes the particle's (inverse) mass and inertia.

Reimplemented from BaseParticle.

 {
     if (isFixed()) return;
     if (isPebble()) return;
  
     if (isClump())
     {
         invMass_ = 1.0 / clumpMass_;
         invInertia_= clumpInertia_.inverse();
  
     }
 }

References clumpInertia_, clumpMass_, MatrixSymmetric3D::inverse(), BaseParticle::invInertia_, BaseParticle::invMass_, BaseParticle::isClump(), BaseParticle::isFixed(), and BaseParticle::isPebble().

◆ copy()

ClumpParticle * ClumpParticle::copy ( ) const

overridevirtual

Particle copy method. Pure virtual as this needs to set in the derived class.

Implements NonSphericalParticle.

 {
     return new ClumpParticle(*this);
 }

References ClumpParticle().

◆ getDzhanibekovParticle()

bool ClumpParticle::getDzhanibekovParticle ( )

inline

     {
         return isDzhanibekovParticle_;
     }

References isDzhanibekovParticle_.

Referenced by ChangingTOIParticle::actionsAfterTimeStep().

◆ getFieldVTK()

std::vector<Mdouble> ClumpParticle::getFieldVTK ( unsigned i ) const

inlineoverridevirtual

Reimplemented from BaseParticle.

     {
         if (i==0)
             return std::vector<Mdouble>(1, isDzhanibekovParticle_);
         else
             return std::vector<Mdouble>(1, isVerticallyOriented_);
     }

References i, isDzhanibekovParticle_, and isVerticallyOriented_.

◆ getInitPrincipalDirections_e1()

Vec3D ClumpParticle::getInitPrincipalDirections_e1 ( ) const

inline

     {
         return Vec3D(initPrincipalDirections_.XX, initPrincipalDirections_.YX, initPrincipalDirections_.ZX);
     }

References initPrincipalDirections_, Matrix3D::XX, Matrix3D::YX, and Matrix3D::ZX.

Referenced by rotateTensorOfInertia().

◆ getInitPrincipalDirections_e2()

Vec3D ClumpParticle::getInitPrincipalDirections_e2 ( ) const

inline

     {
         return Vec3D(initPrincipalDirections_.XY, initPrincipalDirections_.YY, initPrincipalDirections_.ZY);
     }

References initPrincipalDirections_, Matrix3D::XY, Matrix3D::YY, and Matrix3D::ZY.

Referenced by rotateTensorOfInertia().

◆ getInitPrincipalDirections_e3()

Vec3D ClumpParticle::getInitPrincipalDirections_e3 ( ) const

inline

     {
         return Vec3D(initPrincipalDirections_.XZ, initPrincipalDirections_.YZ, initPrincipalDirections_.ZZ);
     }

References initPrincipalDirections_, Matrix3D::XZ, Matrix3D::YZ, and Matrix3D::ZZ.

Referenced by rotateTensorOfInertia().

◆ getKineticEnergy()

Mdouble ClumpParticle::getKineticEnergy ( ) const

inlineoverridevirtual

The following redefines functions of BaseParticles as virtual to make them available in child Clump class

Reimplemented from NonSphericalParticle.

                                              {
         Mdouble res = 0;
         if (isClump_) {
             Vec3D v = getVelocity();
             res = 0.5 * clumpMass_ * (v.X * v.X + v.Y * v.Y + v.Z * v.Z );
         }
         return res;
     }

References clumpMass_, BaseInteractable::getVelocity(), BaseParticle::isClump_, res, and v.

◆ getName()

std::string ClumpParticle::getName ( ) const

overridevirtual

Returns the name of the object. Pure virtual as this needs to set in the derived class.

Implements NonSphericalParticle.

 {
     return "ClumpParticle";
 }

◆ getNameVTK()

std::string ClumpParticle::getNameVTK ( unsigned i ) const

inlineoverridevirtual

Reimplemented from BaseParticle.

     {
         if (i==0)
             return "DzhanibekovParticle";
         else
             return "VerticallyOriented";
     }

References i.

◆ getNumberOfFieldsVTK()

unsigned ClumpParticle::getNumberOfFieldsVTK ( ) const

inlineoverridevirtual

Reimplemented from BaseParticle.

     {
         return 2;
     }

◆ getPebblePositions()

std::vector<Vec3D> ClumpParticle::getPebblePositions ( )

inline

                                           {
         std::vector <Vec3D> globalPos;
         Vec3D e1 = getPrincipalDirections_e1();
         Vec3D e2 = getPrincipalDirections_e2();
         Vec3D e3 = getPrincipalDirections_e3();
         for (int i = 1; i <= NPebble(); i++){
         globalPos.push_back(getPosition() + e1 * pebblePos_[i - 1].X + e2 * pebblePos_[i - 1].Y + e3 * pebblePos_[i - 1].Z);
         }
         return globalPos;
     }

References BaseInteractable::getPosition(), getPrincipalDirections_e1(), getPrincipalDirections_e2(), getPrincipalDirections_e3(), i, NPebble(), and pebblePos_.

Referenced by Mercury3Dclump::checkClumpForInteraction(), and Mercury3Dclump::checkClumpForInteractionPeriodic().

◆ getPebbleRadii()

std::vector<Mdouble> ClumpParticle::getPebbleRadii ( )

inline

253 { return pebbleRadius_; }

References pebbleRadius_.

Referenced by Mercury3Dclump::checkClumpForInteraction(), and Mercury3Dclump::checkClumpForInteractionPeriodic().

◆ getPebbleRadius()

std::vector<Mdouble> ClumpParticle::getPebbleRadius ( ) const

inline

                                                {
         return pebbleRadius_;
     }

References pebbleRadius_.

Referenced by actionsAfterAddObject().

◆ getPrincipalDirections_e1()

Vec3D ClumpParticle::getPrincipalDirections_e1 ( ) const

inline

     {
  
         return Vec3D(principalDirections_.XX, principalDirections_.YX, principalDirections_.ZX);
     }

References principalDirections_, Matrix3D::XX, Matrix3D::YX, and Matrix3D::ZX.

Referenced by ChangingTOIParticle::actionsAfterTimeStep(), getPebblePositions(), rotatePrincipalDirections(), rotateTensorOfInertia(), and updatePebblesVelPos().

◆ getPrincipalDirections_e2()

Vec3D ClumpParticle::getPrincipalDirections_e2 ( ) const

inline

     {
         return Vec3D(principalDirections_.XY, principalDirections_.YY, principalDirections_.ZY);
     }

References principalDirections_, Matrix3D::XY, Matrix3D::YY, and Matrix3D::ZY.

Referenced by ChangingTOIParticle::actionsAfterTimeStep(), getPebblePositions(), rotatePrincipalDirections(), rotateTensorOfInertia(), updateExtraQuantities(), and updatePebblesVelPos().

◆ getPrincipalDirections_e3()

Vec3D ClumpParticle::getPrincipalDirections_e3 ( ) const

inline

     {
         return Vec3D(principalDirections_.XZ, principalDirections_.YZ, principalDirections_.ZZ);
     }

References principalDirections_, Matrix3D::XZ, Matrix3D::YZ, and Matrix3D::ZZ.

Referenced by ChangingTOIParticle::actionsAfterTimeStep(), getPebblePositions(), rotatePrincipalDirections(), rotateTensorOfInertia(), updateExtraQuantities(), and updatePebblesVelPos().

◆ getRotationalEnergy()

Mdouble ClumpParticle::getRotationalEnergy ( ) const

inlineoverridevirtual

Calculates the particle's rotational kinetic energy.

Returns: the particle's rotational kinetic energy

Reimplemented from NonSphericalParticle.

                                                 {
         Mdouble res = 0;
         if (isClump_) {
             Vec3D nn = getAngularVelocity();
             Mdouble nl = nn.getLength();
             Mdouble tol = 1e-10;
             if (nl > tol) {
                 nn /= nl;
                 Mdouble ww = getAngularVelocity().getLengthSquared();
                 Mdouble II = Vec3D::dot(nn, (getInertia() * nn));
                 res = 0.5 * II * ww;
             }
         }
         return res;
  
     }

References Vec3D::dot(), e(), BaseInteractable::getAngularVelocity(), BaseParticle::getInertia(), Vec3D::getLength(), Vec3D::getLengthSquared(), BaseParticle::isClump_, and res.

◆ getRotationMatrix()

Matrix3D ClumpParticle::getRotationMatrix ( ) const

inline

     {
         return rotationMatrix_;
     }

References rotationMatrix_.

Referenced by ChangingTOIParticle::actionsAfterTimeStep().

◆ getTypeVTK()

std::string ClumpParticle::getTypeVTK ( unsigned i ) const

inlineoverridevirtual

Reimplemented from BaseParticle.

     {
         return "Int8";
     }

◆ getVerticallyOriented()

bool ClumpParticle::getVerticallyOriented ( )

inline

     {
         return isVerticallyOriented_;
     }

References isVerticallyOriented_.

◆ integrateAfterForceComputation()

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

overridevirtual

Second step of Velocity Verlet integration (see also http://en.wikipedia.org/wiki/Verlet_integration#Velocity_Verlet).

Parameters

[in]	time	current time
[in]	timeStep	current time step

Reimplemented from BaseParticle.

 {
     if (isPebble()) return;
     if (getInvMass() == 0.0)
     {
         BaseInteractable::integrateAfterForceComputation(time, timeStep);
     }
     else
     {
         // Translational acceleration
         accelerate((getForce() - viscousDamping_ * getVelocity()) * getInvMass() * 0.5 * timeStep);
  
         // PFC4 style angular acceleration of Clumps
         angularAccelerateClumpIterative(timeStep);
  
         // Rotate pebbles
         updatePebblesVelPos();
  
         // Updates extra quantities
         updateExtraQuantities();
     }
 }

References BaseParticle::accelerate(), angularAccelerateClumpIterative(), BaseInteractable::getForce(), BaseParticle::getInvMass(), BaseInteractable::getVelocity(), BaseInteractable::integrateAfterForceComputation(), BaseParticle::isPebble(), updateExtraQuantities(), updatePebblesVelPos(), and viscousDamping_.

◆ integrateBeforeForceComputation()

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

overridevirtual

First step of Velocity Verlet integration (see also http://en.wikipedia.org/wiki/Verlet_integration#Velocity_Verlet).

Parameters

[in]	time	current time
[in]	timeStep	current time step

Reimplemented from BaseParticle.

 {
     if (isPebble()) return;
     if (getInvMass() == 0.0)
     {
         BaseInteractable::integrateBeforeForceComputation(time, timeStep);
     }
     else
     {
 #ifdef MERCURY_USE_MPI
         //For periodic particles in parallel the previous position is required
         setPreviousPosition(getPosition());
 #endif
         accelerate((getForce() - viscousDamping_ * getVelocity()) * getInvMass() * 0.5 * timeStep); // V(t+0.5dt)
         const Vec3D displacement = getVelocity() * timeStep;
         move(displacement); // X(t+dt)
  
         DPMBase* const dpm = getHandler()->getDPMBase();
         if (!dpm->getHGridUpdateEachTimeStep())
         {
             dpm->hGridUpdateMove(this, displacement.getLengthSquared());
         }
  
         // PFC4 style acceleration of Clumps
         angularAccelerateClumpIterative(timeStep); //W(t+0.5dt)
  
         //apply to rotation quaternion q: q = normalise(q + \tilde{C}\omega*timeStep) (see Wouter's notes)
         rotate(getAngularVelocity() * timeStep);
  
         // Rotate
         rotatePrincipalDirections(getAngularVelocity() * timeStep);
  
         // Update pebble nodes
         updatePebblesVelPos();
  
         // Update TOI
         rotateTensorOfInertia();
  
     }
 }

References BaseParticle::accelerate(), angularAccelerateClumpIterative(), BaseInteractable::getAngularVelocity(), BaseHandler< T >::getDPMBase(), BaseInteractable::getForce(), BaseParticle::getHandler(), DPMBase::getHGridUpdateEachTimeStep(), BaseParticle::getInvMass(), Vec3D::getLengthSquared(), BaseInteractable::getPosition(), BaseInteractable::getVelocity(), DPMBase::hGridUpdateMove(), BaseInteractable::integrateBeforeForceComputation(), BaseParticle::isPebble(), BaseInteractable::move(), BaseInteractable::rotate(), rotatePrincipalDirections(), rotateTensorOfInertia(), BaseParticle::setPreviousPosition(), updatePebblesVelPos(), and viscousDamping_.

◆ isSphericalParticle()

bool ClumpParticle::isSphericalParticle ( ) const

inlineoverridevirtual

this flag is used to decide whether to compute orientation, which is not necessary for spherical particles

Todo:: This flag is used badly, and used to determine whether particles are superquadric

Implements BaseParticle.

     {
         return true;
     }

◆ MtoS()

MatrixSymmetric3D ClumpParticle::MtoS ( Matrix3D M )

inlineprivate

345 { return MatrixSymmetric3D(M.XX, M.XY, M.XZ, M.YY, M.YZ, M.ZZ);}

Referenced by rotateTensorOfInertia().

◆ NPebble()

int ClumpParticle::NPebble ( ) const

 {
     return nPebble_;
 }

References nPebble_.

Referenced by actionsAfterAddObject(), Mercury3Dclump::checkClumpForInteraction(), Mercury3Dclump::checkClumpForInteractionPeriodic(), and getPebblePositions().

◆ read()

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

inlineoverridevirtual

Particle read function, which accepts an std::istream as input.

Particle read function. Has an std::istream as argument, from which it extracts the radius_, invMass_ and invInertia_, respectively. From these the mass and inertia are deduced. An additional set of properties is read through the call to the parent's method BaseInteractable::read().

Parameters

[in,out] is input stream with particle properties.

Reimplemented from BaseParticle.

     {
         BaseParticle::read(is);
         std::string dummy;
         is >> dummy >> nPebble_;
         is >> dummy >> nPebble_;
         is >> dummy >> clumpMass_;
         is >> dummy >> viscousDamping_;
         is >> dummy;
         for (int i = 0; i<nPebble_; i++) {is >> pebblePos_[i];}
         is >> dummy;
         for (int i = 0; i<nPebble_; i++) {is >> pebbleRadius_[i];}
         //is >> dummy;
         //for (int i = 0; i<nPebble_; i++) {is >> pebbleParticles_[i];}
         is >> dummy;
         is >> principalDirections_;
         is >> dummy;
         is >> initPrincipalDirections_;
         is >> dummy >> clumpInitInertia_;
         is >> dummy >> clumpInertia_;
         is >> dummy;
         is >> rotationMatrix_;
         is >> dummy >> isPebble_;
         //is >> dummy >> clumpParticle_;
         is >> dummy >> isPebble_;
         is >> dummy >> isDzhanibekovParticle_;
         is >> dummy >> isVerticallyOriented_;
  
  
     }

References clumpInertia_, clumpInitInertia_, clumpMass_, i, initPrincipalDirections_, isDzhanibekovParticle_, BaseParticle::isPebble_, isVerticallyOriented_, nPebble_, pebblePos_, pebbleRadius_, principalDirections_, BaseParticle::read(), rotationMatrix_, oomph::Global_string_for_annotation::string(), and viscousDamping_.

◆ rotatePrincipalDirections()

void ClumpParticle::rotatePrincipalDirections ( Vec3D rotation )

 {
     Mdouble tol = 10e-9;
     Mdouble angle = rotation.getLength();
     if (angle < tol) return;
     Mdouble c1, c2, c3, theta, dist;
     Vec3D e3 = rotation; e3.normalise();
     Vec3D e2 = Vec3D::cross(e3, getPrincipalDirections_e1());
     if (e2.getLength() < 0.1) e2 = Vec3D::cross(e3, getPrincipalDirections_e2());
     if (e2.getLength() < 0.1) e2 = Vec3D::cross(e3, getPrincipalDirections_e3());
     e2.normalise();
     Vec3D e1 = Vec3D::cross(e2, e3);
     Vec3D pa;
     // Rotate principal axis 1
     pa = getPrincipalDirections_e1();
     c1 = Vec3D::dot(pa, e1);
     c2 = Vec3D::dot(pa, e2);
     c3 = Vec3D::dot(pa, e3);
  
     dist = sqrt(c1 * c1 + c2 * c2);
     theta = atan2(c2, c1) + angle;
     setPrincipalDirections_e1(dist * cos(theta) * e1 + dist*sin(theta) * e2 + c3 * e3);
     // Rotate principal axis 2
     pa = getPrincipalDirections_e2();
     c1 = Vec3D::dot(pa, e1);
     c2 = Vec3D::dot(pa, e2);
     c3 = Vec3D::dot(pa, e3);
     dist = sqrt(c1 * c1 + c2 * c2);
     theta = atan2(c2, c1) + angle;
     setPrincipalDirections_e2(dist * cos(theta) * e1 + dist*sin(theta) * e2 + c3 * e3);
     // Rotate principal axis 3
     pa = getPrincipalDirections_e3();
     c1 = Vec3D::dot(pa, e1);
     c2 = Vec3D::dot(pa, e2);
     c3 = Vec3D::dot(pa, e3);
     dist = sqrt(c1 * c1 + c2 * c2);
     theta = atan2(c2, c1) + angle;
     setPrincipalDirections_e3(dist * cos(theta) * e1 + dist*sin(theta) * e2 + c3 * e3);
 }

References Jeffery_Solution::angle(), atan2(), cos(), Vec3D::cross(), Vec3D::dot(), e(), Vec3D::getLength(), getPrincipalDirections_e1(), getPrincipalDirections_e2(), getPrincipalDirections_e3(), Vec3D::normalise(), pa, setPrincipalDirections_e1(), setPrincipalDirections_e2(), setPrincipalDirections_e3(), sin(), sqrt(), and BiharmonicTestFunctions2::theta.

Referenced by integrateBeforeForceComputation().

◆ rotateTensorOfInertia()

void ClumpParticle::rotateTensorOfInertia ( )

 {
    // Initial and current principal directions
    Vec3D e10 = getInitPrincipalDirections_e1();
    Vec3D e20 = getInitPrincipalDirections_e2();
    Vec3D e30 = getInitPrincipalDirections_e3();
  
    Vec3D e1 = getPrincipalDirections_e1();
    Vec3D e2 = getPrincipalDirections_e2();
    Vec3D e3 = getPrincipalDirections_e3();
  
    // Rotation matrix from initial and current principal directions
    Matrix3D Q(Vec3D::dot(e10, e1), Vec3D::dot(e10, e2), Vec3D::dot(e10, e3),
               Vec3D::dot(e20, e1), Vec3D::dot(e20, e2), Vec3D::dot(e20, e3),
               Vec3D::dot(e30, e1), Vec3D::dot(e30, e2), Vec3D::dot(e30, e3));
  
    Matrix3D Qt = transpose(Q);
  
   MatrixSymmetric3D inertia = MtoS(Q * (StoM(clumpInitInertia_) * Qt));
   //  inertia = clumpInitInertia_;  // uncomment to turn off rotation of toi
   clumpInertia_ = inertia;
   invInertia_= clumpInertia_.inverse();
   rotationMatrix_ = Q;
  
 }

References clumpInertia_, clumpInitInertia_, Vec3D::dot(), getInitPrincipalDirections_e1(), getInitPrincipalDirections_e2(), getInitPrincipalDirections_e3(), getPrincipalDirections_e1(), getPrincipalDirections_e2(), getPrincipalDirections_e3(), MatrixSymmetric3D::inverse(), BaseParticle::invInertia_, MtoS(), Q, rotationMatrix_, StoM(), and transpose().

Referenced by integrateBeforeForceComputation().

◆ setClump() [1/2]

void ClumpParticle::setClump ( )

 {
     isClump_ = true;
     isPebble_ = false;
  
  
 }

References BaseParticle::isClump_, and BaseParticle::isPebble_.

◆ setClump() [2/2]

void ClumpParticle::setClump ( ClumpParticle * master )

inline

                                          {
         isClump_ = false;
         isPebble_ = true;
         clumpParticle_ = master;
     }

References BaseParticle::clumpParticle_, BaseParticle::isClump_, and BaseParticle::isPebble_.

◆ setClumpMass()

void ClumpParticle::setClumpMass ( Mdouble mass )

inline

     {
         clumpMass_ = mass;
         invMass_ = 1 / clumpMass_;
     }

References clumpMass_, and BaseParticle::invMass_.

◆ setDamping()

void ClumpParticle::setDamping ( Mdouble damp )

inline

     {
         viscousDamping_ = damp;
     }

References viscousDamping_.

◆ setDzhanibekovParticle()

void ClumpParticle::setDzhanibekovParticle ( bool d )

inline

     {
         isDzhanibekovParticle_ = d;
     }

References isDzhanibekovParticle_.

Referenced by updateExtraQuantities().

◆ setInitInertia()

void ClumpParticle::setInitInertia ( MatrixSymmetric3D inertia )

 {
     clumpInitInertia_ = inertia;
     clumpInertia_ = inertia;
     invInertia_= clumpInertia_.inverse();
 }

References clumpInertia_, clumpInitInertia_, MatrixSymmetric3D::inverse(), and BaseParticle::invInertia_.

Referenced by ChangingTOIParticle::actionsAfterTimeStep().

◆ setInitPrincipalDirections()

void ClumpParticle::setInitPrincipalDirections ( Matrix3D directions )

 {
     initPrincipalDirections_ = directions;
 }

References initPrincipalDirections_.

◆ setPebble()

void ClumpParticle::setPebble	(	int	kPebble,
		ClumpParticle *	pPebble
	)

inline

                                                         {
         pebbleParticles_[kPebble] = pPebble;
     }

References pebbleParticles_.

Referenced by actionsAfterAddObject().

◆ setPrincipalDirections()

void ClumpParticle::setPrincipalDirections ( Matrix3D directions )

 {
     principalDirections_ = directions;
 }

References principalDirections_.

◆ setPrincipalDirections_e1()

void ClumpParticle::setPrincipalDirections_e1 ( Vec3D e )

inline

     {
         principalDirections_.XX = e.X;
         principalDirections_.YX = e.Y;
         principalDirections_.ZX = e.Z;
     }

References e(), principalDirections_, Matrix3D::XX, Matrix3D::YX, and Matrix3D::ZX.

Referenced by rotatePrincipalDirections().

◆ setPrincipalDirections_e2()

void ClumpParticle::setPrincipalDirections_e2 ( Vec3D e )

inline

     {
         principalDirections_.XY = e.X;
         principalDirections_.YY = e.Y;
         principalDirections_.ZY = e.Z;
     }

References e(), principalDirections_, Matrix3D::XY, Matrix3D::YY, and Matrix3D::ZY.

Referenced by rotatePrincipalDirections().

◆ setPrincipalDirections_e3()

void ClumpParticle::setPrincipalDirections_e3 ( Vec3D e )

inline

     {
         principalDirections_.XZ = e.X;
         principalDirections_.YZ = e.Y;
         principalDirections_.ZZ = e.Z;
     }

References e(), principalDirections_, Matrix3D::XZ, Matrix3D::YZ, and Matrix3D::ZZ.

Referenced by rotatePrincipalDirections().

◆ setVerticallyOriented()

void ClumpParticle::setVerticallyOriented ( bool d )

inline

     {
         isVerticallyOriented_ = d;
     }

References isVerticallyOriented_.

Referenced by updateExtraQuantities().

◆ StoM()

Matrix3D ClumpParticle::StoM ( MatrixSymmetric3D M )

inlineprivate

348 { return Matrix3D(M.XX, M.XY, M.XZ, M.XY, M.YY, M.YZ, M.XZ, M.YZ, M.ZZ);}

Referenced by rotateTensorOfInertia().

◆ transpose()

Matrix3D ClumpParticle::transpose ( Matrix3D M )

inlineprivate

351 { return Matrix3D(M.XX, M.YX, M.ZX, M.XY, M.YY, M.ZY, M.XZ, M.YZ, M.ZZ);}

Referenced by rotateTensorOfInertia().

◆ updateExtraQuantities()

void ClumpParticle::updateExtraQuantities ( )

 {
     Mdouble ANG_TOL = 0.1; // 5.7 degrees - tolerance to misalignment
     Mdouble ACC_TOL = 0.1; // Tolerance for angular acceleration magnitude
  
     Mdouble TOL = 10e-8;   // External force tolerance
     ClumpParticle* pPebble;
     Vec3D n3 = getPrincipalDirections_e3();
     Vec3D v = Vec3D(0,0,1);
  
     // Check for vertical alignment
     if (acos(Vec3D::dot(n3, v))<ANG_TOL)
     {
         setVerticallyOriented(true);
         for (int iPebble = 1; iPebble <= nPebble_; iPebble++)
         {
             pPebble = pebbleParticles_[iPebble - 1];
             pPebble->setVerticallyOriented(true);
         }
     }
     else {
         setVerticallyOriented(false);
         for (int iPebble = 1; iPebble <= nPebble_; iPebble++)
         {
             pPebble = pebbleParticles_[iPebble - 1];
             pPebble->setVerticallyOriented(false);
         }
     }
  
     // Check for Dzhanibekov States
  
     Vec3D w  = getAngularVelocity()/getAngularVelocity().getLength();
     Vec3D n2 = getPrincipalDirections_e2();
     Mdouble acc = angularAcceleration_.getLength();
  
     if ((acos(Vec3D::dot(n2, w))<ANG_TOL) || (acc<TOL))
     {
         setDzhanibekovParticle(true);
         for (int iPebble = 1; iPebble <= nPebble_; iPebble++)
         {
             pPebble = pebbleParticles_[iPebble - 1];
             pPebble->setDzhanibekovParticle(true);
         }
     }
  
     // Any contact force/torques break D state
     if ( (getForce().getLength() > TOL)||(getTorque().getLength() > TOL) )
     {
         setDzhanibekovParticle(false);
         for (int iPebble = 1; iPebble <= nPebble_; iPebble++)
         {
             pPebble = pebbleParticles_[iPebble - 1];
             pPebble->setDzhanibekovParticle(false);
         }
     }
  
     return;
 }

References acos(), angularAcceleration_, Vec3D::dot(), e(), BaseInteractable::getAngularVelocity(), BaseInteractable::getForce(), Vec3D::getLength(), getPrincipalDirections_e2(), getPrincipalDirections_e3(), BaseInteractable::getTorque(), nPebble_, pebbleParticles_, setDzhanibekovParticle(), setVerticallyOriented(), v, and w.

Referenced by integrateAfterForceComputation().

◆ updatePebblesVelPos()

void ClumpParticle::updatePebblesVelPos ( )

 {
     BaseParticle* pPebble;
     Vec3D position = getPosition();
     Vec3D angularVelocity = getAngularVelocity();
     Quaternion orientation = getOrientation();
  
     Vec3D e1 = getPrincipalDirections_e1();
     Vec3D e2 = getPrincipalDirections_e2();
     Vec3D e3 = getPrincipalDirections_e3();
  
     Vec3D velocityDueToRotation;
  
     for (int iPebble = 1; iPebble <= nPebble_; iPebble++)
     {
         pPebble = pebbleParticles_[iPebble - 1];
         // pPebble->setMass(clumpMass_);
         pPebble->invMass_ = 1. / clumpMass_;
         pPebble->setAngularVelocity(angularVelocity);
         pPebble->setOrientation(orientation);
         pPebble->setPosition(position + e1 * pebblePos_[iPebble - 1].X + e2 * pebblePos_[iPebble - 1].Y + e3 * pebblePos_[iPebble - 1].Z);
  
  
         velocityDueToRotation = Vec3D::cross(angularVelocity, pPebble->getPosition() - position);
  
         pPebble->setVelocity(getVelocity());
         pPebble->addVelocity(velocityDueToRotation);
     }
 }

References BaseInteractable::addVelocity(), clumpMass_, Vec3D::cross(), BaseInteractable::getAngularVelocity(), BaseInteractable::getOrientation(), BaseInteractable::getPosition(), getPrincipalDirections_e1(), getPrincipalDirections_e2(), getPrincipalDirections_e3(), BaseInteractable::getVelocity(), BaseParticle::invMass_, nPebble_, pebbleParticles_, pebblePos_, BaseInteractable::setAngularVelocity(), BaseInteractable::setOrientation(), BaseInteractable::setPosition(), BaseInteractable::setVelocity(), X, Y, and Z.

Referenced by actionsAfterAddObject(), integrateAfterForceComputation(), and integrateBeforeForceComputation().

◆ write()

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

inlineoverridevirtual

Particle print function, which accepts an std::ostream as input.

BaseParticle print method, which accepts an os std::ostream as input. It prints human readable BaseParticle information to the std::ostream.

Parameters

[in,out] os stream to which the info is written

Reimplemented from BaseParticle.

     {
         BaseParticle::write(os);
         os << " nPebble_ " << nPebble_;
         os << " clumpMass_ " << clumpMass_;
         os << " viscousDamping_ " << viscousDamping_;
         os << " pebblePos_ ";
         for (const auto & pebbleP : pebblePos_) {os << pebbleP;}
         os << " pebbleRadius_ ";
         for (double pebbleRad : pebbleRadius_) {os << pebbleRad;}
         //os << " pebbleParticles_ ";
         //for (auto pebblePart : pebbleParticles_) {os << pebblePart;}
         os << " principalDirections_ ";
         os << principalDirections_;
         os << " initPrincipalDirections_ ";
         os << initPrincipalDirections_;
         os << " clumpInitInertia_ " << clumpInitInertia_;
         os << " clumpInertia_ " << clumpInertia_;
         os << " rotationMatrix_ ";
         os << rotationMatrix_;
         os << " isPebble_ " << isPebble_;
         //os << " clumpParticle_ " << clumpParticle_;
         os << " isPebble_ " << isPebble_;
         os << " isDzhanibekovParticle_ " << isDzhanibekovParticle_;
         os << " isVerticallyOriented_ " << isVerticallyOriented_;
     }

References clumpInertia_, clumpInitInertia_, clumpMass_, initPrincipalDirections_, isDzhanibekovParticle_, BaseParticle::isPebble_, isVerticallyOriented_, nPebble_, pebblePos_, pebbleRadius_, principalDirections_, rotationMatrix_, viscousDamping_, and BaseParticle::write().

Member Data Documentation

◆ angularAcceleration_

Vec3D ClumpParticle::angularAcceleration_

private

Referenced by angularAccelerateClumpIterative(), and updateExtraQuantities().

◆ clumpInertia_

MatrixSymmetric3D ClumpParticle::clumpInertia_

private

Referenced by ClumpParticle(), computeMass(), read(), rotateTensorOfInertia(), setInitInertia(), and write().

◆ clumpInitInertia_

MatrixSymmetric3D ClumpParticle::clumpInitInertia_

private

Referenced by ClumpParticle(), read(), rotateTensorOfInertia(), setInitInertia(), and write().

◆ clumpMass_

Mdouble ClumpParticle::clumpMass_

private

Referenced by ClumpParticle(), computeMass(), getKineticEnergy(), read(), setClumpMass(), updatePebblesVelPos(), and write().

◆ initPrincipalDirections_

Matrix3D ClumpParticle::initPrincipalDirections_

private

Referenced by ClumpParticle(), getInitPrincipalDirections_e1(), getInitPrincipalDirections_e2(), getInitPrincipalDirections_e3(), read(), setInitPrincipalDirections(), and write().

◆ isDzhanibekovParticle_

bool ClumpParticle::isDzhanibekovParticle_

private

Referenced by ClumpParticle(), getDzhanibekovParticle(), getFieldVTK(), read(), setDzhanibekovParticle(), and write().

◆ isVerticallyOriented_

bool ClumpParticle::isVerticallyOriented_

private

Referenced by ClumpParticle(), getFieldVTK(), getVerticallyOriented(), read(), setVerticallyOriented(), and write().

◆ nPebble_

int ClumpParticle::nPebble_

private

Referenced by addPebble(), ClumpParticle(), NPebble(), read(), updateExtraQuantities(), updatePebblesVelPos(), and write().

◆ pebbleParticles_

std::vector<ClumpParticle*> ClumpParticle::pebbleParticles_

private

Referenced by addPebble(), ClumpParticle(), setPebble(), updateExtraQuantities(), and updatePebblesVelPos().

◆ pebblePos_

std::vector<Vec3D> ClumpParticle::pebblePos_

private

Referenced by addPebble(), ClumpParticle(), getPebblePositions(), read(), updatePebblesVelPos(), and write().

◆ pebbleRadius_

std::vector<Mdouble> ClumpParticle::pebbleRadius_

private

Referenced by addPebble(), ClumpParticle(), getPebbleRadii(), getPebbleRadius(), read(), and write().

◆ principalDirections_

Matrix3D ClumpParticle::principalDirections_

private

Referenced by ClumpParticle(), getPrincipalDirections_e1(), getPrincipalDirections_e2(), getPrincipalDirections_e3(), read(), setPrincipalDirections(), setPrincipalDirections_e1(), setPrincipalDirections_e2(), setPrincipalDirections_e3(), and write().

◆ rotationMatrix_

Matrix3D ClumpParticle::rotationMatrix_

private

Referenced by ClumpParticle(), getRotationMatrix(), read(), rotateTensorOfInertia(), and write().

◆ viscousDamping_

Mdouble ClumpParticle::viscousDamping_

private

Referenced by angularAccelerateClumpIterative(), ClumpParticle(), integrateAfterForceComputation(), integrateBeforeForceComputation(), read(), setDamping(), and write().

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ClumpParticle() [1/2]

◆ ClumpParticle() [2/2]

◆ ~ClumpParticle()

Member Function Documentation

◆ actionsAfterAddObject()

◆ addPebble()

◆ angularAccelerateClumpIterative()

◆ computeMass()

◆ copy()

◆ getDzhanibekovParticle()

◆ getFieldVTK()

◆ getInitPrincipalDirections_e1()

◆ getInitPrincipalDirections_e2()

◆ getInitPrincipalDirections_e3()

◆ getKineticEnergy()

◆ getName()

◆ getNameVTK()

◆ getNumberOfFieldsVTK()

◆ getPebblePositions()

◆ getPebbleRadii()

◆ getPebbleRadius()

◆ getPrincipalDirections_e1()

◆ getPrincipalDirections_e2()

◆ getPrincipalDirections_e3()

◆ getRotationalEnergy()

◆ getRotationMatrix()

◆ getTypeVTK()

◆ getVerticallyOriented()

◆ integrateAfterForceComputation()

◆ integrateBeforeForceComputation()

◆ isSphericalParticle()

◆ MtoS()

◆ NPebble()

◆ read()

◆ rotatePrincipalDirections()

◆ rotateTensorOfInertia()

◆ setClump() [1/2]

◆ setClump() [2/2]

◆ setClumpMass()

◆ setDamping()

◆ setDzhanibekovParticle()

◆ setInitInertia()

◆ setInitPrincipalDirections()

◆ setPebble()

◆ setPrincipalDirections()

◆ setPrincipalDirections_e1()

◆ setPrincipalDirections_e2()

◆ setPrincipalDirections_e3()

◆ setVerticallyOriented()

◆ StoM()

◆ transpose()

◆ updateExtraQuantities()

◆ updatePebblesVelPos()

◆ write()

Member Data Documentation

◆ angularAcceleration_

◆ clumpInertia_

◆ clumpInitInertia_

◆ clumpMass_

◆ initPrincipalDirections_

◆ isDzhanibekovParticle_

◆ isVerticallyOriented_

◆ nPebble_

◆ pebbleParticles_

◆ pebblePos_

◆ pebbleRadius_

◆ principalDirections_

◆ rotationMatrix_

◆ viscousDamping_