Container to store pointers to all particles. More...

#include <ParticleHandler.h>

Inheritance diagram for ParticleHandler:

Public Member Functions
	ParticleHandler ()
	Default constructor, it creates an empty ParticleHandler. More...

	ParticleHandler (const ParticleHandler &PH)
	Constructor that copies all BaseParticle it contains and then sets the smallest and largest particle. More...

ParticleHandler &	operator= (const ParticleHandler &rhs)
	Assignment operator. More...

	~ParticleHandler () override
	Destructor, it destructs the ParticleHandler and all BaseParticle it contains. More...

void	addExistingObject (BaseParticle *P) override
	Adds a BaseParticle to the ParticleHandler. More...

void	addObject (BaseParticle *P) override
	Adds a BaseParticle to the ParticleHandler. More...

void	addObject (int fromProcessor, BaseParticle *P)
	Adds a BaseParticle located at processor fromProcessor to toProcessor. More...

void	addGhostObject (int fromProcessor, int toProcessor, BaseParticle *p)
	Adds a ghost particle located at fromProcessor to toProcessor. More...

void	addGhostObject (BaseParticle *P) override
	Adds a BaseParticle to the ParticleHandler. More...

void	removeObject (unsigned int index) override
	Removes a BaseParticle from the ParticleHandler. More...

void	removeGhostObject (unsigned int index)
	Removes a BaseParticle from the ParticleHandler without a global check, this is only to be done for mpi routines. More...

void	removeLastObject ()
	Removes the last BaseParticle from the ParticleHandler. More...

void	computeSmallestParticle ()
	Computes the smallest particle (by interaction radius) and sets it in smallestParticle_. More...

void	computeLargestParticle ()
	Computes the largest particle (by interaction radius) and sets it in largestParticle_. More...

BaseParticle *	getSmallestParticleLocal () const
	Gets a pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler of the local domain. More...

BaseParticle *	getSmallestParticle () const
	Gets a pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler of the local domain. When mercury is running in parallel this function throws an error since a pointer to another domain is useless. More...

BaseParticle *	getLargestParticleLocal () const
	Gets a pointer to the largest BaseParticle (by interactionRadius) in the ParticleHandler of the local domain. More...

BaseParticle *	getLargestParticle () const
	Returns the pointer of the largest particle in the particle handler. When mercury is running in parallel this function throws an error since a pointer to another domain is useless. More...

Mdouble	getSmallestInteractionRadiusLocal () const
	Returns the smallest interaction radius of the current domain. More...

Mdouble	getSmallestInteractionRadius () const
	Returns the smallest interaction radius. More...

Mdouble	getLargestInteractionRadiusLocal () const
	Returns the largest interaction radius of the current domain. More...

Mdouble	getLargestInteractionRadius () const
	Returns the largest interaction radius. More...

BaseParticle *	getFastestParticleLocal () const
	Gets a pointer to the fastest BaseParticle in this ParticleHandler. More...

BaseParticle *	getFastestParticle () const

Mdouble	getKineticEnergy () const

Mdouble	getRotationalEnergy () const

Mdouble	getMass () const

Vec3D	getMassTimesPosition () const

Vec3D	getCentreOfMass () const

Vec3D	getMomentum () const

Vec3D	getAngularMomentum () const

Mdouble	getVolume () const

Mdouble	getMeanRadius () const

BaseParticle *	getLowestPositionComponentParticleLocal (int i) const
	Gets a pointer to the particle with the lowest coordinates in direction i in this ParticleHandler. More...

BaseParticle *	getLowestPositionComponentParticle (int i) const
	Gets a pointer to the particle with the lowest coordinates in direction i in this ParticleHandler. More...

BaseParticle *	getHighestPositionComponentParticleLocal (int i) const
	Gets a pointer to the particle with the highest coordinates in direction i in this ParticleHandler. More...

BaseParticle *	getHighestPositionComponentParticle (int i) const
	Gets a pointer to the particle with the highest coordinates in direction i in this ParticleHandler. More...

BaseParticle *	getLowestVelocityComponentParticleLocal (int i) const
	Gets a pointer to the particle with the lowest velocity in direction i in this ParticleHandler. More...

BaseParticle *	getLowestVelocityComponentParticle (int i) const
	Gets a pointer to the particle with the lowest velocity in direction i in this ParticleHandler. More...

BaseParticle *	getHighestVelocityComponentParticleLocal (int i) const
	Gets a pointer to the particle with the highest velocity in direction i in this ParticleHandler. More...

BaseParticle *	getHighestVelocityComponentParticle (int i) const
	Gets a pointer to the particle with the highest velocity in direction i in this ParticleHandler. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, T >::type	getParticleAttributeLocal (std::function< T(BaseParticle *)> attribute, AttributeType type) const
	Computes an attribute type (min/max/..) of a particle attribute (position/velocity) in a local domain. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, T >::type	getParticleAttribute (std::function< T(BaseParticle *)> attribute, AttributeType type) const
	Computes an attribute type (min/max/..) of a particle attribute(position/velocity) in the global domain. More...

Mdouble	getHighestPositionX () const
	Function returns the highest position in the x-direction. More...

void	clear () override
	Empties the whole ParticleHandler by removing all BaseParticle. More...

unsigned int	getNumberOfFixedParticles () const
	Gets the number of particles that are fixed. More...

unsigned int	getNumberOfUnfixedParticles () const
	Gets the number of particles that are not fixed. More...

BaseParticle *	readAndCreateObject (std::istream &is)
	Create a new particle, based on the information provided in a restart file. More...

void	readAndAddObject (std::istream &is) override

void	write (std::ostream &os) const

void	checkExtrema (BaseParticle *P)
	Checks if the extrema of this ParticleHandler needs updating. More...

void	checkExtremaOnDelete (BaseParticle *P)
	Checks if the extrema of this ParticleHandler needs updating when a particle is deleted. More...

void	computeAllMasses (unsigned int indSpecies)
	Computes the mass for all BaseParticle of the given species in this ParticleHandler. More...

void	computeAllMasses ()
	Computes the mass for all BaseParticle in this ParticleHandler. More...

void	addedFixedParticle ()
	Increment of the number of fixed particles. More...

void	removedFixedParticle ()
	Decrement of the number of fixed particles. More...

std::string	getName () const override
	Returns the name of the handler, namely the string "ParticleHandler". More...

unsigned int	getNumberOfRealObjects () const
	Returns the number of real objects (on all processors) More...

unsigned int	getNumberOfObjects () const override
	Returns the number of objects in the container. In parallel code this practice is forbidden to avoid confusion with real and fake particles. If the size of the container is wished, call size() More...

unsigned int	getNumberOfFixedObjectsLocal () const
	Computes the number of Fixed particles on a local domain. More...

unsigned int	getNumberOfFixedObjects () const
	Computes the number of fixed particles in the whole simulation. More...

unsigned int	getNumberOfRealObjectsLocal () const
	Returns the number of real objects on a local domain. MPI particles and periodic particles are neglected. More...

void	actionsBeforeTimeStep ()

void	actionsAfterTimeStep ()

double	getLiquidFilmVolume () const

void	saveNumberPSDtoCSV (std::string csvFileName, std::vector< double > diameterBins={}) const
	Writes the PSD of the particles currently in the handler to a CSV file, with type PROBABILITYDENSITY_NUMBER_DISTRIBUTION. More...

PSD	getPSD (std::vector< Mdouble > bins={}, Mdouble scaleFactor=1.0) const
	Gets the PSD from the particles currently in the handler. More...

Public Member Functions inherited from BaseHandler< BaseParticle >
	BaseHandler ()
	Default BaseHandler constructor, it creates an empty BaseHandler and assigns DPMBase_ to a null pointer. More...

	BaseHandler (const BaseHandler< BaseParticle > &BH)
	Constructor that copies the objects of the given handler into itself and sets other variables to 0/nullptr. More...

virtual	~BaseHandler ()
	Destructor, it destructs the BaseHandler and all Object it contains. More...

void	copyContentsFromOtherHandler (const BaseHandler< BaseParticle > &BH)
	Function that copies the contents (vector of pointers, maxObject_, nextId_, DPMBase_) from one handler (container) to the other. More...

std::enable_if<!std::is_pointer< U >::value, U * >::type	copyAndAddObject (const U &object)
	Creates a copy of a Object and adds it to the BaseHandler. More...

std::enable_if< std::is_pointer< U >::value, U >::type	copyAndAddObject (const U object)
	Creates a copy of a Object and adds it to the BaseHandler. More...

std::enable_if<!std::is_pointer< U >::value, U * >::type	copyAndAddGhostObject (const U &object)
	Creates a copy of a Object and adds it to the BaseHandler. This is one locally for inserting mpi particles, they avoid the global check if the particle can actually be inserted, because the mpi domain already knows that is the case. More...

std::enable_if< std::is_pointer< U >::value, U >::type	copyAndAddGhostObject (const U object)
	Creates a copy of a Object and adds it to the BaseHandler. This is one locally for inserting mpi particles, they avoid the global check if the particle can actually be inserted, because the mpi domain already knows that is the case. More...

virtual void	addExistingObject (BaseParticle *O)
	Adds an existing object to the BaseHandler without changing the id of the object. More...

virtual void	addObject (BaseParticle *object)
	Adds a new Object to the BaseHandler. More...

virtual void	addGhostObject (BaseParticle *O)
	Adds a new Object to the BaseHandler. called by the to avoid increasing the id. More...

void	removeIf (const std::function< bool(BaseParticle *)> cond)

virtual void	removeObjects (std::vector< unsigned int > indices)

void	removeLastObject ()
	Removes the last Object from the BaseHandler. More...

void	read (std::istream &is)
	Reads all objects from restart data. More...

BaseParticle *	getObjectById (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...

std::vector< BaseParticle * >	getObjectsById (const unsigned int id)
	Gets a vector of pointers to the objects with the specific id. More...

BaseParticle *	getObject (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...

const BaseParticle *	getObject (const unsigned int id) const
	Gets a constant pointer to the Object at the specified index in the BaseHandler. More...

BaseParticle *	getLastObject ()
	Gets a pointer to the last Object in this BaseHandler. More...

const BaseParticle *	getLastObject () const
	Gets a constant pointer to the last Object in this BaseHandler. More...

unsigned int	getSize () const
	Gets the size of the particleHandler (including mpi and periodic particles) More...

unsigned int	getStorageCapacity () const
	Gets the storage capacity of this BaseHandler. More...

void	setStorageCapacity (const unsigned int N)
	Sets the storage capacity of this BaseHandler. More...

void	resize (const unsigned int N, const BaseParticle &obj)
	Resizes the container to contain N elements. More...

const std::vector< BaseParticle * >::const_iterator	begin () const
	Gets the begin of the const_iterator over all Object in this BaseHandler. More...

const std::vector< BaseParticle * >::iterator	begin ()
	Gets the begin of the iterator over all BaseBoundary in this BaseHandler. More...

const std::vector< BaseParticle * >::const_iterator	end () const
	Gets the end of the const_iterator over all BaseBoundary in this BaseHandler. More...

const std::vector< BaseParticle * >::iterator	end ()
	Gets the end of the iterator over all BaseBoundary in this BaseHandler. More...

void	setDPMBase (DPMBase *DPMBase)
	Sets the problem that is solved using this handler. More...

void	setId (BaseParticle *object, unsigned int id)

void	increaseId ()

unsigned int	getNextId ()

void	setNextId (unsigned int id)

DPMBase *	getDPMBase ()
	Gets the problem that is solved using this handler. More...

DPMBase *	getDPMBase () const
	Gets the problem that is solved using this handler and does not change the class. More...

virtual void	writeVTK () const
	now empty function for writing VTK files. More...

unsigned	getNextGroupId ()
	Should be called each time you assign a groupId. Returns the value of nextGroupId_ and increases nextGroupId_ by one. More...

Static Public Member Functions
static BaseParticle *	createObject (const std::string &type)
	Reads BaseParticle into the ParticleHandler from restart data. More...

Private Member Functions
Mdouble	getKineticEnergyLocal () const

Mdouble	getRotationalEnergyLocal () const

Mdouble	getMassLocal () const

Mdouble	getVolumeLocal () const

Vec3D	getMassTimesPositionLocal () const

Mdouble	getSumRadiusLocal () const

Private Attributes
BaseParticle *	largestParticle_
	A pointer to the largest BaseParticle (by interactionRadius) in this ParticleHandler. More...

BaseParticle *	smallestParticle_
	A pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler. More...

unsigned int	NFixedParticles_
	Number of fixed particles. More...

Additional Inherited Members
Protected Attributes inherited from BaseHandler< BaseParticle >
std::vector< BaseParticle * >	objects_
	The actual list of Object pointers. More...

Detailed Description

Container to store pointers to all particles.

The ParticleHandler is a container that stores pointers to all particles belonging to a simulation. It is implemented as a vector of pointers of type BaseParticle*.

Constructor & Destructor Documentation

◆ ParticleHandler() [1/2]

ParticleHandler::ParticleHandler ( )

Default constructor, it creates an empty ParticleHandler.

Constructor of the ParticleHandler class. It creates and empty ParticleHandler.

 {
     largestParticle_ = nullptr;
     smallestParticle_ = nullptr;
     logger(DEBUG, "ParticleHandler::ParticleHandler() finished");
 }

References DEBUG, largestParticle_, logger, and smallestParticle_.

◆ ParticleHandler() [2/2]

ParticleHandler::ParticleHandler ( const ParticleHandler & PH )

Constructor that copies all BaseParticle it contains and then sets the smallest and largest particle.

Parameters

[in] PH The ParticleHandler that has to be copied.

This is not a copy constructor! It copies the DPMBase and all BaseParticle, and sets the other variables to 0. After that, it computes the smallest and largest particle in this handler.

         : BaseHandler<BaseParticle>()
 {
     clear();
     setDPMBase(PH.getDPMBase());
     largestParticle_ = nullptr;
     smallestParticle_ = nullptr;
     copyContentsFromOtherHandler(PH);
     if (!objects_.empty())
     {
         computeLargestParticle();
         computeSmallestParticle();
     }
     logger(DEBUG, "ParticleHandler::ParticleHandler(const ParticleHandler &PH) finished");
 }

References clear(), computeLargestParticle(), computeSmallestParticle(), BaseHandler< BaseParticle >::copyContentsFromOtherHandler(), DEBUG, BaseHandler< T >::getDPMBase(), largestParticle_, logger, BaseHandler< BaseParticle >::objects_, BaseHandler< BaseParticle >::setDPMBase(), and smallestParticle_.

◆ ~ParticleHandler()

ParticleHandler::~ParticleHandler ( )

override

Destructor, it destructs the ParticleHandler and all BaseParticle it contains.

Set the pointers to largestParticle_ and smallestParticle_ to nullptr, all BaseParticle are destroyed by the BaseHandler afterwards.

 {
     //First reset the pointers, such that they are not checked twice when removing particles
     largestParticle_ = nullptr;
     smallestParticle_ = nullptr;
     logger(DEBUG, "ParticleHandler::~ParticleHandler() finished");
 }

References DEBUG, largestParticle_, logger, and smallestParticle_.

Member Function Documentation

◆ actionsAfterTimeStep()

void ParticleHandler::actionsAfterTimeStep ( )

 {
     for (auto i: *this)
     {
         i->actionsAfterTimeStep();
     }
 }

References i.

Referenced by DPMBase::computeOneTimeStep().

◆ actionsBeforeTimeStep()

void ParticleHandler::actionsBeforeTimeStep ( )

 {
     for (auto i: *this)
     {
         i->actionsBeforeTimeStep();
     }
 }

References i.

Referenced by DPMBase::computeOneTimeStep().

◆ addedFixedParticle()

void ParticleHandler::addedFixedParticle ( )

Increment of the number of fixed particles.

Todo:: MX: For Jonny, is this still required, keeping the parallel code in mind?

 {
     NFixedParticles_++;
 }

References NFixedParticles_.

Referenced by BaseParticle::fixParticle().

◆ addExistingObject()

void ParticleHandler::addExistingObject ( BaseParticle * P )

override

Adds a BaseParticle to the ParticleHandler.

Parameters

[in] P A pointer to the BaseParticle that has to be added.

To add a BaseParticle to the ParticleHandler, first check if it has a species, since it is as common bug to use a BaseParticle without species, which leads to a segmentation fault. To help the user with debugging, a warning is given if a particle without species is added. After that, the actions for adding the particle to the BaseHandler are taken, which include adding it to the vector of pointers to all BaseParticle and assigning the correct id and index. Then the particle is added to the HGrid, the particle is told that this is its handler, its mass is computed and finally it is checked if this is the smallest or largest particle in this ParticleHandler. The particle exists, in other words: it has been made before. This implies it already got an id Attached to it and hence we don't want to assign a new ID to it.

 {
     if (P->getSpecies() == nullptr)
     {
         logger(WARN, "WARNING: The particle with ID % that is added in ParticleHandler::addObject does not have a "
                      "species yet. Please make sure that you have "
                      "set the species somewhere in the driver code.", P->getId());
     }
     
     //Puts the particle in the Particle list
     BaseHandler<BaseParticle>::addExistingObject(P);
     if (getDPMBase() != nullptr)
     {
         //This places the particle in this grid
         getDPMBase()->hGridInsertParticle(P);
         //This computes where the particle currently is in the grid
         getDPMBase()->hGridUpdateParticle(P);
     }
     //set the particleHandler pointer
     P->setHandler(this);
     //compute mass of the particle
     P->getSpecies()->computeMass(P);
     //Check if this particle has new extrema
     checkExtrema(P);
 }

References BaseHandler< T >::addExistingObject(), checkExtrema(), BaseHandler< BaseParticle >::getDPMBase(), DPMBase::hGridInsertParticle(), DPMBase::hGridUpdateParticle(), logger, Global_Physical_Variables::P, and WARN.

Referenced by readAndAddObject().

◆ addGhostObject() [1/2]

void ParticleHandler::addGhostObject ( BaseParticle * P )

override

Adds a BaseParticle to the ParticleHandler.

This is a special function that is used in the parallel code. The functions differs from the standard parallel implementation as this function does not check if the particle is an mpi particle and the mpi domain is not updated. When the domain adds mpi particles to the simulation these checks are not required. It also doesnt increase the id of the particle

Parameters

[in] A pointer to the BaseParticle that has to be added.

 {
 #ifdef MERCURYDPM_USE_MPI
     if (P->getSpecies() == nullptr)
     {
         logger(WARN, "[ParticleHandler::adGhostObject(BaseParticle*)] "
                 "WARNING: The particle with ID % that is added in "
                 "ParticleHandler::addObject does not have a species yet."
                 " Please make sure that you have "
                 "set the species somewhere in the driver code.", P->getId());
     }
  
     MPIContainer& communicator = MPIContainer::Instance();
     //Puts the particle in the Particle list
     BaseHandler<BaseParticle>::addGhostObject(P);
     if (getDPMBase() != nullptr)
     {
         //This places the particle in this grid
         getDPMBase()->hGridInsertParticle(P);
         //This computes where the particle currently is in the grid
         getDPMBase()->hGridUpdateParticle(P);
  
         // broadcast particle addition
         getDPMBase()->handleParticleAddition(P->getId(), P);
     }
     //set the particleHandler pointer
     P->setHandler(this);
     //compute mass of the particle
     P->getSpecies()->computeMass(P) ;
     //Check if this particle has new extrema
     checkExtrema(P);
  
     if (getDPMBase() != nullptr)
     {
         // Broadcasts the existence of a new particle
         getDPMBase()->handleParticleAddition(P->getId(), P);
     }
 #else
     logger(INFO,
            "Function ParticleHandler::mpiAddObject(BaseParticle* P) should only be called when compiling with parallel build on");
 #endif
 }

References BaseHandler< T >::addGhostObject(), checkExtrema(), BaseHandler< BaseParticle >::getDPMBase(), DPMBase::handleParticleAddition(), DPMBase::hGridInsertParticle(), DPMBase::hGridUpdateParticle(), INFO, MPIContainer::Instance(), logger, Global_Physical_Variables::P, and WARN.

◆ addGhostObject() [2/2]

void ParticleHandler::addGhostObject	(	int	fromProcessor,
		int	toProcessor,
		BaseParticle *	p
	)

Adds a ghost particle located at fromProcessor to toProcessor.

This function adds a ghost particle from one processor to another processor.

When a periodic ghost particle or a mpi ghost particle is created, the ID should not be updated and hence the addGhostObject needs to be called. Adding a ghost keeps the ID constant. Additionally this function copies the particle information given on processor fromProcessor to all other processors. The target processor then adds the particle.

Parameters

[in]	fromProcessor	processor containing the particle data
[in]	toProcessor	processor that needs to add the particle
[in,out]	particle	that contains the data and receives the data

 {
 #ifdef MERCURYDPM_USE_MPI
     MPIContainer& communicator = MPIContainer::Instance();
     if (fromProcessor == toProcessor)
     {
         if (communicator.getProcessorID() == fromProcessor)
         {
             addGhostObject(p);
         }
  
         return;
     }
  
     //Create communication information object
     MPIParticle pInfo;
     int tag;
     if (communicator.getProcessorID() == fromProcessor)
     {
         pInfo.copyDataFromParticleToMPIParticle(p);
         tag = fromProcessor*MAX_PROC*10 + toProcessor*10 + MercuryMPITag::PARTICLE_DATA;
         communicator.send(&pInfo, MercuryMPIType::PARTICLE, 1, toProcessor, tag);
     }
  
     if (communicator.getProcessorID() == toProcessor)
     {
         tag = fromProcessor*MAX_PROC*10 + toProcessor*10 + MercuryMPITag::PARTICLE_DATA;
         communicator.receive(&pInfo, MercuryMPIType::PARTICLE, 1, fromProcessor, tag);
     }
  
     //Sync the communication
     communicator.sync();
  
     //Add the data to the new particle
     if (communicator.getProcessorID() == toProcessor)
     {
         copyDataFromMPIParticleToParticle(&pInfo, p, this);
     }
  
  
     //Only toProcessor adds the particle, quietly without any check with other processors
     //IMPORTANT NOTE: When adding  a periodic particle in parallel, this is performed just before
     //finding new particles. For that reason we dont have to add a ghostparticle to the mpi communication lists
     if (communicator.getProcessorID() == toProcessor)
     {
         addGhostObject(p);
     }
 #else
     logger(WARN,
            "Function addGhostObject(int fromProcessor, int toProcessor, BaseParticle* p) should not be used in serial code");
 #endif
 }

References copyDataFromMPIParticleToParticle(), MPISphericalParticle::copyDataFromParticleToMPIParticle(), MPIContainer::getProcessorID(), MPIContainer::Instance(), logger, MAX_PROC, p, PARTICLE, PARTICLE_DATA, MPIContainer::receive(), MPIContainer::send(), MPIContainer::sync(), and WARN.

Referenced by PeriodicBoundaryHandler::processLocalGhostParticles(), Domain::processReceivedBoundaryParticleData(), and PeriodicBoundaryHandler::processReceivedGhostParticleData().

◆ addObject() [1/2]

void ParticleHandler::addObject ( BaseParticle * P )

override

Adds a BaseParticle to the ParticleHandler.

Parameters

[in] P A pointer to the BaseParticle that has to be added.

To add a BaseParticle to the ParticleHandler, first check if it has a species, since it is as common bug to use a BaseParticle without species, which leads to a segmentation fault. To help the user with debugging, a warning is given if a particle without species is added. After that, the actions for adding the particle to the BaseHandler are taken, which include adding it to the vector of pointers to all BaseParticle and assigning the correct id and index. Then the particle is added to the HGrid, the particle is told that this is its handler, its mass is computed and finally it is checked if this is the smallest or largest particle in this ParticleHandler.

 {
     if (P->getSpecies() == nullptr)
     {
         logger(WARN, "WARNING: The particle with ID % that is added in "
                      "ParticleHandler::addObject does not have a species yet. "
                      "Please make sure that you have "
                      "set the species somewhere in the driver code.", P->getId());
     }
 #ifdef MERCURYDPM_USE_MPI
     bool insertParticle;
     //Check if the particle P should be added to the current domain
     if (NUMBER_OF_PROCESSORS == 1)
     {
         insertParticle = true;
     }
     else
     {
         insertParticle  = getDPMBase()->mpiInsertParticleCheck(P);
     }
  
     //Add the particle if it is in the mpi domain or if the domain is not yet defined
     if(insertParticle)
     {
 #endif
         //Puts the particle in the Particle list
         BaseHandler<BaseParticle>::addObject(P);
         if (getDPMBase() != nullptr)
         {
             //This places the particle in this grid
             getDPMBase()->hGridInsertParticle(P);
             //This computes where the particle currently is in the grid
             getDPMBase()->hGridUpdateParticle(P);
  
             // Broadcasts the existance of a new particle
             getDPMBase()->handleParticleAddition(P->getId(), P);
  
             // Store the time stamp of creation.
             P->setTimeStamp(getDPMBase()->getNumberOfTimeSteps());
         }
         //set the particleHandler pointer
         P->setHandler(this);
         //compute mass of the particle
         P->getSpecies()->computeMass(P);
         //Check if this particle has new extrema
         checkExtrema(P);
         if (!P->isSphericalParticle())
         {
             getDPMBase()->setRotation(true);
         }
  
         P->actionsAfterAddObject();
  
         if (getDPMBase() != nullptr)
         {
             // Broadcasts the existence of a new particle
             getDPMBase()->handleParticleAddition(P->getId(), P);
         }
  
 #ifdef MERCURYDPM_USE_MPI
         P->setPeriodicComplexity(std::vector<int>(0));
     }
     else
     {
         logger.assert_debug(!P->isMPIParticle(),"Can't add mpi particle as it does not exist");
         logger.assert_debug(!P->isPeriodicGhostParticle(),"Can't add mpi particle as it does not exist");
         //Somehwere a really new particle has been added, so to keep the ID's globally unique, we also update
         //the unique value on all other processors
         BaseHandler<BaseParticle>::increaseId();
     }
  
     //Add the particle to the ghost particle lists
     getDPMBase()->insertGhostParticle(P);
     //Check if this new particle requires an update in the mpi grid (interactionDistance).
     getDPMBase()->updateGhostGrid(P);
  
     //Delete the particle that was supposed to be added (but was not)
     if(!insertParticle)
     {
         delete P;
     }
 #endif
 }

References BaseHandler< T >::addObject(), checkExtrema(), BaseHandler< BaseParticle >::getDPMBase(), DPMBase::handleParticleAddition(), DPMBase::hGridInsertParticle(), DPMBase::hGridUpdateParticle(), BaseHandler< T >::increaseId(), DPMBase::insertGhostParticle(), logger, DPMBase::mpiInsertParticleCheck(), NUMBER_OF_PROCESSORS, Global_Physical_Variables::P, DPMBase::setRotation(), DPMBase::updateGhostGrid(), and WARN.

◆ addObject() [2/2]

void ParticleHandler::addObject	(	int	fromProcessor,
		BaseParticle *	p
	)

Adds a BaseParticle located at processor fromProcessor to toProcessor.

This function adds a particle to the simulation where the information of the particle is not available by the target processor.

When a certain processor generates a particle which needs to be inserted in a domain of another processor, this information needs to be transfered before the particle can be actually added

Parameters

[in]	fromProcessor	processor containing the particle data
[in,out]	particle	that contains the data and receives the data

 {
 #ifdef MERCURYDPM_USE_MPI
     MPIContainer& communicator = MPIContainer::Instance();
  
     //The processor that contains the particle that needs to be copied needs to identify the target, and communicate this
     MPIParticle pInfo;
     if (communicator.getProcessorID() == fromProcessor)
     {
         pInfo.copyDataFromParticleToMPIParticle(p);
     }
  
     //Broadcast from processor i
     communicator.broadcast(&pInfo,MercuryMPIType::PARTICLE,fromProcessor);
     copyDataFromMPIParticleToParticle(&pInfo, p, this);
  
     //All processors now know have the same information and we can proceed with the collective add
     addObject(p);
 #else
     logger(WARN, "Function addObject(int fromProcessor, BaseParticle* p) should not be used in serial code");
 #endif
 }

References addObject(), MPIContainer::broadcast(), copyDataFromMPIParticleToParticle(), MPISphericalParticle::copyDataFromParticleToMPIParticle(), MPIContainer::getProcessorID(), MPIContainer::Instance(), logger, p, PARTICLE, and WARN.

◆ checkExtrema()

void ParticleHandler::checkExtrema ( BaseParticle * P )

Checks if the extrema of this ParticleHandler needs updating.

 \param[in] type The first value of the position.
 \param[in] is The input stream from which the information is read.
 \details The old objects did not have their type in the beginning of the line.
          Instead, the first string of the file was the position in x-direction.
          Since we already read the first string of the file, we need to give
          it to this function and convert it to the position in x-direction.
          The rest of the stream is then read in the usual way.
&zwj;/

void ParticleHandler::readAndCreateOldObject(std::istream& is, const std::string& type) { //read in next line std::stringstream line; helpers::getLineFromStringStream(is, line); logger(VERBOSE, line.str()); //stdcout << line.str() << std::endl;

BaseParticle particle;

//Declare all properties of the particle unsigned int indSpecies; Mdouble radius, inverseMass, inverseInertia; Vec3D position, velocity, euler, angularVelocity;

//Read all values position.X = atof(type.c_str());

line >> position.Y >> position.Z >> velocity >> radius >> euler >> angularVelocity >> inverseMass >> inverseInertia >> indSpecies;

//Put the values in the particle particle.setSpecies(getDPMBase()->speciesHandler.getObject(indSpecies)); particle.setPosition(position); particle.setVelocity(velocity); particle.setRadius(radius); Quaternion q; q.setEuler(euler); particle.setOrientation(q); particle.setAngularVelocity(angularVelocity); if (inverseMass == 0.0) particle.fixParticle(); else { particle.setInverseInertia(MatrixSymmetric3D(1,0,0,1,0,1)*inverseInertia); }

//Put the particle in the handler copyAndAddObject(particle); }

void ParticleHandler::write(std::ostream& os) const {

os << "Particles " << getSize() << '\n';
for (BaseParticle* it : *this)
{
    os << (*it) << '\n';
}

os.flush(); }

/*!

Parameters

[in] P A pointer to the particle, which properties have to be checked against the ParticleHandlers extrema.

 {
     if (P == largestParticle_)
     {
         //if the properties of the largest particle changes
         computeLargestParticle();
     }
     else if (!largestParticle_ || P->getMaxInteractionRadius() > largestParticle_->getMaxInteractionRadius())
     {
         largestParticle_ = P;
     }
     
     if (P == smallestParticle_)
     {
         //if the properties of the smallest particle changes
         computeSmallestParticle();
     }
     else if (!smallestParticle_ || P->getMaxInteractionRadius() < smallestParticle_->getMaxInteractionRadius())
     {
         smallestParticle_ = P;
     }
 }

References computeLargestParticle(), computeSmallestParticle(), BaseParticle::getMaxInteractionRadius(), largestParticle_, Global_Physical_Variables::P, and smallestParticle_.

Referenced by addExistingObject(), addGhostObject(), addObject(), and BaseParticle::setRadius().

◆ checkExtremaOnDelete()

void ParticleHandler::checkExtremaOnDelete ( BaseParticle * P )

Checks if the extrema of this ParticleHandler needs updating when a particle is deleted.

Parameters

[in] P A pointer to the particle, which is going to get deleted.

 {
     if (P == largestParticle_)
     {
         computeLargestParticle();
     }
     if (P == smallestParticle_)
     {
         computeSmallestParticle();
     }
 }

References computeLargestParticle(), computeSmallestParticle(), largestParticle_, Global_Physical_Variables::P, and smallestParticle_.

Referenced by BaseParticle::~BaseParticle(), and SuperQuadricParticle::~SuperQuadricParticle().

◆ clear()

void ParticleHandler::clear ( )

overridevirtual

Empties the whole ParticleHandler by removing all BaseParticle.

Note that the pointers to smallestParticle_ and largestParticle_ are set to nullptr since these particles don't exist anymore after calling this function.

Reimplemented from BaseHandler< BaseParticle >.

 {
     smallestParticle_ = nullptr;
     largestParticle_ = nullptr;
  
     for (auto p0: *this)
     {
         getDPMBase()->handleParticleRemoval(p0->getId());
     }
  
     BaseHandler<BaseParticle>::clear();
 }

References BaseHandler< T >::clear(), BaseHandler< BaseParticle >::getDPMBase(), DPMBase::handleParticleRemoval(), largestParticle_, p0, and smallestParticle_.

◆ computeAllMasses() [1/2]

void ParticleHandler::computeAllMasses ( )

Computes the mass for all BaseParticle in this ParticleHandler.

 {
     for (BaseParticle* particle : objects_)
     {
         particle->getSpecies()->computeMass(particle);
     }
 }

References BaseHandler< BaseParticle >::objects_.

◆ computeAllMasses() [2/2]

void ParticleHandler::computeAllMasses ( unsigned int indSpecies )

Computes the mass for all BaseParticle of the given species in this ParticleHandler.

Parameters

[in] indSpecies Unsigned integer with the index of the species for which the masses must be computed.

 {
     for (BaseParticle* particle : objects_)
     {
         if (particle->getIndSpecies() == indSpecies)
         {
             particle->getSpecies()->computeMass(particle);
         }
     }
 }

References BaseHandler< BaseParticle >::objects_.

Referenced by SpeciesHandler::addObject(), DPMBase::initialiseSolve(), DPMBase::readNextDataFile(), ParticleSpecies::setDensity(), and DPMBase::setParticleDimensions().

◆ computeLargestParticle()

void ParticleHandler::computeLargestParticle ( )

Computes the largest particle (by interaction radius) and sets it in largestParticle_.

 {
     if (getSize() == 0)
     {
         logger(DEBUG, "No particles, so cannot compute the largest particle.");
         largestParticle_ = nullptr;
         return;
     }
     Mdouble max = -std::numeric_limits<Mdouble>::max();
     largestParticle_ = nullptr;
     for (BaseParticle* const particle : objects_)
     {
         //if (!(particle->isMPIParticle() || particle->isPeriodicGhostParticle()))
         {
             if (particle->getMaxInteractionRadius() > max)
             {
                 max = particle->getMaxInteractionRadius();
                 largestParticle_ = particle;
             }
         }
     }
 }

References DEBUG, BaseHandler< BaseParticle >::getSize(), largestParticle_, logger, max, and BaseHandler< BaseParticle >::objects_.

Referenced by DeletionBoundary::checkBoundaryAfterParticleMoved(), checkExtrema(), checkExtremaOnDelete(), operator=(), and ParticleHandler().

◆ computeSmallestParticle()

void ParticleHandler::computeSmallestParticle ( )

Computes the smallest particle (by interaction radius) and sets it in smallestParticle_.

 {
     if (getSize() == 0)
     {
         logger(DEBUG, "No particles, so cannot compute the smallest particle.");
         
         smallestParticle_ = nullptr;
         return;
     }
     Mdouble min = std::numeric_limits<Mdouble>::max();
     smallestParticle_ = nullptr;
     for (BaseParticle* const particle : objects_)
     {
         //if (!(particle->isMPIParticle() || particle->isPeriodicGhostParticle()))
         {
             if (particle->getMaxInteractionRadius() < min)
             {
                 min = particle->getMaxInteractionRadius();
                 smallestParticle_ = particle;
             }
         }
     }
 }

References DEBUG, BaseHandler< BaseParticle >::getSize(), logger, max, min, BaseHandler< BaseParticle >::objects_, and smallestParticle_.

Referenced by DeletionBoundary::checkBoundaryAfterParticleMoved(), checkExtrema(), checkExtremaOnDelete(), operator=(), and ParticleHandler().

◆ createObject()

BaseParticle * ParticleHandler::createObject ( const std::string & type )

static

Reads BaseParticle into the ParticleHandler from restart data.

Parameters

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

 {
     if (type == "BaseParticle") {
         //for backwards compatibility
         return new SphericalParticle;
     }
     else if (type == "SphericalParticle")
     {
         return new SphericalParticle;
     }
     else if (type == "LiquidFilmBaseParticle" || type == "LiquidFilmParticle")
     {
         return new LiquidFilmParticle;
     }
     else if (type == "SuperQuadricParticle")
     {
         return new SuperQuadricParticle;
     }
     else if (type == "ThermalParticle")
     {
         return new ThermalParticle;
     }
     else if (type == "MeltableParticle")
     {
         return new MeltableParticle;
     }
     else if (type == "HeatFluidCoupledBaseParticle")
     {
         return new HeatFluidCoupledParticle;
     }
     else if (type == "Clump")
     {
         return new ClumpParticle;
     }
     else
     {
         logger(WARN, "Particle type % not understood in restart file. Particle will not be read.", type);
         return nullptr;
     }
 }

References logger, compute_granudrum_aor::type, and WARN.

Referenced by readAndCreateObject().

◆ getAngularMomentum()

Vec3D ParticleHandler::getAngularMomentum ( ) const

 {
     Vec3D momentum = {0, 0, 0};
     for (auto p : *this)
         if (!(p->isFixed() || p->isMPIParticle() || p->isPeriodicGhostParticle()))
             momentum += p->getAngularMomentum();
     return getMPISum(momentum);
 }

References getMPISum(), and p.

◆ getCentreOfMass()

Vec3D ParticleHandler::getCentreOfMass ( ) const

 {
     Mdouble m = getMass();
     if (m == 0)
     {
         Vec3D nanvec = {constants::NaN, constants::NaN, constants::NaN};
         return nanvec;
     }
     else
         return getMassTimesPosition() / m;
 }

References getMass(), getMassTimesPosition(), m, and constants::NaN.

Referenced by DPMBase::getCentreOfMass(), and RotatingDrumWet::printTime().

◆ getFastestParticle()

BaseParticle * ParticleHandler::getFastestParticle ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(ERROR,"This function should not be used in parallel");
 #endif
     return getFastestParticleLocal();
 }

References ERROR, getFastestParticleLocal(), and logger.

◆ getFastestParticleLocal()

BaseParticle * ParticleHandler::getFastestParticleLocal ( ) const

Gets a pointer to the fastest BaseParticle in this ParticleHandler.

Returns: A pointer to the fastest BaseParticle in this ParticleHandler.

 {
     if (getSize() == 0)
     {
         logger(WARN, "No particles to set getFastestParticle()");
         return nullptr;
     }
     BaseParticle* p = nullptr;
     Mdouble maxSpeed = -std::numeric_limits<Mdouble>::max();
     for (BaseParticle* const pLoop : objects_)
     {
         if (!(pLoop->isMPIParticle() || pLoop->isPeriodicGhostParticle()))
         {
             if ((pLoop->getVelocity().getLength()) > maxSpeed)
             {
                 maxSpeed = pLoop->getVelocity().getLength();
                 p = pLoop;
             }
         }
     }
     return p;
 }

References BaseHandler< BaseParticle >::getSize(), logger, max, BaseHandler< BaseParticle >::objects_, p, and WARN.

Referenced by getFastestParticle().

◆ getHighestPositionComponentParticle()

BaseParticle * ParticleHandler::getHighestPositionComponentParticle ( int i ) const

Gets a pointer to the particle with the highest coordinates in direction i in this ParticleHandler.

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(ERROR,"This function should not be used in parallel");
 #endif
     return getHighestPositionComponentParticleLocal(i);
 }

References ERROR, getHighestPositionComponentParticleLocal(), i, and logger.

◆ getHighestPositionComponentParticleLocal()

BaseParticle * ParticleHandler::getHighestPositionComponentParticleLocal ( int i ) const

Gets a pointer to the particle with the highest coordinates in direction i in this ParticleHandler.

Parameters

[in] i Direction for which one wants the particle with highest coordinates.

Returns: A pointer to the particle with the highest coordinates in direction i in this ParticleHandler.

 {
     if (getSize() == 0)
     {
         logger(WARN, "No getHighestPositionComponentParticle(const int i) since there are no particles.");
         return nullptr;
     }
     BaseParticle* p = nullptr;
     Mdouble max = -std::numeric_limits<Mdouble>::max();
     for (BaseParticle* const pLoop : objects_)
     {
         if (!(pLoop->isMPIParticle() || pLoop->isPeriodicGhostParticle()))
         {
             if (pLoop->getPosition().getComponent(i) > max)
             {
                 max = pLoop->getPosition().getComponent(i);
                 p = pLoop;
             }
         }
     }
     
     return p;
 }

References BaseHandler< BaseParticle >::getSize(), i, logger, max, BaseHandler< BaseParticle >::objects_, p, and WARN.

Referenced by getHighestPositionComponentParticle().

◆ getHighestPositionX()

Mdouble ParticleHandler::getHighestPositionX ( ) const

Function returns the highest position in the x-direction.

This is a prototype example of how to obtain global particle attributes in the parallel code

Returns: Returns the highest x-position value of all particles

 {
     //Define the attribute function
     std::function<Mdouble(BaseParticle*)> particleAttribute = [](BaseParticle* p) { return p->getPosition().X; };
     
     //Obtain the MAX attribute
     Mdouble positionXGlobal = getParticleAttribute<Mdouble>(particleAttribute, AttributeType::MAX);
     
     return positionXGlobal;
 }

References MAX, and p.

◆ getHighestVelocityComponentParticle()

BaseParticle * ParticleHandler::getHighestVelocityComponentParticle ( int i ) const

Gets a pointer to the particle with the highest velocity in direction i in this ParticleHandler.

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(ERROR,"This function should not be used in parallel");
 #endif
     return getHighestVelocityComponentParticleLocal(i);
 }

References ERROR, getHighestVelocityComponentParticleLocal(), i, and logger.

◆ getHighestVelocityComponentParticleLocal()

BaseParticle * ParticleHandler::getHighestVelocityComponentParticleLocal ( int i ) const

Gets a pointer to the particle with the highest velocity in direction i in this ParticleHandler.

Parameters

[in] i Direction for which you want the particle with highest velocity.

Returns: A pointer to the particle with the highest velocity in direction i in this ParticleHandler.

 {
     if (!getSize())
     {
         logger(WARN, "No getHighestVelocityComponentParticle(const int i) since there are no particles");
         return nullptr;
     }
     BaseParticle* p = nullptr;
     Mdouble max = -std::numeric_limits<Mdouble>::max();
     for (BaseParticle* const pLoop : objects_)
     {
         if (!(pLoop->isMPIParticle() || pLoop->isPeriodicGhostParticle()))
         {
             if (pLoop->getVelocity().getComponent(i) > max)
             {
                 max = pLoop->getVelocity().getComponent(i);
                 p = pLoop;
             }
         }
     }
     return p;
 }

References BaseHandler< BaseParticle >::getSize(), i, logger, max, BaseHandler< BaseParticle >::objects_, p, and WARN.

Referenced by getHighestVelocityComponentParticle().

◆ getKineticEnergy()

Mdouble ParticleHandler::getKineticEnergy ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     Mdouble kineticEnergyLocal = getKineticEnergyLocal();
     Mdouble kineticEnergyGlobal = 0.0;
  
     //sum up over all domains
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(kineticEnergyLocal, kineticEnergyGlobal, MPI_SUM);
  
     return kineticEnergyGlobal;
 #else
     return getKineticEnergyLocal();
 #endif
 }

References getKineticEnergyLocal(), and MPIContainer::Instance().

Referenced by DPMBase::writeEneTimeStep(), and LawinenBox::writeEneTimeStep().

◆ getKineticEnergyLocal()

Mdouble ParticleHandler::getKineticEnergyLocal ( ) const

private

 {
     Mdouble ene = 0;
     for (auto p : *this)
     {
         if (!(p->isMPIParticle() || p->isPeriodicGhostParticle()))
         {
             ene += p->getKineticEnergy();
         }
     }
     return ene;
 }

References p.

Referenced by getKineticEnergy().

◆ getLargestInteractionRadius()

Mdouble ParticleHandler::getLargestInteractionRadius ( ) const

Returns the largest interaction radius.

 {
 #ifdef MERCURYDPM_USE_MPI
     Mdouble largestInteractionRadiusLocal = getLargestInteractionRadiusLocal();
     Mdouble largestInteractionRadiusGlobal = 0.0;
  
     //Obtain the global value
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(largestInteractionRadiusLocal, largestInteractionRadiusGlobal, MPI_MAX);
  
     return largestInteractionRadiusGlobal;
 #else
     return getLargestInteractionRadiusLocal();
 #endif
 }

References getLargestInteractionRadiusLocal(), and MPIContainer::Instance().

Referenced by Contact::actionsAfterSolve(), getPSD(), and DPMBase::read().

◆ getLargestInteractionRadiusLocal()

Mdouble ParticleHandler::getLargestInteractionRadiusLocal ( ) const

Returns the largest interaction radius of the current domain.

 {
     if (!(getLargestParticleLocal() == nullptr))
     {
         return getLargestParticle()->getMaxInteractionRadius();
     }
     else
     {
         return 0.0;
     }
 }

References getLargestParticle(), getLargestParticleLocal(), and BaseParticle::getMaxInteractionRadius().

Referenced by MercuryBase::getHGridTargetMaxInteractionRadius(), and getLargestInteractionRadius().

◆ getLargestParticle()

BaseParticle * ParticleHandler::getLargestParticle ( ) const

Returns the pointer of the largest particle in the particle handler. When mercury is running in parallel this function throws an error since a pointer to another domain is useless.

Returns: A Pointer to the largest BaseParticle (by interactionRadius) in this ParticleHandler

 {
 #ifdef MERCURYDPM_USE_MPIO
     logger(WARN,"getLargestParticle() should not be used in parallel; use getLargestInteractionRadius instead");
     return nullptr;
 #else
     return getLargestParticleLocal();
 #endif
 }

References getLargestParticleLocal(), logger, and WARN.

Referenced by DPMBase::checkParticleForInteractionLocalPeriodic(), ChuteWithPeriodicInflow::computeInternalForces(), LeesEdwardsBoundary::createHorizontalPeriodicParticle(), ShearBoxBoundary::createHorizontalPeriodicParticle(), AngledPeriodicBoundary::createPeriodicParticle(), CircularPeriodicBoundary::createPeriodicParticle(), PeriodicBoundary::createPeriodicParticle(), SubcriticalMaserBoundary::createPeriodicParticle(), SubcriticalMaserBoundaryTEST::createPeriodicParticle(), TimeDependentPeriodicBoundary::createPeriodicParticle(), LeesEdwardsBoundary::createVerticalPeriodicParticle(), ShearBoxBoundary::createVerticalPeriodicParticle(), getLargestInteractionRadiusLocal(), getPSD(), MercuryBase::hGridNeedsRebuilding(), InitialBed::printTime(), CFDDEMCoupleTest::setupInitialConditions(), ParticleCreation::setupInitialConditions(), and BaseCluster::setupInitialConditions().

◆ getLargestParticleLocal()

BaseParticle * ParticleHandler::getLargestParticleLocal ( ) const

Gets a pointer to the largest BaseParticle (by interactionRadius) in the ParticleHandler of the local domain.

Returns: A pointer to the largest BaseParticle (by interactionRadius) in this ParticleHandler.

 {
     return largestParticle_;
 }

References largestParticle_.

Referenced by ConstantMassFlowMaserBoundary::activateMaser(), ConstantMassFlowMaserBoundary::createPeriodicParticle(), getLargestInteractionRadiusLocal(), getLargestParticle(), RotatingDrum::setupInitialConditions(), and DPMBase::writeFstatHeader().

◆ getLiquidFilmVolume()

double ParticleHandler::getLiquidFilmVolume ( ) const

 {
     double liquidVolume = 0;
     for (auto i : objects_) {
         auto j = dynamic_cast<LiquidFilmParticle*>(i);
         if (j and !j->isMPIParticle()) liquidVolume += j->getLiquidVolume();
     }
     return getMPISum(liquidVolume);
 };

References getMPISum(), i, j, and BaseHandler< BaseParticle >::objects_.

Referenced by LiquidMigrationMPI2Test::printTime().

◆ getLowestPositionComponentParticle()

BaseParticle * ParticleHandler::getLowestPositionComponentParticle ( int i ) const

Gets a pointer to the particle with the lowest coordinates in direction i in this ParticleHandler.

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(ERROR,"This function should not be used in parallel");
 #endif
     return getLowestPositionComponentParticleLocal(i);
 }

References ERROR, getLowestPositionComponentParticleLocal(), i, and logger.

◆ getLowestPositionComponentParticleLocal()

BaseParticle * ParticleHandler::getLowestPositionComponentParticleLocal ( int i ) const

Gets a pointer to the particle with the lowest coordinates in direction i in this ParticleHandler.

Parameters

[in] i Direction for which you want the particle with lowest coordinates.

Returns: A pointer to the particle with the lowest coordinates in the given direction in this ParticleHandler.

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(ERROR,"getLowestPositionComponentParticle() not implemented yet in parallel");
 #endif
     if (getSize() == 0)
     {
         logger(WARN, "No getLowestPositionComponentParticle(const int i) since there are no particles.");
         return nullptr;
     }
     BaseParticle* p = nullptr;
     Mdouble min = std::numeric_limits<Mdouble>::max();
     for (BaseParticle* const pLoop : objects_)
     {
         if (!(pLoop->isMPIParticle() || pLoop->isPeriodicGhostParticle()))
         {
             if (pLoop->getPosition().getComponent(i) < min)
             {
                 min = pLoop->getPosition().getComponent(i);
                 p = pLoop;
             }
         }
     }
     return p;
 }

References ERROR, BaseHandler< BaseParticle >::getSize(), i, logger, max, min, BaseHandler< BaseParticle >::objects_, p, and WARN.

Referenced by getLowestPositionComponentParticle().

◆ getLowestVelocityComponentParticle()

BaseParticle * ParticleHandler::getLowestVelocityComponentParticle ( int i ) const

Gets a pointer to the particle with the lowest velocity in direction i in this ParticleHandler.

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(ERROR,"This function should not be used in parallel");
 #endif
     return getLowestVelocityComponentParticleLocal(i);
 }

References ERROR, getLowestVelocityComponentParticleLocal(), i, and logger.

◆ getLowestVelocityComponentParticleLocal()

BaseParticle * ParticleHandler::getLowestVelocityComponentParticleLocal ( int i ) const

Gets a pointer to the particle with the lowest velocity in direction i in this ParticleHandler.

Parameters

[in] i Direction for which you want the particle with lowest velocity.

Returns: A pointer to the particle with the lowest velocity in direction i in this ParticleHandler.

 {
     if (getSize() == 0)
     {
         logger(WARN, "No getLowestVelocityComponentParticle(const int i) since there are no particles");
         return nullptr;
     }
     BaseParticle* p = nullptr;
     Mdouble min = std::numeric_limits<Mdouble>::max();
     for (BaseParticle* const pLoop : objects_)
     {
         if (!(pLoop->isMPIParticle() || pLoop->isPeriodicGhostParticle()))
         {
             if (pLoop->getVelocity().getComponent(i) < min)
             {
                 min = pLoop->getVelocity().getComponent(i);
                 p = pLoop;
             }
         }
     }
     return p;
 }

References BaseHandler< BaseParticle >::getSize(), i, logger, max, min, BaseHandler< BaseParticle >::objects_, p, and WARN.

Referenced by getLowestVelocityComponentParticle().

◆ getMass()

Mdouble ParticleHandler::getMass ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     Mdouble massLocal = getMassLocal();
     Mdouble massGlobal = 0.0;
  
     //Sum up over all domains
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(massLocal, massGlobal, MPI_SUM);
  
     return massGlobal;
 #else
     return getMassLocal();
 #endif
 }

References getMassLocal(), and MPIContainer::Instance().

Referenced by BoundariesSelfTest::actionsAfterTimeStep(), FluxAndPeriodicBoundarySelfTest::actionsAfterTimeStep(), FluxBoundarySelfTest::actionsAfterTimeStep(), FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), getCentreOfMass(), DPMBase::getTotalMass(), HeaterBoundaryTest::setupInitialConditions(), DPMBase::writeEneTimeStep(), and LawinenBox::writeEneTimeStep().

◆ getMassLocal()

Mdouble ParticleHandler::getMassLocal ( ) const

private

 {
     Mdouble m = 0;
     for (auto p : *this)
         if (!(p->isFixed() || p->isMPIParticle() || p->isPeriodicGhostParticle()))
             m += p->getMass();
     return m;
 }

References m, and p.

Referenced by getMass().

◆ getMassTimesPosition()

Vec3D ParticleHandler::getMassTimesPosition ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     Vec3D massTimesPositionLocal = getMassTimesPositionLocal();
     Vec3D massTimesPositionGlobal = {0.0, 0.0, 0.0};
  
     // Sum up over all domains
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(massTimesPositionLocal.X, massTimesPositionGlobal.X, MPI_SUM);
     communicator.allReduce(massTimesPositionLocal.Y, massTimesPositionGlobal.Y, MPI_SUM);
     communicator.allReduce(massTimesPositionLocal.Z, massTimesPositionGlobal.Z, MPI_SUM);
  
     return massTimesPositionGlobal;
 #else
     return getMassTimesPositionLocal();
 #endif
 }

References getMassTimesPositionLocal(), MPIContainer::Instance(), Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by getCentreOfMass(), and DPMBase::writeEneTimeStep().

◆ getMassTimesPositionLocal()

Vec3D ParticleHandler::getMassTimesPositionLocal ( ) const

private

 {
     Vec3D com = {0, 0, 0};
     for (auto p : *this)
         if (!(p->isFixed() || p->isMPIParticle() || p->isPeriodicGhostParticle()))
             com += p->getMass() * p->getPosition();
     return com;
 }

References p.

Referenced by getMassTimesPosition().

◆ getMeanRadius()

Mdouble ParticleHandler::getMeanRadius ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     Mdouble sumRadiusLocal = getSumRadiusLocal();
     unsigned numberOfRealParticlesLocal = getNumberOfRealObjectsLocal();
  
     Mdouble sumRadiusGlobal = 0.0;
     unsigned numberOfRealParticlesGlobal = 0;
  
     //Sum up over all domains
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(sumRadiusLocal, sumRadiusGlobal, MPI_SUM);
     communicator.allReduce(numberOfRealParticlesLocal, numberOfRealParticlesGlobal, MPI_SUM);
  
     return sumRadiusGlobal/numberOfRealParticlesGlobal;
 #else
     return getSumRadiusLocal() / getSize();
 #endif
 }

References getNumberOfRealObjectsLocal(), BaseHandler< BaseParticle >::getSize(), getSumRadiusLocal(), and MPIContainer::Instance().

Referenced by InitialConditions< SpeciesType >::getMeanRelativeContactRadius(), Sintering::getMeanRelativeContactRadius(), regimeForceUnitTest::getMeanRelativeContactRadius(), LaserOnLayer::LaserOnLayer(), GranuDrum::printTime(), Drum::printTime(), RotatingDrumWet::printTime(), RotatingDrumBidisperse::printTime(), regimeForceUnitTest::printTime(), and SingleParticle< SpeciesType >::writeEneTimeStep().

◆ getMomentum()

Vec3D ParticleHandler::getMomentum ( ) const

 {
     Vec3D momentum = {0, 0, 0};
     for (auto p : *this)
         if (!(p->isFixed() || p->isMPIParticle() || p->isPeriodicGhostParticle()))
             momentum += p->getMomentum();
     return getMPISum(momentum);
 }

References getMPISum(), and p.

Referenced by DPMBase::getTotalMomentum(), ParticleBeam::printTime(), and LawinenBox::writeEneTimeStep().

◆ getName()

std::string ParticleHandler::getName ( ) const

overridevirtual

Returns the name of the handler, namely the string "ParticleHandler".

Returns: The string "ParticleHandler".

Implements BaseHandler< BaseParticle >.

 {
     return "ParticleHandler";
 }

◆ getNumberOfFixedObjects()

unsigned int ParticleHandler::getNumberOfFixedObjects ( ) const

Computes the number of fixed particles in the whole simulation.

 {
 #ifdef MERCURYDPM_USE_MPI
     unsigned int numberOfFixedParticlesLocal = getNumberOfFixedObjectsLocal();
     unsigned int numberOfFixedParticles = 0;
  
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(numberOfFixedParticlesLocal, numberOfFixedParticles, MPI_SUM);
     return numberOfFixedParticles;
 #else
     return getNumberOfFixedObjectsLocal();
 #endif
 }

References getNumberOfFixedObjectsLocal(), and MPIContainer::Instance().

Referenced by LawinenBox::setupInitialConditions().

◆ getNumberOfFixedObjectsLocal()

unsigned int ParticleHandler::getNumberOfFixedObjectsLocal ( ) const

Computes the number of Fixed particles on a local domain.

Loops over all particles to check if the particle is fixed or not, in a local domain.

Returns: the number of fixed particles in a local domain

 {
     unsigned int numberOfFixedParticles = 0;
     for (BaseParticle* particle : *this)
     {
         if (particle->isFixed())
         {
             numberOfFixedParticles++;
         }
     }
     return numberOfFixedParticles;
 }

References BaseParticle::isFixed().

Referenced by getNumberOfFixedObjects().

◆ getNumberOfFixedParticles()

unsigned int ParticleHandler::getNumberOfFixedParticles ( ) const

Gets the number of particles that are fixed.

 {
     return NFixedParticles_;
 }

References NFixedParticles_.

◆ getNumberOfObjects()

unsigned int ParticleHandler::getNumberOfObjects ( ) const

overridevirtual

Returns the number of objects in the container. In parallel code this practice is forbidden to avoid confusion with real and fake particles. If the size of the container is wished, call size()

Reimplemented from BaseHandler< BaseParticle >.

 {
 //#ifdef MERCURYDPM_USE_MPI
 //    MPIContainer& communicator = MPIContainer::Instance();
 //    if (communicator.getNumberOfProcessors() > 1)
 //    {
 //        logger(WARN,"When compiling with MPI please do not use getNumberOfObjects(). Instead use: getNumberOfRealObjectsLocal(), getNumberOfRealObjects() or getSize()");
 //    }
 //#endif
     return getSize();
 }

References BaseHandler< BaseParticle >::getSize().

◆ getNumberOfRealObjects()

unsigned int ParticleHandler::getNumberOfRealObjects ( ) const

Returns the number of real objects (on all processors)

 {
 #ifdef MERCURYDPM_USE_MPI
     MPIContainer& communicator = MPIContainer::Instance();
     unsigned int numberOfRealParticles = getNumberOfRealObjectsLocal();
  
     // \todo MX: use an allreduce here
     //Combine the total number of Particles into one number on processor 0
     communicator.reduce(numberOfRealParticles, MPI_SUM);
  
     //Broadcast new number to all the processorsi
     communicator.broadcast(numberOfRealParticles);
     return numberOfRealParticles;
 #else
     return getSize();
 #endif
 }

References MPIContainer::broadcast(), getNumberOfRealObjectsLocal(), BaseHandler< BaseParticle >::getSize(), and MPIContainer::Instance().

Referenced by Membrane::createVertexParticles(), DPMBase::decompose(), getPSD(), and HourGlass2D::setupInitialConditions().

◆ getNumberOfRealObjectsLocal()

unsigned int ParticleHandler::getNumberOfRealObjectsLocal ( ) const

Returns the number of real objects on a local domain. MPI particles and periodic particles are neglected.

Returns: the number of real particles (neglecting MPI and periodic) on a local domain

Todo:: MX: in future also add the periodic mpi particles

 {
 #ifdef MERCURYDPM_USE_MPI
     const MPIContainer& communicator = MPIContainer::Instance();
     if (communicator.getNumberOfProcessors() > 1)
     {
         unsigned int numberOfFakeParticles = 0;
         numberOfFakeParticles += getDPMBase()->domainHandler.getCurrentDomain()->getNumberOfTrueMPIParticles();
         numberOfFakeParticles += getDPMBase()->periodicBoundaryHandler.getNumberOfPeriodicGhostParticles();
         logger.assert_debug(numberOfFakeParticles <= getSize(), "More fake particles than getSize()");
         return (getSize() - numberOfFakeParticles);
     }
     else
     {
         return getSize();
     }
 #else
     return getSize();
 #endif
 }

References DPMBase::domainHandler, DomainHandler::getCurrentDomain(), BaseHandler< BaseParticle >::getDPMBase(), PeriodicBoundaryHandler::getNumberOfPeriodicGhostParticles(), MPIContainer::getNumberOfProcessors(), Domain::getNumberOfTrueMPIParticles(), BaseHandler< BaseParticle >::getSize(), MPIContainer::Instance(), logger, and DPMBase::periodicBoundaryHandler.

Referenced by MaserRepeatedOutInMPI2Test::actionsAfterSolve(), TwoByTwoMPIDomainMPI4Test::actionsAfterTimeStep(), getMeanRadius(), getNumberOfRealObjects(), and DPMBase::outputXBallsData().

◆ getNumberOfUnfixedParticles()

unsigned int ParticleHandler::getNumberOfUnfixedParticles ( ) const

Gets the number of particles that are not fixed.

 {
     return getNumberOfObjects() - NFixedParticles_;
 }

References getNumberOfObjects(), and NFixedParticles_.

◆ getParticleAttribute()

template<typename T >

std::enable_if<std::is_scalar<T>::value, T>::type ParticleHandler::getParticleAttribute	(	std::function< T(BaseParticle *)>	attribute,
		AttributeType	type
	)		const

inline

Computes an attribute type (min/max/..) of a particle attribute(position/velocity) in the global domain.

Many functions the particleHandler return a pointer to a BaseParticle, i.e. the fastest particle, however in parallel this is not useful as pointers can't be send across processes. This function gives the flexibility to find a global particle extremum such as the fastest particle Velocity or lowest particle position.

Parameters

[in]	attribute	A function that obtains a scalar from a particle. i.e. position or radius
[in]	type	An AttributeType tells this function what to do with the attribute, take the maximum or the minimum

Returns: Returns a scalar value representing the AttributeType of the Attribute: In easier terms returns the max/min/... of a particle attribute such as radius

     {
 #ifdef MERCURYDPM_USE_MPI
         T particleAttributeLocal = getParticleAttributeLocal(attribute, type);
         T particleAttributeGlobal;
  
         //Communicate local to global using the approriate rule
         MPIContainer& communicator = MPIContainer::Instance();
         switch(type)
         {
             case AttributeType::MIN :
                 communicator.allReduce(particleAttributeLocal,particleAttributeGlobal,MPI_MIN);
                 break;
             case AttributeType::MAX :
                 communicator.allReduce(particleAttributeLocal,particleAttributeGlobal,MPI_MAX);
                 break;
             default :
                 logger(ERROR,"Attribute type is not recognised");
                 break;
         }
         return particleAttributeGlobal;
 #else
         return getParticleAttributeLocal(attribute, type);
 #endif
     }

References calibrate::default, ERROR, getParticleAttributeLocal(), MPIContainer::Instance(), logger, MAX, MIN, and compute_granudrum_aor::type.

◆ getParticleAttributeLocal()

template<typename T >

std::enable_if<std::is_scalar<T>::value, T>::type ParticleHandler::getParticleAttributeLocal	(	std::function< T(BaseParticle *)>	attribute,
		AttributeType	type
	)		const

inline

Computes an attribute type (min/max/..) of a particle attribute (position/velocity) in a local domain.

Computes an attribute type (min/max/..) of a particle attribute (position/velocity) in a local domain

Many functions the particleHandler return a pointer to a BaseParticle, i.e. the fastest particle, however in parallel this is not useful as pointers can't be send across processes. This function gives the flexibility to find a global particle extremum such as the fastest particle Velocity or lowest particle position.

Parameters

[in]	attribute	A function that obtains a scalar from a particle. i.e. position or radius
[in]	type	An AttributeType tells this function what to do with the attribute, take the maximum or the minimum

Returns: Returns a scalar value representing the AttributeType of the Attribute: In easier terms returns the max/min/... of a particle attribute such as radius

     {
         T attributeParticle;
         T attributeFinal;
         
         if ((*this).getSize() == 0)
         {
             logger(WARN, "ParticleHandler is empty: returning 0.0");
             attributeFinal = 0;
             return 0.0;
         }
         else
         {
             //Initialise with the first particle found
             attributeParticle = attribute(objects_[0]);
             attributeFinal = attributeParticle;
             
             //Find the final attribute
             for (BaseParticle* particle : (*this))
             {
                 //Obtain the attribute
                 if (!(particle->isMPIParticle() || particle->isPeriodicGhostParticle() || particle->isFixed()))
                 {
                     attributeParticle = attribute(particle);
                 }
                 
                 //Decide what to do with the magnitude of the attribute
                 switch (type)
                 {
                     case AttributeType::MIN :
                         if (attributeParticle < attributeFinal)
                         {
                             attributeFinal = attributeParticle;
                         }
                         break;
                     case AttributeType::MAX :
                         if (attributeParticle > attributeFinal)
                         {
                             attributeFinal = attributeParticle;
                         }
                         break;
                     default :
                         logger(ERROR, "Attribute type is not recognised");
                         break;
                 }
             }
             return attributeFinal;
         }
     }

References calibrate::default, ERROR, logger, MAX, MIN, BaseHandler< BaseParticle >::objects_, compute_granudrum_aor::type, and WARN.

Referenced by getParticleAttribute().

◆ getPSD()

PSD ParticleHandler::getPSD	(	std::vector< Mdouble >	bins = `{}`,
		Mdouble	scaleFactor = `1.0`
	)		const

Gets the PSD from the particles currently in the handler.

When no bins are provided, they will be created linearly between the smallest and largest particle radius in the handler. When bins are provided and don't include the smallest/largest particle size currently in the handler, they will be added. For the largest particle size this is a necessity, otherwise there is no way to account for larger particles. For the smallest particle size this isn't strictly necessary, however it is preferred to have the PSD start with zero probability.

Parameters

bins	Optionally, the bins of interest.
scaleFactor	Optionally, value to scale the bins by, to convert them to radii. E.g. 0.5 when diameters are provided.

Returns

 {
     // check that there is at least one particle in the handler
     if (getNumberOfObjects()==0) {
         logger(WARN, "getPSD: Empty PSD is returned, as particleHandler is empty.");
         return PSD();
     }
  
     // check that the bins vector is set
 #ifdef MERCURYDPM_USE_MPI
     double rMin = getSmallestInteractionRadius();
     double rMax = getLargestInteractionRadius();
 #else
     double rMin = getSmallestParticle()->getRadius();
     double rMax = getLargestParticle()->getRadius();
 #endif
     if (bins.empty()) {
         // Number of bins needed with average of 20 particles in each bin.
         int n = (int)std::ceil(getNumberOfObjects()/20);
         // Limit number of bins to a certain maximum and minimum.
         n = std::min(100, n);
         n = std::max(5, n);
         bins.reserve(n);
         double dr = (rMax-rMin)/(n-1);
         for (int i = 0; i<n-1; i++) {
             bins.push_back(rMin + i * dr);
         }
     } else {
         // make sure values are in increasing order
         std::sort(bins.begin(), bins.end());
         // and convert to radius
         for (auto& b : bins) {
             b *= scaleFactor;
         }
     }
  
     // set the first/last bin to include the smallest/largest particle (first bin to make PSD start with zero probability)
     if (bins.front() > rMin) {
         bins.insert(bins.begin(), rMin);
     }
     if (bins.back() < rMax) {
         bins.push_back(rMax);
     }
  
     // PSD vector, all probabilities initialised to 0
     std::vector<DistributionElements> des;
     des.reserve(bins.size());
     for (const Mdouble bin : bins) {
         des.push_back({ bin, 0.0 });
     }
  
     // calculate the probabilities
     for (const auto& p : *this) {
         if (p->isFixed() || p->isMPIParticle() || p->isPeriodicGhostParticle()) {
             continue;
         }
         // the first "bin"/radius is skipped, since the probabilities for each bin are assigned to its upper radius
         // i.e. the PSD should start with zero probability
         for (auto bin = des.begin() + 1; bin != des.end(); bin++) {
             if (p->getRadius() <= bin->internalVariable) {
                 bin->probability += 1.0 / getNumberOfRealObjects();
                 break;
             }
         }
     }
  
     // create and return PSD
     PSD psd;
     psd.setPSDFromVector(des, PSD::TYPE::PROBABILITYDENSITY_NUMBER_DISTRIBUTION);
     return psd;
 }

References b, UniformPSDSelfTest::bins, Eigen::bfloat16_impl::ceil(), getLargestInteractionRadius(), getLargestParticle(), getNumberOfObjects(), getNumberOfRealObjects(), BaseParticle::getRadius(), getSmallestInteractionRadius(), getSmallestParticle(), i, int(), logger, max, min, n, p, PSD::PROBABILITYDENSITY_NUMBER_DISTRIBUTION, PSD::setPSDFromVector(), and WARN.

Referenced by saveNumberPSDtoCSV().

◆ getRotationalEnergy()

Mdouble ParticleHandler::getRotationalEnergy ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     Mdouble rotationalEnergyLocal = getRotationalEnergyLocal();
     Mdouble rotationalEnergyGlobal = 0.0;
  
     //sum up over all domains
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(rotationalEnergyLocal, rotationalEnergyGlobal, MPI_SUM);
  
     return rotationalEnergyGlobal;
 #else
     return getRotationalEnergyLocal();
 #endif
 }

References getRotationalEnergyLocal(), and MPIContainer::Instance().

Referenced by DPMBase::writeEneTimeStep(), and LawinenBox::writeEneTimeStep().

◆ getRotationalEnergyLocal()

Mdouble ParticleHandler::getRotationalEnergyLocal ( ) const

private

 {
     Mdouble ene = 0;
     for (auto p : *this)
     {
         if (!(p->isMPIParticle() || p->isPeriodicGhostParticle()))
         {
             ene += p->getRotationalEnergy();
         }
     }
     return ene;
 }

References p.

Referenced by getRotationalEnergy().

◆ getSmallestInteractionRadius()

Mdouble ParticleHandler::getSmallestInteractionRadius ( ) const

Returns the smallest interaction radius.

 {
 #ifdef MERCURYDPM_USE_MPI
     //Compute the local value
     Mdouble smallestInteractionRadiusLocal = getSmallestInteractionRadiusLocal();
     Mdouble smallestInteractionRadiusGlobal = 0.0;
  
     //Obtain the global value
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(smallestInteractionRadiusLocal, smallestInteractionRadiusGlobal, MPI_MIN);
  
     return smallestInteractionRadiusGlobal;
  
 #else
     return getSmallestInteractionRadiusLocal();
 #endif
 }

References getSmallestInteractionRadiusLocal(), and MPIContainer::Instance().

Referenced by Contact::actionsAfterSolve(), getPSD(), and main().

◆ getSmallestInteractionRadiusLocal()

Mdouble ParticleHandler::getSmallestInteractionRadiusLocal ( ) const

Returns the smallest interaction radius of the current domain.

 {
     if (!(getSmallestParticleLocal() == nullptr))
     {
         return getSmallestParticleLocal()->getMaxInteractionRadius();
     }
     else
     {
         return 0.0;
     }
 }

References BaseParticle::getMaxInteractionRadius(), and getSmallestParticleLocal().

Referenced by MercuryBase::getHGridTargetMinInteractionRadius(), and getSmallestInteractionRadius().

◆ getSmallestParticle()

BaseParticle * ParticleHandler::getSmallestParticle ( ) const

Gets a pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler of the local domain. When mercury is running in parallel this function throws an error since a pointer to another domain is useless.

Returns: A pointer to the to the smallest BaseParticle (by interactionRadius) in this ParticleHandler.

 {
 #ifdef MERCURYDPM_USE_MPI
     logger(WARN,"getSmallestParticle should not be used in parallel; use getSmallestInteractionRadius or "
              "ParticleSpecies::getSmallestParticleMass instead");
     return nullptr;
 #else
     return getSmallestParticleLocal();
 #endif
 }

References getSmallestParticleLocal(), logger, and WARN.

Referenced by RotatingDrumBidisperseInitialise::actionsAfterTimeStep(), getPSD(), and CFDDEMCoupleTest::setupInitialConditions().

◆ getSmallestParticleLocal()

BaseParticle * ParticleHandler::getSmallestParticleLocal ( ) const

Gets a pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler of the local domain.

Returns: A pointer to the to the smallest BaseParticle (by interactionRadius) in this ParticleHandler.

 {
     return smallestParticle_;
 }

References smallestParticle_.

Referenced by getSmallestInteractionRadiusLocal(), getSmallestParticle(), RotatingDrum::setupInitialConditions(), and DPMBase::writeFstatHeader().

◆ getSumRadiusLocal()

Mdouble ParticleHandler::getSumRadiusLocal ( ) const

private

Returns: The sum of all particle radii

 {
     Mdouble sumRadius = 0;
     for (BaseParticle* const p : objects_)
     {
         if (!(p->isMPIParticle() || p->isPeriodicGhostParticle()))
         {
             sumRadius += p->getRadius();
         }
     }
     return sumRadius;
 }

References BaseHandler< BaseParticle >::objects_, and p.

Referenced by getMeanRadius().

◆ getVolume()

Mdouble ParticleHandler::getVolume ( ) const

 {
 #ifdef MERCURYDPM_USE_MPI
     Mdouble volumeLocal = getVolumeLocal();
     Mdouble volumeGlobal = 0.0;
  
     // sum up over all domains
     MPIContainer& communicator = MPIContainer::Instance();
     communicator.allReduce(volumeLocal, volumeGlobal, MPI_SUM);
  
     return volumeGlobal;
 #else
     return getVolumeLocal();
 #endif
 }

References getVolumeLocal(), and MPIContainer::Instance().

Referenced by PSDManualInsertionSelfTest::actionsAfterSolve(), ShearStage::actionsAfterTimeStep(), LeesEdwardsDemo::actionsAfterTimeStep(), ShiftingConstantMassFlowMaserBoundarySelfTest::actionsAfterTimeStep(), ShiftingMaserBoundarySelfTest::actionsAfterTimeStep(), TimeDependentPeriodicBoundary3DSelfTest::actionsAfterTimeStep(), TimeDependentPeriodicBoundaryTest::actionsAfterTimeStep(), FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and GranuHeap::GranuHeap().

◆ getVolumeLocal()

Mdouble ParticleHandler::getVolumeLocal ( ) const

private

 {
     Mdouble volume = 0;
     for (auto p : *this)
     {
         if (!(p->isFixed() || p->isPeriodicGhostParticle() || p->isMPIParticle()))
             volume += p->getVolume();
     }
     return volume;
 }

References p.

Referenced by getVolume().

◆ operator=()

ParticleHandler & ParticleHandler::operator= ( const ParticleHandler & rhs )

Assignment operator.

Parameters

[in] rhs The ParticleHandler on the right hand side of the assignment.

This is not a copy assignment operator! It copies the DPMBase and all BaseParticle, and sets the other variables to 0. After that, it computes the smallest and largest particle in this handler.

 {
     if (this != &rhs)
     {
         clear();
         largestParticle_ = nullptr;
         smallestParticle_ = nullptr;
         copyContentsFromOtherHandler(rhs);
         if (!objects_.empty())
         {
             computeLargestParticle();
             computeSmallestParticle();
         }
     }
     logger(DEBUG, "ParticleHandler::operator = (const ParticleHandler& rhs) finished");
     return *this;
 }

References clear(), computeLargestParticle(), computeSmallestParticle(), BaseHandler< BaseParticle >::copyContentsFromOtherHandler(), DEBUG, largestParticle_, logger, BaseHandler< BaseParticle >::objects_, and smallestParticle_.

◆ readAndAddObject()

void ParticleHandler::readAndAddObject ( std::istream & is )

overridevirtual

     \brief Create a new particle, based on the information from old-style restart data.
    &zwj;/

void readAndCreateOldObject(std::istream &is, const std::string& type);

/*!
   \brief Create a new particle in the WallHandler, based on the information provided in a restart file.

Parameters

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

Implements BaseHandler< BaseParticle >.

 {
     BaseParticle* o = readAndCreateObject(is);
     addExistingObject(o);
 }

References addExistingObject(), and readAndCreateObject().

Referenced by DPMBase::read().

◆ readAndCreateObject()

BaseParticle * ParticleHandler::readAndCreateObject ( std::istream & is )

Create a new particle, based on the information provided in a restart file.

Parameters

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

Todo:: check what is special about this case

 {
     std::string type;
     BaseParticle* particle = nullptr;
     if (getNumberOfObjects()>0) logger(DEBUG,"size % % %",getNumberOfObjects(),getLastObject()->getVelocity(),getLastObject()->getRadius());
     if (getStorageCapacity() > 0)
     {
         is >> type;
         logger(DEBUG, "ParticleHandler::readAndCreateObject(is): type %", type);
         particle = createObject(type);
         particle->setHandler(this);
         particle->read(is);
     }
     else //for insertion boundaries
     {
         is >> type;
         logger(DEBUG, "ParticleHandler::readAndCreateObject(is): type %", type);
         particle = createObject(type);
         particle->setHandler(this);
         particle->read(is);
     }
     particle->setSpecies(getDPMBase()->speciesHandler.getObject(particle->getIndSpecies()));
     return particle;
 }

References createObject(), DEBUG, BaseHandler< BaseParticle >::getDPMBase(), BaseInteractable::getIndSpecies(), BaseHandler< BaseParticle >::getLastObject(), getNumberOfObjects(), BaseHandler< BaseParticle >::getStorageCapacity(), logger, BaseParticle::read(), BaseParticle::setHandler(), BaseParticle::setSpecies(), oomph::Global_string_for_annotation::string(), and compute_granudrum_aor::type.

Referenced by InsertionBoundary::read(), and readAndAddObject().

◆ removedFixedParticle()

void ParticleHandler::removedFixedParticle ( )

Decrement of the number of fixed particles.

Todo:: MX: For Jonny, is this still required, keeping the parallel code in mind?

 {
     NFixedParticles_--;
 }

References NFixedParticles_.

Referenced by BaseParticle::unfix(), and BaseParticle::~BaseParticle().

◆ removeGhostObject()

void ParticleHandler::removeGhostObject ( unsigned int index )

Removes a BaseParticle from the ParticleHandler without a global check, this is only to be done for mpi routines.

Parameters

[in] index The index of which BaseParticle has to be removed from this ParticleHandler.

The BaseParticle with index is removed and the last BaseParticle in the vector is moved to its position. It also removes the BaseParticle from the HGrid. This function is only called by the parallel routines where we are sure the particles have been flushed out of the communication boundaries.

 {
 #ifdef MERCURYDPM_USE_MPI
 #ifdef CONTACT_LIST_HGRID
     getDPMBase()->getPossibleContactList().remove_ParticlePosibleContacts(getObject(id));
 #endif
     getDPMBase()->hGridRemoveParticle(getObject(index));
     // broadcast the particle removal
     getDPMBase()->handleParticleRemoval(getObject(index)->getId());
     BaseHandler<BaseParticle>::removeObject(index);
 #else
     logger(ERROR, "This function should only be used interally for mpi routines");
 #endif
 }

References ERROR, BaseHandler< BaseParticle >::getDPMBase(), BaseHandler< BaseParticle >::getObject(), DPMBase::handleParticleRemoval(), DPMBase::hGridRemoveParticle(), logger, and BaseHandler< T >::removeObject().

Referenced by DeletionBoundary::checkBoundaryAfterParticleMoved(), DPMBase::checkInteractionWithBoundaries(), PeriodicBoundaryHandler::clearCommunicationLists(), and DPMBase::deleteGhostParticles().

◆ removeLastObject()

void ParticleHandler::removeLastObject ( )

Removes the last BaseParticle from the ParticleHandler.

Function that removes the last object from this ParticleHandler. It also removes the particle from the HGrid.

 {
 #ifdef CONTACT_LIST_HGRID
     getDPMBase()->getPossibleContactList().remove_ParticlePosibleContacts(getLastObject());
 #endif
     getDPMBase()->hGridRemoveParticle(getLastObject());
     getDPMBase()->handleParticleRemoval(getLastObject()->getId());
     BaseHandler<BaseParticle>::removeLastObject();
 }

References BaseHandler< BaseParticle >::getDPMBase(), BaseHandler< BaseParticle >::getLastObject(), DPMBase::handleParticleRemoval(), DPMBase::hGridRemoveParticle(), and BaseHandler< T >::removeLastObject().

Referenced by Penetration::setupInitialConditions().

◆ removeObject()

void ParticleHandler::removeObject ( unsigned int index )

overridevirtual

Removes a BaseParticle from the ParticleHandler.

Parameters

[in] index The index of which BaseParticle has to be removed from this ParticleHandler.

The BaseParticle with index is removed and the last BaseParticle in the vector is moved to its position. It also removes the BaseParticle from the HGrid. When running this in parallel a warning is thrown that deleting particles might cause havoc in the communication between boundaries, as the deleted particle might still be in one of the boundary lists

Reimplemented from BaseHandler< BaseParticle >.

 {
 #ifdef MERCURYDPM_USE_MPI
     MPIContainer& communicator = MPIContainer::Instance();
     if (communicator.getNumberOfProcessors() > 1 )
     {
         logger(WARN, "[ParticleHandler::removeObject(const unsigned int)] Using the function removeObject in parallel could lead to out-of-sync communication, Instead use deletion boundaries");
     }
 #endif
 #ifdef CONTACT_LIST_HGRID
     getDPMBase()->getPossibleContactList().remove_ParticlePosibleContacts(getObject(id));
 #endif
     getDPMBase()->hGridRemoveParticle(getObject(index));
     // broadcast the particle removal
     getDPMBase()->handleParticleRemoval(getObject(index)->getId());
     BaseHandler<BaseParticle>::removeObject(index);
 }

References BaseHandler< BaseParticle >::getDPMBase(), MPIContainer::getNumberOfProcessors(), BaseHandler< BaseParticle >::getObject(), DPMBase::handleParticleRemoval(), DPMBase::hGridRemoveParticle(), MPIContainer::Instance(), logger, BaseHandler< T >::removeObject(), and WARN.

Referenced by AngleOfRepose::actionsBeforeTimeStep(), PeriodicWallsWithSlidingFrictionUnitTest::actionsBeforeTimeStep(), SilbertPeriodic::add_flow_particles(), CircularPeriodicBoundary::checkBoundaryAfterParticleMoved(), ConstantMassFlowMaserBoundary::checkBoundaryAfterParticleMoved(), DeletionBoundary::checkBoundaryAfterParticleMoved(), ChuteWithContraction::ChuteWithContraction(), ChuteWithPeriodicInflowAndContraction::ChuteWithPeriodicInflowAndContraction(), ChuteWithPeriodicInflow::cleanChute(), ChuteWithContraction::cleanChute(), Funnel::cleanChute(), Chute::cleanChute(), ContactDetectionTester::cleanup(), ContractionWithPeriodicInflow::ContractionWithPeriodicInflow(), ChuteBottom::makeRoughBottom(), CurvyChute::recreateBottom(), DPMBase::removeDuplicatePeriodicParticles(), CSCWalls::saveWalls(), and AngleOfRepose::setupInitialConditions().

◆ saveNumberPSDtoCSV()

void ParticleHandler::saveNumberPSDtoCSV	(	std::string	csvFileName,
		std::vector< double >	diameterBins = `{}`
	)		const

Writes the PSD of the particles currently in the handler to a CSV file, with type PROBABILITYDENSITY_NUMBER_DISTRIBUTION.

Parameters

csvFileName	The filename to write to.
diameterBins	Optionally, the bins of interest.

 {
     // get the PSD, with scale factor 0.5 to scale diameter to radius
     PSD psd = getPSD(diameterBins, 0.5);
     // get the PSD vector by the required type, with scale factor 2 to scale radius to diameter
     std::vector<DistributionElements> psdVector = psd.getParticleSizeDistributionByType(PSD::TYPE::PROBABILITYDENSITY_NUMBER_DISTRIBUTION, 2.0);
  
     logger(INFO,"Writing PSD to %",csvFileName);
     std::ofstream csv(csvFileName);
     logger.assert_always(csv.is_open(),"File % could not be opened",csvFileName);
     csv << "Diameter" << ',' << "Probability Number Distribution" << '\n';
     for (const auto& bin : psdVector) {
         csv << bin.internalVariable << ',' << bin.probability << '\n';
     }
     csv.close();
 }

References PSD::getParticleSizeDistributionByType(), getPSD(), INFO, logger, and PSD::PROBABILITYDENSITY_NUMBER_DISTRIBUTION.

Referenced by main().

◆ write()

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

Referenced by EllipsoidsBouncingOnWallDemo::actionsAfterSolve(), EllipticalSuperQuadricCollision::actionsAfterSolve(), SphericalSuperQuadricCollision::actionsAfterSolve(), VisualisationTest::actionsAfterSolve(), and DPMBase::write().

Member Data Documentation

◆ largestParticle_

BaseParticle* ParticleHandler::largestParticle_

private

A pointer to the largest BaseParticle (by interactionRadius) in this ParticleHandler.

Todo:: TW: note that checkExtrema gets called if a particle gets created and its Species and Radius gets set, even if it's not yet included in the particleHandler! This is necessary to check a not included particle for overlaps before inserting it into the handler. Not sure if this is a sensible structure; to be discussed. Note: these statistic now include mpi and ghost particles as well

Referenced by checkExtrema(), checkExtremaOnDelete(), clear(), computeLargestParticle(), getLargestParticleLocal(), operator=(), ParticleHandler(), and ~ParticleHandler().

◆ NFixedParticles_

unsigned int ParticleHandler::NFixedParticles_

private

Number of fixed particles.

Referenced by addedFixedParticle(), getNumberOfFixedParticles(), getNumberOfUnfixedParticles(), and removedFixedParticle().

◆ smallestParticle_

BaseParticle* ParticleHandler::smallestParticle_

private

A pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler.

Referenced by checkExtrema(), checkExtremaOnDelete(), clear(), computeSmallestParticle(), getSmallestParticleLocal(), operator=(), ParticleHandler(), and ~ParticleHandler().

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ParticleHandler() [1/2]

◆ ParticleHandler() [2/2]

◆ ~ParticleHandler()

Member Function Documentation

◆ actionsAfterTimeStep()

◆ actionsBeforeTimeStep()

◆ addedFixedParticle()

◆ addExistingObject()

◆ addGhostObject() [1/2]

◆ addGhostObject() [2/2]

◆ addObject() [1/2]

◆ addObject() [2/2]

◆ checkExtrema()

◆ checkExtremaOnDelete()

◆ clear()

◆ computeAllMasses() [1/2]

◆ computeAllMasses() [2/2]

◆ computeLargestParticle()

◆ computeSmallestParticle()

◆ createObject()

◆ getAngularMomentum()

◆ getCentreOfMass()

◆ getFastestParticle()

◆ getFastestParticleLocal()

◆ getHighestPositionComponentParticle()

◆ getHighestPositionComponentParticleLocal()

◆ getHighestPositionX()

◆ getHighestVelocityComponentParticle()

◆ getHighestVelocityComponentParticleLocal()

◆ getKineticEnergy()

◆ getKineticEnergyLocal()

◆ getLargestInteractionRadius()

◆ getLargestInteractionRadiusLocal()

◆ getLargestParticle()

◆ getLargestParticleLocal()

◆ getLiquidFilmVolume()

◆ getLowestPositionComponentParticle()

◆ getLowestPositionComponentParticleLocal()

◆ getLowestVelocityComponentParticle()

◆ getLowestVelocityComponentParticleLocal()

◆ getMass()

◆ getMassLocal()

◆ getMassTimesPosition()

◆ getMassTimesPositionLocal()

◆ getMeanRadius()

◆ getMomentum()

◆ getName()

◆ getNumberOfFixedObjects()

◆ getNumberOfFixedObjectsLocal()

◆ getNumberOfFixedParticles()

◆ getNumberOfObjects()

◆ getNumberOfRealObjects()

◆ getNumberOfRealObjectsLocal()

◆ getNumberOfUnfixedParticles()

◆ getParticleAttribute()

◆ getParticleAttributeLocal()

◆ getPSD()

◆ getRotationalEnergy()

◆ getRotationalEnergyLocal()

◆ getSmallestInteractionRadius()

◆ getSmallestInteractionRadiusLocal()

◆ getSmallestParticle()

◆ getSmallestParticleLocal()

◆ getSumRadiusLocal()

◆ getVolume()

◆ getVolumeLocal()

◆ operator=()

◆ readAndAddObject()

◆ readAndCreateObject()

◆ removedFixedParticle()

◆ removeGhostObject()

◆ removeLastObject()

◆ removeObject()