Domain Class Reference

The simulation can be subdivided into Domain's used in parallel code. More...

#include <Domain.h>

Inheritance diagram for Domain:

Public Member Functions
	Domain ()
	Default Domain constructor. More...
	Domain (std::vector< unsigned > globalMeshIndex)
	Constructs an empty domain with a globalMeshIndex. More...
	Domain (const Domain &d)
	Constructor that copies the domain range and rank from a given domain. More...
	~Domain () override
	Destructor, destroys the domain. More...
void	constructor ()
	contructor of a domain More...
virtual Domain *	copy () const
	Function that creates a copy of this current domain, using the copy constructor. More...
void	read (std::istream &is) override
	This function does nothing. More...
void	write (std::ostream &os) const override
	This function does nothing. More...
std::string	getName () const override
	Returns the name of the object. More...
void	setRange (Direction direction, Mdouble min, Mdouble max)
	Sets the domain range in a given direction. More...
void	setBounds (std::vector< double > domainLeft, std::vector< double > domainRight, bool computeMiddle)
	Sets the domain bounds. More...
std::vector< double >	getDomainMin ()
	Gets the minimum domain bounds. More...
std::vector< double >	getDomainMax ()
	Gets the maximum domain bounds. More...
int	getRank ()
	Gets the rank associated with the assigned processorID. More...
void	setRank (int rank)
	Sets the rank associated with the assigned processorID. More...
void	setHandler (DomainHandler *handler)
	Sets the domainHandler. More...
DomainHandler *	getHandler () const
	Gets the domainHandler. More...
int	getGlobalIndex ()
	Gets the global index of the domain. More...
std::vector< unsigned >	getGlobalMeshIndex ()
	Gets the global mesh index of the domain. More...
void	setGlobalMeshIndex (std::vector< unsigned > globalMeshIndex)
	Sets the global mesh index of the domain. More...
void	disableBoundary (unsigned localIndex)
	Disables a boundary of the domain with a neighbouring domain. More...
void	disableBoundaries ()
	disables all domain boundaries that have no neighbour More...
std::vector< bool >	getActiveBoundaryList ()
	Returns a list of boundaries that are active in mpi communication. More...
bool	containsParticle (BaseParticle *particle, Mdouble offset=0.0)
	Check to see if a given particle is within the current domain. More...
bool	isInGreaterDomain (BaseParticle *particle)
	Check to see if a given particle is in the current domain or in neighbouring communication zones. More...
bool	isInInnerDomain (BaseParticle *particle)
	Check if the particle is in the current domain but not in the communication zone. More...
bool	isInCommunicationZone (BaseParticle *particle)
	Check if the particle is in the communication zone of the current domain. More...
void	createLookUpTable ()
	Create a look up table between local index system to global index system. More...
int	getLocalIndex (int i, int j, int k)
	return the local index of a domain given local mesh indices i,j and k More...
int	getLocalIndex (std::vector< int > localMeshIndex)
	return the local index of a domain given the localMeshIndex vector More...
std::vector< int >	getLocalIndexInverse (int localMeshIndex)
BaseParticle *	findParticleInList (unsigned int identification, std::vector< BaseParticle * > particleList)
	Searches for a particle with a specific id in a list of particles. More...
std::vector< int >	findNearbyBoundaries (BaseParticle *particle, Mdouble offset=0)
	This function finds if a given particle is close to a given boundary. More...
bool	inBoundary (BaseParticle *particle, int localIndex)
void	addParticlesToLists (BaseParticle *particle, std::vector< std::vector< BaseParticle * > > &list)
	Function that adds the particles to the appropriate boundary list. More...
void	findNewMPIParticles (const ParticleHandler &particleHandler)
	Function that finds new particles in the particle handler that should be added to the communication lists. More...
void	findNewMPIParticle (BaseParticle *particle)
	Function that check if a given particle should be added to the communication lists. More...
bool	isInNewBoundaryParticleList (BaseParticle *object, int localIndex) const
void	findNewMPIInteractions ()
	Finds interactions that have to be send over to another domain. More...
void	collectBoundaryParticleData (int localIndex)
	collects the data of a particle that has to be communicated to other processors More...
void	collectInteractionData (int localIndex)
	Collects the data of an interaction that has to be communicated to other processors. More...
void	processReceivedBoundaryParticleData (unsigned index, std::vector< BaseParticle * > &newParticles)
	Function that copies the mpi data format of a base particle to a real particle and adds it to the particleHandler. More...
void	processSentBoundaryParticles (unsigned index)
	Bookkeep the newly send particles. More...
void	processReceivedInteractionData (unsigned index, std::vector< BaseParticle * > &newParticles)
	Processes the received interactions from newly added mpi particles More...
void	debugInformation ()
void	sendAndReceiveCount (MercuryMPITag tag, unsigned &countReceive, unsigned &countSend, unsigned localIndexNeighbour)
	A symmetric communication between two domains exchanging a send/receive count. More...
void	prepareBoundaryDataTransmission ()
	Prepares the MPI transmission of particle and interaction data from particles in particleHandler. More...
void	prepareBoundaryDataTransmission (BaseParticle *particle)
	Prepares the MPI transmission of a single particle and its interactions. More...
void	performBoundaryDataTransmission ()
	Collects data to be transmitted and then performs the transmission of the data. More...
void	finaliseBoundaryDataTransmission ()
	This function processes the transmitted data. More...
void	updateParticles (std::set< BaseParticle * > &ghostParticlesToBeDeleted)
	This step updates all communication lists and particles in the communication zone. More...
void	updateParticlePosition (int localIndex)
	Updates the position of particles which are flagged as MPIParticles. More...
void	updateParticleVelocity (int localIndex)
	Updates the velocity of particles which are flagged as MPIParticles. More...
void	preparePositionAndVelocityUpdate ()
	Function that sends particle position and velocity data for ghost particles to other processors. More...
void	finalisePositionAndVelocityUpdate (std::set< BaseParticle * > &ghostParticlesToBeDeleted)
	processes position and velocity data for ghost particles More...
void	prepareVelocityUpdate ()
	Function that sends particle velocity data for ghost particles. More...
void	finaliseVelocityUpdate ()
	Processes particle velocity data for ghost particles. More...
template<typename T >
void	sendAndReceiveMPIData (MercuryMPITag tag, MercuryMPIType type, T *receiveData, unsigned receiveCount, T *sendData, unsigned sendCount, unsigned localIndexNeighbour)
	Function that sends transmissionData/positionData/velocityData to other processors. More...
void	addNewParticles ()
	Initialises the MPIParticles by communicating newly found particles. More...
void	addParticle (BaseParticle *particle)
	Initialises a single particle which is added during the simulation. More...
void	updateStatus (std::set< BaseParticle * > &ghostParticlesToBeDeleted)
	Updates particles that are not in the current domain and communicates newly added particles. More...
void	updateVelocity ()
	Updates MPI particle velocity at the half-time step. More...
unsigned int	getNumberOfMPIParticles ()
	Obtains the number of particles in the particleHandler that are MPIParticles. More...
unsigned int	getNumberOfTrueMPIParticles ()
	Obtains the number of particles in the particleHandler that are MPIParticles, but NOT periodic particles. More...
void	flushParticles (std::set< BaseParticle * > &toBeDeletedList)
	Particles that are going to be deleted from the simulation are flushed out of the communication boundaries. More...
void	flushParticlesFromList (std::vector< BaseParticle * > &list, std::set< BaseParticle * > &toBeDeletedList)
	Particles that are going to be deleted from the simulation are flushed out of a give communication boundary. More...
Vec3D	getMiddle () const
	Gives the middle of the domain. More...
void	cleanCommunicationLists ()
	Removes nullptrs from boundaryParticleList_ and boundaryParticleListNeighbour_. More...
void	cleanCommunicationList (std::vector< BaseParticle * > &list)
	Removes nullptr's from a given particle list. More...
Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...
	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...
virtual	~BaseObject ()=default
	virtual destructor More...
virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...
void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...
void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...
unsigned int	getIndex () const
	Returns the index of the object in the handler. More...
unsigned int	getId () const
	Returns the unique identifier of any particular object. More...
void	setGroupId (unsigned groupId)
unsigned	getGroupId () const

Private Attributes
DomainHandler *	domainHandler_
	Pointer to the domain's DomainHandler container. More...
std::vector< double >	domainMin_
	Minimum domain bounds in the x,y and z direction. More...
std::vector< double >	domainMax_
	Maximum domain bounds in the x,y and z direction. More...
Vec3D	middle_
	Middle of the closed domain. More...
int	globalIndex_
	Global index of the domain in the mesh. More...
std::vector< unsigned >	globalMeshIndex_
	Vector containing the global mesh indices i,j,k. More...
std::vector< int >	localIndexToGlobalIndexTable_
	look-up table to get the global index given a local domain index More...
std::vector< int >	localIndexToProcessorList_
	look-up table to get the processor of the domain given a local domain index More...
std::vector< bool >	activeBoundaryList_
	A list of flags corresponding to an inactive or active boundary. More...
std::vector< int >	boundaryList_
	A list of indices of all the active boundaries. More...
std::vector< std::vector< BaseParticle * > >	boundaryParticleList_
	A list of boundary particles in the communication zone that are ghost particles on other domains. More...
std::vector< std::vector< BaseParticle * > >	boundaryParticleListNeighbour_
	a list of ghost particles on the current domain, which are real on the neighbour domain More...
std::vector< std::vector< BaseParticle * > >	newBoundaryParticleList_
	Array that queues particles that need to be transmitted. More...
std::vector< std::vector< BaseInteraction * > >	newInteractionList_
	Array that queues interactions that need to be transmitted. More...
std::vector< unsigned >	numberOfParticlesSend_
	Counter that keeps track of the number of particles that are being send to other domains. More...
std::vector< unsigned >	numberOfParticlesReceive_
	Counter that keeps track of the number of particles that are being received by this domain. More...
std::vector< unsigned >	numNewInteractionsSend_
	Counter that keeps track of the number of interactions that are being send to other domains. More...
std::vector< unsigned >	numNewInteractionsReceive_
	Counter that keeps track of the number of interactions that are being received by this domain. More...
std::vector< std::vector< MPIParticle > >	boundaryParticleDataSend_
	Container that keeps a list of MPIParticles that are being send to other domains. More...
std::vector< std::vector< MPIParticle > >	boundaryParticleDataReceive_
	Container that keeps a list of MPIParticles that are being received by this domain. More...
std::vector< std::vector< MPIParticlePosition > >	updatePositionDataSend_
	Container that keeps a list of MPIParticlePositions that are being send to other domains. More...
std::vector< std::vector< MPIParticlePosition > >	updatePositionDataReceive_
	Container that keeps a list of MPIParticlePositions that are being received by this domain. More...
std::vector< std::vector< MPIParticleVelocity > >	updateVelocityDataSend_
	Container that keeps a list of MPIParticleVelocities that are being send to other domains. More...
std::vector< std::vector< MPIParticleVelocity > >	updateVelocityDataReceive_
	Container that keeps a list of MPIParticleVelocities that are being received by this domain. More...
std::vector< void * >	interactionDataSend_
	Container that keeps a void array of all the interaction data that are being send to other domains, interpretation is done by the interaction handler. More...
std::vector< void * >	interactionDataReceive_
	Container that keeps a void array of all the interaction data that is being received by this domain, interpretation is done by the interaction handler. More...
int	rank_
	Rank of the domain which identifies to which processor it belongs. More...

Detailed Description

The simulation can be subdivided into Domain's used in parallel code.

The domain class defines a region in the simulation domain, given by a min vector and a max vector. The domain also as a processorID assigned to it. It has a check to see whether a given particle is in the domain or not.

Constructor & Destructor Documentation

Domain() [1/3]

Domain::Domain

(

)

Default Domain constructor.

Constructs an empty domain.

Constructor of the domain class. It creates a domain with infinite bounds and no processor or domainHandler assigned to it and initialises all communication lists

{
    constructor();
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"Domain::Domain() finished"<<std::endl;
#endif
}

References constructor().

Referenced by copy().

Domain() [2/3]

Domain::Domain ( std::vector< unsigned >  globalMeshIndex )

explicit

Constructs an empty domain with a globalMeshIndex.

Constructor of the domain class. It creates a domain with infinite bounds and no processor or domainHandler assigned to it and initialises all communication lists

                                                  : globalMeshIndex_(std::move(globalMeshIndex))
{
    constructor();
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"Domain::Domain() finished"<<std::endl;
#endif
}

References constructor().

Domain() [3/3]

Domain::Domain

(

const Domain &

b

)

Constructor that copies the domain range and rank from a given domain.

Copies a domain.

Parameters

[in]

PH

The domain that has to be copied.

This constructor copies all the private variables of the current domain into the input domain.

        : BaseObject(b)
{
    rank_ = b.rank_;
    domainHandler_ = b.domainHandler_;
    domainMin_ = b.domainMin_;
    domainMax_ = b.domainMax_;
    globalMeshIndex_ = b.globalMeshIndex_;
    middle_ = b.middle_;
    
    //A cube has 3^3=27 neighbours
    unsigned long numberOfNeighbours = 27;
    
    //Create all lists
    localIndexToGlobalIndexTable_ = std::vector<int>(numberOfNeighbours);
    localIndexToProcessorList_ = std::vector<int>(numberOfNeighbours);
    boundaryParticleList_ = std::vector<std::vector<BaseParticle*> >(numberOfNeighbours, std::vector<BaseParticle*>(0));
    boundaryParticleListNeighbour_ = std::vector<std::vector<BaseParticle*> >(numberOfNeighbours,
                                                                              std::vector<BaseParticle*>(0));
    newBoundaryParticleList_ = std::vector<std::vector<BaseParticle*> >(numberOfNeighbours,
                                                                        std::vector<BaseParticle*>(0));
    newInteractionList_ = std::vector<std::vector<BaseInteraction*> >(numberOfNeighbours,
                                                                      std::vector<BaseInteraction*>(0));
    numberOfParticlesSend_ = std::vector<unsigned>(numberOfNeighbours);
    numberOfParticlesReceive_ = std::vector<unsigned>(numberOfNeighbours);
    numNewInteractionsSend_ = std::vector<unsigned>(numberOfNeighbours);
    numNewInteractionsReceive_ = std::vector<unsigned>(numberOfNeighbours);
    boundaryParticleDataSend_ = std::vector<std::vector<MPIParticle> >(numberOfNeighbours);
    boundaryParticleDataReceive_ = std::vector<std::vector<MPIParticle> >(numberOfNeighbours);
    updatePositionDataSend_ = std::vector<std::vector<MPIParticlePosition> >(numberOfNeighbours);
    updatePositionDataReceive_ = std::vector<std::vector<MPIParticlePosition> >(numberOfNeighbours);
    updateVelocityDataSend_ = std::vector<std::vector<MPIParticleVelocity> >(numberOfNeighbours);
    updateVelocityDataReceive_ = std::vector<std::vector<MPIParticleVelocity> >(numberOfNeighbours);
    interactionDataSend_ = std::vector<void*>(numberOfNeighbours);
    interactionDataReceive_ = std::vector<void*>(numberOfNeighbours);
    activeBoundaryList_ = std::vector<bool>(numberOfNeighbours, true);
    boundaryList_ = std::vector<int>(0);
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"Domain::Domain(const Domain &b) finished"<<std::endl;
#endif
}

References activeBoundaryList_, b, boundaryList_, boundaryParticleDataReceive_, boundaryParticleDataSend_, boundaryParticleList_, boundaryParticleListNeighbour_, domainHandler_, domainMax_, domainMin_, globalMeshIndex_, interactionDataReceive_, interactionDataSend_, localIndexToGlobalIndexTable_, localIndexToProcessorList_, middle_, newBoundaryParticleList_, newInteractionList_, numberOfParticlesReceive_, numberOfParticlesSend_, numNewInteractionsReceive_, numNewInteractionsSend_, rank_, updatePositionDataReceive_, updatePositionDataSend_, updateVelocityDataReceive_, and updateVelocityDataSend_.

~Domain()

Domain::~Domain ( )

override

Destructor, destroys the domain.

Destructor

{
#ifdef DEBUG_DESTRUCTOR
    std::cout << "Domain::~Domain() finished"<<std::endl;
#endif
}

Member Function Documentation

addNewParticles()

void Domain::addNewParticles

(

)

Initialises the MPIParticles by communicating newly found particles.

Adds new MPI ghost particles to the simulation. This is done in a three stage process where first the particles are located that generate ghosts, secondly their data is transmitted to the correct processor and thirdly that data is then used to create ghost particles.

{
    //Step 1: For every MPIDomain boundary, create a list of particles that have to be transmitted
    //queue send and receive instructions for the number of particles
    prepareBoundaryDataTransmission();
    MPIContainer::Instance().sync();
    
    //Step 2: queue send and receive of data
    performBoundaryDataTransmission();
    MPIContainer::Instance().sync();
    
    //Step 3: Add the received particles to the particleHandler of the current domain
    finaliseBoundaryDataTransmission();
}

References finaliseBoundaryDataTransmission(), MPIContainer::Instance(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), and MPIContainer::sync().

Referenced by DomainHandler::addNewParticles().

addParticle()

void Domain::addParticle

(

BaseParticle *

particle

)

Initialises a single particle which is added during the simulation.

Initialises a single particle which was added by the user after the domain creation.

This function is used when a single particle is added during the simulation In that case it has to be added to the mpi domains manually using this function. Examples are insertion boundaries that occasionally add particles to the domain

Parameters

[in]

particle

The single particle that has to be inserted into the domain

{
    //Step1: check if the particle has to be sent to other processors
    prepareBoundaryDataTransmission(particle);
    MPIContainer::Instance().sync();
    
    //Step2: queue send and receive data. Note for an inserted particle, no interactions should be required
    performBoundaryDataTransmission();
    MPIContainer::Instance().sync();
    
    //Step3: Add the received particles to the particleHandler of the current domain
    finaliseBoundaryDataTransmission();
    MPIContainer::Instance().sync();
}

References finaliseBoundaryDataTransmission(), MPIContainer::Instance(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), and MPIContainer::sync().

Referenced by DPMBase::insertGhostParticle().

addParticlesToLists()

void Domain::addParticlesToLists	(	BaseParticle *	particle,
		std::vector< std::vector< BaseParticle * > > &	list
	)

Function that adds the particles to the appropriate boundary list.

Function that adds the particles to the appropriate boundary lists.

This function computes the complexity of the particle. The complexity is defined by the number of boundaries the particle is close-by. Depending on this complexity value the particle has to be added to different boundary lists.

Parameters

[in]	particle	pointer to base particle
[in,out]	list	a list of lists of particles which the particle might be added to

{
    std::vector<int> boundaryIndex = findNearbyBoundaries(particle);
   
    //Compute and set complexity of the particle
    unsigned int complexity = boundaryIndex[0] + 3 * boundaryIndex[1] + 9 * boundaryIndex[2] + 13;
    unsigned int list_complexity = 0;
    for (int d = 0; d < 3; d++) //Loop over all directions
    {
        list_complexity += std::abs(boundaryIndex[d]);
    }
    particle->setCommunicationComplexity(complexity);
    //particle->setCommunicationComplexity(list_complexity);
    
    //Based on the complexity of the particle, add it to the appropriate list
    switch (list_complexity)
    {
        //The particle is not close at all
        case 0:
            break;
            //The particle is close to one side
            // 1 side contribution
        case 1 :
            //Add the side contribution
            list[getLocalIndex(boundaryIndex)].push_back(particle);
            break;
            //The particle is close to two neighbouring directions
            //2 side and 1 rib contribution
        case 2 :
        {
            //Add the two side contributions
            for (int d = 0; d < 3; d++)
            {
                std::vector<int> localMeshIndex = {0, 0, 0};
                localMeshIndex[d] = boundaryIndex[d];
                //Avoid adding the particle in the wrong direction by excluding localMeshIndex[d] = 0
                if (localMeshIndex[d] != 0)
                {
                    list[getLocalIndex(localMeshIndex)].push_back(particle);
                }
            }
        }
            //Add the rib contribution
            list[getLocalIndex(boundaryIndex)].push_back(particle);
            break;
            
            //The particle is close to three neighbouring directions
            // 3 side, 3 rib and 1 corner contribution
        case 3 :
        {
            //Add the three side contributions
            for (int d = 0; d < 3; d++)
            {
                std::vector<int> localMeshIndex = {0, 0, 0};
                //Reset index vector
                localMeshIndex[d] = boundaryIndex[d];
                list[getLocalIndex(localMeshIndex)].push_back(particle);
            }
            
            //Add the three rib contributions
            for (int d = 0; d < 3; d++)
            {
                std::vector<int> localMeshIndex = boundaryIndex;
                //All rib boundary indices are given by the boundaryIndex and setting one of the components to zero
                localMeshIndex[d] = 0;
                list[getLocalIndex(localMeshIndex)].push_back(particle);
            }
        }
            
            //Add the corner contribution
            list[getLocalIndex(boundaryIndex)].push_back(particle);
            break;
        
        default :
            logger(INFO, "boundaryIndex : %,%,% | list_complexity: %", boundaryIndex[0], boundaryIndex[1], boundaryIndex[2],
                   list_complexity);
            logger(ERROR, "Particle is in contact with the wrong number of boundaries");
            break;
    }
}

References abs(), calibrate::default, ERROR, findNearbyBoundaries(), getLocalIndex(), INFO, logger, and BaseParticle::setCommunicationComplexity().

Referenced by findNewMPIParticle().

cleanCommunicationList()

void Domain::cleanCommunicationList

(

std::vector< BaseParticle * > &

list

)

Removes nullptr's from a given particle list.

Removes nullptrs from a list of base particles efficiently by replacing the last entry to an empty nullptr space.m

Parameters

[in]

list

The list that needs to be cleansed from nullptrs

{
    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 Domain::cleanCommunicationLists

(

)

Removes nullptrs from boundaryParticleList_ and boundaryParticleListNeighbour_.

After particles have been updated, the communication lists contains nullptrs, remove these from the boundaryParticleList and boundaryParticleListNeighbour

{
    //For all active boundaries
    for (int i : boundaryList_)
    {
        cleanCommunicationList(boundaryParticleList_[i]);
        cleanCommunicationList(boundaryParticleListNeighbour_[i]);
    }
}

References boundaryList_, boundaryParticleList_, boundaryParticleListNeighbour_, cleanCommunicationList(), and i.

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

collectBoundaryParticleData()

void Domain::collectBoundaryParticleData

(

int

localIndex

)

collects the data of a particle that has to be communicated to other processors

collects the data of a particles that has to be communicated to other processors

Only the relevant data of a baseParticle is being send to other processors, therefore this function collects the relevant data and puts it in a format compatible with data transmission

Parameters

[in]

localIndex

the local index of a boundary

{
    //For all particles
    for (BaseParticle* particle : newBoundaryParticleList_[localIndex])
    {
        //Add the data to the transmission list
        boundaryParticleDataSend_[localIndex].push_back(copyDataFromParticleToMPIParticle(particle));
    }
}

References boundaryParticleDataSend_, copyDataFromParticleToMPIParticle(), and newBoundaryParticleList_.

Referenced by performBoundaryDataTransmission().

collectInteractionData()

void Domain::collectInteractionData

(

int

localIndex

)

Collects the data of an interaction that has to be communicated to other processors.

Interactions have to be reformatted in an MPI-suitable format to transmit over to other processors

Parameters

[in]

localIndex

The local index of a boundary

{
    //Copy interactions to the data array
    unsigned int indexInteraction = 0;
    for (BaseInteraction* interaction : newInteractionList_[localIndex])
    {
        interaction->getMPIInteraction(interactionDataSend_[localIndex], indexInteraction);
        indexInteraction++;
    }
}

References interactionDataSend_, and newInteractionList_.

Referenced by performBoundaryDataTransmission().

constructor()

void Domain::constructor

(

)

contructor of a domain

constructs the domain

the boundaries are set to infinity, no processor is assigned. all lists that require a full 3D domain element to function are created

{
    rank_ = constants::intMax;
    domainHandler_ = nullptr;
    domainMin_ = {-constants::inf, -constants::inf, -constants::inf};
    domainMax_ = {constants::inf, constants::inf, constants::inf};
    
    //A cube has 3^3=27 neighbours
    int numberOfNeighbours = 27;
    
    //Create all lists
    localIndexToGlobalIndexTable_ = std::vector<int>(numberOfNeighbours);
    localIndexToProcessorList_ = std::vector<int>(numberOfNeighbours);
    boundaryParticleList_ = std::vector<std::vector<BaseParticle*> >(numberOfNeighbours, std::vector<BaseParticle*>(0));
    boundaryParticleListNeighbour_ = std::vector<std::vector<BaseParticle*> >(numberOfNeighbours,
                                                                              std::vector<BaseParticle*>(0));
    newBoundaryParticleList_ = std::vector<std::vector<BaseParticle*> >(numberOfNeighbours,
                                                                        std::vector<BaseParticle*>(0));
    newInteractionList_ = std::vector<std::vector<BaseInteraction*> >(numberOfNeighbours,
                                                                      std::vector<BaseInteraction*>(0));
    numberOfParticlesSend_ = std::vector<unsigned>(numberOfNeighbours);
    numberOfParticlesReceive_ = std::vector<unsigned>(numberOfNeighbours);
    numNewInteractionsSend_ = std::vector<unsigned>(numberOfNeighbours);
    numNewInteractionsReceive_ = std::vector<unsigned>(numberOfNeighbours);
    boundaryParticleDataSend_ = std::vector<std::vector<MPIParticle> >(numberOfNeighbours);
    boundaryParticleDataReceive_ = std::vector<std::vector<MPIParticle> >(numberOfNeighbours);
    updatePositionDataSend_ = std::vector<std::vector<MPIParticlePosition> >(numberOfNeighbours);
    updatePositionDataReceive_ = std::vector<std::vector<MPIParticlePosition> >(numberOfNeighbours);
    updateVelocityDataSend_ = std::vector<std::vector<MPIParticleVelocity> >(numberOfNeighbours);
    updateVelocityDataReceive_ = std::vector<std::vector<MPIParticleVelocity> >(numberOfNeighbours);
    interactionDataSend_ = std::vector<void*>(numberOfNeighbours);
    interactionDataReceive_ = std::vector<void*>(numberOfNeighbours);
    activeBoundaryList_ = std::vector<bool>(numberOfNeighbours, true);
    boundaryList_ = std::vector<int>(0);
}

References activeBoundaryList_, boundaryList_, boundaryParticleDataReceive_, boundaryParticleDataSend_, boundaryParticleList_, boundaryParticleListNeighbour_, domainHandler_, domainMax_, domainMin_, constants::inf, interactionDataReceive_, interactionDataSend_, constants::intMax, localIndexToGlobalIndexTable_, localIndexToProcessorList_, newBoundaryParticleList_, newInteractionList_, numberOfParticlesReceive_, numberOfParticlesSend_, numNewInteractionsReceive_, numNewInteractionsSend_, rank_, updatePositionDataReceive_, updatePositionDataSend_, updateVelocityDataReceive_, and updateVelocityDataSend_.

Referenced by Domain().

containsParticle()

bool Domain::containsParticle	(	BaseParticle *	particle,
		Mdouble	offset = 0.0
	)

Check to see if a given particle is within the current domain.

Checks if a particle is in the domain.

Checks if the particle is in the domain, but with an offset. this offset is set to zero standard

Parameters

[in]	particle	Pointer to a particle
[in]	offset	offset from the domain boundary

Returns

True if the particle is in the domain. False if it is outside

{
    for (unsigned i = 0; i < 3; i++)
    {
        if (!(((domainMin_[i] + offset) < particle->getPosition().getComponent(i))
              &&
              ((domainMax_[i] - offset) >= particle->getPosition().getComponent(i)))
                )
        {
            return false;
        }
    }
    return true;
}

References domainMax_, domainMin_, Vec3D::getComponent(), BaseInteractable::getPosition(), and i.

Referenced by isInCommunicationZone(), isInGreaterDomain(), isInInnerDomain(), prepareBoundaryDataTransmission(), and updateParticles().

copy()

Domain * Domain::copy ( ) const

virtual

Function that creates a copy of this current domain, using the copy constructor.

Copy method.

Uses copy constructor to create a copy on the heap. Useful for polymorphism.

Returns

pointer to the domain's copy

{
    return new Domain(*this);
}

References Domain().

createLookUpTable()

void Domain::createLookUpTable

(

)

Create a look up table between local index system to global index system.

Function that creates a lookup table from the local index system to the global index system

{
    int localIndex;
    int globalIndex;
    //Get the global decomposition vector, (nx,ny,nz) and compute the mesh multipliers: (1,nx,nx*ny)
    std::vector<unsigned> numberOfDomains = domainHandler_->getNumberOfDomains();
    std::vector<unsigned> globalMeshMultiplier = {1,
                                                  numberOfDomains[Direction::XAXIS],
                                                  numberOfDomains[Direction::XAXIS] *
                                                  numberOfDomains[Direction::YAXIS]};
    
    //Compute the globalIndex of this domain
    globalIndex_ = globalMeshMultiplier[Direction::XAXIS] * globalMeshIndex_[Direction::XAXIS] +
                   globalMeshMultiplier[Direction::YAXIS] * globalMeshIndex_[Direction::YAXIS] +
                   globalMeshMultiplier[Direction::ZAXIS] * globalMeshIndex_[Direction::ZAXIS];
    
    //Create the lookup table from localIndex to globalIndex of the neighbours
    for (int i = -1; i < 2; i++)
    {
        for (int j = -1; j < 2; j++)
        {
            for (int k = -1; k < 2; k++)
            {
                //Get the local index  
                localIndex = i + 3 * j + 9 * k + 13;
                //Compute the global index
                globalIndex = globalMeshMultiplier[Direction::XAXIS] * (globalMeshIndex_[Direction::XAXIS] + i) +
                              globalMeshMultiplier[Direction::YAXIS] * (globalMeshIndex_[Direction::YAXIS] + j) +
                              globalMeshMultiplier[Direction::ZAXIS] * (globalMeshIndex_[Direction::ZAXIS] + k);
                //Fill in the look-up table
                localIndexToGlobalIndexTable_[localIndex] = globalIndex;
            }
        }
    }
    //Create the lookup table from localIndex to processorRank
    rank_ = globalIndex_;
    localIndexToProcessorList_ = localIndexToGlobalIndexTable_;
}

References domainHandler_, DomainHandler::getNumberOfDomains(), globalIndex_, globalMeshIndex_, i, j, k, localIndexToGlobalIndexTable_, localIndexToProcessorList_, rank_, XAXIS, YAXIS, and ZAXIS.

debugInformation()

void Domain::debugInformation

(

)

                              {
    std::stringstream s;
    std::stringstream m;
    for (auto p : getHandler()->getDPMBase()->particleHandler) {
        if (p->isMPIParticle())
            m << std::setw(4) << p->getId();
        else
            s << std::setw(4) << p->getId();
    }
    logger(INFO,"Particles %, MPI %",s.str(),m.str());
}

References getHandler(), INFO, logger, m, p, and s.

disableBoundaries()

void Domain::disableBoundaries

(

)

disables all domain boundaries that have no neighbour

This function can only disable a square mesh. If you want to make a concave mesh then this function has to be adapted, especially for the case when the numberOfDomains[d] = 1.

{
    std::vector<unsigned> numberOfDomains = domainHandler_->getNumberOfDomains();
    std::vector<int> localMeshIndex(3);
    int localIndex;
    
    //disable own list
    activeBoundaryList_[13] = false;
    
    //Special case when numberOfDomains[d] = 1 -> disable all d direction boundaries
    for (unsigned d = 0; d < 3; d++) //Loop over all dimensions
    {
        //If there is only one domain in the d-direction, take action
        if (numberOfDomains[d] == 1)
        {
            //Loop over all localIndices
            for (int i = -1; i < 2; i++)
            {
                localMeshIndex[Direction::XAXIS] = i;
                for (int j = -1; j < 2; j++)
                {
                    localMeshIndex[Direction::YAXIS] = j;
                    for (int k = -1; k < 2; k++)
                    {
                        localMeshIndex[Direction::ZAXIS] = k;
                        //Disable all boundaries that are not in the "middle" of the mesh in the d-direction
                        // i.e. a localMeshIndex[d] = -1 is a neighbour in the d-direction, however there is only one
                        // element in that direction so it can't be a real neighbour.
                        if (localMeshIndex[d] != 0)
                        {
                            //Disable the boundary
                            localIndex = getLocalIndex(localMeshIndex);
                            activeBoundaryList_[localIndex] = false;
                        }
                    }
                }
            }
        }
    }
    
    //Compute the boundaryIndex for all other cases where numberOfDomains is larger than 1
    std::vector<int> boundaryIndex(3);
    for (int d = 0; d < 3; d++)
    {
        //Check if the domain is on the simulationDomainMin boundary
        if (globalMeshIndex_[d] == 0)
        {
            //Update boundary index
            boundaryIndex[d] = -1;
        }
            //Check if the domain is on the simulationDomainMax boundary
        else if (globalMeshIndex_[d] == (numberOfDomains[d] - 1))
        {
            //Update boundary index
            boundaryIndex[d] = 1;
        }
    }
    
    //Disable the boundaries that are on the edge of the simulation domain
    for (int d = 0; d < 3; d++)
    {
        //If boundary is on the edge of the simulation domain
        if (boundaryIndex[d] != 0)
        {
            //Loop over all local indices
            for (int i = -1; i < 2; i++)
            {
                for (int j = -1; j < 2; j++)
                {
                    for (int k = -1; k < 2; k++)
                    {
                        localMeshIndex = {i, j, k};
                        //Set the localMeshIndex to the boundaryIndex in the d-direction
                        //Since we are only interested in the domains on this boundary
                        localMeshIndex[d] = boundaryIndex[d];
                        //Disable the boundary
                        localIndex = getLocalIndex(localMeshIndex);
                        activeBoundaryList_[localIndex] = false;
                    }
                }
            }
        }
    }
    
    //Create a list of the active boundaries
    localIndex = 0;
    for (bool active : activeBoundaryList_)
    {
        if (active)
        {
            boundaryList_.push_back(localIndex);
        }
        localIndex++;
    }
}

References activeBoundaryList_, boundaryList_, domainHandler_, getLocalIndex(), DomainHandler::getNumberOfDomains(), globalMeshIndex_, i, j, k, XAXIS, YAXIS, and ZAXIS.

disableBoundary()

void Domain::disableBoundary

(

unsigned

localIndex

)

Disables a boundary of the domain with a neighbouring domain.

This function disables the communication of a boundary. Each domain in the parallel code has 27 boundaries: (6 sides, 12 ribs, 8 corners) and for convenience one is associated with the domain itself (used for local indexing). Boundaries that are inactive, such as domains that extend to infinity, do not need to be considered in the parallel computation. This function disables that boundary.

Parameters

[in]

localIndex

The local index of a neighbour of the current domain

{
    activeBoundaryList_[localIndex] = false;
}

References activeBoundaryList_.

finaliseBoundaryDataTransmission()

void Domain::finaliseBoundaryDataTransmission

(

)

This function processes the transmitted data.

copies the received mpi data into the particles/interactions and adds them to the particleHandler/interactionHandler All vectors that have been used in transmitting data are then cleaned up

Parameters

[in,out]	particleHandler	Handles all particles in the current domain, on output contains the newly received particles
[in,out]	interactionHandler	Handles all interactions in the current domain, on output contains the newly received interactions

        {
            //For all boundaries
            for (int localIndex : boundaryList_)
            {
                //copy the received data into the particleHandler and neighbour particle list
                std::vector<BaseParticle*> newParticles;
                processReceivedBoundaryParticleData(localIndex, newParticles);
                //All particles in the current domain that have been send to the other domains need to be flagged as communicating particles
                processSentBoundaryParticles(localIndex);
                //copy the received interaction data into the standard dpm structure
                processReceivedInteractionData(localIndex, newParticles);
 
                //Delete all send/receive data
                boundaryParticleDataSend_[localIndex].clear();
                boundaryParticleDataReceive_[localIndex].clear();
                getHandler()->getDPMBase()->interactionHandler.deleteMPIInteractionDataArray(interactionDataSend_[localIndex]);
                getHandler()->getDPMBase()->interactionHandler.deleteMPIInteractionDataArray(
                        interactionDataReceive_[localIndex]);
 
                //Reset all counters
                numberOfParticlesSend_[localIndex] = 0;
                numberOfParticlesReceive_[localIndex] = 0;
                numNewInteractionsSend_[localIndex] = 0;
                numNewInteractionsReceive_[localIndex] = 0;
 
                //Reset all lists
                newBoundaryParticleList_[localIndex].clear();
                newInteractionList_[localIndex].clear();
            }
        }

References boundaryList_, boundaryParticleDataReceive_, boundaryParticleDataSend_, InteractionHandler::deleteMPIInteractionDataArray(), BaseHandler< T >::getDPMBase(), getHandler(), interactionDataReceive_, interactionDataSend_, DPMBase::interactionHandler, newBoundaryParticleList_, newInteractionList_, numberOfParticlesReceive_, numberOfParticlesSend_, numNewInteractionsReceive_, numNewInteractionsSend_, processReceivedBoundaryParticleData(), processReceivedInteractionData(), and processSentBoundaryParticles().

Referenced by addNewParticles(), and addParticle().

finalisePositionAndVelocityUpdate()

void Domain::finalisePositionAndVelocityUpdate

(

std::set< BaseParticle * > &

ghostParticlesToBeDeleted

)

processes position and velocity data for ghost particles

After the data has been received from other processors, this function will update the ghost particles with the new position and velocity data. Afterwards the status of the particles will be updated based on their new positions. Sometimes a particle needs to be removed from the simulation, however since this particle might still be active in the periodic boundary it is not deleted straight away but stored in ghostParticlesToBeDeleted. Finally the communication data is removed.

Parameters

[in,out]

ghostParticlesToBeDeleted

A vector containing particles that need to be removed from the simulation

{
    
    //For all active boundaries
    for (int localIndex : boundaryList_)
    {
        updateParticlePosition(localIndex);
        updateParticleVelocity(localIndex);
    }
    
    //Based on the new position, update the particle lists. 
    //Remove particles that left the communication zone, they will be re-communicated in a later step
    updateParticles(ghostParticlesToBeDeleted);
    
    //For all active boundaries clear the data lists
    for (int localIndex : boundaryList_)
    {
        updatePositionDataSend_[localIndex].clear();
        updateVelocityDataSend_[localIndex].clear();
        updatePositionDataReceive_[localIndex].clear();
        updateVelocityDataReceive_[localIndex].clear();
    }
    
}

References boundaryList_, updateParticlePosition(), updateParticles(), updateParticleVelocity(), updatePositionDataReceive_, updatePositionDataSend_, updateVelocityDataReceive_, and updateVelocityDataSend_.

Referenced by updateStatus().

finaliseVelocityUpdate()

void Domain::finaliseVelocityUpdate

(

)

Processes particle velocity data for ghost particles.

This function is not in use

{
    //For all active boundaries
    for (int localIndex : boundaryList_)
    {
        updateParticleVelocity(localIndex);
    }
    
    //For all active boundaries clear the data lists
    for (int localIndex : boundaryList_)
    {
        updateVelocityDataSend_[localIndex].clear();
        updateVelocityDataReceive_[localIndex].clear();
    }
}

References boundaryList_, updateParticleVelocity(), updateVelocityDataReceive_, and updateVelocityDataSend_.

Referenced by updateVelocity().

findNearbyBoundaries()

std::vector< int > Domain::findNearbyBoundaries	(	BaseParticle *	particle,
		Mdouble	offset = 0
	)

This function finds if a given particle is close to a given boundary.

This function detects in how many boundaries the particle is located and is stored in the boundaryIndex. The boundary Index in the x-direction: a) -1 if the particle is at the left boundary b) 0 if the particle is not at a boundary c) 1 if the particle is at the right boundary The same holds for the y and z direction as well

Parameters

[in]	particle	a base particle
[out]	offset	the L1 distance between the domain boundary and the wanted boundary

Returns

boundaryIndex a vector indicating at which boundary the particle is

{
    std::vector<int> boundaryIndex(3);
    Mdouble interactionDistance = domainHandler_->getInteractionDistance();
    
    //for x,y,z directions, find if the particle is close to the left or right wall or not at all
    for (int d = 0; d < 3; d++)
    {
        //Check if the particle is close to Lx
        if ((particle->getPosition().getComponent(d)) < (domainMin_[d] + interactionDistance + offset))
        {
            //Update switch
            boundaryIndex[d] = -1;
        }
            //Check if particle is close to Rx
        else if ((particle->getPosition().getComponent(d)) >= (domainMax_[d] - interactionDistance - offset))
        {
            //Update switch
            boundaryIndex[d] = 1;
        }
    }
    return boundaryIndex;
}

References domainHandler_, domainMax_, domainMin_, Vec3D::getComponent(), DomainHandler::getInteractionDistance(), and BaseInteractable::getPosition().

Referenced by addParticlesToLists(), inBoundary(), and updateParticles().

findNewMPIInteractions()

void Domain::findNewMPIInteractions

(

)

Finds interactions that have to be send over to another domain.

Finds interactions that have to be sent over to another domain.

Newly added particles to the communication lists might have history interactions with the particles already there. The other domains need to be aware of these history interactions and this function collects the relevant interactions.

                            {
                                //For all active boundaries
                                for (int localIndex : boundaryList_)
                                {
                                    //Check all newly added particles for interactions with already known particles
                                    for (BaseParticle* newBoundaryParticle : newBoundaryParticleList_[localIndex])
                                    {
                                        //Loop over all interactions of the new particle
                                        std::vector<BaseInteraction*> interactions = newBoundaryParticle->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 (newBoundaryParticle == particleP)
                                            {
                                                //Check if the new particle is interacting with a wall
                                                if (!objectI)
                                                {
                                                    //Check if the interaction is still valid
                                                    BaseWall* wall = dynamic_cast<BaseWall*>(interaction->getI());
                                                    Mdouble distance;
                                                    Vec3D normal;
                                                    wall->getDistanceAndNormal(*particleP, distance, normal);
                                                    if (distance <= particleP->getMaxInteractionRadius())
                                                    {
                                                        //Add the interaction to the list if there are still in contact (hence the if statement)
                                                        newInteractionList_[localIndex].push_back(interaction);
                        }
                    }
                    else //is I a particle
                    {
                        //check if particle is in mpi domain OR (TODO) if it is in the newBoundaryParticleList_
                        if (objectI->isInMPIDomain() || isInNewBoundaryParticleList(objectI, localIndex))
                        {
                            // iff the interaction partner of the new particle is in the communication zone, transmit the interaction
                            if (inBoundary(objectI,localIndex))
                            {
                                //Is the particle still interacting after the position update?
                                Vec3D branchVector = particleP->getPosition() - objectI->getPosition();
                                //Get the square of the distance between particle i and particle j
                                Mdouble distanceSquared = Vec3D::getLengthSquared(branchVector);
                                Mdouble sumOfInteractionRadii =
                                    objectI->getSumOfInteractionRadii(particleP);
                                if (distanceSquared < (sumOfInteractionRadii * sumOfInteractionRadii))
                                {
                                    //Add the interaction to the list
                                    newInteractionList_[localIndex].push_back(interaction);
                                }
                            }
                        }
                    }
                }
                else //newBoundaryParticle is I in the interaction, P can only be a particle
                {
                    //it is "I" in the interaction structure, check if it is in the mpi domain
                    if (particleP->isInMPIDomain() || isInNewBoundaryParticleList(particleP, localIndex))
                    {
                        //Is the particle still interacting after the position update?
                        Vec3D branchVector = particleP->getPosition() - objectI->getPosition();
                        //Get the square of the distance between particle i and particle j
                        Mdouble distanceSquared = Vec3D::getLengthSquared(branchVector);
                        Mdouble sumOfInteractionRadii =
                                objectI->getSumOfInteractionRadii(particleP);
                        if (distanceSquared < (sumOfInteractionRadii * sumOfInteractionRadii))
                        {
                            //Add the interaction to the list
                            newInteractionList_[localIndex].push_back(interaction);
                        }
                    }
                }
            }
        }
    }
}

References boundaryList_, BaseWall::getDistanceAndNormal(), Vec3D::getLengthSquared(), BaseInteractable::getPosition(), BaseParticle::getSumOfInteractionRadii(), inBoundary(), BaseParticle::isInMPIDomain(), isInNewBoundaryParticleList(), newBoundaryParticleList_, newInteractionList_, and WallFunction::normal().

Referenced by prepareBoundaryDataTransmission().

findNewMPIParticle()

void Domain::findNewMPIParticle

(

BaseParticle *

particle

)

Function that check if a given particle should be added to the communication lists.

Function that checks if a given particle should be added to the communication lists and adds it accordingly.

Parameters

[in]

particle

point to a particle that is being checked if it should be added to the communication lists

{
    //If the particle is an MPI particle
    if (!particle->isInMPIDomain() && !particle->isPeriodicGhostParticle())
    {
        addParticlesToLists(particle, newBoundaryParticleList_);
    }
}

References addParticlesToLists(), BaseParticle::isInMPIDomain(), BaseParticle::isPeriodicGhostParticle(), and newBoundaryParticleList_.

Referenced by findNewMPIParticles(), and prepareBoundaryDataTransmission().

findNewMPIParticles()

void Domain::findNewMPIParticles

(

const ParticleHandler &

particleHandler

)

Function that finds new particles in the particle handler that should be added to the communication lists.

Parameters

[in]

particleHandler

the container that contains all particles

{
    //For all particles inside the given domain, loop over all the particles to
    //see if we have to add the particles to the new particle list
    for (BaseParticle* particle : particleHandler)
    {
        findNewMPIParticle(particle);
    }
}

References findNewMPIParticle().

Referenced by prepareBoundaryDataTransmission().

findParticleInList()

BaseParticle * Domain::findParticleInList	(	unsigned int	identification,
		std::vector< BaseParticle * >	particleList
	)

Searches for a particle with a specific id in a list of particles.

When interactions are copied over MPI from an MPI particle, the unique id of the particles they interact with need to be looked up. This functions searches for the correct particle

Todo:

MX: This is probably not the fastest method

Parameters

[in]	identification	The unique ID of a particle
[in]	particleList	List of particles

Returns

Either the particle with the id identification or a nullptr when the particle has not been found

{
    for (BaseParticle* particle : particleList)
    {
        if (particle->getId() == identification)
        {
            return particle;
        }
    }
    return nullptr;
}

flushParticles()

void Domain::flushParticles

(

std::set< BaseParticle * > &

toBeFlushedList

)

Particles that are going to be deleted from the simulation are flushed out of the communication boundaries.

Parameters

[in]

toBeFlushedList

A list of particles that is going to be deleted

{
    //For all active boundaries
    for (int localIndex : boundaryList_)
    {
        flushParticlesFromList(boundaryParticleList_[localIndex], toBeFlushedList);
        flushParticlesFromList(boundaryParticleListNeighbour_[localIndex], toBeFlushedList);
    }
}

References boundaryList_, boundaryParticleList_, boundaryParticleListNeighbour_, and flushParticlesFromList().

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

flushParticlesFromList()

void Domain::flushParticlesFromList	(	std::vector< BaseParticle * > &	list,
		std::set< BaseParticle * > &	toBeDeletedList
	)

Particles that are going to be deleted from the simulation are flushed out of a give communication boundary.

{
    //Firstly: turn all particles that need to be flushed into nullptrs
    for (auto& p : list)
    {
        if (p != nullptr)
        {
            BaseParticle* particle1 = p;
            for (BaseParticle* particle2 : toBeFlushedList)
            {
                //If the particle was found in the list, make a nullptr
                if (particle1 == particle2)
                {
                    logger(VERBOSE, "Removing particle from mpi domain at: %", particle1->getPosition());
                    p = nullptr;
                }
            }
        }
    }
}

References BaseInteractable::getPosition(), logger, p, and VERBOSE.

Referenced by flushParticles().

getActiveBoundaryList()

std::vector< bool > Domain::getActiveBoundaryList

(

)

Returns a list of boundaries that are active in mpi communication.

Returns a list of boundaries that are active in mpi communication

Returns

List of active mpi communication boundaries

{
    return activeBoundaryList_;
}

References activeBoundaryList_.

getDomainMax()

std::vector< double > Domain::getDomainMax

(

)

Gets the maximum domain bounds.

Gets the domain's maximum domain bounds

Returns

Maximum bounds of the domain

{
    return domainMax_;
}

References domainMax_.

getDomainMin()

std::vector< double > Domain::getDomainMin

(

)

Gets the minimum domain bounds.

Gets the domain's minimum domain bounds

Returns

Minimum bounds of the domain

{
    return domainMin_;
}

References domainMin_.

getGlobalIndex()

int Domain::getGlobalIndex

(

)

Gets the global index of the domain.

Returns the global index of the domain in the whole simulation domain

Returns

Returns the global index of the domain

{
    return globalIndex_;
}

References globalIndex_.

getGlobalMeshIndex()

std::vector< unsigned > Domain::getGlobalMeshIndex

(

)

Gets the global mesh index of the domain.

returns a vector with the global mesh indices (i,j,k)

Returns

global mesh indices i,j and k

{
    return globalMeshIndex_;
}

References globalMeshIndex_.

getHandler()

DomainHandler * Domain::getHandler

(

)

const

Gets the domainHandler.

Returns the pointer to the DomainHandler the domain belongs to

Returns

pointer to the handler

{
    return domainHandler_;
}

References domainHandler_.

Referenced by debugInformation(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), processReceivedBoundaryParticleData(), processReceivedInteractionData(), setBounds(), setRange(), and updateParticlePosition().

getLocalIndex() [1/2]

int Domain::getLocalIndex	(	int	i,
		int	j,
		int	k
	)

return the local index of a domain given local mesh indices i,j and k

Given i,j,k (where i=0,j=0,k=0 is the current domain), get the local index of a neighbouring domain

Parameters

[in]	i	Index in the x-direction with i=0 corresponding to the current domain
[in]	j	Index in the y-direction with j=0 corresponding to the current domain
[in]	k	Index in the z-direction with k=0 corresponding to the current domain

Returns

The localIndex of the neighbour is returned.

{
    return i + 3 * j + 9 * k + 13;
}

References i, j, and k.

Referenced by addParticlesToLists(), and disableBoundaries().

getLocalIndex() [2/2]

int Domain::getLocalIndex

(

std::vector< int >

localMeshIndex

)

return the local index of a domain given the localMeshIndex vector

Given i,j,k (where i=0,j=0,k=0 is the current domain), get the local index of a neighbouring domain

Parameters

[in]

localMeshIndex

(i,j,k) where (0,0,0) corresponds to the current domain

Returns

The localIndex of the neighbour is returned.

{
    return localMeshIndex[Direction::XAXIS] + 3 * localMeshIndex[Direction::YAXIS] +
           9 * localMeshIndex[Direction::ZAXIS] + 13;
}

References XAXIS, YAXIS, and ZAXIS.

getLocalIndexInverse()

std::vector< int > Domain::getLocalIndexInverse

(

int

localMeshIndex

)

Does the inverse action of getLocalIndex (un-bundles the localIndex into the three dimensions)

                                                          {
    localIndex -= 13;
    return {localIndex%3, (localIndex/3)%3, (localIndex/9)%3};
}

Referenced by inBoundary().

getMiddle()

Vec3D Domain::getMiddle

(

)

const

Gives the middle of the domain.

Returns the middle of this square domain, required for periodic particles

Returns

middle_ The middle position of a cubic domain

{
    return middle_;
}

References middle_.

Referenced by PeriodicBoundaryHandler::findTargetProcessor(), and ForceLawsMPI2Test::printTime().

getName()

std::string Domain::getName ( ) const

overridevirtual

Returns the name of the object.

Returns the object's class name (i.e. 'DeletionBoundary').

Returns

the object's class name

Implements BaseObject.

{
    return "Domain";
}

getNumberOfMPIParticles()

unsigned int Domain::getNumberOfMPIParticles

(

)

Obtains the number of particles in the particleHandler that are MPIParticles.

All the MPIParticles are located in the neighbour lists and we only need to take a sum of these lists to obtain the number of MPIParticles. This function is required to keep track of the number of real particles in the domain.

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

References boundaryParticleListNeighbour_.

getNumberOfTrueMPIParticles()

unsigned int Domain::getNumberOfTrueMPIParticles

(

)

Obtains the number of particles in the particleHandler that are MPIParticles, but NOT periodic particles.

All the MPIParticles are located in the neighbour lists and we only need to take a sum of these lists to obtain the number of MPIParticles. This function is required to keep track of the number of real particles in the domain.

{
    unsigned int count = 0;
    for (auto& index : boundaryParticleListNeighbour_)
    {
        for (auto& p : index)
        {
            if (!p->isPeriodicGhostParticle())
            {
                count++;
            }
        }
    }
    return count;
}

References boundaryParticleListNeighbour_, and p.

Referenced by ParticleHandler::getNumberOfRealObjectsLocal().

getRank()

int Domain::getRank

(

)

Gets the rank associated with the assigned processorID.

Gets the domain's rank, corresponding to a processorID.

Returns

rank of the domain

{
    return rank_;
}

References rank_.

inBoundary()

bool Domain::inBoundary	(	BaseParticle *	particle,
		int	localIndex
	)

checks whether the particle is in the localIndex zone.

                                                               {
    std::vector<int> boundaryIndex = findNearbyBoundaries(particle);
    std::vector<int> localIndex = getLocalIndexInverse(localIndex_);
    // if the particle is in the boundary zone into which we want to transmit
    for (int i = 0; i < 3; ++i)
    {
        if (localIndex[i]!=0 && boundaryIndex[i]!=localIndex[i]) {
            return false;
        }
    }
    return true;
}

References findNearbyBoundaries(), getLocalIndexInverse(), and i.

Referenced by findNewMPIInteractions().

isInCommunicationZone()

bool Domain::isInCommunicationZone

(

BaseParticle *

particle

)

Check if the particle is in the communication zone of the current domain.

Check if the particle is inside the communication zone

Parameters

[in]

particle

Pointer to a particle

Returns

True if the particle is in the communication zone, i.e. in the domain, but not in the inner domain. False if it is outside the communication zone.

{
    //First check if the particle is actually in the domain
    //Secondly check if the particle is in the inner domain
    return containsParticle(particle) && !(isInInnerDomain(particle));
}

References containsParticle(), and isInInnerDomain().

Referenced by DPMBase::mpiIsInCommunicationZone().

isInGreaterDomain()

bool Domain::isInGreaterDomain

(

BaseParticle *

particle

)

Check to see if a given particle is in the current domain or in neighbouring communication zones.

Check if the particle is inside the domain + the communication zone around it

Parameters

[in]

particle

Pointer to a particle

Returns

True if the particle is in the domain or the whole communication zone around it. False if it is outside

{
    return containsParticle(particle, -domainHandler_->getInteractionDistance());
}

References containsParticle(), domainHandler_, and DomainHandler::getInteractionDistance().

isInInnerDomain()

bool Domain::isInInnerDomain

(

BaseParticle *

particle

)

Check if the particle is in the current domain but not in the communication zone.

Parameters

[in]

particle

Pointer to a particle

Returns

Returns true if the particle is in the inner domain (i.e. not in the communication zone of the domain)

{
    return containsParticle(particle, domainHandler_->getInteractionDistance());
}

References containsParticle(), domainHandler_, and DomainHandler::getInteractionDistance().

Referenced by isInCommunicationZone().

isInNewBoundaryParticleList()

bool Domain::isInNewBoundaryParticleList	(	BaseParticle *	object,
		int	localIndex
	)		const

Checks whether a particle is in the list of new particles received by this thread

{
    for (BaseParticle *q : newBoundaryParticleList_[localIndex]) {
        if (q == objectI)
            return true;
    }
    return false;
}

References newBoundaryParticleList_, and Eigen::numext::q.

Referenced by findNewMPIInteractions().

performBoundaryDataTransmission()

void Domain::performBoundaryDataTransmission

(

)

Collects data to be transmitted and then performs the transmission of the data.

The particles and interactions are copied into a data class that can be transmitted to other processors. The data is then accordingly send to the appropriate processors

Parameters

[in]

interactionHandler

Handler that contains all interactions, required to collect interaction data

        {
            //For all active boundaries
            for (int localIndex : boundaryList_)
            {
                //make sure enough memory is reserved to receive the data
                boundaryParticleDataReceive_[localIndex].resize(numberOfParticlesReceive_[localIndex]);
 
                //Collect the particle data
                collectBoundaryParticleData(localIndex);
 
                //Send the data
                sendAndReceiveMPIData(MercuryMPITag::PARTICLE_DATA, MercuryMPIType::PARTICLE,
                                      boundaryParticleDataReceive_[localIndex].data(), numberOfParticlesReceive_[localIndex],
                                      boundaryParticleDataSend_[localIndex].data(), numberOfParticlesSend_[localIndex],
                                      localIndex);
 
 
                //create arrays for sending and receiving interaction data
                interactionDataSend_[localIndex] = getHandler()->getDPMBase()->interactionHandler.createMPIInteractionDataArray(
                        numNewInteractionsSend_[localIndex]);
                interactionDataReceive_[localIndex] = getHandler()->getDPMBase()->interactionHandler.createMPIInteractionDataArray(
                        numNewInteractionsReceive_[localIndex]);
 
                //Collect the interaction data
                collectInteractionData(localIndex);
 
                //Send the data
                sendAndReceiveMPIData(MercuryMPITag::INTERACTION_DATA, MercuryMPIType::INTERACTION,
                                      interactionDataReceive_[localIndex], numNewInteractionsReceive_[localIndex],
                                      interactionDataSend_[localIndex], numNewInteractionsSend_[localIndex], localIndex);
            }
        }

References boundaryList_, boundaryParticleDataReceive_, boundaryParticleDataSend_, collectBoundaryParticleData(), collectInteractionData(), InteractionHandler::createMPIInteractionDataArray(), data, BaseHandler< T >::getDPMBase(), getHandler(), INTERACTION, INTERACTION_DATA, interactionDataReceive_, interactionDataSend_, DPMBase::interactionHandler, numberOfParticlesReceive_, numberOfParticlesSend_, numNewInteractionsReceive_, numNewInteractionsSend_, PARTICLE, PARTICLE_DATA, and sendAndReceiveMPIData().

Referenced by addNewParticles(), and addParticle().

prepareBoundaryDataTransmission() [1/2]

void Domain::prepareBoundaryDataTransmission

(

)

Prepares the MPI transmission of particle and interaction data from particles in particleHandler.

This function checks all the particles in the particle handler to see if they have moved in the communication domain. If that is the case they are added to a list of particles that need to be send. After all particles are evaluated the number of new particles to be send is send to the appropriate processors The same is being done to the interactions of the newly found particles

Parameters

[in]

particleHandler

handles all the particles in the current domain

        {
            //Find new particles that have entered the communication zone
            findNewMPIParticles(getHandler()->getDPMBase()->particleHandler);
 
            //Find interactions between new particles and other particles in the communication zone
            findNewMPIInteractions();
 
            //Compute number of particles to send
            //For all boundaries
            for (int localIndex : boundaryList_)
            {
                numberOfParticlesSend_[localIndex] = newBoundaryParticleList_[localIndex].size();
                numNewInteractionsSend_[localIndex] = newInteractionList_[localIndex].size();
            }
 
            //For all active boundaries
            for (int localIndex : boundaryList_)
            {
                //Send and receive the number of new boundary particles
                sendAndReceiveCount(MercuryMPITag::PARTICLE_COUNT, (numberOfParticlesReceive_[localIndex]),
                                    (numberOfParticlesSend_[localIndex]), localIndex);
 
                //Send and receive the new interactions
                sendAndReceiveCount(MercuryMPITag::INTERACTION_COUNT, (numNewInteractionsReceive_[localIndex]),
                                    (numNewInteractionsSend_[localIndex]), localIndex);
            }
        }

References boundaryList_, findNewMPIInteractions(), findNewMPIParticles(), getHandler(), INTERACTION_COUNT, newBoundaryParticleList_, newInteractionList_, numberOfParticlesReceive_, numberOfParticlesSend_, numNewInteractionsReceive_, numNewInteractionsSend_, PARTICLE_COUNT, and sendAndReceiveCount().

Referenced by addNewParticles(), and addParticle().

prepareBoundaryDataTransmission() [2/2]

void Domain::prepareBoundaryDataTransmission

(

BaseParticle *

particle

)

Prepares the MPI transmission of a single particle and its interactions.

When a single particle has to be added to the communication zone (i.e. when the user adds a particle during the simulation) then all processors should be informed if they receive the particle or not. The functionality of this function is practically the same as that of prepareBoundaryDataTransmission(ParticleHandler &particleHandler) The same is being done to the interactions of the newly found particles

Parameters

[in]

particle

A base particle that needs to be transmitted

        {
            //Assign the particle to the correct lists if the particle belongs to this domain
            if (containsParticle(particle))
            {
                findNewMPIParticle(particle);
            }
 
            //Note: When inserting a single particle, it has no interactions, so no interactions to be copied either
 
            //Compute number of particles to send
            //For all boundaries
            for (int localIndex : boundaryList_)
            {
                numberOfParticlesSend_[localIndex] = newBoundaryParticleList_[localIndex].size();
                numNewInteractionsSend_[localIndex] = newInteractionList_[localIndex].size();
            }
 
 
            //For all active boundaries
            for (int localIndex : boundaryList_)
            {
                //Send and receive the number of new boundary particles
                sendAndReceiveCount(MercuryMPITag::PARTICLE_COUNT, (numberOfParticlesReceive_[localIndex]),
                                    (numberOfParticlesSend_[localIndex]), localIndex);
 
                //Send and receive the new interactions
                sendAndReceiveCount(MercuryMPITag::INTERACTION_COUNT, (numNewInteractionsReceive_[localIndex]),
                                    (numNewInteractionsSend_[localIndex]), localIndex);
            }
        }

References boundaryList_, containsParticle(), findNewMPIParticle(), INTERACTION_COUNT, newBoundaryParticleList_, newInteractionList_, numberOfParticlesReceive_, numberOfParticlesSend_, numNewInteractionsReceive_, numNewInteractionsSend_, PARTICLE_COUNT, and sendAndReceiveCount().

preparePositionAndVelocityUpdate()

void Domain::preparePositionAndVelocityUpdate

(

)

Function that sends particle position and velocity data for ghost particles to other processors.

When the real particle moves on it's actual domain, it's ghost particles have to get an update this function sends the data to the processors that require the update

{
    //For all active boundaries
    for (int localIndex : boundaryList_)
    {
        numberOfParticlesSend_[localIndex] = boundaryParticleList_[localIndex].size();
        numberOfParticlesReceive_[localIndex] = boundaryParticleListNeighbour_[localIndex].size();
        
        //Increase capacity for the receiving data files
        updatePositionDataReceive_[localIndex].resize(numberOfParticlesReceive_[localIndex]);
        updateVelocityDataReceive_[localIndex].resize(numberOfParticlesReceive_[localIndex]);
        
        
        //Collect data
        for (BaseParticle* particle : boundaryParticleList_[localIndex])
        {
            updatePositionDataSend_[localIndex].push_back(copyPositionFrom(particle));
            updateVelocityDataSend_[localIndex].push_back(copyVelocityFrom(particle));
        }
        
        //Send and receive the data
        sendAndReceiveMPIData(MercuryMPITag::POSITION_DATA, MercuryMPIType::POSITION,
                              updatePositionDataReceive_[localIndex].data(), numberOfParticlesReceive_[localIndex],
                              updatePositionDataSend_[localIndex].data(), numberOfParticlesSend_[localIndex],
                              localIndex);
        sendAndReceiveMPIData(MercuryMPITag::VELOCITY_DATA, MercuryMPIType::VELOCITY,
                              updateVelocityDataReceive_[localIndex].data(), numberOfParticlesReceive_[localIndex],
                              updateVelocityDataSend_[localIndex].data(), numberOfParticlesSend_[localIndex],
                              localIndex);
    }
}

References boundaryList_, boundaryParticleList_, boundaryParticleListNeighbour_, copyPositionFrom(), copyVelocityFrom(), data, numberOfParticlesReceive_, numberOfParticlesSend_, POSITION, POSITION_DATA, sendAndReceiveMPIData(), updatePositionDataReceive_, updatePositionDataSend_, updateVelocityDataReceive_, updateVelocityDataSend_, VELOCITY, and VELOCITY_DATA.

Referenced by updateStatus().

prepareVelocityUpdate()

void Domain::prepareVelocityUpdate

(

)

Function that sends particle velocity data for ghost particles.

This function is not in use

{
    //For all active boundaries
    for (int localIndex : boundaryList_)
    {
        numberOfParticlesSend_[localIndex] = boundaryParticleList_[localIndex].size();
        numberOfParticlesReceive_[localIndex] = boundaryParticleListNeighbour_[localIndex].size();
        
        //Resize the vector to the correct size
        updateVelocityDataReceive_[localIndex].resize(numberOfParticlesReceive_[localIndex]);
        
        //Collect data
        for (BaseParticle* particle : boundaryParticleList_[localIndex])
        {
            updateVelocityDataSend_[localIndex].push_back(copyVelocityFrom(particle));
        }
        
        //Send the data
        sendAndReceiveMPIData(MercuryMPITag::VELOCITY_DATA, MercuryMPIType::VELOCITY,
                              updateVelocityDataReceive_[localIndex].data(), numberOfParticlesReceive_[localIndex],
                              updateVelocityDataSend_[localIndex].data(), numberOfParticlesSend_[localIndex],
                              localIndex);
    }
}

References boundaryList_, boundaryParticleList_, boundaryParticleListNeighbour_, copyVelocityFrom(), data, numberOfParticlesReceive_, numberOfParticlesSend_, sendAndReceiveMPIData(), updateVelocityDataReceive_, updateVelocityDataSend_, VELOCITY, and VELOCITY_DATA.

Referenced by updateVelocity().

processReceivedBoundaryParticleData()

void Domain::processReceivedBoundaryParticleData	(	unsigned	index,
		std::vector< BaseParticle * > &	newParticles
	)

Function that copies the mpi data format of a base particle to a real particle and adds it to the particleHandler.

When adding a particle with this function it's always a ghost particle and therefor gets the MPIParticle flag

Parameters

[in]	index	The boundary index of the boundary list currently being treated
[in,out]	particleHandler	Container containing the particles of the current domain, will contain the new MPI particles as well

{
    
    ParticleHandler& particleHandler = getHandler()->getDPMBase()->particleHandler;
    //for all MPIParticles that have been received on the other side
    for (int i = 0; i < numberOfParticlesReceive_[index]; i++)
    {
        //copy data from data
        BaseParticle* p0 = MPIParticle::newParticle();
        copyDataFromMPIParticleToParticle(&(boundaryParticleDataReceive_[index][i]), p0, &particleHandler);
        
        //Flag that the particle is a ghost particle of a real particle in the neighbour domain
        p0->setMPIParticle(true);
        //Flag that the particle is list as a particle in the mpi domain
        p0->setInMPIDomain(true);
        //add particle to handler
        particleHandler.addGhostObject(p0);
        //Set previous position as current position
        BaseParticle* pGhost = particleHandler.getLastObject();
        pGhost->setPreviousPosition(particleHandler.getLastObject()->getPosition());
        //Add to the newParticle list
        newParticles.push_back(pGhost);
        logger(VERBOSE, "Adding mpi particle % at: %", particleHandler.getLastObject()->getId(),
               particleHandler.getLastObject()->getPosition());
        
        //add pointer to the particle to the list and set the status to idle
        boundaryParticleListNeighbour_[index].push_back(particleHandler.getLastObject());
    }
}

References ParticleHandler::addGhostObject(), boundaryParticleDataReceive_, boundaryParticleListNeighbour_, copyDataFromMPIParticleToParticle(), BaseHandler< T >::getDPMBase(), getHandler(), BaseObject::getId(), BaseHandler< T >::getLastObject(), BaseInteractable::getPosition(), i, logger, MPISphericalParticle::newParticle(), numberOfParticlesReceive_, p0, DPMBase::particleHandler, BaseParticle::setPreviousPosition(), and VERBOSE.

Referenced by finaliseBoundaryDataTransmission().

processReceivedInteractionData()

void Domain::processReceivedInteractionData	(	unsigned	index,
		std::vector< BaseParticle * > &	newParticles
	)

Processes the received interactions from newly added mpi particles

Processes the received interactions from newly added mpi particles.

The received interaction data is scanned for interaction id's P and I they are then matches to the actual particle or wall and the interaction is created. The history details of the interaction are filled in after creation.

Bug:

There is a subtle and very rare bug in here, where two particles with an interaction across a periodic boundary pass into the next domain at the same time step. In this case, the interactions should be copied over before the ghost-particles are constructed. However, since the interaction is with the ghost particle, this cannot be done. That is why there is a 'continue' if one of the particles of the interaction is not found. An illustration of this situation is given in PeriodicBoundaryEnteringMpiDomainMPI2Test.

Parameters

[in]	localIndex	The boundary index of the boundary list currently being treated
[in,out]	interactionHandler	Handler containing all interactions on the current domain

{
    InteractionHandler& iH = getHandler()->getDPMBase()->interactionHandler;
    for (unsigned int l = 0; l < numNewInteractionsReceive_[localIndex]; l++)
    {
        unsigned int identificationP;
        unsigned int identificationI;
        bool isWallInteraction;
        unsigned timeStamp;
        
        //Get the general information required to setup a new interaction
        iH.getInteractionDetails(interactionDataReceive_[localIndex],
                                 l, identificationP, identificationI,
                                 isWallInteraction, timeStamp);
        
        logger(VERBOSE, "interaction details: %, %, idP %, idI %, wall %, time %", interactionDataReceive_[localIndex],
               l, identificationP, identificationI,
               isWallInteraction, timeStamp);
        
        //Find the particle in the newParticle list
        BaseParticle* pGhost = nullptr;
        int idOther;
        for (BaseParticle* particle : newParticles)
        {
            if (particle->getId() == identificationP)
            {
                pGhost = particle;
                idOther = identificationI;
                break;
            }
            
            if (particle->getId() == identificationI)
            {
                pGhost = particle;
                idOther = identificationP;
                break;
            }
        }
        if (pGhost == nullptr)
        {
            logger(WARN, "In Domain::processReceivedInteractionData: pGhost (id %) is nullptr, the interaction data is not copied. Two particles possibly moved into domain simultaneously.", identificationP);
            continue;
        }
        
        //If it is a wall interaction, do stuff
        if (isWallInteraction)
        {
            BaseInteractable* I = getHandler()->getDPMBase()->wallHandler.getObjectById(identificationI);
            //Create interactions
            BaseInteraction* j = I->getInteractionWith(pGhost, timeStamp, &iH);
            if (j!= nullptr) j->setMPIInteraction(interactionDataReceive_[localIndex], l, false);
            
        }
        else
        {
            //Obtain potential interaction particles
            std::vector<BaseParticle*> interactingParticleList;
            getHandler()->getDPMBase()->hGridGetInteractingParticleList(pGhost, interactingParticleList);
            
            //Find the other interacting particle
            BaseParticle* otherParticle = nullptr;
            for (BaseParticle* p2 : interactingParticleList)
            {
                if (p2->getId() == idOther)
                {
                    otherParticle = p2;
                    break;
                }
            }
            if (otherParticle == nullptr) {
                //search for the other particle in the newParticles list
                for (BaseParticle *particle : newParticles) {
                    if (particle->getId() == idOther) {
                        otherParticle = particle;
                        break;
                    }
                }
                if (otherParticle == nullptr) {
                    logger(WARN,
                           "In Domain::processReceivedInteractionData: otherParticle (id %) is nullptr, the interaction data with pGhost (id %) is not copied. Two particles possibly moved into domain simultaneously. nt = %",
                           identificationI, identificationP, getHandler()->getDPMBase()->getNumberOfTimeSteps());
                    continue;
                }
            }
            //Add the interaction
            // flipped order of other and ghost, so it is in the same order as received
            BaseInteraction* j;
            if (otherParticle->getId() < pGhost->getId()) {
                j = pGhost->getInteractionWith(otherParticle, timeStamp, &iH);
            } else {
                j = otherParticle->getInteractionWith(pGhost, timeStamp, &iH);
            }
            if (j != nullptr) j->setMPIInteraction(interactionDataReceive_[localIndex], l, false);
        }
    }
}

References BaseHandler< T >::getDPMBase(), getHandler(), BaseObject::getId(), InteractionHandler::getInteractionDetails(), BaseParticle::getInteractionWith(), BaseHandler< T >::getObjectById(), DPMBase::hGridGetInteractingParticleList(), I, interactionDataReceive_, DPMBase::interactionHandler, j, logger, numNewInteractionsReceive_, VERBOSE, DPMBase::wallHandler, and WARN.

Referenced by finaliseBoundaryDataTransmission().

processSentBoundaryParticles()

void Domain::processSentBoundaryParticles

(

unsigned

index

)

Bookkeep the newly send particles.

Each domain keeps a list of particles that have copies on other domains. The order of these lists is exactly the same order of the neighbour particle lists of the neighbour domain.

Parameters

[in]

index

The boundary index of the boundary list currently being treated

{
    for (BaseParticle* particle : newBoundaryParticleList_[index])
    {
        boundaryParticleList_[index].push_back(particle);
        particle->setInMPIDomain(true);
    }
}

References boundaryParticleList_, and newBoundaryParticleList_.

Referenced by finaliseBoundaryDataTransmission().

read()

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

overridevirtual

This function does nothing.

Reads the object from a given istream.

Reads the object's id_ from the given istream

Parameters

[in,out]

is

istream the id_ is read from

Todo:

MX: why would this function be called?

Implements BaseObject.

{
    logger(WARN, "[Domain::read] should not be called");
    //BaseObject::read(is);
}

References logger, and WARN.

sendAndReceiveCount()

void Domain::sendAndReceiveCount	(	MercuryMPITag	tag,
		unsigned &	countReceive,
		unsigned &	countSend,
		unsigned	localIndexNeighbour
	)

A symmetric communication between two domains exchanging a send/receive count.

Before real data (i.e. particle data) can be transmitted to other processors, these receiving processors need to know how many data objects they are receiving. This function facilitates a symmetric send mechanism between two domains to communicate how much objects they get from each-other

Parameters

[in]	tag	A MercuryMPITag that indicates what type of count is being send
[out]	countReceive	unsigned integer containing the receiving count
[in]	countSend	unsigned integer containing the sending count
[in]	localIndexNeighbour	the local index of the domain with which the communication is being done

        {
            int globalIndexNeighbour = localIndexToGlobalIndexTable_[localIndexNeighbour];
            int processor = localIndexToProcessorList_[localIndexNeighbour];
 
            //Create communication tags
            int tagReceive = globalIndexNeighbour * MAX_PROC + globalIndex_ * 10 + tag;
            int tagSend = globalIndex_ * MAX_PROC + globalIndexNeighbour * 10 + tag;
 
            logger.assert_debug(tagSend > 0, "Send tag is wrong. Tag: %", tagSend);
            logger.assert_debug(tagReceive > 0, "Receive tag is wrong. Tag: %", tagReceive);
            logger.assert_debug(processor >= 0, "Processor is wrong. processor: %", processor);
 
            //Communicate the requests
            MPIContainer::Instance().receive(countReceive, processor, tagReceive);
            MPIContainer::Instance().send(countSend, processor, tagSend);
        }

References globalIndex_, MPIContainer::Instance(), localIndexToGlobalIndexTable_, localIndexToProcessorList_, logger, MAX_PROC, MPIContainer::receive(), and MPIContainer::send().

Referenced by prepareBoundaryDataTransmission().

sendAndReceiveMPIData()

template<typename T >

void Domain::sendAndReceiveMPIData ( MercuryMPITag  tag, MercuryMPIType  type, T *  receiveData, unsigned  receiveCount, T *  sendData, unsigned  sendCount, unsigned  localIndexNeighbour  )

inline

Function that sends transmissionData/positionData/velocityData to other processors.

This function is heavily templated on the type of data that can be send. All the types that are located in the MercuryMPIType enum class can be used to transmit data. Examples are MPIParticle and MPIParticlePosition data types

Parameters

[in]	tag	A MercuryMPITag that indicates what type of data is being send
[in]	type	A MercuryMPIType that tells the MPI what MPI_Data structure to use
[out]	receiveData	The data that will be received by the current domain
[in]	receiveCount	The number of items that are being received by the current domain
[in]	sendData	The data that will be send by the current domain
[in]	sendCount	The number of items that are being send by the current domain
[in]	localIndexNeighbour	the local index to the neighbouring domain

    {
        int globalIndexNeighbour = localIndexToGlobalIndexTable_[localIndexNeighbour];
        int processor = localIndexToProcessorList_[localIndexNeighbour];
        int tagReceive = globalIndexNeighbour * MAX_PROC + globalIndex_ * 10 + tag;
        int tagSend = globalIndex_ * MAX_PROC + globalIndexNeighbour * 10 + tag;
        
        //Communicate the requests
        if (receiveCount != 0)
        {
            MPIContainer::Instance().receive(receiveData, type, receiveCount, processor, tagReceive);
        }
        if (sendCount != 0)
        {
            MPIContainer::Instance().send(sendData, type, sendCount, processor, tagSend);
        }
    }

References globalIndex_, MPIContainer::Instance(), localIndexToGlobalIndexTable_, localIndexToProcessorList_, MAX_PROC, MPIContainer::receive(), MPIContainer::send(), and compute_granudrum_aor::type.

Referenced by performBoundaryDataTransmission(), preparePositionAndVelocityUpdate(), and prepareVelocityUpdate().

setBounds()

void Domain::setBounds	(	std::vector< double >	domainMin,
		std::vector< double >	domainMax,
		bool	computeMiddle
	)

Sets the domain bounds.

This function sets the bound for the domain, it also computes the middle of the square domain, useful for mixed periodic/mpi particles.

Parameters

[in]	domainMin	Minimum values of the domain in x-,y-,z-direction
[in]	domainMax	Maximum values of the domain in x-,y-,z-direction

{
    domainMin_ = domainMin;
    domainMax_ = domainMax;
    
    //Compute the middle of the closed domain
    if (computeMiddle)
    {
        double minClosed;
        double maxClosed;
        for (int i = 0; i < 3; i++)
        {
            minClosed = domainMin_[i];
            maxClosed = domainMax_[i];
            if (domainMin_[i] == -constants::inf)
            {
                minClosed = getHandler()->getDPMBase()->getMin().getComponent(i);
            }
            
            if (domainMax_[i] == constants::inf)
            {
                maxClosed = getHandler()->getDPMBase()->getMax().getComponent(i);
            }
            
            middle_.setComponent(i, minClosed + (maxClosed - minClosed) / 2.0);
        }
    }
}

References domainMax_, domainMin_, Vec3D::getComponent(), BaseHandler< T >::getDPMBase(), getHandler(), DPMBase::getMax(), DPMBase::getMin(), i, constants::inf, middle_, and Vec3D::setComponent().

setGlobalMeshIndex()

void Domain::setGlobalMeshIndex

(

std::vector< unsigned >

globalMeshIndex

)

Sets the global mesh index of the domain.

sets the global mesh index

global mesh index has the shape of (i,j,k)

Parameters

[in]

globalMeshIndex

the mesh index vector i,j,k

{
    globalMeshIndex_ = globalMeshIndex;
}

References globalMeshIndex_.

setHandler()

void Domain::setHandler

(

DomainHandler *

domainHandler

)

Sets the domainHandler.

Sets the pointer to the DomainHandler the domain belongs to

Parameters

[in]

domainHandler

pointer to the DomainHandler

{
    domainHandler_ = domainHandler;
}

References domainHandler_.

setRange()

void Domain::setRange	(	Direction	direction,
		Mdouble	min,
		Mdouble	max
	)

Sets the domain range in a given direction.

Sets the domain's range in a given direction.

Parameters

[in]	direction	Direction 0,1,2 corresponds to direction x,y,z respectively
[in]	min	Minimum domain bound
[in]	max	Maximum domain bound

{
    if (min > max)
    {
        logger(ERROR, "[MercuryMPI ERROR]: min is larger than max. (%,%)", min, max);
    }
    
    double maxClosed;
    double minClosed;
    if (min == -constants::inf)
    {
        minClosed = getHandler()->getDPMBase()->getMin().getComponent(direction);
    }
    
    if (max == constants::inf)
    {
        maxClosed = getHandler()->getDPMBase()->getMax().getComponent(direction);
    }
    
    
    switch (direction)
    {
        case Direction::XAXIS :
            domainMin_[0] = min;
            domainMax_[0] = max;
            middle_.X = minClosed + (maxClosed - minClosed) / 2.0;
            break;
        case Direction::YAXIS :
            domainMin_[1] = min;
            domainMax_[1] = max;
            middle_.Y = minClosed + (maxClosed - minClosed) / 2.0;
            break;
        case Direction::ZAXIS :
            domainMin_[2] = min;
            domainMax_[2] = max;
            middle_.Z = minClosed + (maxClosed - minClosed) / 2.0;
            break;
        default :
            logger(ERROR, "Direction is not a valid direction. (%)", direction);
            break;
    }
}

References calibrate::default, domainMax_, domainMin_, ERROR, Vec3D::getComponent(), BaseHandler< T >::getDPMBase(), getHandler(), DPMBase::getMax(), DPMBase::getMin(), constants::inf, logger, max, middle_, min, Vec3D::X, XAXIS, Vec3D::Y, YAXIS, Vec3D::Z, and ZAXIS.

setRank()

void Domain::setRank

(

int

rank

)

Sets the rank associated with the assigned processorID.

Sets the domain's rank, corresponding to a processorID.

Parameters

[in]

rank

Integer corresponding to a processorID

{
    rank_ = rank;
}

References rank_.

updateParticlePosition()

void Domain::updateParticlePosition

(

int

localIndex

)

Updates the position of particles which are flagged as MPIParticles.

Manually updates the position of the particles, the displacement and the orientation It additionally updates the position of the particle in the hGrid

Parameters

[in]

localIndex

an index to the boundary being updated

        {
            //process the updated information
            unsigned int index = 0;
            for (BaseParticle* particle : boundaryParticleListNeighbour_[localIndex])
            {
                logger.assert_debug(particle->getId() == updatePositionDataReceive_[localIndex][index].id,
                              "MPI particle lists are not in sync");
 
                //set position
        particle->setPreviousPosition(particle->getPosition());
        particle->setPosition(updatePositionDataReceive_[localIndex][index].position);
        particle->setOrientation(updatePositionDataReceive_[localIndex][index].orientation);
        if (std::is_base_of<MPILiquidFilmParticle,MPIParticle>())  /* will never occur */
            static_cast<LiquidFilmParticle*>(particle)->setLiquidVolume(updatePositionDataReceive_[localIndex][index].liquidVolume);
 
        //Update hGrid
        Vec3D displacement = particle->getPreviousPosition() - particle->getPosition();
        getHandler()->getDPMBase()->hGridUpdateMove(particle, displacement.getLengthSquared());
        
        index++;
    }
}

References boundaryParticleListNeighbour_, BaseHandler< T >::getDPMBase(), getHandler(), Vec3D::getLengthSquared(), DPMBase::hGridUpdateMove(), logger, and updatePositionDataReceive_.

Referenced by finalisePositionAndVelocityUpdate().

updateParticles()

void Domain::updateParticles

(

std::set< BaseParticle * > &

ghostParticlesToBeDeleted

)

This step updates all communication lists and particles in the communication zone.

After all the mpi particles have received a position and velocity update, a check is required to see if the particle needs to be treated differently. Comments inside the code show all possible options. Note that when a particle needs to be deleted, it will not be deleted straight away, but added to a list to be deleted later. Additionally the location in the communication lists will not be emptied by assigning a nullptr to it. When all particles are considered this nullptrs are removed from the list, to ensure that the mirror list on another processor keeps the same order in particles. A) The particle moves from the Neighbour domain to the current domain B) The particle moves out of the communication zone, into the neighbouring domain C) The particle moves out of the communication zone, into the current domain D) The particle changes complexity: A special case where the particle required a re-evaluation in which boundary list it belongs

Parameters

[in]

particleHandler

Handler that takes care of all particles in this domain

        {
            int complexityNew;
            std::vector<int> boundaryIndex;
 
            //For all active boundaries
            for (int localIndex : boundaryList_)
            {
                //Step 1A: Remove the particles from the boundaryParticleList_ which require re-assignment
                //or have just moved away from the region
                for (int p = 0; p < boundaryParticleList_[localIndex].size(); p++)
                {
                    BaseParticle* particle = boundaryParticleList_[localIndex][p];
                    //Check if the particle is still in the domain, but not in the communication zone
                    if (containsParticle(particle))
                    {
                        //check if the complexity has changed
                        boundaryIndex = findNearbyBoundaries(particle);
                        complexityNew = boundaryIndex[0] + 3 * boundaryIndex[1] + 9 * boundaryIndex[2] + 13;
                        if (particle->getCommunicationComplexity() != complexityNew)
                        {
                            logger(VERBOSE, "time: % | global index: % in list % | particle % | CURRENT DOMAIN - CHANGES "
                                            "COMPLEXITY", domainHandler_->getDPMBase()->getTime(), globalIndex_,
                                   localIndexToGlobalIndexTable_[localIndex], particle->getId());
                            //Flag the particle that it no longer participates in the communication layer
                            //so it can be reintroduced in the transmission step
                            particle->setMPIParticle(false);
                            particle->setInMPIDomain(false);
                            particle->setCommunicationComplexity(0);
                            boundaryParticleList_[localIndex][p] = nullptr;
                        }
                    }
                    else
                    {
                        logger(VERBOSE, "time: % | global index: % in list % | particle % | CURRENT DOMAIN - TO NEIGHBOURING "
                                        "DOMAIN", domainHandler_->getDPMBase()->getTime(), globalIndex_,
                               localIndexToGlobalIndexTable_[localIndex], particle->getId());
 
                        ghostParticlesToBeDeleted.insert(particle);
                        boundaryParticleList_[localIndex][p] = nullptr;
                    }
                }
 
                //Step 1B: Remove the particles from the boundaryParticleListNeighbour_ which require re-assignment
                //or have just moved away from the region
                for (int p = 0; p < boundaryParticleListNeighbour_[localIndex].size(); p++)
                {
                    BaseParticle* particle = boundaryParticleListNeighbour_[localIndex][p];
                    //Check if the particle moved out of the neighbour domain
                    if (!(domainHandler_->getObject(localIndexToGlobalIndexTable_[localIndex])->containsParticle(particle)))
                    {
                        //The particle has moved to this domain
                        if (containsParticle(particle))
                        {
                            logger(VERBOSE,
                                   "time: % | global index: % in list % | particle % | NEIGHBOURING DOMAIN - TO CURRENT DOMAIN",
                                   domainHandler_->getDPMBase()->getTime(), globalIndex_,
                                   localIndexToGlobalIndexTable_[localIndex], particle->getId());
 
                            //Flag the particle as not yet communicated
                            particle->setMPIParticle(false);
                            particle->setInMPIDomain(false);
                            particle->setCommunicationComplexity(0);
                            boundaryParticleListNeighbour_[localIndex][p] = nullptr;
                        }
                            //The particle has moved to a different domain
                        else
                        {
                            logger(VERBOSE,
                                   "time: % | global index: % in list % | particle % | NEIGHBOURING DOMAIN - TO OTHER DOMAIN",
                                   domainHandler_->getDPMBase()->getTime(), globalIndex_,
                                   localIndexToGlobalIndexTable_[localIndex], particle->getId());
                            //Cruelly destroy the particle without any mercy.
                            ghostParticlesToBeDeleted.insert(particle);
                            boundaryParticleListNeighbour_[localIndex][p] = nullptr;
                        }
                    }
                    else
                    {
                        //check if the complexity has changed
                        boundaryIndex = domainHandler_->getObject(
                                localIndexToGlobalIndexTable_[localIndex])->findNearbyBoundaries(particle);
                        complexityNew = boundaryIndex[0] + 3 * boundaryIndex[1] + 9 * boundaryIndex[2] + 13;
                        if (particle->getCommunicationComplexity() != complexityNew)
                        {
                            logger(VERBOSE,
                                   "time: % | global index: % in list % | particle % | NEIGHBOURING DOMAIN - CHANGES COMPLEXITY",
                                   domainHandler_->getDPMBase()->getTime(), globalIndex_,
                                   localIndexToGlobalIndexTable_[localIndex], particle->getId());
                            //Cruelly destroy the particle without any mercy.
                            ghostParticlesToBeDeleted.insert(particle);
                            boundaryParticleListNeighbour_[localIndex][p] = nullptr;
                        }
                    }
                }
            }
        }

References boundaryList_, boundaryParticleList_, boundaryParticleListNeighbour_, containsParticle(), domainHandler_, findNearbyBoundaries(), BaseParticle::getCommunicationComplexity(), BaseHandler< T >::getDPMBase(), BaseObject::getId(), BaseHandler< T >::getObject(), DPMBase::getTime(), globalIndex_, localIndexToGlobalIndexTable_, logger, p, BaseParticle::setCommunicationComplexity(), BaseParticle::setInMPIDomain(), BaseParticle::setMPIParticle(), and VERBOSE.

Referenced by finalisePositionAndVelocityUpdate().

updateParticleVelocity()

void Domain::updateParticleVelocity

(

int

localIndex

)

Updates the velocity of particles which are flagged as MPIParticles.

Updates the translation but also the angular velocity

Parameters

[in]

localIndex

an index to the boundary being updated

{
    //process the updated information
    unsigned int index = 0;
    for (BaseParticle* particle: boundaryParticleListNeighbour_[localIndex])
    {
        //set velocity
        particle->setVelocity(updateVelocityDataReceive_[localIndex][index].velocity);
        particle->setAngularVelocity(updateVelocityDataReceive_[localIndex][index].angularVelocity);
        index++;
    }
}

References boundaryParticleListNeighbour_, updateVelocityDataReceive_, and Jeffery_Solution::velocity().

Referenced by finalisePositionAndVelocityUpdate(), and finaliseVelocityUpdate().

updateStatus()

void Domain::updateStatus

(

std::set< BaseParticle * > &

ghostParticlesToBeDeleted

)

Updates particles that are not in the current domain and communicates newly added particles.

First the newly positions of the ghost particles are communicated, based on the new positions these particles will be updated accordingly. Secondly a new sweep through all particles is performed to see if we need to add any particles to the list which have moved into the communication zone. Particles that need to be removed from the simulation are stored in a vector and will be destroyed at a later point in the code.

Parameters

[in,out]

ghostParticlesToBeDeleted

A list of particles which will be deleted afterwards

{
    //Collect new positions and velocities and send them to the other domains
    preparePositionAndVelocityUpdate();
    MPIContainer::Instance().sync();
    
    //Receive the new positions and velocities from other domains
    //and update the mpi flagged particles accordingly. removes and switched particles in the lists
    finalisePositionAndVelocityUpdate(ghostParticlesToBeDeleted);
    MPIContainer::Instance().sync();
}

References finalisePositionAndVelocityUpdate(), MPIContainer::Instance(), preparePositionAndVelocityUpdate(), and MPIContainer::sync().

Referenced by DomainHandler::updateStatus().

updateVelocity()

void Domain::updateVelocity

(

)

Updates MPI particle velocity at the half-time step.

: not in use

{
    //collect new velocity data and send
    prepareVelocityUpdate();
    MPIContainer::Instance().sync();
    
    //process the received data
    finaliseVelocityUpdate();
    MPIContainer::Instance().sync();
}

References finaliseVelocityUpdate(), MPIContainer::Instance(), prepareVelocityUpdate(), and MPIContainer::sync().

Referenced by DomainHandler::updateVelocity().

write()

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

overridevirtual

This function does nothing.

Adds the object's id_ to the given ostream

Parameters

[in]

os

ostream the id_ is added to

Todo:

MX: why would this function be called?

Implements BaseObject.

{
    logger(WARN, "[Domain::write] should not be called");
    //BaseObject::write(os);
}

References logger, and WARN.

Member Data Documentation

activeBoundaryList_

std::vector<bool> Domain::activeBoundaryList_

private

A list of flags corresponding to an inactive or active boundary.

Referenced by constructor(), disableBoundaries(), disableBoundary(), Domain(), and getActiveBoundaryList().

boundaryList_

std::vector<int> Domain::boundaryList_

private

A list of indices of all the active boundaries.

Todo:

TW, Marnix should this be unsigned int

Referenced by cleanCommunicationLists(), constructor(), disableBoundaries(), Domain(), finaliseBoundaryDataTransmission(), finalisePositionAndVelocityUpdate(), finaliseVelocityUpdate(), findNewMPIInteractions(), flushParticles(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), preparePositionAndVelocityUpdate(), prepareVelocityUpdate(), and updateParticles().

boundaryParticleDataReceive_

std::vector<std::vector<MPIParticle> > Domain::boundaryParticleDataReceive_

private

Container that keeps a list of MPIParticles that are being received by this domain.

Referenced by constructor(), Domain(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), and processReceivedBoundaryParticleData().

boundaryParticleDataSend_

std::vector<std::vector<MPIParticle> > Domain::boundaryParticleDataSend_

private

Container that keeps a list of MPIParticles that are being send to other domains.

Referenced by collectBoundaryParticleData(), constructor(), Domain(), finaliseBoundaryDataTransmission(), and performBoundaryDataTransmission().

boundaryParticleList_

std::vector<std::vector<BaseParticle*> > Domain::boundaryParticleList_

private

A list of boundary particles in the communication zone that are ghost particles on other domains.

Referenced by cleanCommunicationLists(), constructor(), Domain(), flushParticles(), preparePositionAndVelocityUpdate(), prepareVelocityUpdate(), processSentBoundaryParticles(), and updateParticles().

boundaryParticleListNeighbour_

std::vector<std::vector<BaseParticle*> > Domain::boundaryParticleListNeighbour_

private

a list of ghost particles on the current domain, which are real on the neighbour domain

Referenced by cleanCommunicationLists(), constructor(), Domain(), flushParticles(), getNumberOfMPIParticles(), getNumberOfTrueMPIParticles(), preparePositionAndVelocityUpdate(), prepareVelocityUpdate(), processReceivedBoundaryParticleData(), updateParticlePosition(), updateParticles(), and updateParticleVelocity().

domainHandler_

DomainHandler* Domain::domainHandler_

private

Pointer to the domain's DomainHandler container.

Referenced by constructor(), createLookUpTable(), disableBoundaries(), Domain(), findNearbyBoundaries(), getHandler(), isInGreaterDomain(), isInInnerDomain(), setHandler(), and updateParticles().

domainMax_

std::vector<double> Domain::domainMax_

private

Maximum domain bounds in the x,y and z direction.

Referenced by constructor(), containsParticle(), Domain(), findNearbyBoundaries(), getDomainMax(), setBounds(), and setRange().

domainMin_

std::vector<double> Domain::domainMin_

private

Minimum domain bounds in the x,y and z direction.

Referenced by constructor(), containsParticle(), Domain(), findNearbyBoundaries(), getDomainMin(), setBounds(), and setRange().

globalIndex_

int Domain::globalIndex_

private

Global index of the domain in the mesh.

Note

for a standard decomposition this compares straight to the rank of the processor

Referenced by createLookUpTable(), getGlobalIndex(), sendAndReceiveCount(), sendAndReceiveMPIData(), and updateParticles().

globalMeshIndex_

std::vector<unsigned> Domain::globalMeshIndex_

private

Vector containing the global mesh indices i,j,k.

Referenced by createLookUpTable(), disableBoundaries(), Domain(), getGlobalMeshIndex(), and setGlobalMeshIndex().

interactionDataReceive_

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

private

Container that keeps a void array of all the interaction data that is being received by this domain, interpretation is done by the interaction handler.

Referenced by constructor(), Domain(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), and processReceivedInteractionData().

interactionDataSend_

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

private

Container that keeps a void array of all the interaction data that are being send to other domains, interpretation is done by the interaction handler.

Referenced by collectInteractionData(), constructor(), Domain(), finaliseBoundaryDataTransmission(), and performBoundaryDataTransmission().

localIndexToGlobalIndexTable_

std::vector<int> Domain::localIndexToGlobalIndexTable_

private

look-up table to get the global index given a local domain index

Todo:

TW, Marnix should this be unsigned int

Referenced by constructor(), createLookUpTable(), Domain(), sendAndReceiveCount(), sendAndReceiveMPIData(), and updateParticles().

localIndexToProcessorList_

std::vector<int> Domain::localIndexToProcessorList_

private

look-up table to get the processor of the domain given a local domain index

Todo:

TW, Marnix should this be unsigned int

Referenced by constructor(), createLookUpTable(), Domain(), sendAndReceiveCount(), and sendAndReceiveMPIData().

middle_

Vec3D Domain::middle_

private

Middle of the closed domain.

Referenced by Domain(), getMiddle(), setBounds(), and setRange().

newBoundaryParticleList_

std::vector<std::vector<BaseParticle*> > Domain::newBoundaryParticleList_

private

Array that queues particles that need to be transmitted.

Referenced by collectBoundaryParticleData(), constructor(), Domain(), finaliseBoundaryDataTransmission(), findNewMPIInteractions(), findNewMPIParticle(), isInNewBoundaryParticleList(), prepareBoundaryDataTransmission(), and processSentBoundaryParticles().

newInteractionList_

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

private

Array that queues interactions that need to be transmitted.

Referenced by collectInteractionData(), constructor(), Domain(), finaliseBoundaryDataTransmission(), findNewMPIInteractions(), and prepareBoundaryDataTransmission().

numberOfParticlesReceive_

std::vector<unsigned> Domain::numberOfParticlesReceive_

private

Counter that keeps track of the number of particles that are being received by this domain.

Referenced by constructor(), Domain(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), preparePositionAndVelocityUpdate(), prepareVelocityUpdate(), and processReceivedBoundaryParticleData().

numberOfParticlesSend_

std::vector<unsigned> Domain::numberOfParticlesSend_

private

Counter that keeps track of the number of particles that are being send to other domains.

Referenced by constructor(), Domain(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), preparePositionAndVelocityUpdate(), and prepareVelocityUpdate().

numNewInteractionsReceive_

std::vector<unsigned> Domain::numNewInteractionsReceive_

private

Counter that keeps track of the number of interactions that are being received by this domain.

Referenced by constructor(), Domain(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), prepareBoundaryDataTransmission(), and processReceivedInteractionData().

numNewInteractionsSend_

std::vector<unsigned> Domain::numNewInteractionsSend_

private

Counter that keeps track of the number of interactions that are being send to other domains.

Referenced by constructor(), Domain(), finaliseBoundaryDataTransmission(), performBoundaryDataTransmission(), and prepareBoundaryDataTransmission().

rank_

int Domain::rank_

private

Rank of the domain which identifies to which processor it belongs.

Referenced by constructor(), createLookUpTable(), Domain(), getRank(), and setRank().

updatePositionDataReceive_

std::vector<std::vector<MPIParticlePosition> > Domain::updatePositionDataReceive_

private

Container that keeps a list of MPIParticlePositions that are being received by this domain.

Referenced by constructor(), Domain(), finalisePositionAndVelocityUpdate(), preparePositionAndVelocityUpdate(), and updateParticlePosition().

updatePositionDataSend_

std::vector<std::vector<MPIParticlePosition> > Domain::updatePositionDataSend_

private

Container that keeps a list of MPIParticlePositions that are being send to other domains.

Referenced by constructor(), Domain(), finalisePositionAndVelocityUpdate(), and preparePositionAndVelocityUpdate().

updateVelocityDataReceive_

std::vector<std::vector<MPIParticleVelocity> > Domain::updateVelocityDataReceive_

private

Container that keeps a list of MPIParticleVelocities that are being received by this domain.

Referenced by constructor(), Domain(), finalisePositionAndVelocityUpdate(), finaliseVelocityUpdate(), preparePositionAndVelocityUpdate(), prepareVelocityUpdate(), and updateParticleVelocity().

updateVelocityDataSend_

std::vector<std::vector<MPIParticleVelocity> > Domain::updateVelocityDataSend_

private

Container that keeps a list of MPIParticleVelocities that are being send to other domains.

Referenced by constructor(), Domain(), finalisePositionAndVelocityUpdate(), finaliseVelocityUpdate(), preparePositionAndVelocityUpdate(), and prepareVelocityUpdate().

---

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

• Domain.h
• Domain.cc