Container to store Interaction objects. More...

#include <InteractionHandler.h>

Inheritance diagram for InteractionHandler:

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

	InteractionHandler (const InteractionHandler &IH UNUSED)
	Copy constructor, but since interactions must not be copied, it creates an empty InteractionHandler. More...

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

	~InteractionHandler () override
	Destructor, it destructs the InteractionHandler and all BaseInteraction it contains. More...

void	addObject (BaseInteraction *I) override
	Adds an Interaction to the InteractionHandler. More...

void	read (std::istream &is)

void	readAndAddObject (std::istream &is) override
	Reads an Interaction into the InteractionHandler from restart data. More...

BaseInteraction *	getExistingInteraction (const BaseInteractable P, const BaseInteractable I) const
	Returns the Interaction between the BaseInteractable's P and I if it exists, otherwise returns a null pointer. More...

BaseInteraction *	addInteraction (BaseInteractable P, BaseInteractable I, unsigned timeStamp)

void	resetNewObjectsOMP ()

void	addNewObjectsOMP ()

BaseInteraction *	getInteraction (BaseInteractable P, BaseInteractable I, unsigned timeStamp)
	Returns the Interaction between the BaseInteractable's P and I. More...

BaseInteraction *	createEmptyInteraction () const
	Creates an empty interaction. More...

void	deleteEmptyInteraction (BaseInteraction *interaction) const
	Deletes an empty interaction. More...

void *	createMPIInteractionDataArray (unsigned int numberOfInteractions) const
	creates an empty MPIInteractionDataArray More...

void	deleteMPIInteractionDataArray (void *dataArray)
	deletes an MPIInteractionDataArray More...

void	getInteractionDetails (void *interactionData, unsigned int index, unsigned int &identificationP, unsigned int &identificationI, bool &isWallInteraction, unsigned &timeStamp)
	reads the basic interaction details from an MPIInteractionDataArray More...

BaseInteraction *	getInteraction (BaseInteractable P, BaseInteractable I, unsigned timeStamp, const Vec3D &normal)
	Returns the Interaction between the BaseInteractable's P and I closest to the contact point (should be used when multiple contacts are possible). More...

void	removeObjectKeepingPeriodics (unsigned int id)
	Removes interactions of periodic particles when the periodic particles get deleted (see DPMBase::removeDuplicatePeriodicParticles) More...

void	eraseOldInteractions (unsigned)
	erases interactions which have an old timestamp. More...

void	actionsAfterTimeStep ()

Mdouble	getMeanOverlap () const
	The mean overlap of all interactions. More...

void	write (std::ostream &os) const
	Writes the InteractionHandler to an output stream, for example a restart file. More...

void	setWriteVTK (FileType f)

FileType	getWriteVTK () const

std::string	getName () const override
	Returns the name of the object. More...

double	getLiquidBridgeVolume () const

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

	BaseHandler (const BaseHandler< BaseInteraction > &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< BaseInteraction > &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 (BaseInteraction *O)
	Adds an existing object to the BaseHandler without changing the id of the object. More...

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

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

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

virtual void	removeObject (unsigned const int index)
	Removes an Object from the BaseHandler. More...

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

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

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

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

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

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

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

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

virtual unsigned int	getNumberOfObjects () const
	Gets the number of real Object in this BaseHandler. (i.e. no mpi or periodic particles) 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 BaseInteraction &obj)
	Resizes the container to contain N elements. More...

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

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

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

const std::vector< BaseInteraction * >::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 (BaseInteraction *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 std::string	getName () const=0
	Gets the name of this handler. 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...

Public Attributes
std::vector< std::vector< BaseInteraction * > >	newObjects_

Private Attributes
FileType	writeVTK_

std::map< unsigned, BaseParticle * >	particleById

std::map< unsigned, BaseWall * >	wallById

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

Detailed Description

Container to store Interaction objects.

The InteractionHandler is a container to store all Interaction objects. It is implemented as a vector of BaseInteraction pointers.

Constructor & Destructor Documentation

◆ InteractionHandler() [1/2]

InteractionHandler::InteractionHandler ( )

Default constructor, it creates an empty InteractionHandler.

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

 {
     writeVTK_ = FileType::NO_FILE;
     logger(DEBUG, "InteractionHandler::InteractionHandler() finished");
 }

References FATAL, logger, and writeVTK_.

◆ InteractionHandler() [2/2]

InteractionHandler::InteractionHandler ( const InteractionHandler &IH UNUSED )

Copy constructor, but since interactions must not be copied, it creates an empty InteractionHandler.

Parameters

[in] IH The InteractionHandler that has to be copied.

This is not a copy constructor! It only clears all variables, since by default interactions are not copied.

Todo:: Please check if interactions indeed don't need to be copied.

         : BaseHandler<BaseInteraction>()
 {
     writeVTK_ = IH.writeVTK_;
     //By default interactions are not copied.
     logger(DEBUG, "InteractionHandler::InteractionHandler(const "
                   "InteractionHandler &IH) finished, please note that no interactions"
                   " have been copied.");
 }

References FATAL, logger, and writeVTK_.

◆ ~InteractionHandler()

InteractionHandler::~InteractionHandler ( )

override

Destructor, it destructs the InteractionHandler and all BaseInteraction it contains.

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

References FATAL, and logger.

Member Function Documentation

◆ actionsAfterTimeStep()

void InteractionHandler::actionsAfterTimeStep ( )

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

References constants::i.

Referenced by DPMBase::computeOneTimeStep(), and DPMBase::solve().

◆ addInteraction()

BaseInteraction * InteractionHandler::addInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I,
		unsigned	timeStamp
	)

 {
     BaseSpecies* species = getDPMBase()->speciesHandler.getMixedObject(P->getIndSpecies(), I->getIndSpecies());
     BaseInteraction* C = species->getNewInteraction(P, I, timeStamp);
     addObject(C);
     return C;
 }

References addObject(), BaseHandler< BaseInteraction >::getDPMBase(), BaseInteractable::getIndSpecies(), SpeciesHandler::getMixedObject(), BaseSpecies::getNewInteraction(), and DPMBase::speciesHandler.

Referenced by DPMBase::readNextFStatFile().

◆ addNewObjectsOMP()

void InteractionHandler::addNewObjectsOMP ( )

                                           {
     for (auto objects : newObjects_) {
         for (auto object : objects) {
             addObject(object);
         }
     }
 }

References addObject(), and newObjects_.

Referenced by DPMBase::computeAllForces().

◆ addObject()

void InteractionHandler::addObject ( BaseInteraction * I )

override

Adds an Interaction to the InteractionHandler.

Parameters

[in] P A pointer to the BaseInteraction (or derived class) that has to be added.

 {
     //set the particleHandler pointer
     I->setHandler(this);
     //Puts the interaction in the Interaction list
     BaseHandler<BaseInteraction>::addObject(I);
     I->getP()->addInteraction(I);
     I->getI()->addInteraction(I);
 }

References BaseInteractable::addInteraction(), BaseHandler< T >::addObject(), BaseInteraction::getI(), BaseInteraction::getP(), and BaseInteraction::setHandler().

Referenced by addInteraction(), addNewObjectsOMP(), BaseInteraction::copySwitchPointer(), and getInteraction().

◆ createEmptyInteraction()

BaseInteraction * InteractionHandler::createEmptyInteraction ( ) const

Creates an empty interaction.

Returns the Interaction between the BaseInteractable's P and I.

Empty interactions are required when dealing with parallel code. it is used a proto type interaction that can handle the MPI interaction data type which is a void array

 {
     //NOTE: assuming the interaction type of a species is the same for all species
     BaseSpecies* species = this->getDPMBase()->speciesHandler.getObject(0);
     BaseInteraction* emptyInteraction = species->getEmptyInteraction();
     
     return emptyInteraction;
 }

References BaseHandler< BaseInteraction >::getDPMBase(), BaseSpecies::getEmptyInteraction(), BaseHandler< T >::getObject(), and DPMBase::speciesHandler.

Referenced by createMPIInteractionDataArray(), deleteMPIInteractionDataArray(), and getInteractionDetails().

◆ createMPIInteractionDataArray()

void * InteractionHandler::createMPIInteractionDataArray ( unsigned int numberOfInteractions ) const

creates an empty MPIInteractionDataArray

When sending interactions to other processors it is done with a void* array, because interactions come in many different sizes and shapes. The size of an interaction depends on the type f interaction. By creating an emptyInteraction, the size can be determined and an empty vector can be allocated

Parameters

[in] numberOfInteractions The number of interactions that are added to the MPIInteractionDataArray

Returns: Returns a void pointer to a block of memory that will contain the interaction data

 {
     BaseInteraction* emptyInteraction = this->createEmptyInteraction();
     //create a vector based on the first interaction. This is to avoid templating the whole class
     void* historyData = emptyInteraction->createMPIInteractionDataArray(numberOfInteractions);
     this->deleteEmptyInteraction(emptyInteraction);
     
     return historyData;
 }

References createEmptyInteraction(), BaseInteraction::createMPIInteractionDataArray(), and deleteEmptyInteraction().

Referenced by PeriodicBoundaryHandler::collectInteractionData(), Domain::performBoundaryDataTransmission(), and PeriodicBoundaryHandler::performNewParticleTransmission().

◆ deleteEmptyInteraction()

void InteractionHandler::deleteEmptyInteraction ( BaseInteraction * interaction ) const

Deletes an empty interaction.

When handling the Interaction MPI data type, an empty interaction is created. This function destroys that empty function again

Parameters

[in,out] interaction Pointer to a base interaction that needs to be deleted

 {
     BaseSpecies* species = this->getDPMBase()->speciesHandler.getObject(0);
     species->deleteEmptyInteraction(interaction);
 }

References BaseSpecies::deleteEmptyInteraction(), BaseHandler< BaseInteraction >::getDPMBase(), BaseHandler< T >::getObject(), and DPMBase::speciesHandler.

Referenced by createMPIInteractionDataArray(), deleteMPIInteractionDataArray(), and getInteractionDetails().

◆ deleteMPIInteractionDataArray()

void InteractionHandler::deleteMPIInteractionDataArray ( void * dataArray )

deletes an MPIInteractionDataArray

An empty interaction is created that can recast the data array into an array of the interactions. After the conversion the data of the array is cleaned up

Parameters

[in] dataArray void pointer to a data array

 {
     BaseInteraction* emptyInteraction = this->createEmptyInteraction();
     emptyInteraction->deleteMPIInteractionDataArray(dataArray);
     this->deleteEmptyInteraction(emptyInteraction);
 }

References createEmptyInteraction(), deleteEmptyInteraction(), and BaseInteraction::deleteMPIInteractionDataArray().

Referenced by Domain::finaliseBoundaryDataTransmission().

◆ eraseOldInteractions()

void InteractionHandler::eraseOldInteractions ( unsigned currentNTime )

erases interactions which have an old timestamp.

Each interaction contains a time stamp, which stores the last time that an interaction object has been called. Thus, one can see that an interaction has ended by comparing the time stamp with the last value of DPMBase::time_. This function erases all interactions that have ended.

Parameters

[in] lastTimeStep the last used value of DPMBase::time_.

Todo:: TW: this function has to be sped up with sth like this: erase(remove_if(begin(), end(), bind2nd(checkSpringTime(), lastTimeStep)), end());

 {
     //std::cout<<"void InteractionHandler::eraseOldInteractions(Mdouble lastTimeStep)"<<std::endl;
     //std::cout<<"Current interactions="<<getNumberOfObjects()<<std::endl;
     //Remove_if reconstructs the vector with only elements passing the check_spring_time function
     //Erase removes the end of the vector
     for (unsigned int id = 0; id < getNumberOfObjects(); id++)
     {
         if (getObject(id)->getTimeStamp() <= currentNTime)
         {
             getObject(id)->actionsOnErase();
             removeObject(id);
             --id;
         }
     }
 }

References BaseInteraction::actionsOnErase(), BaseHandler< BaseInteraction >::getNumberOfObjects(), BaseHandler< BaseInteraction >::getObject(), BaseInteraction::getTimeStamp(), and BaseHandler< BaseInteraction >::removeObject().

Referenced by DPMBase::computeOneTimeStep().

◆ getExistingInteraction()

BaseInteraction * InteractionHandler::getExistingInteraction	(	const BaseInteractable *	P,
		const BaseInteractable *	I
	)		const

Returns the Interaction between the BaseInteractable's P and I if it exists, otherwise returns a null pointer.

Parameters

[in]	P	the first BaseInteractable by which the interaction is defined.
[in]	I	the first BaseInteractable by which the interaction is defined.

Returns: the Interaction between the BaseInteractable's P and I, if it exists.

 {
     //for particle-particle collision it is assumed BaseInteractable P has a lower index then I, so we only have to check for I, not P
     {
         for (unsigned j = 0; j < P->getInteractions().size(); ++j) {
             auto i = P->getInteractions()[j];
             if (i->getI() == I) {
                 return i;
             }
         }
     }
     return nullptr;
 }

References BaseInteractable::getInteractions(), and constants::i.

Referenced by MeshTriangle::checkInteractions(), getInteraction(), and removeObjectKeepingPeriodics().

◆ getInteraction() [1/2]

BaseInteraction * InteractionHandler::getInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I,
		unsigned	timeStamp
	)

Returns the Interaction between the BaseInteractable's P and I.

Returns a pointer to the existing Interaction, if the Interaction already exists otherwise creates a new Interaction and returns a pointer to it.

Parameters

[in]	P	the first BaseInteractable by which the interaction is defined.
[in]	I	the first BaseInteractable by which the interaction is defined.
[in]	timeStamp	the current value of DPMBase::time_.

Returns: the Interaction between the BaseInteractable's P and I

Todo:: TW this can bet set earlier

 {
     const BaseSpecies* const species = getDPMBase()->speciesHandler.getMixedObject(P->getIndSpecies(),
                                                                                    I->getIndSpecies());
     
     BaseInteraction* C = getExistingInteraction(P, I);
     if (C == nullptr) {
         C = species->getNewInteraction(P, I, timeStamp);
         #ifdef MERCURY_USE_OMP
         if (omp_get_num_threads()>1) {
             newObjects_[omp_get_thread_num()].push_back(C);
             C->setHandler(this);
         } else {
             addObject(C);
         }
         #else
         addObject(C);
         #endif
     }
     
     //set timeStamp
     C->setTimeStamp(timeStamp);
     
     //set species of collision
     C->setSpecies(species);
     
     return C;
 }

References addObject(), BaseHandler< BaseInteraction >::getDPMBase(), getExistingInteraction(), BaseInteractable::getIndSpecies(), SpeciesHandler::getMixedObject(), BaseSpecies::getNewInteraction(), newObjects_, BaseInteraction::setHandler(), BaseInteraction::setSpecies(), BaseInteraction::setTimeStamp(), and DPMBase::speciesHandler.

◆ getInteraction() [2/2]

BaseInteraction * InteractionHandler::getInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I,
		unsigned	timeStamp,
		const Vec3D &	normal
	)

Returns the Interaction between the BaseInteractable's P and I closest to the contact point (should be used when multiple contacts are possible).

Returns a pointer to the existing Interaction, if the Interaction already exists otherwise creates a new Interaction and returns a pointer to it.

Parameters

[in]	P	the first BaseInteractable by which the interaction is defined.
[in]	I	the first BaseInteractable by which the interaction is defined.
[in]	timeStamp	the current value of DPMBase::time_.

Returns: the Interaction between the BaseInteractable's P and I

 {
     BaseInteraction* c = nullptr;
     Mdouble dNormalMax = 0.9; //minimal agreement required
     for (const auto& i : P->getInteractions())
     {
         if (i->getI() == I && i->getTimeStamp() != timeStamp)
         {
             const Mdouble dNormal = Vec3D::dot(normal, i->getNormal());
             if (dNormal > dNormalMax)
             {
                 c = i;
                 dNormalMax = dNormal;
             }
         }
     }
     
     BaseSpecies* species = getDPMBase()->speciesHandler.getMixedObject(P->getIndSpecies(), I->getIndSpecies());
     
     if (c)
     {
         c->setTimeStamp(timeStamp);
     }
     else
     {
         c = species->getNewInteraction(P, I, timeStamp);
         c->setSpecies(species);
         addObject(c);
         //logger(INFO,"new interaction t=%: i=%, n=%",timeStamp,getNumberOfObjects(),normal);
     }
     
     return c;
 }

References addObject(), Vec3D::dot(), BaseHandler< BaseInteraction >::getDPMBase(), BaseInteractable::getIndSpecies(), BaseInteractable::getInteractions(), SpeciesHandler::getMixedObject(), BaseSpecies::getNewInteraction(), constants::i, BaseInteraction::setSpecies(), BaseInteraction::setTimeStamp(), and DPMBase::speciesHandler.

◆ getInteractionDetails()

void InteractionHandler::getInteractionDetails	(	void *	interactionData,
		unsigned int	index,
		unsigned int &	identificationP,
		unsigned int &	identificationI,
		bool &	isWallInteraction,
		unsigned &	timeStamp
	)

reads the basic interaction details from an MPIInteractionDataArray

because the interactionData array is a void pointer array, it is not possibly to directly read out the interaction data this function reads the basic information such as which objects are interacting and at what time.

Parameters

[in]	interactionData	void pointer to the mpi interaction data
[in]	index	The index of the interaction in the interaction data
[out]	identificationP	the unique id of the P object
[out]	idientificationI	the unique id of the I object
[out]	isWallInteraction	a bool that flags if the interaction is a wall interaction or not
[out]	timeStamp	reads the timestamp of the interaction

 {
     BaseInteraction* emptyInteraction = this->createEmptyInteraction();
     emptyInteraction->getInteractionDetails(interactionData, index, identificationP, identificationI, isWallInteraction,
                                             timeStamp);
     this->deleteEmptyInteraction(emptyInteraction);
 }

References createEmptyInteraction(), deleteEmptyInteraction(), and BaseInteraction::getInteractionDetails().

Referenced by PeriodicBoundaryHandler::processLocalInteractionData(), PeriodicBoundaryHandler::processReceivedInteractionData(), and Domain::processReceivedInteractionData().

◆ getLiquidBridgeVolume()

double InteractionHandler::getLiquidBridgeVolume ( ) const

                                                        {
     double liquidVolume = 0;
     for (auto i : objects_) {
         auto j = dynamic_cast<LiquidMigrationWilletInteraction*>(i);
         if (j and !static_cast<BaseParticle*>(j->getP())->isMPIParticle()) liquidVolume += j->getLiquidBridgeVolume();
     }
     return getMPISum(liquidVolume);
 };

References getMPISum(), constants::i, BaseParticle::isMPIParticle(), and BaseHandler< BaseInteraction >::objects_.

Referenced by LiquidMigrationMPI2Test::printTime().

◆ getMeanOverlap()

Mdouble InteractionHandler::getMeanOverlap ( ) const

The mean overlap of all interactions.

Returns: The mean overlap of all interactions

 {
     Mdouble sum = 0;
     Mdouble n = 0;
     for (BaseInteraction* const p : objects_)
     {
         if (p->getOverlap() > 0)
         {
             sum += p->getOverlap();
             n++;
         }
     }
     return sum / n;
 }

References n, and BaseHandler< BaseInteraction >::objects_.

Referenced by InitialConditions< SpeciesType >::getMeanRelativeContactRadius(), Sintering::getMeanRelativeContactRadius(), regimeForceUnitTest::getMeanRelativeContactRadius(), and main().

◆ getName()

std::string InteractionHandler::getName ( ) const

override

Returns the name of the object.

Returns: the string InteractionHandler

 {
     return "InteractionHandler";
 }

Referenced by read().

◆ getWriteVTK()

FileType InteractionHandler::getWriteVTK ( ) const

 {
     return writeVTK_;
 }

References writeVTK_.

Referenced by DPMBase::write(), DPMBase::writePythonFileForVTKVisualisation(), and DPMBase::writeVTKFiles().

◆ operator=()

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

Assignment operator.

Parameters

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

 {
     if (this != &rhs)
     {
         clear();
     }
     writeVTK_ = rhs.writeVTK_;
     logger(DEBUG, "InteractionHandler::operator =(const InteractionHandler& rhs) finished.");
     return *this;
 }

References BaseHandler< BaseInteraction >::clear(), FATAL, logger, and writeVTK_.

◆ read()

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

Parameters

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

 {
     clear();
     unsigned int N;
     std::string dummy;
     is >> dummy;
     std::stringstream line;
     helpers::getLineFromStringStream(is, line);
     line >> N;
     if (N > 1e5)
     {
         logger(INFO, "Reading % %", N, dummy);
     }
     logger(VERBOSE, "In %::read(is): reading in % objects.", getName(), N);
     setStorageCapacity(N);
     // set map
     particleById.clear();
     for (BaseParticle* p: getDPMBase()->particleHandler)
     {
         particleById[p->getId()] = p;
     }
     wallById.clear();
     for (BaseWall* w: getDPMBase()->wallHandler)
     {
         wallById[w->getId()] = w;
     }
     for (unsigned int i = 0; i < N; i++)
     {
         readAndAddObject(is);
     }
     particleById.clear();
     wallById.clear();
 }

References BaseHandler< BaseInteraction >::clear(), BaseHandler< BaseInteraction >::getDPMBase(), helpers::getLineFromStringStream(), getName(), constants::i, INFO, logger, particleById, readAndAddObject(), BaseHandler< BaseInteraction >::setStorageCapacity(), VERBOSE, and wallById.

Referenced by DPMBase::read().

◆ readAndAddObject()

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

overridevirtual

Reads an Interaction into the InteractionHandler from restart data.

Parameters

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

Todo:: Ant This is a tmp fix as in some cases the line before has not be finished reading. This should be looked at again at a later date.

Todo:: TW: Change identifier in restart file from id to index; is there any reason the id should be kept after restarting, once this is done? (Note, the id is set to the old one in the particle handler because interactions store id, not indices; also note id's are slow

Implements BaseHandler< BaseInteraction >.

 {
     std::string type, dummy, idType;
     unsigned int id0, id1;
     Mdouble doubleTimeStamp;
     unsigned timeStamp;
     
     is >> type;
     logger(DEBUG, "InteractionHandler::readAndAddObject(is): reading type %.", type);
     Mdouble timeStampDouble;
     is >> idType >> id0 >> id1 >> dummy >> timeStampDouble;
     timeStamp = timeStampDouble; //in order to read old restart files
  
     BaseInteraction* C;
  
 #ifdef MERCURY_USE_MPI
     if (idType.compare("particleIds") == 0)
     {
         std::vector<BaseParticle*> list0 = getDPMBase()->particleHandler.getObjectsById(id0);
         std::vector<BaseParticle*> list1 = getDPMBase()->particleHandler.getObjectsById(id1);
         for (int p0 = 0; p0 < list0.size(); p0++)
         {
             for (int p1  = 0; p1 < list1.size(); p1++)
             {
                 C = getInteraction(list0[p0],list1[p1], timeStamp);
                 if (C != nullptr)
                 {
                    is >> *C;
                 }
             }
         }
  
     }
     else
     {
         std::vector<BaseParticle*> list0 = getDPMBase()->particleHandler.getObjectsById(id0);
         for (int p0 = 0; p0 < list0.size(); p0++)
         {
             C = getInteraction(list0[p0],getDPMBase()->wallHandler.getObjectById(id1), timeStamp);
             if (C != nullptr)
             {
                 is >> *C;
             }
         }
     }
 #else
     //this requires particleById/wallById to be set, which is done in the read() function
     if (idType == "particleIds")
         C = getInteraction(particleById[id0],particleById[id1],timeStamp);
     else
         C = getInteraction(particleById[id0],wallById[id1], timeStamp);
     is >> (*C);
 #endif
     is.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 }

References FATAL, BaseHandler< BaseInteraction >::getDPMBase(), getInteraction(), BaseHandler< T >::getObjectsById(), logger, particleById, DPMBase::particleHandler, and wallById.

Referenced by read().

◆ removeObjectKeepingPeriodics()

void InteractionHandler::removeObjectKeepingPeriodics ( unsigned int id )

Removes interactions of periodic particles when the periodic particles get deleted (see DPMBase::removeDuplicatePeriodicParticles)

Deleting the three periodic interactions between two real particles is difficult, because its interaction information has to be saved. If the two real particles interacted (which can be checked by looking at the time stamp), the interaction between the real particles is kept, and all interactions that involve ghost particles gets removed; otherwise, the interaction between the lower-indexed real particle with the ghost particle of the higher indexed particles is saved (with the ghost particle replaced by the real particle), and all other interactions removed.

This is what this function is intended for, and it does it in the following way: When an interaction is removed the periodic particle has to be stored in the I pointer So when an interaction is removed where P is normal and I is periodic, and the information is new it will be transfered when the index of P is lower than the index of the real particle of I.

Parameters

[in] the id of the Interaction that needs to be deleted.

Todo:: TW The code assumes in a few places that P->getIndex()<I->getIndex(), but the copySwitchPointer function does not obey that rule; we have to check if this is valid behaviour.

Todo:: this function will create an error if the timeStamp is in the future! This should not happen (ever), but who knows.

 {
     BaseInteraction* iMain = getObject(id);
     
     BaseParticle* P = dynamic_cast<BaseParticle*>(iMain->getP());
     BaseParticle* I = dynamic_cast<BaseParticle*>(iMain->getI());
     if (P != nullptr && I != nullptr) //check that both P and I are particles (not walls)
     {
         BaseInteractable* realI = I->getPeriodicFromParticle();
         if (realI != nullptr && !P->getPeriodicFromParticle()) //check that P is a real and I is a ghost particle
         {
             if (P->getIndex() < realI->getIndex())
             {
                 BaseInteraction* iOther = getExistingInteraction(P, realI);
                 //You have to also check for existing interactions of the particles in reverse order since the copySwitchPointer function can revert the order of the particles
                 if (iOther == nullptr)
                 {
                     iOther = getExistingInteraction(realI, P);
                 }
                 if (iOther != nullptr) //if the interaction existed before the ghost particles were created
                 {
                     //Here we decide which of the two interactions should be kept:
                     //the interaction between the two real particles (iMain), or
                     //the interaction between the real and a ghost particle (iOther).
                     //It picks the one for which a collision has happened,
                     //i.e. the one with the newer timeStamp.
                     if (iOther->getTimeStamp() <
                         iMain->getTimeStamp()) //if the interaction has been active during the last computeForce routine, make this the new (real) interaction.
                     
                     {
                         iMain->setI(realI);
                         removeObject(iOther->getIndex());
                         return;
                     }
                     else  //if the interaction has not been active during the last computeForce routine
                     {
                         BaseHandler<BaseInteraction>::removeObject(id);
                         return;
                     }
                 }
                 else //if the interaction has been created during the last computeForce routine, make this a new (real) interaction. 
                 {
                     iMain->setI(realI);
                     return;
                 }
             }
         }
     }
     //this point is reached if either P or I are walls, or P and I are both ghost particles; in these cases, the interaction gets deleted
     BaseHandler<BaseInteraction>::removeObject(id);
 }

References getExistingInteraction(), BaseInteraction::getI(), BaseObject::getIndex(), BaseHandler< BaseInteraction >::getObject(), BaseInteraction::getP(), BaseParticle::getPeriodicFromParticle(), BaseInteraction::getTimeStamp(), BaseHandler< T >::removeObject(), BaseHandler< BaseInteraction >::removeObject(), and BaseInteraction::setI().

Referenced by SilbertPeriodic::add_flow_particles(), and DPMBase::removeDuplicatePeriodicParticles().

◆ resetNewObjectsOMP()

void InteractionHandler::resetNewObjectsOMP ( )

                                             {
     #ifdef MERCURY_USE_OMP
     newObjects_.clear();
     newObjects_.resize(getDPMBase()->getNumberOfOMPThreads());
     #endif
 }

References BaseHandler< BaseInteraction >::getDPMBase(), and newObjects_.

Referenced by DPMBase::computeAllForces().

◆ setWriteVTK()

void InteractionHandler::setWriteVTK ( FileType f )

 {
     writeVTK_ = fileType;
 }

References writeVTK_.

Referenced by DPMBase::read(), DPMBase::setInteractionsWriteVTK(), and MovingWalls::setupInitialConditions().

◆ write()

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

Writes the InteractionHandler to an output stream, for example a restart file.

Parameters

[in] os The output stream where the InteractionHandler must be written to, usually a restart file.

 {
 #ifdef MERCURY_USE_MPI
     //note: this function only prints the particles on processor 0
     //The rest of the particles are processed in the restart file write function
     MPIContainer& communicator = MPIContainer::Instance();
     unsigned int totalNumberOfInteractions = getNumberOfObjects();
     os << "Interactions " << totalNumberOfInteractions << '\n';
     //logger(INFO,"% interactions",getNumberOfObjects());
     for (BaseInteraction* it : *this)
     {
     os << (*it) << '\n';
     }
 #else
     os << "Interactions " << getNumberOfObjects() << '\n';
     for (BaseInteraction* i : objects_)
         os << (*i) << '\n';
 #endif
 }

References BaseHandler< BaseInteraction >::getNumberOfObjects(), constants::i, MPIContainer::Instance(), and BaseHandler< BaseInteraction >::objects_.

Referenced by DPMBase::write().

Member Data Documentation

◆ newObjects_

std::vector<std::vector<BaseInteraction*> > InteractionHandler::newObjects_

Referenced by addNewObjectsOMP(), getInteraction(), and resetNewObjectsOMP().

◆ particleById

std::map<unsigned,BaseParticle*> InteractionHandler::particleById

private

Referenced by read(), and readAndAddObject().

◆ wallById

std::map<unsigned,BaseWall*> InteractionHandler::wallById

private

Referenced by read(), and readAndAddObject().

◆ writeVTK_

FileType InteractionHandler::writeVTK_

private

Referenced by getWriteVTK(), InteractionHandler(), operator=(), and setWriteVTK().

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

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ InteractionHandler() [1/2]

◆ InteractionHandler() [2/2]

◆ ~InteractionHandler()

Member Function Documentation

◆ actionsAfterTimeStep()

◆ addInteraction()

◆ addNewObjectsOMP()

◆ addObject()

◆ createEmptyInteraction()

◆ createMPIInteractionDataArray()

◆ deleteEmptyInteraction()

◆ deleteMPIInteractionDataArray()

◆ eraseOldInteractions()

◆ getExistingInteraction()

◆ getInteraction() [1/2]

◆ getInteraction() [2/2]

◆ getInteractionDetails()

◆ getLiquidBridgeVolume()

◆ getMeanOverlap()

◆ getName()

◆ getWriteVTK()

◆ operator=()

◆ read()

◆ readAndAddObject()

◆ removeObjectKeepingPeriodics()

◆ resetNewObjectsOMP()

◆ setWriteVTK()

◆ write()

Member Data Documentation

◆ newObjects_

◆ particleById

◆ wallById

◆ writeVTK_