Container to store all BaseParticle. 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 ()
	Destructor, it destructs the ParticleHandler and all BaseParticle it contains. More...

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

virtual void	removeObject (unsigned const int id)
	Removes a BaseParticle from the ParticleHandler. 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 *	getSmallestParticle () const
	Gets a pointer to the smallest BaseParticle (by interactionRadius) in this ParticleHandler. More...

BaseParticle *	getLargestParticle () const
	Gets a pointer to the largest BaseParticle (by interactionRadius) in this ParticleHandler. More...

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

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

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

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

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

BaseParticle *	getLightestParticle () const
	Gets a pointer to the lightest BaseParticle (by mass) in this ParticleHandler. More...

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

void	readObject (std::istream &is)
	Reads BaseParticle into the ParticleHandler from restart data. More...

void	readOldObject (std::string type, std::istream &is)
	Reads BaseParticle into the ParticleHandler from old-style restart data. More...

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

std::string	getName () const
	Returns the name of the handler, namely the string "ParticleHandler". 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...

U *	copyAndAddObject (const U &O)
	Creates a copy of a Object and adds it to the BaseHandler. More...

U *	copyAndAddObject (U *O)
	Creates a copy of a Object and adds it to the BaseHandler. More...

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

void	clear ()
	Empties the whole BaseHandler by removing all Objects and setting all other variables to 0. 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...

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	getNumberOfObjects () const
	Gets the number of Object in this BaseHandler. 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...

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

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

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

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

The ParticleHandler is a container to store all BaseParticle. It is implemented by a vector of pointers to BaseParticle.

Definition at line 41 of file ParticleHandler.h.

Constructor & Destructor Documentation

ParticleHandler::ParticleHandler ( )

Default constructor, it creates an empty ParticleHandler.

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

Definition at line 39 of file ParticleHandler.cc.

References DEBUG, largestParticle_, logger, and smallestParticle_.

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

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.

Definition at line 52 of file ParticleHandler.cc.

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

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

ParticleHandler::~ParticleHandler ( )

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.

Definition at line 96 of file ParticleHandler.cc.

References DEBUG, largestParticle_, logger, and smallestParticle_.

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

Member Function Documentation

void ParticleHandler::addObject ( BaseParticle * P )

virtual

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.

Reimplemented from BaseHandler< BaseParticle >.

Definition at line 117 of file ParticleHandler.cc.

References BaseHandler< T >::addObject(), checkExtrema(), ParticleSpecies::computeMass(), BaseHandler< BaseParticle >::getDPMBase(), BaseInteractable::getSpecies(), DPMBase::hGridInsertParticle(), DPMBase::hGridUpdateParticle(), and BaseParticle::setHandler().

Referenced by CircularPeriodicBoundary::checkBoundaryAfterParticleMoved(), LeesEdwardsBoundary::createHorizontalPeriodicParticles(), CircularPeriodicBoundary::createPeriodicParticles(), MaserBoundary::createPeriodicParticles(), AngledPeriodicBoundary::createPeriodicParticles(), PeriodicBoundary::createPeriodicParticles(), and LeesEdwardsBoundary::createVerticalPeriodicParticles().

 {
     //\todo I diasbled the MERCURY_DEPRECATED attribute until we actually fixed the deprecation issue. This will scare users away.
     // 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>::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);
     }
     //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);
 }

void ParticleHandler::checkExtrema ( BaseParticle * P )

Checks if the extrema of this ParticleHandler needs updating.

Parameters

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

Definition at line 488 of file ParticleHandler.cc.

References computeLargestParticle(), computeSmallestParticle(), BaseParticle::getInteractionRadius(), largestParticle_, and smallestParticle_.

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

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

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.

Definition at line 514 of file ParticleHandler.cc.

References computeLargestParticle(), computeSmallestParticle(), largestParticle_, and smallestParticle_.

Referenced by BaseParticle::~BaseParticle().

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

void ParticleHandler::clear ( )

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.

Definition at line 389 of file ParticleHandler.cc.

References BaseHandler< T >::clear(), largestParticle_, and smallestParticle_.

Referenced by operator=(), ParticleHandler(), and DPMBase::read().

 {
     smallestParticle_ = nullptr;
     largestParticle_ = nullptr;
     BaseHandler<BaseParticle>::clear();
 }

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.

Definition at line 530 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::objects_.

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

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

void ParticleHandler::computeAllMasses ( )

Computes the mass for all BaseParticle in this ParticleHandler.

Definition at line 541 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::objects_.

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

void ParticleHandler::computeLargestParticle ( )

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

Definition at line 192 of file ParticleHandler.cc.

References BaseParticle::getInteractionRadius(), BaseHandler< BaseParticle >::getNumberOfObjects(), largestParticle_, logger, BaseHandler< BaseParticle >::objects_, and WARN.

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

 {
     if (getNumberOfObjects() == 0)
     {
         logger(WARN, "No particles, so cannot compute the largest particle.");
         return;
     }
     Mdouble max = -std::numeric_limits<Mdouble>::max();
     largestParticle_ = nullptr;
     for (BaseParticle* const particle : objects_)
     {
         if (particle->getInteractionRadius() > max)
         {
             max = particle->getInteractionRadius();
             largestParticle_ = particle;
         }
     }
 }

void ParticleHandler::computeSmallestParticle ( )

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

Definition at line 173 of file ParticleHandler.cc.

References BaseParticle::getInteractionRadius(), BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, smallestParticle_, and WARN.

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

 {
     if (getNumberOfObjects() == 0)
     {
         logger(WARN, "No particles, so cannot compute the smallest particle.");
         return;
     }
     Mdouble min = std::numeric_limits<Mdouble>::max();
     smallestParticle_ = nullptr;
     for (BaseParticle* const particle : objects_)
     {
         if (particle->getInteractionRadius() < min)
         {
             min = particle->getInteractionRadius();
             smallestParticle_ = particle;
         }
     }
 }

BaseParticle * ParticleHandler::getFastestParticle ( ) const

Gets a pointer to the fastest BaseParticle in this ParticleHandler.

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

Definition at line 240 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, and WARN.

 {
     if (getNumberOfObjects() == 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->getVelocity().getLength()) > maxSpeed)
         {
             maxSpeed = pLoop->getVelocity().getLength();
             p = pLoop;
         }
     }
     return p;
 }

BaseParticle * ParticleHandler::getHighestPositionComponentParticle ( const 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.

Definition at line 290 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, and WARN.

 {
     if (getNumberOfObjects() == 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->getPosition().getComponent(i) > max)
         {
             max = pLoop->getPosition().getComponent(i);
             p = pLoop;
         }
     }
     
     return p;
 }

BaseParticle * ParticleHandler::getHighestVelocityComponentParticle ( const 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.

Definition at line 341 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, and WARN.

 {
     if (!getNumberOfObjects())
     {
         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->getVelocity().getComponent(i) > max)
         {
             max = pLoop->getVelocity().getComponent(i);
             p = pLoop;
         }
     }
     return p;
 }

BaseParticle * ParticleHandler::getLargestParticle ( ) const

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

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

Definition at line 228 of file ParticleHandler.cc.

References largestParticle_, logger, and WARN.

Referenced by LeesEdwardsBoundary::createHorizontalPeriodicParticles(), CircularPeriodicBoundary::createPeriodicParticles(), MaserBoundary::createPeriodicParticles(), AngledPeriodicBoundary::createPeriodicParticles(), PeriodicBoundary::createPeriodicParticles(), LeesEdwardsBoundary::createVerticalPeriodicParticles(), MercuryBase::getHGridTargetMaxInteractionRadius(), MercuryBase::hGridNeedsRebuilding(), HGridOptimiser::initialise(), and DPMBase::writeFstatHeader().

 {
     if (largestParticle_ == nullptr)
     {
         logger(WARN, "No particles to set get_LargestParticle()");
     }
     return largestParticle_;
 }

BaseParticle * ParticleHandler::getLightestParticle ( ) const

Gets a pointer to the lightest BaseParticle (by mass) in this ParticleHandler.

Returns: A pointer to the to the lightest BaseParticle (by mass) in this ParticleHandler.

Definition at line 364 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, and WARN.

 {
     if (getNumberOfObjects() == 0)
     {
         logger(WARN, "No particles to set getLightestParticle()");
         return nullptr;
     }
     BaseParticle* p = nullptr;
     Mdouble minMass = std::numeric_limits<Mdouble>::max();
     for (BaseParticle* const pLoop : objects_)
     {
         if (pLoop->getMass() < minMass)
         {
             minMass = pLoop->getMass();
             p = pLoop;
         }
     }
     return p;
 }

BaseParticle * ParticleHandler::getLowestPositionComponentParticle ( const 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.

Definition at line 265 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, and WARN.

 {
     if (getNumberOfObjects() == 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->getPosition().getComponent(i) < min)
         {
             min = pLoop->getPosition().getComponent(i);
             p = pLoop;
         }
     }
     return p;
 }

BaseParticle * ParticleHandler::getLowestVelocityComponentParticle ( const 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.

Definition at line 316 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects(), logger, BaseHandler< BaseParticle >::objects_, and WARN.

 {
     if (getNumberOfObjects() == 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->getVelocity().getComponent(i) < min)
         {
             min = pLoop->getVelocity().getComponent(i);
             p = pLoop;
         }
     }
     return p;
 }

std::string ParticleHandler::getName ( ) const

virtual

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

Returns: The string "ParticleHandler".

Implements BaseHandler< BaseParticle >.

Definition at line 552 of file ParticleHandler.cc.

 {
     return "ParticleHandler";
 }

BaseParticle * ParticleHandler::getSmallestParticle ( ) const

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

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

Definition at line 215 of file ParticleHandler.cc.

References logger, smallestParticle_, and WARN.

Referenced by MercuryBase::getHGridTargetMinInteractionRadius(), HGridOptimiser::initialise(), and DPMBase::writeFstatHeader().

 {
     if (smallestParticle_ == nullptr)
     {
         logger(WARN, "No particles to return in getSmallestParticle()");
     }
     return smallestParticle_;
 }

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.

Definition at line 74 of file ParticleHandler.cc.

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

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

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

virtual

Reads BaseParticle into the ParticleHandler from restart data.

Parameters

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

Todo:: make sure setting the id doesn't break the id setter :)

Todo:: {Remove for final version}

Implements BaseHandler< BaseParticle >.

Definition at line 399 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::copyAndAddObject(), ERROR, BaseObject::getId(), BaseHandler< BaseParticle >::getLastObject(), logger, BaseParticle::oldRead(), readOldObject(), and BaseObject::setId().

Referenced by DPMBase::read().

 {
     std::string type;
     is >> type;
     if (type == "BaseParticle")
     {
         BaseParticle baseParticle;
         is >> baseParticle;
         copyAndAddObject(baseParticle);
         getLastObject()->setId(baseParticle.getId()); //to ensure old id
     }
     else if (type == "BP")
     {
         BaseParticle baseParticle;
         baseParticle.oldRead(is);
         copyAndAddObject(baseParticle);
         getLastObject()->setId(baseParticle.getId()); //to ensure old id
     }
     else if (isdigit(type[0]))
     {
         readOldObject(type, is);
     }
     else
     {
         logger(ERROR, "Particle type % not understood in restart file. Particle has not been read.", type);
         return;
     }
 }

void ParticleHandler::readOldObject	(	std::string	type,
		std::istream &	is
	)

Reads BaseParticle into the ParticleHandler from old-style restart data.

Parameters

[in]	type	The first value of the position.
[in]	is	The input stream from which the information is read.

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.

Definition at line 439 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::copyAndAddObject(), helpers::getLineFromStringStream(), logger, VERBOSE, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by readObject().

 {
     //read in next line
     std::stringstream line(std::stringstream::in | std::stringstream::out);
     helpers::getLineFromStringStream(is, line);
     logger(VERBOSE, line.str());
     //std::cout << line.str() << std::endl;
 
     BaseParticle particle;
     
     //Declare all properties of the particle
     unsigned int indSpecies;
     Mdouble radius, inverseMass, inverseInertia;
     Vec3D position, velocity, orientation, angularVelocity;
     
     //Read all values
     position.X = atof(type.c_str());
 
     line >> position.Y >> position.Z >> velocity >> radius >> orientation >> angularVelocity >> inverseMass >> inverseInertia >> indSpecies;
     
     //Put the values in the particle    
     particle.setIndSpecies(indSpecies);
     particle.setPosition(position);
     particle.setVelocity(velocity);
     particle.setRadius(radius);
     particle.setOrientation(orientation);
     particle.setAngularVelocity(angularVelocity);
     if (inverseMass == 0.0)
         particle.fixParticle();
     else
     {
         particle.setInertia(1./inverseInertia);
     }
     
     //Put the particle in the  handler
     copyAndAddObject(particle);
 }

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.

Definition at line 164 of file ParticleHandler.cc.

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

Referenced by DPMBase::readNextDataFile().

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

void ParticleHandler::removeObject ( unsigned const int id )

virtual

Removes a BaseParticle from the ParticleHandler.

Parameters

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

The BaseParticle at position id is removed by moving the last BaseParticle in the vector to the position of id. It also removes the BaseParticle from the HGrid.

Reimplemented from BaseHandler< BaseParticle >.

Definition at line 151 of file ParticleHandler.cc.

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

Referenced by DeletionBoundary::checkBoundaryAfterParticleMoved(), CircularPeriodicBoundary::checkBoundaryAfterParticleMoved(), Chute::cleanChute(), ChuteBottom::makeRoughBottom(), and DPMBase::removeDuplicatePeriodicParticles().

 {
 #ifdef CONTACT_LIST_HGRID
     getDPMBase()->getPossibleContactList().remove_ParticlePosibleContacts(getObject(id));
 #endif
     getDPMBase()->hGridRemoveParticle(getObject(id));
     BaseHandler<BaseParticle>::removeObject(id);
 }

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

Definition at line 477 of file ParticleHandler.cc.

References BaseHandler< BaseParticle >::getNumberOfObjects().

Referenced by DPMBase::write().

 {
     os << "Particles " << getNumberOfObjects() << std::endl;
     for (BaseParticle* it : *this)
         os << (*it) << std::endl;
 }

Member Data Documentation

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.

Definition at line 180 of file ParticleHandler.h.

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

BaseParticle* ParticleHandler::smallestParticle_

private

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

Definition at line 185 of file ParticleHandler.h.

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation