PeriodicBoundaryHandler Class Reference

Container to store pointers to all BasePeriodicBoundary objects. More...

#include <PeriodicBoundaryHandler.h>

Inheritance diagram for PeriodicBoundaryHandler:

Public Member Functions
	PeriodicBoundaryHandler ()
	Default constructor, it creates an empty PeriodicBoundaryHandler. More...
	PeriodicBoundaryHandler (const PeriodicBoundaryHandler &BH)
	Constructor that copies all BasePeriodicBoundary it contains and sets the other variables to 0/nullptr. More...
PeriodicBoundaryHandler	operator= (const PeriodicBoundaryHandler &rhs)
	Assignment operator, copies only the vector of BasePeriodicBoundary and sets the other variables to 0/nullptr. More...
	~PeriodicBoundaryHandler () override
	Destructor, it destructs the PeriodicBoundaryHandler and all BasePeriodicBoundary it contains. More...
void	addObject (BasePeriodicBoundary *P) override
	Adds a BasePeriodicBoundary to the PeriodicBoundaryHandler. More...
void	readAndAddObject (std::istream &is) override
	Pure virtual function needs implementation, but it does nothing for the periodicBoudnaryHandler. More...
std::string	getName () const override
	Returns the name of the handler, namely the string "PeriodicBoundaryHandler". More...
void	setInteractionDistance (Mdouble interactionDistance)
	Sets the interaction distance. More...
Mdouble	getInteractionDistance ()
	Returns the interaction distance. More...
void	updateStatus (std::set< BaseParticle * > &ghostParticlesToBeDeleted)
	Updates the positions/velocity of ghost particles and accordingly the status of these particles. More...
void	shiftParticle (BaseParticle *particle)
	Shifts the position of the particle based on its current periodic complexity. More...
void	shiftParticle (BaseParticle *particle, const std::vector< int > &complexity)
	Shifts the position of the particle based on a given periodic complexity. More...
std::vector< int >	computePeriodicComplexity (Vec3D position)
	Computes the periodic complexity based on a given position. More...
void	computePeriodicComplexity (std::vector< int > &periodicComplexity, int &totalPeriodicComplexity, Vec3D position)
	Computes the periodic complexity and total periodic complexity based on a given position. More...
void	addNewParticles ()
	Adds new particles to the periodic particle lists. More...
void	addNewParticle (BaseParticle *particle)
	Adds a new particle to the periodic list. More...
unsigned int	getNumberOfPeriodicGhostParticles ()
	Returns the number of particles that are flagged is periodicGhostParticle. More...
Mdouble	getNumberOfTruePeriodicGhostParticles ()
	Returns the number of particles that are flagged as periodicGhostParticles, but not as MPIParticles. More...
void	getMPIFlags (BaseParticle *particle, bool &isInMPIDomain, bool &isMPIParticle)
	Determines if a given particle is in the MPI domain and if it is an MPI Particle. More...
void	setMPIFlags (BaseParticle *particle)
	Sets the MPIParticle and isMPIParticle flags of a given particle. More...
void	generateGhosts (std::vector< std::vector< int > > &list, std::vector< int > periodicComplexity, std::vector< int > &complexity, int level)
	generates a list of periodic complexities corresponding to a give real particle. More...
void	collectGhostParticleData ()
	Collects ghost particle data that needs to be be sent to other processors. More...
void	collectInteractionData ()
	Collects interaction data into an MPI data structure. More...
void	processReceivedGhostParticleData (int targetIndex, std::vector< BaseParticle * > &newParticles)
	Processes the received ghost data, creates a ghost particle and does some book keeping. More...
void	processReceivedInteractionData (int targetIndex, std::vector< BaseParticle * > &newParticles)
	Process the received interaction data. More...
void	processLocalInteractionData (std::vector< BaseParticle * > &newParticles)
	Process the interaction data for local ghosts. More...
void	processPeriodicParticles ()
	Creates a periodioc particle ID for book keeping and moves the ID to the correct list. More...
void	processLocalGhostParticles (std::vector< BaseParticle * > &newParticles)
	Creates ghost particles of periodic particles that are located on the same processor. More...
void	updateParticles ()
	Updates position/velocity and periodic complexity of ghost particles. More...
bool	checkIsReal (std::vector< int > complexity)
	checks if a periodic complexity is real More...
bool	checkChanged (std::vector< int > previousComplexity, std::vector< int > complexity)
	checks of two periodic complexities differ More...
void	updateParticleStatus (std::set< BaseParticle * > &particlesToBeDeleted)
	Updates the status of periodic particles and ghost particles. More...
int	findTargetProcessor (const std::vector< int > &complexity)
	For a given complexity this function returns the target processor. More...
void	findNewParticle (BaseParticle *particle)
	Checks if a particle is in the periodic domain, but are not flagged as being in the periodic domain. More...
bool	checkIfAddNewParticle (BaseParticle *particle)
void	findNewParticles ()
	Loops over all particles in the simulation to check if they need to be added to the periodic lists. More...
void	findNewInteractions ()
	Finds interactions that accompany future ghost particles. More...
void	communicateTargetDomains ()
	Creats a list of send and receive targets for periodic/ghost particles. More...
void	communicateNumberOfNewParticlesAndInteractions ()
	Communicate the number of new particles and interactions to target processors. More...
void	prepareNewParticleTransmission ()
	Initial preparation work for sending ghost particles. More...
void	performNewParticleTransmission ()
	Collects and sends the ghost particle data. More...
void	finaliseNewParticleTransmission ()
	creates the ghost particles and performs some bookkeeping to keep track of them More...
void	preparePositionAndVelocityUpdate ()
	Collects the position and velocity data from periodic boundaries. More...
void	finalisePositionAndVelocityUpdate ()
	Communicates position and velocity data from periodic boundaries and updates ghost particles. More...
void	flushParticles (std::set< BaseParticle * > &particlesToBeFlushed)
	Removes particles from the periodiocParticleList_ and periociGhostList_. More...
void	cleanCommunicationList (std::vector< MpiPeriodicParticleIDBase * > &list)
	Removes the nullptr's from a communication list. More...
void	cleanCommunicationLists ()
void	clearCommunicationLists ()
	Removes all ghost particles and bookkeeping for a fresh start. More...
void	initialise ()
	Initialises the communication list vectors as they can not be determined on compile time. More...
void	flushPeriodicParticles (std::set< BaseParticle * > &particlesToBeDeleted)
	Flushes periodioc particles that need to be deleted from the periodic lists. More...
void	performActionsBeforeAddingParticles ()
	Actions that boundaries perform before adding new periodic/ghost particles. More...
void	updateMaserParticle (BaseParticle *particle)
	Updates the maser flag of particles leaving the maser. More...
void	findBoundariesToIgnore (BaseParticle *particle, std::vector< int > &periodicComplexity, int &totalPeriodicComplexity)
	Disables boundaries that need to be ignored (i.e. a non-maser particle needs to ignore the maser boundary) More...
Public Member Functions inherited from BaseHandler< BasePeriodicBoundary >
	BaseHandler ()
	Default BaseHandler constructor, it creates an empty BaseHandler and assigns DPMBase_ to a null pointer. More...
	BaseHandler (const BaseHandler< BasePeriodicBoundary > &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< BasePeriodicBoundary > &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 (BasePeriodicBoundary *O)
	Adds an existing object to the BaseHandler without changing the id of the object. More...
virtual void	addObject (BasePeriodicBoundary *object)
	Adds a new Object to the BaseHandler. More...
virtual void	addGhostObject (BasePeriodicBoundary *O)
	Adds a new Object to the BaseHandler. called by the to avoid increasing the id. More...
void	removeIf (const std::function< bool(BasePeriodicBoundary *)> cond)
virtual void	removeObject (unsigned const int index)
	Removes an Object from the BaseHandler. More...
virtual void	removeObjects (std::vector< unsigned int > indices)
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...
BasePeriodicBoundary *	getObjectById (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...
std::vector< BasePeriodicBoundary * >	getObjectsById (const unsigned int id)
	Gets a vector of pointers to the objects with the specific id. More...
BasePeriodicBoundary *	getObject (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...
const BasePeriodicBoundary *	getObject (const unsigned int id) const
	Gets a constant pointer to the Object at the specified index in the BaseHandler. More...
BasePeriodicBoundary *	getLastObject ()
	Gets a pointer to the last Object in this BaseHandler. More...
const BasePeriodicBoundary *	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 BasePeriodicBoundary &obj)
	Resizes the container to contain N elements. More...
const std::vector< BasePeriodicBoundary * >::const_iterator	begin () const
	Gets the begin of the const_iterator over all Object in this BaseHandler. More...
const std::vector< BasePeriodicBoundary * >::iterator	begin ()
	Gets the begin of the iterator over all BaseBoundary in this BaseHandler. More...
const std::vector< BasePeriodicBoundary * >::const_iterator	end () const
	Gets the end of the const_iterator over all BaseBoundary in this BaseHandler. More...
const std::vector< BasePeriodicBoundary * >::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 (BasePeriodicBoundary *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...

Private Attributes
Mdouble	interactionDistance_
	The interaction distance between a position and the boundary for which particles start to participate with a boundary or not. More...
std::vector< int >	receiveTargetList_
	A list that keeps track which target processors the current processor is receiving new particles from. More...
std::vector< int >	sendTargetList_
	A list that keeps track to which targets this processor is sending new particles to. More...
std::vector< int >	numberOfNewPeriodicGhostParticlesReceive_
	A vector that stores how many new ghost particles will be received from other processors. More...
std::vector< int >	numberOfNewPeriodicGhostParticlesSend_
	A vector that stores how many particles are going to be send to other processors. More...
std::vector< int >	numberOfNewInteractionsSend_
	Stores the number of new interactions to be send to target processor corresponding to sendTargetList_. More...
std::vector< int >	numberOfNewInteractionsReceive_
	Stores the number of new interactions to be received from target processor corresponding to receiveTargetList_. More...
std::vector< std::vector< MPIParticle > >	periodicGhostParticleReceive_
	Data container for particles that are being received from other processors. More...
std::vector< std::vector< MPIParticle > >	periodicGhostParticleSend_
	Data container for particles that are being send to other processors. More...
std::vector< std::vector< int > >	periodicGhostComplexityReceive_
	Data container for periodic complexity that is being received from other processors. More...
std::vector< std::vector< int > >	periodicGhostComplexitySend_
	Data container for periodic complexity that is being send to other processors. More...
std::vector< std::vector< MPIParticlePosition > >	updatePositionDataReceive_
	Data container for position data that is being received from other processors. More...
std::vector< std::vector< MPIParticlePosition > >	updatePositionDataSend_
	Data container for position data that is being send to other processors. More...
std::vector< std::vector< MPIParticleVelocity > >	updateVelocityDataReceive_
	Data container for velocity data that is being received from other processors. More...
std::vector< std::vector< MPIParticleVelocity > >	updateVelocityDataSend_
	Data container for velocity data that is being send to other processors. More...
std::vector< void * >	interactionDataSend_
	Stores the interaction data that is going to be send. More...
std::vector< void * >	interactionDataReceive_
	Stores the interaction data that is going to be received. More...
std::vector< PeriodicList >	newPeriodicParticleList_
std::vector< std::vector< BaseInteraction * > >	newInteractionList_
std::vector< PeriodicList >	periodicParticleList_
	A vector the size of the number of processors, each entry containing a vector of periodic particle ID's to keep track of periodic particles and their corresponding ghosts. More...
std::vector< PeriodicGhostList >	periodicGhostList_
	A vector the size of the number of processors, each entry containing a vector of ghost periodioc particle ID's to keep track of periodic ghost particles and their corresponding real particles. More...

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

Detailed Description

Container to store pointers to all BasePeriodicBoundary objects.

The PeriodicBoundaryHandler is a container to store all BasePeriodicBoundary. It is implemented by a vector of pointers to BasePeriodicBoundary.

Constructor & Destructor Documentation

PeriodicBoundaryHandler() [1/2]

PeriodicBoundaryHandler::PeriodicBoundaryHandler

(

)

Default constructor, it creates an empty PeriodicBoundaryHandler.

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

{
    interactionDistance_ = 0;
    logger(DEBUG, "PeriodicBoundaryHandler::PeriodicBoundaryHandler() finished");
}

References DEBUG, interactionDistance_, and logger.

PeriodicBoundaryHandler() [2/2]

PeriodicBoundaryHandler::PeriodicBoundaryHandler

(

const PeriodicBoundaryHandler &

PBH

)

Constructor that copies all BasePeriodicBoundary it contains and sets the other variables to 0/nullptr.

Parameters

[in]

BH

The PeriodicBoundaryHandler that has to be copied.

This is not a copy constructor! It just copies all BasePeriodicBoundary from the other handler into this handler, and clears all other variables.

{
    objects_.clear();
    setDPMBase(nullptr);
    interactionDistance_ = PBH.interactionDistance_;
    logger(DEBUG, "PeriodicBoundaryHandler::PeriodicBoundaryHandler(const PeriodicBoundaryHandler &BH) finished");
}

References DEBUG, interactionDistance_, logger, BaseHandler< BasePeriodicBoundary >::objects_, and BaseHandler< BasePeriodicBoundary >::setDPMBase().

~PeriodicBoundaryHandler()

PeriodicBoundaryHandler::~PeriodicBoundaryHandler ( )

override

Destructor, it destructs the PeriodicBoundaryHandler and all BasePeriodicBoundary it contains.

Default destructor. Note that the delete for all boundaries is done in the BaseHandler.

Todo:

MX: Because the periodicBoundaryHandler contains a pointer to a boundary, which is also in the boundary handler currently we just need to empty the PeriodicBoundaryHandler without destroying the object Otherwise we create a segfault in the BoundaryHandler

{
    objects_.clear();
    
    logger(DEBUG, "PeriodicBoundaryHandler::~PeriodicBoundaryHandler() finished");
}

References DEBUG, logger, and BaseHandler< BasePeriodicBoundary >::objects_.

Member Function Documentation

addNewParticle()

void PeriodicBoundaryHandler::addNewParticle

(

BaseParticle *

particle

)

Adds a new particle to the periodic list.

When a user or an insertion boundary is adding a single new particle to the system, this function will add it to the corresponding lists if required. If this is the case, the particle will be communicated to the receiving processor in a three step process. First the processors communicate which each other to determine who is getting how many particles from who. Secondly the actual data transfer is performed and thirdly the received data is processed into the correct bookkeeping lists.

Parameters

[in]

particle

The particle that is (or not) being add to the periodic lists.

{
#ifdef MERCURYDPM_USE_MPI
    if (NUMBER_OF_PROCESSORS == 1)
    {
        return;
    }
    if (getDPMBase()->getCurrentDomain()->containsParticle(particle))
    {
        //Step 1: Find if the new particle needs to be added
        findNewParticle(particle);
    }
    //Follow the standard communication routine
    prepareNewParticleTransmission();
    performNewParticleTransmission();
    finaliseNewParticleTransmission();
#endif
}

References finaliseNewParticleTransmission(), findNewParticle(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), NUMBER_OF_PROCESSORS, performNewParticleTransmission(), and prepareNewParticleTransmission().

Referenced by DPMBase::insertGhostParticle().

addNewParticles()

void PeriodicBoundaryHandler::addNewParticles

(

)

Adds new particles to the periodic particle lists.

This function adds new particles to the periodiocBoundary lists. Particles that are not yet flagged as periodic(ghost) particles are checked if they entered the interaction distances of periodic boundaries. If this is the case these will be communicated to the other processors in a three step process. First the processors communicate which each other to determine who is getting how many particles from who. Secondly the actual data transfer is performed and thirdly the received data is processed into the correct bookkeeping lists.

{
#ifdef MERCURYDPM_USE_MPI
    if (NUMBER_OF_PROCESSORS == 1)
    {
        return;
    }
    //Step 0: Perform actions before finding new particles. I.e. opening maser boundary
    performActionsBeforeAddingParticles();
 
    //Step 1: Find new particles, such that the target domains can be found
    findNewParticles();
 
    //Step 3: Communicate number of particles/interactions to other dommains
    prepareNewParticleTransmission();
 
    //Step 4: Perform data transmission
    performNewParticleTransmission();
 
    //Step 5: Finalise data transmission
    finaliseNewParticleTransmission();
#endif
}

References finaliseNewParticleTransmission(), findNewParticles(), NUMBER_OF_PROCESSORS, performActionsBeforeAddingParticles(), performNewParticleTransmission(), and prepareNewParticleTransmission().

Referenced by SubcriticalMaserBoundaryTEST::activateMaser(), addObject(), DPMBase::performGhostParticleUpdate(), DPMBase::read(), and DPMBase::updateGhostGrid().

addObject()

void PeriodicBoundaryHandler::addObject ( BasePeriodicBoundary *  P )

override

Adds a BasePeriodicBoundary to the PeriodicBoundaryHandler.

Parameters

[in]

P

A pointer to the BasePeriodicBoundary (or derived class) that has to be added. Add the object and tell the object that this is his handler.

{
#ifdef MERCURYDPM_USE_MPI
    if (NUMBER_OF_PROCESSORS == 1)
    {
        return;
    }
    //Puts the particle in the Particle list
    objects_.push_back(P);
    //set the particleHandler pointer
    P->setPeriodicHandler(this);
    //Remove all ghost particles
    clearCommunicationLists();
    //Initialise ghost particles
    addNewParticles();
#endif
}

References addNewParticles(), clearCommunicationLists(), NUMBER_OF_PROCESSORS, BaseHandler< BasePeriodicBoundary >::objects_, and Global_Physical_Variables::P.

Referenced by BoundaryHandler::addObject().

checkChanged()

bool PeriodicBoundaryHandler::checkChanged	(	std::vector< int >	previousComplexity,
		std::vector< int >	complexity
	)

checks of two periodic complexities differ

A large part of the status update requires on if the periodic complexity of the real particle is changed. This function will check if the previous and current periodic complexity differ. If this is the case it returns true, if they remain the same the function returns false

Parameters

[in]	previousPeriodicComplexity	A periodioc complexity vector that is used as reference
[in]	currentPeriodicComplexity	A periodic complexity that is checked for difference against a reference periodic complexity.

Returns

True if the periodic complexity as changed with respect to the reference periodic complexity. returns false if the periodic complexity is exactly the same.

{
    bool changed = false;
    
    for (int i = 0; i < currentComplexity.size(); i++)
    {
        if (previousComplexity[i] != currentComplexity[i])
        {
            changed = true;
        }
    }
    
    return changed;
}

References i.

Referenced by updateParticleStatus().

checkIfAddNewParticle()

bool PeriodicBoundaryHandler::checkIfAddNewParticle

(

BaseParticle *

particle

)

{
    if (particle->isPeriodicGhostParticle())
    {
        return false;
    }
    if (particle->isInPeriodicDomain())
    {
        return false;
    }
    return true;
}

References BaseParticle::isInPeriodicDomain(), and BaseParticle::isPeriodicGhostParticle().

Referenced by findNewParticle().

checkIsReal()

bool PeriodicBoundaryHandler::checkIsReal

(

std::vector< int >

complexity

)

checks if a periodic complexity is real

An important distinction between periodic particles is if they are real or not. This check is generally required for the particle status update. A real particle only has positive periodic complexity values. So the moment a negative value is found it is clear the particle is not real.

Parameters

[in]

complexity

The periodic complexity that indicates the status of the periodic particle

Returns

When the particle is real this function returns true, otherwise it will return false.

{
    bool isReal = true;
    for (int i = 0; i < getSize(); i++)
    {
        if (mathsFunc::sign(complexity[i]) == -1)
        {
            isReal = false;
        }
    }
    
    return isReal;
}

References BaseHandler< BasePeriodicBoundary >::getSize(), i, and mathsFunc::sign().

Referenced by updateParticleStatus().

cleanCommunicationList()

void PeriodicBoundaryHandler::cleanCommunicationList

(

std::vector< MpiPeriodicParticleIDBase * > &

list

)

Removes the nullptr's from a communication list.

When a particle is deleted the ID is also removed, but to ensure everything happens in the same order a nullptr is introduced instead. This function removes these nullptr's by adding the last entry of the list on such empty spot and making the list shorter.

Parameters

[in]

list

A list of MPiPeriodicParticleIDBase's that need to be cleaned from empty entries

{
    for (int i = 0; i < list.size(); i++)
    {
        if (list[i] == nullptr)
        {
            list[i] = list.back();
            list.pop_back();
            i--;
        }
    }
}

References i.

Referenced by cleanCommunicationLists().

cleanCommunicationLists()

void PeriodicBoundaryHandler::cleanCommunicationLists

(

)

{
    for (int i = 0; i < NUMBER_OF_PROCESSORS; i++)
    {
        cleanCommunicationList(periodicParticleList_[i]);
        cleanCommunicationList(periodicGhostList_[i]);
    }
}

References cleanCommunicationList(), i, NUMBER_OF_PROCESSORS, periodicGhostList_, and periodicParticleList_.

Referenced by DPMBase::checkInteractionWithBoundaries(), and DPMBase::deleteGhostParticles().

clearCommunicationLists()

void PeriodicBoundaryHandler::clearCommunicationLists

(

)

Removes all ghost particles and bookkeeping for a fresh start.

This function deletes all periodic/ghost ID's and all corresponding ghosts. starting with a fresh clean periodicBoundaryHandler. Useful when another boundary is added - after - particles already have been added

{
    if (NUMBER_OF_PROCESSORS > 1)
    {
        //Clear ID lists
        for (auto& i : periodicParticleList_)
        {
            //logger(INFO,"Size: %",periodicParticleList_[i].size());
            for (int j = 0; j < i.size(); j++)
            {
                delete i[j];
            }
            i.clear();
        }
        
        for (auto& i : periodicGhostList_)
        {
            for (int j = 0; j < i.size(); j++)
            {
                delete i[j];
            }
            i.clear();
        }
        
        //Collect all ghost particles and unflag
        ParticleHandler& pH = getDPMBase()->particleHandler;
        std::set<BaseParticle*> toBeDeleted; //Set because I am too lazy to implement a vector based flushParticle function
        for (BaseParticle* particle : pH)
        {
            if (particle->isPeriodicGhostParticle())
            {
                toBeDeleted.insert(particle);
            }
            
            //Unflag its periodicity
            particle->setInPeriodicDomain(false);
        }
        
        //Flush from mpi boundary and clean the lists
        getDPMBase()->getCurrentDomain()->flushParticles(toBeDeleted);
        getDPMBase()->getCurrentDomain()->cleanCommunicationLists();
        
        //Delete particles
        for (BaseParticle* particle : toBeDeleted)
        {
            pH.removeGhostObject(particle->getIndex());
        }
    }
}

References Domain::cleanCommunicationLists(), Domain::flushParticles(), DPMBase::getCurrentDomain(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), i, j, NUMBER_OF_PROCESSORS, DPMBase::particleHandler, periodicGhostList_, periodicParticleList_, and ParticleHandler::removeGhostObject().

Referenced by SubcriticalMaserBoundaryTEST::activateMaser(), and addObject().

collectGhostParticleData()

void PeriodicBoundaryHandler::collectGhostParticleData

(

)

Collects ghost particle data that needs to be be sent to other processors.

Sending ghosts to other processors is done in an non-blocking communication way and hence the data needs to be stored somewhere. This function collects and stores the data in a convenient format.

{
    //For all new target lists
    unsigned long numberOfTargets = sendTargetList_.size();
    periodicGhostParticleSend_.resize(numberOfTargets);
    periodicGhostComplexitySend_.resize(numberOfTargets);
    for (int i = 0; i < numberOfTargets; i++)
    {
        if (sendTargetList_[i] != PROCESSOR_ID)
        {
            //For all new ghost particles copy particle data and periodic complexity
            for (int j = 0; j < numberOfNewPeriodicGhostParticlesSend_[i]; j++)
            {
                MpiPeriodicParticleID* ppid = newPeriodicParticleList_[sendTargetList_[i]][j];
                BaseParticle* particle = ppid->particle;
                periodicGhostParticleSend_[i].push_back(copyDataFromParticleToMPIParticle(particle));
                for (int k = 0; k < getSize(); k++)
                {
                    periodicGhostComplexitySend_[i].push_back(ppid->targetPeriodicComplexity[k]);
                }
            }
        }
    }
}

References copyDataFromParticleToMPIParticle(), BaseHandler< BasePeriodicBoundary >::getSize(), i, j, k, newPeriodicParticleList_, numberOfNewPeriodicGhostParticlesSend_, MpiPeriodicParticleIDBase::particle, periodicGhostComplexitySend_, periodicGhostParticleSend_, PROCESSOR_ID, sendTargetList_, and MpiPeriodicParticleIDBase::targetPeriodicComplexity.

Referenced by performNewParticleTransmission().

collectInteractionData()

void PeriodicBoundaryHandler::collectInteractionData

(

)

Collects interaction data into an MPI data structure.

Not only particles need to be copied to other ghosts, also their interactions with their surroundings, because these interactions contain history parameters. This function collects the basic interaction data and history data into a useful MPI structure

{
    //For all send target lists
    InteractionHandler& iH = getDPMBase()->interactionHandler;
    unsigned long numberOfTargets = sendTargetList_.size();
    interactionDataSend_.resize(numberOfTargets);
    for (int i = 0; i < numberOfTargets; i++)
    {
        //Allocate enough space
        interactionDataSend_[i] = iH.createMPIInteractionDataArray(numberOfNewInteractionsSend_[i]);
        
        //Fill in the vector
        unsigned int indexInteraction = 0;
        for (BaseInteraction* interaction : newInteractionList_[i])
        {
            interaction->getMPIInteraction(interactionDataSend_[i], indexInteraction);
            indexInteraction++;
        }
    }
}

References InteractionHandler::createMPIInteractionDataArray(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), i, interactionDataSend_, DPMBase::interactionHandler, newInteractionList_, numberOfNewInteractionsSend_, and sendTargetList_.

Referenced by performNewParticleTransmission().

communicateNumberOfNewParticlesAndInteractions()

void PeriodicBoundaryHandler::communicateNumberOfNewParticlesAndInteractions

(

)

Communicate the number of new particles and interactions to target processors.

Every receiving target that will receive ghost particle data will need to know how many particles are coming their way. This function performs that communication step. The same for interactions, not every ghost particle receives the same number of interactions and hence that step is done seperately.

{
    MPIContainer& communicator = MPIContainer::Instance();
    //Communicate to how many particles the target domains receive
    int tagSend;
    for (int i = 0; i < sendTargetList_.size(); i++)
    {
        if (sendTargetList_[i] != PROCESSOR_ID)
        {
            tagSend = PROCESSOR_ID * MAX_PROC + sendTargetList_[i] * 10 + MercuryMPITag::PARTICLE_COUNT;
            communicator.send(numberOfNewPeriodicGhostParticlesSend_[i], sendTargetList_[i], tagSend);
            
            tagSend = PROCESSOR_ID * MAX_PROC + sendTargetList_[i] * 10 + MercuryMPITag::INTERACTION_COUNT;
            communicator.send(numberOfNewInteractionsSend_[i], sendTargetList_[i], tagSend);
        }
    }
    
    //Perform the receive routines
    numberOfNewPeriodicGhostParticlesReceive_.resize(receiveTargetList_.size());
    numberOfNewInteractionsReceive_.resize(receiveTargetList_.size());
    int tagReceive;
    for (int i = 0; i < receiveTargetList_.size(); i++)
    {
        if (receiveTargetList_[i] != PROCESSOR_ID)
        {
            tagReceive = receiveTargetList_[i] * MAX_PROC + PROCESSOR_ID * 10 + MercuryMPITag::PARTICLE_COUNT;
            communicator.receive(numberOfNewPeriodicGhostParticlesReceive_[i], receiveTargetList_[i], tagReceive);
            
            tagReceive = receiveTargetList_[i] * MAX_PROC + PROCESSOR_ID * 10 + MercuryMPITag::INTERACTION_COUNT;
            communicator.receive(numberOfNewInteractionsReceive_[i], receiveTargetList_[i], tagReceive);
        }
    }
}

References i, MPIContainer::Instance(), INTERACTION_COUNT, MAX_PROC, numberOfNewInteractionsReceive_, numberOfNewInteractionsSend_, numberOfNewPeriodicGhostParticlesReceive_, numberOfNewPeriodicGhostParticlesSend_, PARTICLE_COUNT, PROCESSOR_ID, MPIContainer::receive(), receiveTargetList_, MPIContainer::send(), and sendTargetList_.

Referenced by prepareNewParticleTransmission().

communicateTargetDomains()

void PeriodicBoundaryHandler::communicateTargetDomains

(

)

Creats a list of send and receive targets for periodic/ghost particles.

When communicating ghost particles from periodic boundaries in paralell, it is not clear from the start which processor is sending to which processor. First all processors check to how many domains the processor is sending. A second communication step is then performed to tell all other processors which domains the processor is sending to. After this function has completed every processor has a list of targets that the processor sends data to and a list of targets the processor receives data from.

{
#ifdef MERCURYDPM_USE_MPI
    //Step 1: Check to how many domains this domain has to send particles
    int numberOfTargetDomainsLocal = 0;
    for (int index = 0; index < NUMBER_OF_PROCESSORS; index++) 
    {
        if (newPeriodicParticleList_[index].size() > 0)
        {
            numberOfTargetDomainsLocal++;
            sendTargetList_.push_back(index);
            numberOfNewPeriodicGhostParticlesSend_.push_back(newPeriodicParticleList_[index].size());
        }
    }
 
    //Communicate with other domains to how many domains this domain is sending
    std::vector<int> numberOfTargetDomains(NUMBER_OF_PROCESSORS);
    MPIContainer::Instance().allGather(numberOfTargetDomainsLocal,1,numberOfTargetDomains,1);    
 
    //Step 2: Communicate to other domains what the target domains are
    std::vector<int> receiveTargetList;
    for (int index = 0; index < NUMBER_OF_PROCESSORS; index++)
    {
        if (numberOfTargetDomains[index] > 0)
        {
            if (index == PROCESSOR_ID)
            {
                MPIContainer::Instance().broadcast(sendTargetList_.data(), numberOfTargetDomainsLocal, index);
            }
            else
            {
                receiveTargetList.resize(numberOfTargetDomains[index], 0);
                MPIContainer::Instance().broadcast(receiveTargetList.data(),numberOfTargetDomains[index],index);
            }
        
            //If this domain is a target, flag it.
            for (int i = 0; i < receiveTargetList.size(); i++)
            {
                if (receiveTargetList[i] == PROCESSOR_ID)
                {
                    receiveTargetList_.push_back(index);
                }
            } 
        }
    }
#endif
}

References MPIContainer::broadcast(), i, MPIContainer::Instance(), newPeriodicParticleList_, NUMBER_OF_PROCESSORS, numberOfNewPeriodicGhostParticlesSend_, PROCESSOR_ID, receiveTargetList_, sendTargetList_, and size.

Referenced by prepareNewParticleTransmission().

computePeriodicComplexity() [1/2]

void PeriodicBoundaryHandler::computePeriodicComplexity	(	std::vector< int > &	periodicComplexity,
		int &	totalPeriodicComplexity,
		Vec3D	position
	)

Computes the periodic complexity and total periodic complexity based on a given position.

This function computes the periodic complexity, a vector of intergers that indicate how this particle is related to the periodic boundaries. Every boundary has a status value following: [2] = Real particle, not in the proximity of the boundary [1] = Real particle, in the proximity of the boundary [-1] = ghost particle, in the proximity of the boundary [-2] = ghost particle, not in the proximity of the boundary In addition to the periodic complexity it also computes the totalPeriodicComplexity that indicates with how many boundaries this position is in close proximity

Parameters

[in,out]	periodicComplexity	The periodic complexity indicating how a given position is related to the periodic boundaries.
[in,out]	totalPeriodicComplexity	The number of boundaries the position is in close proximity with.
[in]	position	The input position for which the relation to the boundaries are determined.

{
    //Compute the new position
    periodicComplexity.resize(this->getSize());
    totalPeriodicComplexity = 0;
    int index = 0;
    for (BasePeriodicBoundary* boundary : *this)
    {
        Mdouble distance = boundary->getDistance(position);
        if (std::abs(distance) <= interactionDistance_)
        {
            if (distance > 0)
            {
                //real particle
                periodicComplexity[index] = 1;
                totalPeriodicComplexity++;
            }
            else if (distance < 0)
            {
                //ghost particle
                periodicComplexity[index] = -1;
            }
            else //distance == 0 In extremely rare cases (test cases mostly)
            {
                //Check if on left or right side of boundary
                if (boundary->isClosestToLeftBoundary(position))
                {
                    //ghost particle on the left side
                    periodicComplexity[index] = -1;
                }
                else
                {
                    //real particle on the right side
                    periodicComplexity[index] = 1;
                    totalPeriodicComplexity++;
                }
            }
        }
        else
        {
            if (distance < 0)
            {
                periodicComplexity[index] = -2;
            }
            else
            {
                periodicComplexity[index] = 2;
            }
        }
        index++;
    }
/*
    //Modify periodic complexity in case of maser
    for (int b = 0; b < getSize(); b++)
    {
        objects_[b]->modifyPeriodicComplexity(periodicComplexity, position, b);
    }
*/
}

References abs(), BasePeriodicBoundary::getDistance(), BaseHandler< BasePeriodicBoundary >::getSize(), interactionDistance_, and BasePeriodicBoundary::isClosestToLeftBoundary().

computePeriodicComplexity() [2/2]

std::vector< int > PeriodicBoundaryHandler::computePeriodicComplexity

(

Vec3D

position

)

Computes the periodic complexity based on a given position.

This function computes the periodic complexity, a vector of intergers that indicate how this particle is related to the periodic boundaries. Every boundary has a status value following: [2] = Real particle, not in the proximity of the boundary [1] = Real particle, in the proximity of the boundary [-1] = ghost particle, in the proximity of the boundary [-2] = ghost particle, not in the proximity of the boundary

Parameters

[in]

position

The input position for which the relation to the boundaries are determined.

Returns

Periodic complexity of the given position

{
    std::vector<int> periodicComplexity;
    int totalPeriodicComplexity;
    
    computePeriodicComplexity(periodicComplexity, totalPeriodicComplexity, position);
    
    return periodicComplexity;
}

Referenced by findNewParticle(), processReceivedGhostParticleData(), updateParticles(), and updateParticleStatus().

finaliseNewParticleTransmission()

void PeriodicBoundaryHandler::finaliseNewParticleTransmission

(

)

creates the ghost particles and performs some bookkeeping to keep track of them

{
    //Process the global received data
    for (int i = 0; i < receiveTargetList_.size(); i++)
    {
        std::vector<BaseParticle*> newGhostParticles;
        processReceivedGhostParticleData(i, newGhostParticles);
        processReceivedInteractionData(i, newGhostParticles);
    }
    
    //Process the local data
    std::vector<BaseParticle*> newGhostParticles;
    processLocalGhostParticles(newGhostParticles);
    processLocalInteractionData(newGhostParticles);
    
    //Process the periodic particles;
    processPeriodicParticles();
    
    //Clear lists
    receiveTargetList_.clear();
    sendTargetList_.clear();
    numberOfNewPeriodicGhostParticlesReceive_.clear();
    numberOfNewPeriodicGhostParticlesSend_.clear();
    numberOfNewInteractionsSend_.clear();
    numberOfNewInteractionsReceive_.clear();
    periodicGhostParticleReceive_.clear();
    periodicGhostParticleSend_.clear();
    periodicGhostComplexityReceive_.clear();
    periodicGhostComplexitySend_.clear();
    interactionDataSend_.clear();
    interactionDataReceive_.clear();
    newInteractionList_.clear();
    for (auto& i : newPeriodicParticleList_)
    {
        i.clear();
    }
    for (auto& i : newPeriodicParticleList_)
    {
        i.clear();
    }
}

References i, interactionDataReceive_, interactionDataSend_, newInteractionList_, newPeriodicParticleList_, numberOfNewInteractionsReceive_, numberOfNewInteractionsSend_, numberOfNewPeriodicGhostParticlesReceive_, numberOfNewPeriodicGhostParticlesSend_, periodicGhostComplexityReceive_, periodicGhostComplexitySend_, periodicGhostParticleReceive_, periodicGhostParticleSend_, processLocalGhostParticles(), processLocalInteractionData(), processPeriodicParticles(), processReceivedGhostParticleData(), processReceivedInteractionData(), receiveTargetList_, and sendTargetList_.

Referenced by addNewParticle(), and addNewParticles().

finalisePositionAndVelocityUpdate()

void PeriodicBoundaryHandler::finalisePositionAndVelocityUpdate

(

)

Communicates position and velocity data from periodic boundaries and updates ghost particles.

{
    //Update the positions, velocities and periodic complexities of particles
    updateParticles();
    
    //Delete vectors
    updatePositionDataSend_.clear();
    updatePositionDataReceive_.clear();
    updateVelocityDataSend_.clear();
    updateVelocityDataReceive_.clear();
}

References updateParticles(), updatePositionDataReceive_, updatePositionDataSend_, updateVelocityDataReceive_, and updateVelocityDataSend_.

Referenced by updateStatus().

findBoundariesToIgnore()

void PeriodicBoundaryHandler::findBoundariesToIgnore	(	BaseParticle *	particle,
		std::vector< int > &	periodicComplexity,
		int &	totalPeriodicComplexity
	)

Disables boundaries that need to be ignored (i.e. a non-maser particle needs to ignore the maser boundary)

findNewInteractions()

void PeriodicBoundaryHandler::findNewInteractions

(

)

Finds interactions that accompany future ghost particles.

Ghost particles have interactions with history parameters. These interactions also need to be copied to the other processor. This function finds these interactions and stores them.

{
    //Check all new particle lists
    newInteractionList_.resize(sendTargetList_.size());
    for (int i = 0; i < sendTargetList_.size(); i++)
    {
        for (int p = 0; p < newPeriodicParticleList_[sendTargetList_[i]].size(); p++)
        {
            BaseParticle* particle = newPeriodicParticleList_[sendTargetList_[i]][p]->particle;
            
            //Loop over all its interactions
            std::vector<BaseInteraction*> interactions = particle->getInteractions();
            for (BaseInteraction* interaction : interactions)
            {
                //Find out what the new particle is interacting with
                BaseParticle* particleP = dynamic_cast<BaseParticle*>(interaction->getP());
                BaseParticle* objectI = dynamic_cast<BaseParticle*>(interaction->getI());
                
                //If the P in the interaction structure is the new particle, find I
                if (particle == particleP)
                {
                    //Check if the new particle is interacting with a wall
                    if (!objectI)
                    {
                        newInteractionList_[i].push_back(interaction);
                    }
                    else //is I a particle
                    {
                        newInteractionList_[i].push_back(interaction);
                    }
                }
                else //newBoundaryParticle is I in the interaction, P can only be a particle
                {
                    newInteractionList_[i].push_back(interaction);
                }
            }
        }
        
        //Store the number of interactions
        numberOfNewInteractionsSend_.push_back(newInteractionList_[i].size());
    }
}

References BaseInteractable::getInteractions(), i, newInteractionList_, newPeriodicParticleList_, numberOfNewInteractionsSend_, p, sendTargetList_, and size.

Referenced by prepareNewParticleTransmission().

findNewParticle()

void PeriodicBoundaryHandler::findNewParticle

(

BaseParticle *

particle

)

Checks if a particle is in the periodic domain, but are not flagged as being in the periodic domain.

Particles that are located close to a periodic boundary, but not flagged as being in the periodic domain will be added to a list by this function. If they indeed have to be added a periodic ID will be created that stores some basic information required to setup a ghost particle.

Parameters

[in]

particle

A particle that is considered to be added to the periodic boundary lists

{
    //Skip the ghost particles
    if (checkIfAddNewParticle(particle))
    {
        //If the particle was not yet flagged to be in the periodic domain, check if it is in the domain
        //if(!particle->isInPeriodicDomain())
        {
            int totalPeriodicComplexity;
            std::vector<int> periodicComplexity;
            computePeriodicComplexity(periodicComplexity, totalPeriodicComplexity, particle->getPosition());
            
            //Modify periodic complexity tailored to specific boundary requirements
            for (int b = 0; b < getSize(); b++)
            {
                objects_[b]->modifyPeriodicComplexity(periodicComplexity, totalPeriodicComplexity, particle, b);
            }
            
            //Set periodicComplexity
            particle->setPeriodicComplexity(periodicComplexity);
            
            //Create ghost particle ID's
            std::vector<std::vector<int> > list(0);
            if (totalPeriodicComplexity > 0)
            {
                periodicComplexity = particle->getPeriodicComplexity();
                
                //Generating all possible complexities.
                generateGhosts(list, periodicComplexity, periodicComplexity, getSize());
                //logger(VERBOSE,"New ghost particles: %",list.size() - 1);
                
                //Note: the first one in the list is the real particle such that we skip it
                for (int i = 1; i < list.size(); i++)
                {
                    //Compute target domain
                    //logger(VERBOSE,"Particle position: %",particle->getPosition());
                    int targetProcessor = findTargetProcessor(list[i]);
                    
                    //Create periodic particle ID
                    MpiPeriodicParticleID* ppid = new MpiPeriodicParticleID;
                    ppid->particle = particle;
                    ppid->periodicComplexity = periodicComplexity;
                    ppid->targetPeriodicComplexity = list[i];
                    ppid->targetProcessor = targetProcessor;
                    newPeriodicParticleList_[targetProcessor].push_back(ppid);
                    logger(VERBOSE, "Adding a periodic particle with id % and real particle position: %",
                           particle->getId(), particle->getPosition());
                }
            }
        }
    }
}

References b, checkIfAddNewParticle(), computePeriodicComplexity(), findTargetProcessor(), generateGhosts(), BaseObject::getId(), BaseParticle::getPeriodicComplexity(), BaseInteractable::getPosition(), BaseHandler< BasePeriodicBoundary >::getSize(), i, logger, newPeriodicParticleList_, BaseHandler< BasePeriodicBoundary >::objects_, MpiPeriodicParticleIDBase::particle, MpiPeriodicParticleIDBase::periodicComplexity, BaseParticle::setPeriodicComplexity(), MpiPeriodicParticleIDBase::targetPeriodicComplexity, MpiPeriodicParticleIDBase::targetProcessor, and VERBOSE.

Referenced by addNewParticle(), and findNewParticles().

findNewParticles()

void PeriodicBoundaryHandler::findNewParticles

(

)

Loops over all particles in the simulation to check if they need to be added to the periodic lists.

Loops over all base particles in the domain to see if they have to be added to the periodic domain lists

{
    //Check for all particles if there are unassigned periodic particles
    for (auto particle_it = getDPMBase()->particleHandler.begin();
         particle_it != getDPMBase()->particleHandler.end(); particle_it++)
    {
        findNewParticle(*particle_it);
    }
    
}

References findNewParticle(), and BaseHandler< BasePeriodicBoundary >::getDPMBase().

Referenced by addNewParticles().

findTargetProcessor()

int PeriodicBoundaryHandler::findTargetProcessor

(

const std::vector< int > &

complexity

)

For a given complexity this function returns the target processor.

A given complexity can be turned into a particle position, somewhere in the simulation domain. This position belongs to a specific processor and this function computes which processor this actually is. Note: When an PMG particle is in the periodic domain, it needs to be copied into a PG"MG" particle. A particle that is in the MG domain, but is not updated by the M boundaries. The position of this MG particle is not in the actual domain to where it has to be copied, but slightly outside. For that reason the position is shifted to the middle of the domain the official particle is found on, and that position is used to determine the actual domain the particle has to go to. Note that currently this only works for a structured grid with equal domain sizes

Parameters

[in]

complexity

A complexity vector which determines the location of a ghost particle

Returns

The processor ID of the ghost particle location

{
    //Find the middle of this domain (or any valid point anyway)
    Vec3D middlePosition = getDPMBase()->domainHandler.getCurrentDomain()->getMiddle();
    
    //Create the particle with a target position
    SphericalParticle particle;
    particle.setPosition(middlePosition);
    shiftParticle(&particle, complexity);
    
    //Obtain target domain
    int targetGlobalIndex = getDPMBase()->domainHandler.getParticleDomainGlobalIndex(&particle);
    return getDPMBase()->domainHandler.getParticleProcessor(targetGlobalIndex);
}

References DPMBase::domainHandler, DomainHandler::getCurrentDomain(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), Domain::getMiddle(), DomainHandler::getParticleDomainGlobalIndex(), DomainHandler::getParticleProcessor(), BaseInteractable::setPosition(), and shiftParticle().

Referenced by findNewParticle().

flushParticles()

void PeriodicBoundaryHandler::flushParticles

(

std::set< BaseParticle * > &

particlesToBeFlushed

)

Removes particles from the periodiocParticleList_ and periociGhostList_.

Todo:

This function uses a brute force method to flush the particles, this can be done in a smarter way if profiling shows that this is a bottleneck.

{
    std::set<MpiPeriodicParticleIDBase*> toBeDeleted;
    for (auto p_it : particlesToBeFlushed)
    {
        for (int i = 0; i < NUMBER_OF_PROCESSORS; i++)
        {
            for (auto& p : periodicParticleList_[i])
            {
                if (p != nullptr)
                {
                    if (p_it == p->particle)
                    {
                        toBeDeleted.insert(p);
                        p = nullptr;
                    }
                }
            }
        }
        
        for (int i = 0; i < NUMBER_OF_PROCESSORS; i++)
        {
            for (auto& p : periodicGhostList_[i])
            {
                if (p != nullptr)
                {
                    if (p_it == p->particle)
                    {
                        toBeDeleted.insert(p);
                        p = nullptr;
                    }
                }
            }
        }
    }
    
    //Delete ID's
    for (auto id_it : toBeDeleted)
    {
        delete id_it;
    }
    
}

References i, NUMBER_OF_PROCESSORS, p, periodicGhostList_, and periodicParticleList_.

Referenced by DPMBase::checkInteractionWithBoundaries(), and DPMBase::deleteGhostParticles().

flushPeriodicParticles()

void PeriodicBoundaryHandler::flushPeriodicParticles

(

std::set< BaseParticle * > &

particlesToBeDeleted

)

Flushes periodioc particles that need to be deleted from the periodic lists.

generateGhosts()

void PeriodicBoundaryHandler::generateGhosts	(	std::vector< std::vector< int > > &	list,
		std::vector< int >	periodicComplexity,
		std::vector< int > &	complexity,
		int	level
	)

generates a list of periodic complexities corresponding to a give real particle.

Given a real particle that interacts with periodic boundaries, ghosts need to be generated. Depending on the number of boundaries this particle is interacting the number of ghosts differs. A recursive function makes sure that all possibilities of the periodic complexity of the real particle are generated. Note that the first periodic complexity in the list returned by this function is always the periodic complexity of the real particle.

Parameters

[in,out]	list	A list containing all possible ghost periodic complexities for a given periodic complexity
[in]	periodicComplexity	A periodic complexity of a real particle that is used to determine all its possible ghost periodic complexities
[in,out]	complexity	One of the possible permutations of the ghost periodic complexity
[in]	level	Indicator at which level the recursive function is

{
    //Add the complexity to the list
    if (level == 0)
    {
        //logger(VERBOSE,"complexity: [%, %, %]",complexity[0], complexity[1], complexity[2]);
        list.push_back(complexity);
    }
    else
    {
        //Vary complexity values of level
        if (periodicComplexity[level - 1] == 1)
        {
            complexity[level - 1] = 1;
            generateGhosts(list, periodicComplexity, complexity, level - 1);
            
            complexity[level - 1] = -1;
            generateGhosts(list, periodicComplexity, complexity, level - 1);
        }
        else
        {
            generateGhosts(list, periodicComplexity, complexity, level - 1);
        }
    }
}

Referenced by findNewParticle().

getInteractionDistance()

Mdouble PeriodicBoundaryHandler::getInteractionDistance

(

)

Returns the interaction distance.

This distance determines when a particle starts to interact with a periodic boundary.

Returns

The interaction distance.

{
    return interactionDistance_;
}

References interactionDistance_.

getMPIFlags()

void PeriodicBoundaryHandler::getMPIFlags	(	BaseParticle *	particle,
		bool &	isInMPIDomain,
		bool &	isMPIParticle
	)

Determines if a given particle is in the MPI domain and if it is an MPI Particle.

Mixed particles that are both a interacting with a periodic boundary and also in an mpi boundary are special cases that need to be handled with care. As example a real particle that moves to another domain will be removed by the mpi boundaries. To avoid segmentation faults the particle needs to be flushed from the periodic boundaries as well. This function determines if a particle is in the MPI domain and if it is a MPIParticle or not.

Parameters

[in]	particle	The particle for which the MPI flags are being computed
[in,out]	isInMPIDomain	A check to see if the particle is in the MPI domain (true) or not (false)
[in,out]	isMPIParticle	A bool to see if the particle is a ghost in the MPI domain (true) or not (false)

{
    //Check if the particle is actually in this domain. If not the case it is an "MG"-particle
    Domain* domain = getDPMBase()->domainHandler.getCurrentDomain();
    if (domain->containsParticle(particle))
    {
        //If the particle is in the inner domain, it is not in the mpi doamin
        if (domain->isInInnerDomain(particle))
        {
            isInMPIDomain = false;
            isMPIParticle = false;
        }
        else
        {
            isInMPIDomain = true;
            isMPIParticle = false;
        }
    }
    else
    {
        //If the particle is outside the communication zone it is not in the mpi domain
        if (domain->isInGreaterDomain(particle))
        {
            isInMPIDomain = true;
            isMPIParticle = true;
        }
        else
        {
            isInMPIDomain = false;
            isMPIParticle = true;
        }
    }
}

References domain, DPMBase::domainHandler, DomainHandler::getCurrentDomain(), and BaseHandler< BasePeriodicBoundary >::getDPMBase().

Referenced by setMPIFlags(), and updateParticleStatus().

getName()

std::string PeriodicBoundaryHandler::getName ( ) const

overridevirtual

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

This determines the unique name of the current class

Returns

The string "PeriodicBoundaryHandler"

Implements BaseHandler< BasePeriodicBoundary >.

{
    return "PeriodicBoundaryHandler";
}

getNumberOfPeriodicGhostParticles()

unsigned int PeriodicBoundaryHandler::getNumberOfPeriodicGhostParticles

(

)

Returns the number of particles that are flagged is periodicGhostParticle.

Counts the number of periodic ghost particles by simply checking how many entries there are in the periodicGhostLists.

Returns

The number of particles that have isPeriodicGhostParticle() == true

{
    unsigned int sum = 0;
    for (auto& index : periodicGhostList_)
    {
        sum += index.size();
    }
    return sum;
}

References periodicGhostList_.

Referenced by ParticleHandler::getNumberOfRealObjectsLocal().

getNumberOfTruePeriodicGhostParticles()

Mdouble PeriodicBoundaryHandler::getNumberOfTruePeriodicGhostParticles

(

)

Returns the number of particles that are flagged as periodicGhostParticles, but not as MPIParticles.

Counts the number of true periodic ghost particles by checking how many entries there are in the periodiocGhostLists, but ignores mixed ghost particles that additionally have the flay isMPIParticle() == true.

Returns

The number of periodic particles that are not also MPIParticles

{
    int sum = 0;
    for (auto& index : periodicGhostList_)
    {
        int numberOfMPIParticles = 0;
        for (int pIndex = 0; pIndex < index.size(); pIndex++)
        {
            if (index[pIndex]->particle->isMPIParticle() == true)
            {
                numberOfMPIParticles++;
            }
        }
        sum += (index.size() - numberOfMPIParticles);
    }
    return sum;
}

References periodicGhostList_.

initialise()

void PeriodicBoundaryHandler::initialise

(

)

Initialises the communication list vectors as they can not be determined on compile time.

On compile time it is not clear how many processors will be used when running the simulation and therefore the basic periodioc lists can't be initialised /bi the constructor. This function initialises the vectors to avoid segmentationfaults.

{
    newPeriodicParticleList_ = std::vector<PeriodicList>(NUMBER_OF_PROCESSORS, PeriodicList(0));
    periodicParticleList_ = std::vector<PeriodicList>(NUMBER_OF_PROCESSORS, PeriodicList(0));
    periodicGhostList_ = std::vector<PeriodicGhostList>(NUMBER_OF_PROCESSORS, PeriodicGhostList(0));
}

References newPeriodicParticleList_, NUMBER_OF_PROCESSORS, periodicGhostList_, and periodicParticleList_.

Referenced by DPMBase::constructor(), and DPMBase::DPMBase().

operator=()

PeriodicBoundaryHandler PeriodicBoundaryHandler::operator=

(

const PeriodicBoundaryHandler &

rhs

)

Assignment operator, copies only the vector of BasePeriodicBoundary and sets the other variables to 0/nullptr.

Parameters

[in]

rhs

The PeriodicBoundaryHandler on the right hand side of the assignment.

This is not a copy assignment operator! It just copies all BaseBoundary from the other handler into this handler, and clears all other variables.

{
    if (this != &rhs)
    {
        objects_.clear();
        interactionDistance_ = rhs.interactionDistance_;
    }
    logger(DEBUG, "PeriodicBoundaryHandler PeriodicBoundaryHandler::operator =(const BoundaryHandler& rhs)");
    return *this;
}

References DEBUG, interactionDistance_, logger, and BaseHandler< BasePeriodicBoundary >::objects_.

performActionsBeforeAddingParticles()

void PeriodicBoundaryHandler::performActionsBeforeAddingParticles

(

)

Actions that boundaries perform before adding new periodic/ghost particles.

{
    for (BasePeriodicBoundary* boundary : *this)
    {
        boundary->performActionsBeforeAddingParticles();
    }
}

References BasePeriodicBoundary::performActionsBeforeAddingParticles().

Referenced by addNewParticles().

performNewParticleTransmission()

void PeriodicBoundaryHandler::performNewParticleTransmission

(

)

Collects and sends the ghost particle data.

{
    MPIContainer& communicator = MPIContainer::Instance();
    int numberOfTargetsReceive = receiveTargetList_.size();
    int numberOfTargetsSend = sendTargetList_.size();
    
    //Make sure that the receiving vectors have the correct length
    periodicGhostParticleReceive_.resize(numberOfTargetsReceive);
    periodicGhostComplexityReceive_.resize(numberOfTargetsReceive);
    interactionDataReceive_.resize(numberOfTargetsReceive);
    InteractionHandler& iH = getDPMBase()->interactionHandler;
    for (int i = 0; i < numberOfTargetsReceive; i++)
    {
        periodicGhostParticleReceive_[i].resize(numberOfNewPeriodicGhostParticlesReceive_[i]);
        periodicGhostComplexityReceive_[i].resize(numberOfNewPeriodicGhostParticlesReceive_[i] * getSize());
        interactionDataReceive_[i] = iH.createMPIInteractionDataArray(numberOfNewInteractionsReceive_[i]);
    }
    
    //Collect data for sending
    collectGhostParticleData();
    collectInteractionData();
    
    //Send particle and interaction data
    for (int i = 0; i < numberOfTargetsSend; i++)
    {
        if (sendTargetList_[i] != PROCESSOR_ID)
        {
            //Send particle data
            int sendCount = numberOfNewPeriodicGhostParticlesSend_[i];
            int processor = sendTargetList_[i];
            int tagSend = PROCESSOR_ID * MAX_PROC + sendTargetList_[i] * 10 + MercuryMPITag::PARTICLE_DATA;
            communicator.send(periodicGhostParticleSend_[i].data(), MercuryMPIType::PARTICLE, sendCount, processor,
                              tagSend);
            
            //Send complexity
            tagSend = PROCESSOR_ID * MAX_PROC + sendTargetList_[i] * 10 + MercuryMPITag::PERIODIC_COMPLEXITY;
            sendCount = numberOfNewPeriodicGhostParticlesSend_[i] * getSize();
            communicator.send(periodicGhostComplexitySend_[i].data(), sendCount, processor, tagSend);
            
            //Send interactions
            tagSend = PROCESSOR_ID * MAX_PROC + sendTargetList_[i] * 10 + MercuryMPITag::INTERACTION_DATA;
            sendCount = numberOfNewInteractionsSend_[i];
            if (sendCount > 0)
            {
                communicator.send(interactionDataSend_[i], MercuryMPIType::INTERACTION, sendCount, processor, tagSend);
            }
        }
    }
    
    //Receive data
    for (int i = 0; i < numberOfTargetsReceive; i++)
    {
        if (receiveTargetList_[i] != PROCESSOR_ID)
        {
            //Receive particle data
            int receiveCount = numberOfNewPeriodicGhostParticlesReceive_[i];
            int processor = receiveTargetList_[i];
            int tagReceive = receiveTargetList_[i] * MAX_PROC + PROCESSOR_ID * 10 + MercuryMPITag::PARTICLE_DATA;
            communicator.receive(periodicGhostParticleReceive_[i].data(), MercuryMPIType::PARTICLE,
                                 receiveCount, processor, tagReceive);
            
            //Receive complexity
            tagReceive = receiveTargetList_[i] * MAX_PROC + PROCESSOR_ID * 10 + MercuryMPITag::PERIODIC_COMPLEXITY;
            receiveCount = numberOfNewPeriodicGhostParticlesReceive_[i] * getSize();
            communicator.receive(periodicGhostComplexityReceive_[i].data(), receiveCount, processor, tagReceive);
            
            //Send interactions
            tagReceive = receiveTargetList_[i] * MAX_PROC + PROCESSOR_ID * 10 + MercuryMPITag::INTERACTION_DATA;
            receiveCount = numberOfNewInteractionsReceive_[i];
            if (receiveCount > 0)
            {
                communicator.receive(interactionDataReceive_[i], MercuryMPIType::INTERACTION, receiveCount, processor,
                                     tagReceive);
            }
        }
    }
    
    //Synchronise the communications
    communicator.sync();
}

References collectGhostParticleData(), collectInteractionData(), InteractionHandler::createMPIInteractionDataArray(), data, BaseHandler< BasePeriodicBoundary >::getDPMBase(), BaseHandler< BasePeriodicBoundary >::getSize(), i, MPIContainer::Instance(), INTERACTION, INTERACTION_DATA, interactionDataReceive_, interactionDataSend_, DPMBase::interactionHandler, MAX_PROC, numberOfNewInteractionsReceive_, numberOfNewInteractionsSend_, numberOfNewPeriodicGhostParticlesReceive_, numberOfNewPeriodicGhostParticlesSend_, PARTICLE, PARTICLE_DATA, PERIODIC_COMPLEXITY, periodicGhostComplexityReceive_, periodicGhostComplexitySend_, periodicGhostParticleReceive_, periodicGhostParticleSend_, PROCESSOR_ID, MPIContainer::receive(), receiveTargetList_, MPIContainer::send(), sendTargetList_, and MPIContainer::sync().

Referenced by addNewParticle(), and addNewParticles().

prepareNewParticleTransmission()

void PeriodicBoundaryHandler::prepareNewParticleTransmission

(

)

Initial preparation work for sending ghost particles.

The first step in adding new particles is the prepare step. First the target domains are determined such that every processors knows where particles are coming from. This step includes finding new particles. The second step is to find the interactions that have to be send with the new particles. The receiving targets need to know how many particles and interactions they receive which is the third step. Finally a communication synchronisation is performed to actually perform the communications which were pending in the MPIContainer.

{
    //Communicate which domains send and which domains receive particles
    communicateTargetDomains();
    
    //Find new interactions
    findNewInteractions();
    
    //Communicate the number of particles and interactions send to the other domains
    communicateNumberOfNewParticlesAndInteractions();
    
    //Synchronise the communications
    MPIContainer::Instance().sync();
}

References communicateNumberOfNewParticlesAndInteractions(), communicateTargetDomains(), findNewInteractions(), MPIContainer::Instance(), and MPIContainer::sync().

Referenced by addNewParticle(), and addNewParticles().

preparePositionAndVelocityUpdate()

void PeriodicBoundaryHandler::preparePositionAndVelocityUpdate

(

)

Collects the position and velocity data from periodic boundaries.

{
    MPIContainer& communicator = MPIContainer::Instance();
    unsigned int numberOfProcessors = communicator.getNumberOfProcessors();
    unsigned int processorID = communicator.getProcessorID();
    
    //For all lists that contain periodic particles
    for (unsigned int i = 0; i < numberOfProcessors; i++)
    {
        unsigned int numberOfParticles = periodicParticleList_[i].size();
        if (numberOfParticles > 0 && i != processorID)
        {
            //Increase the vector size;
            updatePositionDataSend_.emplace_back(0);
            updateVelocityDataSend_.emplace_back(0);
            
            //Collect the data
            for (unsigned int p = 0; p < numberOfParticles; p++)
            {
                BaseParticle* particle = periodicParticleList_[i][p]->particle;
                updatePositionDataSend_.back().push_back(copyPositionFrom(particle));
                updateVelocityDataSend_.back().push_back(copyVelocityFrom(particle));
            }
            
            //Send position data
            unsigned int count = numberOfParticles;
            unsigned int processor = i;
            unsigned int tag = processorID * MAX_PROC + processor * 10 + MercuryMPITag::POSITION_DATA;
            communicator.send(updatePositionDataSend_.back().data(), MercuryMPIType::POSITION, count, processor, tag);
            
            //Send velocity data
            tag = processorID * MAX_PROC + processor * 10 + MercuryMPITag::VELOCITY_DATA;
            communicator.send(updateVelocityDataSend_.back().data(), MercuryMPIType::VELOCITY, count, processor, tag);
        }
    }
    
    //For all lists that contain ghost particles
    for (int i = 0; i < numberOfProcessors; i++)
    {
        unsigned int numberOfParticles = periodicGhostList_[i].size();
        if (numberOfParticles > 0 && i != processorID)
        {
            //Increase the vector size
            updatePositionDataReceive_.emplace_back(numberOfParticles);
            updateVelocityDataReceive_.emplace_back(numberOfParticles);
            
            //Receive position data
            int count = numberOfParticles;
            int processor = i;
            int tag = processor * MAX_PROC + processorID * 10 + MercuryMPITag::POSITION_DATA;
            communicator.receive(updatePositionDataReceive_.back().data(), MercuryMPIType::POSITION, count, processor,
                                 tag);
            
            //Receive velocity data
            tag = processor * MAX_PROC + processorID * 10 + MercuryMPITag::VELOCITY_DATA;
            communicator.receive(updateVelocityDataReceive_.back().data(), MercuryMPIType::POSITION, count, processor,
                                 tag);
        }
    }
    
    //Synchronise all the requests
    communicator.sync();
}

References copyPositionFrom(), copyVelocityFrom(), MPIContainer::getNumberOfProcessors(), MPIContainer::getProcessorID(), i, MPIContainer::Instance(), MAX_PROC, p, periodicGhostList_, periodicParticleList_, POSITION, POSITION_DATA, MPIContainer::receive(), MPIContainer::send(), MPIContainer::sync(), updatePositionDataReceive_, updatePositionDataSend_, updateVelocityDataReceive_, updateVelocityDataSend_, VELOCITY, and VELOCITY_DATA.

Referenced by updateStatus().

processLocalGhostParticles()

void PeriodicBoundaryHandler::processLocalGhostParticles

(

std::vector< BaseParticle * > &

newParticles

)

Creates ghost particles of periodic particles that are located on the same processor.

Ghost particles sometimes are located on the same processor as the original periodic particle. These particles are processed in this function. Firstly the ghost is created with the correct position, periodic complexity and flags and is added to the particleHandler. Secondly ID's are made for both ghost and periodic particles to keep track of their movements. Periodic particles are flaged now as being in the periodic domain.

{
    for (int i = 0; i < sendTargetList_.size(); i++)
    {
        //Check if the processor is sending ghosts to itself
        if (sendTargetList_[i] == PROCESSOR_ID)
        {
            for (int j = 0; j < numberOfNewPeriodicGhostParticlesSend_[i]; j++)
            {
                MpiPeriodicParticleID* ppid = newPeriodicParticleList_[PROCESSOR_ID][j];
                BaseParticle* particle = ppid->particle;
                
                //Create ghost particle
                BaseParticle* pGhost = particle->copy();
                
                //Obtain and set the ghost periodic complexity
                pGhost->setPeriodicComplexity(ppid->targetPeriodicComplexity);
                
                //Shift the particle
                shiftParticle(pGhost);
                
                //Set the correct flags
                pGhost->setPeriodicGhostParticle(true);
                pGhost->setInPeriodicDomain(true);
                //Note: mpi flags dont have to be set for local particles
                //these flags are copied from the original particle
                logger(VERBOSE, "Adding a ghost with id % at position %", pGhost->getId(), pGhost->getPosition());
                
                //Finally add it to the particle handler
                getDPMBase()->particleHandler.addGhostObject(pGhost);
                
                //Do some bookkeeping
                MpiPeriodicGhostParticleID* gpid = new MpiPeriodicGhostParticleID;
                gpid->particle = pGhost;
                gpid->otherParticle = particle;
                gpid->realPeriodicComplexity = particle->getPeriodicComplexity();
                periodicGhostList_[PROCESSOR_ID].push_back(gpid);
                
                //Flag real particle and do some bookkeeping
                particle->setInPeriodicDomain(true);
                ppid->otherParticle = pGhost;
                
                //Add to the new particle list for an interaction update
                newParticles.push_back(pGhost);
            }
        }
    }
}

References ParticleHandler::addGhostObject(), BaseParticle::copy(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), BaseObject::getId(), BaseParticle::getPeriodicComplexity(), BaseInteractable::getPosition(), i, j, logger, newPeriodicParticleList_, numberOfNewPeriodicGhostParticlesSend_, MpiPeriodicParticleIDBase::otherParticle, MpiPeriodicParticleIDBase::particle, DPMBase::particleHandler, periodicGhostList_, PROCESSOR_ID, MpiPeriodicParticleIDBase::realPeriodicComplexity, sendTargetList_, BaseParticle::setInPeriodicDomain(), BaseParticle::setPeriodicComplexity(), BaseParticle::setPeriodicGhostParticle(), shiftParticle(), MpiPeriodicParticleIDBase::targetPeriodicComplexity, and VERBOSE.

Referenced by finaliseNewParticleTransmission().

processLocalInteractionData()

void PeriodicBoundaryHandler::processLocalInteractionData

(

std::vector< BaseParticle * > &

newParticles

)

Process the interaction data for local ghosts.

Newly added ghost particles also need their interactions. This function adds the interactions to the correct ghost particles. The interaction data send over MPI only contains the ID's of the particles so a search has to be performed to obtain the particle pointers. For the ghost particles we use the newParticle list that contains all newly added ghost particles. For the other particle an hgrid search is performed. Finally when the two interactables are found the data is copied from the data vector. Note: because these ghost particles are local, the data is actually never send.

Parameters

[in]

newParticles

A list containing the newly added ghost particles

{
    InteractionHandler& iH = getDPMBase()->interactionHandler;
    for (int i = 0; i < sendTargetList_.size(); i++)
    {
        if (sendTargetList_[i] == PROCESSOR_ID)
        {
            for (int l = 0; l < numberOfNewInteractionsSend_[i]; l++)
            {
                unsigned int identificationP;
                unsigned int identificationI;
                bool isWallInteraction;
                unsigned timeStamp;
                
                //Get the general information required to setup a new interaction
                iH.getInteractionDetails(interactionDataSend_[i], l, identificationP, identificationI,
                                         isWallInteraction, timeStamp);
                
                //Obtain the particle pointer of the ghost
                BaseParticle* pGhost;
                int idOther;
                //Check if the particle is P
                for (BaseParticle* particle : newParticles)
                {
                    if (particle->getId() == identificationP)
                    {
                        pGhost = particle;
                        idOther = identificationI;
                        break;
                    }
                    
                    if (particle->getId() == identificationI)
                    {
                        pGhost = particle;
                        idOther = identificationP;
                        break;
                    }
                }
                
                //If it is a wall interaction, do stuff
                if (isWallInteraction)
                {
                    BaseWall* I = getDPMBase()->wallHandler.getObjectById(identificationI);
                    //Create interactions
                    BaseInteraction* j = I->getInteractionWith(pGhost, timeStamp, &iH);
                    if (j!= nullptr) j->setMPIInteraction(interactionDataSend_[i], l, false);
                    logger(VERBOSE, "Wall interaction added!");
                }
                else
                {
                    //Obtain potential interaction particles
                    std::vector<BaseParticle*> interactingParticleList;
                    getDPMBase()->hGridGetInteractingParticleList(pGhost, interactingParticleList);
                    
                    if (interactingParticleList.empty())
                    {
                        logger(VERBOSE, "Failed in creating an interaction :(");
                    }
                    
                    //Find the other interacting particle
                    BaseParticle* otherParticle = nullptr;
                    for (BaseParticle* p2 : interactingParticleList)
                    {
                        if (p2->getId() == idOther)
                        {
                            otherParticle = p2;
                            break;
                        }
                    }
                    if (otherParticle == nullptr)
                    {
                        //The interacting object can't be found
                        continue;
                    }
                    
                    //Add the interaction
                    BaseInteraction* j = pGhost->getInteractionWith(otherParticle, timeStamp, &iH);
                    if (j!= nullptr) j->setMPIInteraction(interactionDataSend_[i], l, false);
                }
            }
        }
    }
}

References BaseHandler< BasePeriodicBoundary >::getDPMBase(), InteractionHandler::getInteractionDetails(), BaseParticle::getInteractionWith(), BaseHandler< T >::getObjectById(), DPMBase::hGridGetInteractingParticleList(), i, I, interactionDataSend_, DPMBase::interactionHandler, j, logger, numberOfNewInteractionsSend_, PROCESSOR_ID, sendTargetList_, VERBOSE, and DPMBase::wallHandler.

Referenced by finaliseNewParticleTransmission().

processPeriodicParticles()

void PeriodicBoundaryHandler::processPeriodicParticles

(

)

Creates a periodioc particle ID for book keeping and moves the ID to the correct list.

Periodic particles that have a copy somewhere else create an ID for book keeping This function also flags the particle being in the periodic domain such that it is ignored when finding new periodic particles.

{
    for (int i : sendTargetList_)
    {
        for (int j = 0; j < newPeriodicParticleList_[i].size(); j++)
        {
            //Update the particle status
            MpiPeriodicParticleID* ppid = newPeriodicParticleList_[i][j];
            ppid->particle->setInPeriodicDomain(true);
            
            //make new entry in the list
            periodicParticleList_[i].push_back(ppid);
        }
    }
}

References i, j, newPeriodicParticleList_, MpiPeriodicParticleIDBase::particle, periodicParticleList_, sendTargetList_, and BaseParticle::setInPeriodicDomain().

Referenced by finaliseNewParticleTransmission().

processReceivedGhostParticleData()

void PeriodicBoundaryHandler::processReceivedGhostParticleData	(	int	targetIndex,
		std::vector< BaseParticle * > &	newParticles
	)

Processes the received ghost data, creates a ghost particle and does some book keeping.

When processors have received new ghost particle data they have to be processed. First the periodic complexity of the ghost is determined. Secondly the ghost is created and given the correct flags and position and is added to the simulation. Thirdly a periodicGhost ID is created for book keeping purposes. A newParticle list is tracking the newly added ghost particles for a later step, processing the interactions.

Parameters

[in]	targetIndex	The index in the receiveTargetList which indicates where the data is coming from
[in]	newParticles	A list to which new ghost particles are added.

{
    for (int j = 0; j < numberOfNewPeriodicGhostParticlesReceive_[targetIndex]; j++)
    {
        //Create the ghost particle and copy basic information
        BaseParticle* particle = MPIParticle::newParticle();
        copyDataFromMPIParticleToParticle(&(periodicGhostParticleReceive_[targetIndex][j]),
                                          particle, &(getDPMBase()->particleHandler));
        
        //Obtain real periodic complexity
        std::vector<int> realPeriodicComplexity = computePeriodicComplexity(particle->getPosition());
        
        //Obtain and set the ghost periodic complexity
        std::vector<int> ghostPeriodicComplexity(getSize());
        for (int k = 0; k < getSize(); k++)
        {
            ghostPeriodicComplexity[k] = periodicGhostComplexityReceive_[targetIndex][getSize() * j + k];
        }
        particle->setPeriodicComplexity(ghostPeriodicComplexity);
        
        //Shift the ghost particle to it's correct positions and velocities
        shiftParticle(particle, ghostPeriodicComplexity);
        
        //Add particle to simulation
        logger(VERBOSE, "Adding a ghost at position %", particle->getPosition());
        getDPMBase()->particleHandler.addGhostObject(particle);
        
        //Set the correct flags
        BaseParticle* pGhost = getDPMBase()->particleHandler.getLastObject();
        pGhost->setPeriodicGhostParticle(true);
        pGhost->setInPeriodicDomain(true);
        //Give the correct mpi flags 
        setMPIFlags(pGhost);
        
        //Create the periodic ID
        MpiPeriodicGhostParticleID* gpid = new MpiPeriodicGhostParticleID;
        gpid->realPeriodicComplexity = realPeriodicComplexity;
        gpid->particle = pGhost;
        periodicGhostList_[receiveTargetList_[targetIndex]].push_back(gpid);
        
        //Add to the newParticle list used for possible interactions
        newParticles.push_back(pGhost);
    }
}

References ParticleHandler::addGhostObject(), computePeriodicComplexity(), copyDataFromMPIParticleToParticle(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), BaseHandler< T >::getLastObject(), BaseInteractable::getPosition(), BaseHandler< BasePeriodicBoundary >::getSize(), j, k, logger, MPISphericalParticle::newParticle(), numberOfNewPeriodicGhostParticlesReceive_, MpiPeriodicParticleIDBase::particle, DPMBase::particleHandler, periodicGhostComplexityReceive_, periodicGhostList_, periodicGhostParticleReceive_, MpiPeriodicParticleIDBase::realPeriodicComplexity, receiveTargetList_, BaseParticle::setInPeriodicDomain(), setMPIFlags(), BaseParticle::setPeriodicComplexity(), BaseParticle::setPeriodicGhostParticle(), shiftParticle(), and VERBOSE.

Referenced by finaliseNewParticleTransmission().

processReceivedInteractionData()

void PeriodicBoundaryHandler::processReceivedInteractionData	(	int	targetIndex,
		std::vector< BaseParticle * > &	newParticles
	)

Process the received interaction data.

Newly added ghost particles also need their interactions. This function adds the interactions to the correct ghost particles. The interaction data send over MPI only contains the ID's of the particles so a search has to be performed to obtain the particle pointers. For the ghost particles we use the newParticle list that contains all newly added ghost particles. For the other particle an hgrid search is performed. Finally when the two interactables are found the data is copied from the data vector.

Parameters

[in]	targetIndex	The index in the receiveTargetList which indicates where the data is coming from
[in]	newParticles	A list containing the newly added ghost particles

{
    InteractionHandler& iH = getDPMBase()->interactionHandler;
    for (int l = 0; l < numberOfNewInteractionsReceive_[targetIndex]; l++)
    {
        unsigned int identificationP;
        unsigned int identificationI;
        bool isWallInteraction;
        unsigned timeStamp;
        
        //Get the general information required to setup a new interaction
        iH.getInteractionDetails(interactionDataReceive_[targetIndex], l, identificationP, identificationI,
                                 isWallInteraction, timeStamp);
        
        //Obtain the particle pointer of the ghost
        BaseParticle* pGhost;
        int idOther;
        //Check if the particle is P
        for (BaseParticle* particle : newParticles)
        {
            if (particle->getId() == identificationP)
            {
                pGhost = particle;
                idOther = identificationI;
                break;
            }
            
            if (particle->getId() == identificationI)
            {
                pGhost = particle;
                idOther = identificationP;
                break;
            }
        }
        
        //If it is a wall interaction, do stuff
        if (isWallInteraction)
        {
            BaseInteractable* I = getDPMBase()->wallHandler.getObjectById(identificationI);
            //Create interactions
            BaseInteraction* i = I->getInteractionWith(pGhost, timeStamp, &iH);
            if (i!= nullptr) i->setMPIInteraction(interactionDataReceive_[targetIndex], l, false);
        }
        else
        {
            //Obtain potential interaction particles
            std::vector<BaseParticle*> interactingParticleList;
            getDPMBase()->hGridGetInteractingParticleList(pGhost, interactingParticleList);
            
            //Find the other interacting particle
            BaseParticle* otherParticle;
            for (BaseParticle* p2 : interactingParticleList)
            {
                if (p2->getId() == idOther)
                {
                    otherParticle = p2;
                    break;
                }
            }
            
            //Add the interaction
            BaseInteraction* i = pGhost->getInteractionWith(otherParticle, timeStamp, &iH);
            if (i!= nullptr) i->setMPIInteraction(interactionDataReceive_[targetIndex], l, false);
        }
    }
}

References BaseHandler< BasePeriodicBoundary >::getDPMBase(), InteractionHandler::getInteractionDetails(), BaseParticle::getInteractionWith(), BaseHandler< T >::getObjectById(), DPMBase::hGridGetInteractingParticleList(), i, I, interactionDataReceive_, DPMBase::interactionHandler, numberOfNewInteractionsReceive_, and DPMBase::wallHandler.

Referenced by finaliseNewParticleTransmission().

readAndAddObject()

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

overridevirtual

Pure virtual function needs implementation, but it does nothing for the periodicBoudnaryHandler.

The periodic boundary handler does not need to read anything, it will be reconstructed.

Implements BaseHandler< BasePeriodicBoundary >.

{
}

setInteractionDistance()

void PeriodicBoundaryHandler::setInteractionDistance

(

Mdouble

interactionDistance

)

Sets the interaction distance.

This distance determines when a particle starts to interact with a periodic boundary

Parameters

[in]

interactionDistance

The distance from a boundary when a particle starts to interact with it.

{
    interactionDistance_ = interactionDistance;
}

References interactionDistance_.

Referenced by DPMBase::read(), and DPMBase::updateGhostGrid().

setMPIFlags()

void PeriodicBoundaryHandler::setMPIFlags

(

BaseParticle *

particle

)

Sets the MPIParticle and isMPIParticle flags of a given particle.

Mixed particles that are in periodic and mpi domains, PM-particles can create ghosts of themselves PGM and PMG and additionally PGMG-particles. These last particles can't be created both by the periodic routines and the paralle routines and therefore the design choice is that these fully depend on the periodic routines. The update of their MPI flags such as isInMPIDomain and isMPIParticle is handled by this function.

Parameters

[in]

particle

A particle that receives the correct MPI flags

{
    bool isInMPIDomain;
    bool isMPIParticle;
    getMPIFlags(particle, isInMPIDomain, isMPIParticle);
    particle->setInMPIDomain(isInMPIDomain);
    particle->setMPIParticle(isMPIParticle);
}

References getMPIFlags(), BaseParticle::setInMPIDomain(), and BaseParticle::setMPIParticle().

Referenced by processReceivedGhostParticleData(), and updateParticleStatus().

shiftParticle() [1/2]

void PeriodicBoundaryHandler::shiftParticle

(

BaseParticle *

particle

)

Shifts the position of the particle based on its current periodic complexity.

This function shifts the position of the particle with respect to the periodic boundaries based on the periodic complexity it currently has. Note that some boundaries such as the angular periodic boundary do not only shift the position, but also the velocity. In that sense this function name is a bit of a misnomer.

Parameters

[in]

particle

The particle that shifts position (and possibly other properties)

{
    shiftParticle(particle, particle->getPeriodicComplexity());
}

References BaseParticle::getPeriodicComplexity().

Referenced by findTargetProcessor(), processLocalGhostParticles(), processReceivedGhostParticleData(), and updateParticles().

shiftParticle() [2/2]

void PeriodicBoundaryHandler::shiftParticle	(	BaseParticle *	particle,
		const std::vector< int > &	complexity
	)

Shifts the position of the particle based on a given periodic complexity.

This function shifts the position of the particle with respect to the periodic boundaries based on a given periodic complexity. Note that some boundaries such as the angular periodic boundary do not only shift the position, but also the velocity. In that sense this function name is a bit of a misnomer.

Parameters

[in]	particle	The particle that shifts position (and possibly other properties)
[in]	complexity	The periodic complexity that determines how the particle is shifted

{
    int boundaryIndex = 0;
    for (BasePeriodicBoundary* boundary : *this)
    {
        if (complexity[boundaryIndex] == -1)
        {
            boundary->shiftPosition(particle);
        }
        boundaryIndex++;
    }
}

References BasePeriodicBoundary::shiftPosition().

updateMaserParticle()

void PeriodicBoundaryHandler::updateMaserParticle

(

BaseParticle *

particle

)

Updates the maser flag of particles leaving the maser.

When a periodic particle changes complexity and remains real, there is a possibility the particle moved over a maser boundary. If that is indeed the case then flag the particle as being not a maser particle

Parameters

[in,out]

particle

The particle that needs to check the isMaserParticle flag

Bug:

This only works if all insertions happen on the root if there is a maser present, as the ID is increased locally

{
    if (particle->isMaserParticle())
    {
        for (int b = 0; b < getSize(); b++)
        {
            if (particle->getPeriodicComplexity(b) == 3)
            {
                particle->setMaserParticle(false);
                
                logger(VERBOSE, "particle % with position % goes into outflow domain, new ID = %", particle->getId(),
                       particle->getPosition(), getDPMBase()->particleHandler.getNextId());
                const unsigned int newID = getDPMBase()->particleHandler.getNextId();
                logger(VERBOSE, "new id % position X %", newID, particle->getPosition().X);
                particle->setId(newID);
                getDPMBase()->particleHandler.increaseId();
            }
        }
    }
}

References b, BaseHandler< BasePeriodicBoundary >::getDPMBase(), BaseObject::getId(), BaseHandler< T >::getNextId(), BaseParticle::getPeriodicComplexity(), BaseInteractable::getPosition(), BaseHandler< BasePeriodicBoundary >::getSize(), BaseHandler< T >::increaseId(), BaseParticle::isMaserParticle(), logger, DPMBase::particleHandler, BaseObject::setId(), BaseParticle::setMaserParticle(), VERBOSE, and Vec3D::X.

Referenced by updateParticleStatus().

updateParticles()

void PeriodicBoundaryHandler::updateParticles

(

)

Updates position/velocity and periodic complexity of ghost particles.

This function updates the position/velocity and periodic complexity of ghost particles. There are two versions of update, a local and a global one. The local one can update the particles through pointers, as the periodic particle is located ont he same processor as the ghost. The local version has received data from other processors which is stored in the corresponding vectors

{
    //For all lists that contain ghost particles
    //The variable dataIndex indicates which index in update<...>Receive_ the data is located
    int dataIndex = -1;
    for (int i = 0; i < NUMBER_OF_PROCESSORS; i++)
    {
        unsigned long numberOfParticles = periodicGhostList_[i].size();
        bool global;
        if (numberOfParticles > 0)
        {
            //Check if the update is global or from the current processor
            if (i != PROCESSOR_ID)
            {
                global = true;
                dataIndex++;
            }
            else
            {
                global = false;
            }
            
            //Update all particles
            for (int p = 0; p < numberOfParticles; p++)
            {
                MpiPeriodicGhostParticleID* pgid = periodicGhostList_[i][p];
                BaseParticle* pGhost = pgid->particle;
                
                //Depending on where the particle is located the data is stored in a different place
                if (global)
                {
                    //logger(VERBOSE,"i: %, numberOfParticles: %, dataIndex: %",i,numberOfParticles, dataIndex);
                    //Check if this particle really belongs to the data that is send
                    logger.assert_debug(pGhost->getId() == updatePositionDataReceive_[dataIndex][p].id,
                                  "Periodic particle lists are not in syc");
                    
                    //Add the real position and velocity of the particles
                    //Note: The before updating the position is the position of the ghost
                    //Note: The received position and velocity values are of the real particle
                    //Note: It will be shifted to the correct values after the complexity is computed
                    pGhost->setPreviousPosition(pGhost->getPosition());
                    pGhost->setPosition(updatePositionDataReceive_[dataIndex][p].position);
                    pGhost->setOrientation(updatePositionDataReceive_[dataIndex][p].orientation);
                    pGhost->setVelocity(updateVelocityDataReceive_[dataIndex][p].velocity);
                    pGhost->setAngularVelocity(updateVelocityDataReceive_[dataIndex][p].angularVelocity);
                    
                }
                else
                {
                    //MpiPeriodicGhostParticleID * pgip = periodicGhostList_[i][p];
                    pGhost->setPreviousPosition(pGhost->getPosition());
                    pGhost->setPosition(pgid->otherParticle->getPosition());
                    pGhost->setOrientation(pgid->otherParticle->getOrientation());
                    pGhost->setVelocity(pgid->otherParticle->getVelocity());
                    pGhost->setAngularVelocity(pgid->otherParticle->getAngularVelocity());
                }
                
                //Move current periodic complexity to previous periodic complexity
                pGhost->setPreviousPeriodicComplexity(pGhost->getPeriodicComplexity());
                
                //Compute the new realPeriodicComplexity
                std::vector<int> previousRealPeriodicComplexity = periodicGhostList_[i][p]->realPeriodicComplexity;
                //The ghost particle has the real position at the moment, so compute the real periodic complexity here
                std::vector<int> realPeriodicComplexity = computePeriodicComplexity(pGhost->getPosition());
                std::vector<int> periodicComplexity(getSize());
                for (int b = 0; b < getSize(); b++)
                {
                    int sign = mathsFunc::sign(previousRealPeriodicComplexity[b]
                                               * realPeriodicComplexity[b]
                                               * pGhost->getPreviousPeriodicComplexity()[b]);
                    periodicComplexity[b] = sign * abs(realPeriodicComplexity[b]);
                    //The maser boundary needs this correction
                    if (periodicComplexity[b] == -3)
                    {
                        periodicComplexity[b] = 1;
                    }
                    
                }
                pGhost->setPeriodicComplexity(periodicComplexity);
                
                for (int b = 0; b < getSize(); b++)
                {
                    objects_[b]->modifyGhostAfterCreation(pGhost, b);
                }
                //Shift the particle to correct position
                //Note: If the real particle changed complexity this position will be calculated incorrectly
                //Hence the previous complexity is used.
                shiftParticle(pGhost, pGhost->getPreviousPeriodicComplexity());
                
                //Update hGrid
                Vec3D displacement = pGhost->getPreviousPosition() - pGhost->getPosition();
                getDPMBase()->hGridUpdateMove(pGhost, displacement.getLengthSquared());
                
                //Do some book keeping
                periodicGhostList_[i][p]->realPeriodicComplexity = realPeriodicComplexity;
                
            }
        }
    }
    
    //Update periodic complexity of periodic particles
    for (BaseParticle* particle : getDPMBase()->particleHandler)
    {
        if ((particle->isInPeriodicDomain()) && !(particle->isPeriodicGhostParticle()))
        {
            //Update the periodicComplexity of the real particles
            particle->setPreviousPeriodicComplexity(particle->getPeriodicComplexity());
            std::vector<int> periodicComplexity;
            int totalPeriodicComplexity;
            computePeriodicComplexity(periodicComplexity, totalPeriodicComplexity, particle->getPosition());
            //Modify periodic complexity tailored to specific boundary requirements
            for (int b = 0; b < getSize(); b++)
            {
                objects_[b]->modifyPeriodicComplexity(periodicComplexity, totalPeriodicComplexity, particle, b);
            }
            particle->setPeriodicComplexity(periodicComplexity);
        }
    }
}

References abs(), b, computePeriodicComplexity(), BaseInteractable::getAngularVelocity(), BaseHandler< BasePeriodicBoundary >::getDPMBase(), BaseObject::getId(), Vec3D::getLengthSquared(), BaseInteractable::getOrientation(), BaseParticle::getPeriodicComplexity(), BaseInteractable::getPosition(), BaseParticle::getPreviousPeriodicComplexity(), BaseParticle::getPreviousPosition(), BaseHandler< BasePeriodicBoundary >::getSize(), BaseInteractable::getVelocity(), DPMBase::hGridUpdateMove(), i, logger, NUMBER_OF_PROCESSORS, BaseHandler< BasePeriodicBoundary >::objects_, MpiPeriodicParticleIDBase::otherParticle, p, MpiPeriodicParticleIDBase::particle, periodicGhostList_, PROCESSOR_ID, BaseInteractable::setAngularVelocity(), BaseInteractable::setOrientation(), BaseParticle::setPeriodicComplexity(), BaseInteractable::setPosition(), BaseParticle::setPreviousPeriodicComplexity(), BaseParticle::setPreviousPosition(), BaseInteractable::setVelocity(), shiftParticle(), mathsFunc::sign(), SYCL::sign(), updatePositionDataReceive_, updateVelocityDataReceive_, and Jeffery_Solution::velocity().

Referenced by finalisePositionAndVelocityUpdate().

updateParticleStatus()

void PeriodicBoundaryHandler::updateParticleStatus

(

std::set< BaseParticle * > &

particlesToBeDeleted

)

Updates the status of periodic particles and ghost particles.

This function updates the status of the particles based on the periodic complexity of the particles. this is beneficial as no round-off errors are made due to the shift in position. If a particle changes it's periodic complexity it is either removed or turned into a real particle. The real particle will be re-introduced in a later step. Particles that need to be deleted will be stored in a vector as these particles might also need to be flushed from the Domain.h lists.

Parameters

[in,out]

particlesToBeDeleted

List of particles that will need to be removed from the simulation

{
    MPIContainer& communicator = MPIContainer::Instance();
    int numberOfProcessors = communicator.getNumberOfProcessors();
    std::set<MpiPeriodicParticleID*> deletePeriodicIDList;
    std::set<MpiPeriodicGhostParticleID*> deletePeriodicGhostIDList;
    std::set<BaseParticle*> specialUpdateParticleList;
    
    //For all domains
    for (int i = 0; i < numberOfProcessors; i++)
    {
        int numberOfPeriodicParticles = periodicParticleList_[i].size();
        int numberOfPeriodicGhostParticles = periodicGhostList_[i].size();
        
        //Loop over all periodic particles to see if their complexity changed 
        for (int p = 0; p < numberOfPeriodicParticles; p++)
        {
            MpiPeriodicParticleID* ppid = periodicParticleList_[i][p];
            BaseParticle* particle = ppid->particle;
            
            //Check particle status
            bool isReal = checkIsReal(particle->getPeriodicComplexity());
            bool changed = checkChanged(particle->getPreviousPeriodicComplexity(), particle->getPeriodicComplexity());
            
            //Only if the particle changed we need to undertake action
            if (changed)
            {
                if (isReal)
                {
                    //Flag this particle as normal, it will be re-introduced when finding new periodic particles
                    logger(VERBOSE, "Real particle % changed complexity at: %", particle->getId(),
                           particle->getPosition());
                    particle->setInPeriodicDomain(false);
                    //Incase of a special flag 3, perform update action
                    updateMaserParticle(particle);
                }
                else
                {
                    //Oh noes, the particle became a ghost. Kill it with balefire!!... if it is necessary
                    logger(VERBOSE, "Real particle % changed to ghost at: %", particle->getId(),
                           particle->getPosition());
                    particlesToBeDeleted.insert(particle);
                }
                
                //Delete the ID
                deletePeriodicIDList.insert(ppid);
                periodicParticleList_[i][p] = nullptr;
            }
            
            
            //If a PM particle changes from to PMG it will need to be deleted.
            //The deletion will be done by the M boundary, but it still needs to be flushed from the periodic lists
            if (particle->isInMPIDomain())
            {
                //Store old values and compute new to see if the status has changed
                bool isMPIParticleOld = particle->isMPIParticle();
                bool isMPIParticle;
                bool isInMPIDomain;
                getMPIFlags(particle, isInMPIDomain, isMPIParticle);
                
                //Particle needs to be removed from lists if it becomes an MG particle
                if (isMPIParticleOld != isMPIParticle)
                {
                    logger(VERBOSE, "PM to PMG: Flush from boundary");
                    deletePeriodicIDList.insert(ppid);
                    periodicParticleList_[i][p] = nullptr;
                }
                
                //MG particle needs to be removed from lists if it moves to another domain
                if (!isInMPIDomain)
                {
                    if (particle->isMPIParticle())
                    {
                        logger(VERBOSE, "PMG leaves domain: Flush from boundary");
                        deletePeriodicIDList.insert(ppid);
                        periodicParticleList_[i][p] = nullptr;
                    }
                }
            }
        }
        
        //Loop over all periodic ghost particles to see if their complexity changed
        for (int p = 0; p < numberOfPeriodicGhostParticles; p++)
        {
            MpiPeriodicGhostParticleID* pgid = periodicGhostList_[i][p];
            BaseParticle* pGhost = pgid->particle;
            
            //Check particle status
            bool isReal = checkIsReal(pGhost->getPeriodicComplexity());
            bool changed = checkChanged(pGhost->getPreviousPeriodicComplexity(), pGhost->getPeriodicComplexity());
            
            //Update mixed particles, particles that also are in the mpi domain also need an update
            //Note that these particles are not listed in the domain lists, they are taken care here.
            //Store old values and update status of pGhost
            bool isInMPIDomainOld = pGhost->isInMPIDomain();
            bool isMPIParticleOld = pGhost->isMPIParticle();
            setMPIFlags(pGhost);
            if (isInMPIDomainOld)
            {
                
                //Case 1: pGhost changed from real to mpi particle
                if (isMPIParticleOld != pGhost->isMPIParticle())
                {
                    //Case 1: turned from M ghost to M
                    //The correct flags have been set above already
                    
                    //Case 2: Turned from M to M ghost
                    if (pGhost->isMPIParticle())
                    {
                        logger(VERBOSE, "PGM to PGMG: Deleting particle.");
                        particlesToBeDeleted.insert(pGhost);
                        deletePeriodicGhostIDList.insert(pgid);
                        periodicGhostList_[i][p] = nullptr;
                    }
                    
                }
                
                //Case 2: pGhost left the mpi domain
                if (pGhost->isInMPIDomain() != isInMPIDomainOld)
                {
                    //Case 1: Moved inside the current domain
                    //The correct flags have been set above already
                    
                    //Case 2: Moved to a neighbour domain
                    if (pGhost->isMPIParticle())
                    {
                        logger(VERBOSE, "PGMG moved out of domain: Deleting particle.");
                        particlesToBeDeleted.insert(pGhost);
                        deletePeriodicGhostIDList.insert(pgid);
                        periodicGhostList_[i][p] = nullptr;
                    }
                }
            }
            
            //Check if the particles need to be deleted based on their periodic complexity
            if (changed)
            {
                if (isReal)
                {
                    //Check if the complexity of the particle is truely real based on it's current position
                    std::vector<int> pc = computePeriodicComplexity(pGhost->getPosition());
                    int tpc = 0;
                    for (int b = 0; b < getSize(); b++)
                    {
                        objects_[b]->modifyPeriodicComplexity(pc, tpc, pGhost, b);
                    }
                    if (!checkIsReal(pc))
                    {
                        logger(ERROR, "Round-off error detected.");
                        //logger(WARN,"Round-off error corrected, phew!");
                    }
                    
                    //There are two cases
                    //Case 1: PGMG particles turning PMG; These are still not real
                    //Case 2: PGM particles turning PG; These are truely real
                    if (pGhost->isMPIParticle())
                    {
                        logger(VERBOSE, "PGMG turned PMG: delete it");
                        particlesToBeDeleted.insert(pGhost);
                    }
                    else
                    {
                        //Turn the particle real
                        logger(VERBOSE, "Ghost particle changed to real at position: %", pGhost->getPosition());
                        pGhost->setInPeriodicDomain(false);
                        pGhost->setPeriodicGhostParticle(false);
                        //Make sure this particle can be detected now by the parallel boundaries
                        pGhost->setInMPIDomain(false);
                    }
                }
                else
                {
                    //Delete the particle
                    logger(VERBOSE, "Ghost particle changed complexity at position: %", pGhost->getPosition());
                    particlesToBeDeleted.insert(pGhost);
                }
                
                //Delete the ID
                deletePeriodicGhostIDList.insert(pgid);
                periodicGhostList_[i][p] = nullptr;
            }
        }
        
    }
    
    //Delete IDs 
    for (auto ppid_it : deletePeriodicIDList)
    {
        delete ppid_it;
    }
    
    for (auto pgid_it : deletePeriodicGhostIDList)
    {
        delete pgid_it;
    }
    unsigned int nextId = getDPMBase()->particleHandler.getNextId();
    communicator.broadcast(nextId);
    getDPMBase()->particleHandler.setNextId(nextId);
}

References b, MPIContainer::broadcast(), checkChanged(), checkIsReal(), computePeriodicComplexity(), ERROR, BaseHandler< BasePeriodicBoundary >::getDPMBase(), BaseObject::getId(), getMPIFlags(), BaseHandler< T >::getNextId(), MPIContainer::getNumberOfProcessors(), BaseParticle::getPeriodicComplexity(), BaseInteractable::getPosition(), BaseParticle::getPreviousPeriodicComplexity(), BaseHandler< BasePeriodicBoundary >::getSize(), i, MPIContainer::Instance(), BaseParticle::isInMPIDomain(), BaseParticle::isMPIParticle(), logger, BaseHandler< BasePeriodicBoundary >::objects_, p, MpiPeriodicParticleIDBase::particle, DPMBase::particleHandler, pc, periodicGhostList_, periodicParticleList_, BaseParticle::setInMPIDomain(), BaseParticle::setInPeriodicDomain(), setMPIFlags(), BaseHandler< T >::setNextId(), BaseParticle::setPeriodicGhostParticle(), updateMaserParticle(), and VERBOSE.

Referenced by updateStatus().

updateStatus()

void PeriodicBoundaryHandler::updateStatus

(

std::set< BaseParticle * > &

particlesToBeDeleted

)

Updates the positions/velocity of ghost particles and accordingly the status of these particles.

This function updates the status of periodic particles and periodic ghost particles. This is done in two steps. The first step is to update the ghost particles with the position of their corresponding real particles. Based on this new position their status will be updated. Occasionally a particle needs to be removed and because this particle might also be listed in the communication boundaries, it will be deleted after those lists have been flushed.

Parameters

[in]

particlesToBeDeleted

A list of particles that need to be deleted, but can't yet be deleted to avoid segmentation faults

{
    //Step 1: collect position and velocity data of the real particle and send the data
    preparePositionAndVelocityUpdate();
    
    //Step 2: finalise the data transision
    finalisePositionAndVelocityUpdate();
    
    //Step 3: Update the status of the ghost and real particles
    updateParticleStatus(particlesToBeDeleted);
}

References finalisePositionAndVelocityUpdate(), preparePositionAndVelocityUpdate(), and updateParticleStatus().

Referenced by DPMBase::performGhostParticleUpdate().

Member Data Documentation

interactionDataReceive_

std::vector<void*> PeriodicBoundaryHandler::interactionDataReceive_

private

Stores the interaction data that is going to be received.

Referenced by finaliseNewParticleTransmission(), performNewParticleTransmission(), and processReceivedInteractionData().

interactionDataSend_

std::vector<void*> PeriodicBoundaryHandler::interactionDataSend_

private

Stores the interaction data that is going to be send.

Referenced by collectInteractionData(), finaliseNewParticleTransmission(), performNewParticleTransmission(), and processLocalInteractionData().

interactionDistance_

Mdouble PeriodicBoundaryHandler::interactionDistance_

private

The interaction distance between a position and the boundary for which particles start to participate with a boundary or not.

Referenced by computePeriodicComplexity(), getInteractionDistance(), operator=(), PeriodicBoundaryHandler(), and setInteractionDistance().

newInteractionList_

std::vector<std::vector<BaseInteraction*> > PeriodicBoundaryHandler::newInteractionList_

private

A list that stores the new interactions that have to be send to target processor, corresponding to sendTargetList_

Referenced by collectInteractionData(), finaliseNewParticleTransmission(), and findNewInteractions().

newPeriodicParticleList_

std::vector<PeriodicList> PeriodicBoundaryHandler::newPeriodicParticleList_

private

A vector the size of the number of processors, each entry containing a vector of newly found periodic particles that need to be send to other processors

Referenced by collectGhostParticleData(), communicateTargetDomains(), finaliseNewParticleTransmission(), findNewInteractions(), findNewParticle(), initialise(), processLocalGhostParticles(), and processPeriodicParticles().

numberOfNewInteractionsReceive_

std::vector<int> PeriodicBoundaryHandler::numberOfNewInteractionsReceive_

private

Stores the number of new interactions to be received from target processor corresponding to receiveTargetList_.

Referenced by communicateNumberOfNewParticlesAndInteractions(), finaliseNewParticleTransmission(), performNewParticleTransmission(), and processReceivedInteractionData().

numberOfNewInteractionsSend_

std::vector<int> PeriodicBoundaryHandler::numberOfNewInteractionsSend_

private

Stores the number of new interactions to be send to target processor corresponding to sendTargetList_.

Referenced by collectInteractionData(), communicateNumberOfNewParticlesAndInteractions(), finaliseNewParticleTransmission(), findNewInteractions(), performNewParticleTransmission(), and processLocalInteractionData().

numberOfNewPeriodicGhostParticlesReceive_

std::vector<int> PeriodicBoundaryHandler::numberOfNewPeriodicGhostParticlesReceive_

private

A vector that stores how many new ghost particles will be received from other processors.

Referenced by communicateNumberOfNewParticlesAndInteractions(), finaliseNewParticleTransmission(), performNewParticleTransmission(), and processReceivedGhostParticleData().

numberOfNewPeriodicGhostParticlesSend_

std::vector<int> PeriodicBoundaryHandler::numberOfNewPeriodicGhostParticlesSend_

private

A vector that stores how many particles are going to be send to other processors.

Referenced by collectGhostParticleData(), communicateNumberOfNewParticlesAndInteractions(), communicateTargetDomains(), finaliseNewParticleTransmission(), performNewParticleTransmission(), and processLocalGhostParticles().

periodicGhostComplexityReceive_

std::vector<std::vector<int> > PeriodicBoundaryHandler::periodicGhostComplexityReceive_

private

Data container for periodic complexity that is being received from other processors.

Referenced by finaliseNewParticleTransmission(), performNewParticleTransmission(), and processReceivedGhostParticleData().

periodicGhostComplexitySend_

std::vector<std::vector<int> > PeriodicBoundaryHandler::periodicGhostComplexitySend_

private

Data container for periodic complexity that is being send to other processors.

Referenced by collectGhostParticleData(), finaliseNewParticleTransmission(), and performNewParticleTransmission().

periodicGhostList_

std::vector<PeriodicGhostList> PeriodicBoundaryHandler::periodicGhostList_

private

A vector the size of the number of processors, each entry containing a vector of ghost periodioc particle ID's to keep track of periodic ghost particles and their corresponding real particles.

Referenced by cleanCommunicationLists(), clearCommunicationLists(), flushParticles(), getNumberOfPeriodicGhostParticles(), getNumberOfTruePeriodicGhostParticles(), initialise(), preparePositionAndVelocityUpdate(), processLocalGhostParticles(), processReceivedGhostParticleData(), updateParticles(), and updateParticleStatus().

periodicGhostParticleReceive_

std::vector<std::vector<MPIParticle> > PeriodicBoundaryHandler::periodicGhostParticleReceive_

private

Data container for particles that are being received from other processors.

Referenced by finaliseNewParticleTransmission(), performNewParticleTransmission(), and processReceivedGhostParticleData().

periodicGhostParticleSend_

std::vector<std::vector<MPIParticle> > PeriodicBoundaryHandler::periodicGhostParticleSend_

private

Data container for particles that are being send to other processors.

Referenced by collectGhostParticleData(), finaliseNewParticleTransmission(), and performNewParticleTransmission().

periodicParticleList_

std::vector<PeriodicList> PeriodicBoundaryHandler::periodicParticleList_

private

A vector the size of the number of processors, each entry containing a vector of periodic particle ID's to keep track of periodic particles and their corresponding ghosts.

Referenced by cleanCommunicationLists(), clearCommunicationLists(), flushParticles(), initialise(), preparePositionAndVelocityUpdate(), processPeriodicParticles(), and updateParticleStatus().

receiveTargetList_

std::vector<int> PeriodicBoundaryHandler::receiveTargetList_

private

A list that keeps track which target processors the current processor is receiving new particles from.

Referenced by communicateNumberOfNewParticlesAndInteractions(), communicateTargetDomains(), finaliseNewParticleTransmission(), performNewParticleTransmission(), and processReceivedGhostParticleData().

sendTargetList_

std::vector<int> PeriodicBoundaryHandler::sendTargetList_

private

A list that keeps track to which targets this processor is sending new particles to.

Referenced by collectGhostParticleData(), collectInteractionData(), communicateNumberOfNewParticlesAndInteractions(), communicateTargetDomains(), finaliseNewParticleTransmission(), findNewInteractions(), performNewParticleTransmission(), processLocalGhostParticles(), processLocalInteractionData(), and processPeriodicParticles().

updatePositionDataReceive_

std::vector<std::vector<MPIParticlePosition> > PeriodicBoundaryHandler::updatePositionDataReceive_

private

Data container for position data that is being received from other processors.

Referenced by finalisePositionAndVelocityUpdate(), preparePositionAndVelocityUpdate(), and updateParticles().

updatePositionDataSend_

std::vector<std::vector<MPIParticlePosition> > PeriodicBoundaryHandler::updatePositionDataSend_

private

Data container for position data that is being send to other processors.

Referenced by finalisePositionAndVelocityUpdate(), and preparePositionAndVelocityUpdate().

updateVelocityDataReceive_

std::vector<std::vector<MPIParticleVelocity> > PeriodicBoundaryHandler::updateVelocityDataReceive_

private

Data container for velocity data that is being received from other processors.

Referenced by finalisePositionAndVelocityUpdate(), preparePositionAndVelocityUpdate(), and updateParticles().

updateVelocityDataSend_

std::vector<std::vector<MPIParticleVelocity> > PeriodicBoundaryHandler::updateVelocityDataSend_

private

Data container for velocity data that is being send to other processors.

Referenced by finalisePositionAndVelocityUpdate(), and preparePositionAndVelocityUpdate().

---

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

• PeriodicBoundaryHandler.h
• PeriodicBoundaryHandler.cc