This class contains all information and functions required for communication between processors. More...

#include <MpiContainer.h>

Public Member Functions
void	initialiseMercuryMPITypes (const SpeciesHandler &speciesHandler)
	Creates the MPI types required for communication of Mercury data through the MPI interface. More...

void	sync ()
	Process all pending asynchronous communication requests before continuing. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	send (T &t, int to, int tag)
	Asynchronously send a scalar to some other processor. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	send (T *t, int count, int to, int tag)

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	receive (T &t, int from, int tag)
	asynchronously receive a scalar from some other processor. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	receive (T *t, int count, int from, int tag)

template<typename T >
void	send (T *t, MercuryMPIType type, int count, int to, int tag)
	asynchronously send a list of MercuryMPITypes objects to some other processor. More...

template<typename T >
void	receive (T *t, MercuryMPIType type, int count, int from, int tag)
	asynchronously receive a list of MercuryMPIType objects from some other processor. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	directSend (T &t, int count, int to, int tag)
	synchronously send a list of scalars to another processor. the data should be received directly or the program will stall More...

template<typename T >
void	directSend (T *t, MercuryMPIType type, int count, int to, int tag)

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	directReceive (T &t, int count, int from, int tag)
	synchronously receive a list of scalars from another processor. if the send command has not been issued, this function will stall the program More...

template<typename T >
void	directReceive (T *t, MercuryMPIType type, int count, int from, int tag)

template<typename T >
void	gather (T &send_t, T *receive_t)
	Gathers a scaler from all processors to a vector of scalars on the root. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	broadcast (T &t, int fromProcessor=0)
	Broadcasts a scalar from the root to all other processors. More...

template<typename T >
std::enable_if< std::is_scalar< T >::value, void >::type	broadcast (T *t, int size, int fromProcessor)
	Broadcasts a scalar from the root to all other processors. More...

template<typename T >
void	broadcast (T *t, MercuryMPIType type, int fromProcessor=0)
	Broadcasts an MercuryMPIType to all other processors. More...

std::size_t	getProcessorID ()
	Reduces a scalar on all processors to one scalar on a target processor. More...

std::size_t	getNumberOfProcessors () const
	Get the total number of processors participating in this simulation. More...

template<typename T >
void	createMercuryMPIType (T t, MercuryMPIType type)
	Get the communicator used for MPI commands. More...

void	deleteMercuryMPITypes ()
	Deletes the MercuryMPITypes. More...

	MPIContainer (const MPIContainer &orig)=delete
	Copy constructor is disabled, to enforce a singleton pattern. More...

Static Public Member Functions
static MPIContainer &	Instance ()
	fetch the instance to be used for communication More...

Private Member Functions
	MPIContainer ()
	Constructor. More...

Private Attributes
int	processorID_
	The ID of the processor this class is running on. More...

int	numberOfProcessors_
	The total number of processors in the communicator. More...

Detailed Description

This class contains all information and functions required for communication between processors.

This class contains of a newly created MPI_COMM communicator used communicate between processors. The reason that MPI_COMM_WORLD is not used, is that other libraries might also be communicating in parallel and you don't want to interfere with these communications. It is a signleton pattern, restricting to one instance of the class. The class furthermore keeps track of the number of processors, processorID's and of asynchronous send/receive requests.

Constructor & Destructor Documentation

◆ MPIContainer() [1/2]

MPIContainer::MPIContainer ( const MPIContainer & orig )

delete

Copy constructor is disabled, to enforce a singleton pattern.

◆ MPIContainer() [2/2]

MPIContainer::MPIContainer ( )

private

Constructor.

Initialise the communicator after MPI has been initalised.

 {
 #ifdef MERCURYDPM_USE_MPI
     int Mpi_init_flag = 0;
     MPI_Initialized(&Mpi_init_flag);
     if(!Mpi_init_flag)
     {
         logger(FATAL,"MPI should be initialised before calling the MPIContainer constructor");
     }
     //A personal communicator will be created to ensure we don't meddle with communicators of other libraries
     MPI_Group groupID;
     MPI_Comm_group(MPI_COMM_WORLD, &groupID);
     MPI_Comm_create(MPI_COMM_WORLD,groupID,&communicator_);
     MPI_Comm_rank(MPI_COMM_WORLD,&processorID_);
     MPI_Comm_size(MPI_COMM_WORLD,&numberOfProcessors_);
  
 #else
     numberOfProcessors_ = 1;
     processorID_ = 0;
 #endif
 }

References FATAL, logger, numberOfProcessors_, and processorID_.

Member Function Documentation

◆ broadcast() [1/3]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::broadcast	(	T &	t,
		int	fromProcessor = `0`
	)

inline

Broadcasts a scalar from the root to all other processors.

Parameters

[in,out] t scalar data that is being send by the root and received by the processors

     {
 #ifdef MERCURYDPM_USE_MPI
         MPI_Bcast(&t,1,Detail::toMPIType(t),fromProcessor,communicator_);
 #endif
     }

Referenced by ParticleHandler::addObject(), InsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), DPMBase::checkParticleForInteraction(), PeriodicBoundaryHandler::communicateTargetDomains(), SubcriticalMaserBoundaryTEST::copyExtraParticles(), SubcriticalMaserBoundaryTEST::extendBottom(), ParticleHandler::getNumberOfRealObjects(), DPMBase::mpiIsInCommunicationZone(), RNG::randomise(), DPMBase::synchroniseParticle(), and PeriodicBoundaryHandler::updateParticleStatus().

◆ broadcast() [2/3]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::broadcast	(	T *	t,
		int	size,
		int	fromProcessor
	)

inline

Broadcasts a scalar from the root to all other processors.

Parameters

[in,out] t scalar data that is being send by the root and received by the processors

     {
 #ifdef MERCURYDPM_USE_MPI
         MPI_Bcast((void *)t,size,Detail::toMPIType(t[0]),fromProcessor,communicator_);
  
 #endif
     }

◆ broadcast() [3/3]

template<typename T >

void MPIContainer::broadcast	(	T *	t,
		MercuryMPIType	type,
		int	fromProcessor = `0`
	)

inline

Broadcasts an MercuryMPIType to all other processors.

Parameters

[in,out] t MercuryMPIType data that is being send by the root and received by the processors

     {
 #ifdef MERCURYDPM_USE_MPI
         MPI_Bcast((void *)t,1,dataTypes_[type],fromProcessor,communicator_);
 #endif
     }

◆ createMercuryMPIType()

template<typename T >

void MPIContainer::createMercuryMPIType	(	T	t,
		MercuryMPIType	type
	)

inline

Get the communicator used for MPI commands.

Creates the MPI types telling the MPI interface how each data object looks like

NOTE: The current manner of creating MPI data types might not be compatible when computing on different computers with different architecture and compilers. The "padding" which different compilers and computers add to the class might be different which has a huge effect on the mpi data type because it needs to be consistent over all computers. To resolve this, one can easily create a consistent data type for all types required. I wish goodluck to the person that needs it, because it is a lot of type work and for now I am not doing it. /MX

     {
 #ifdef MERCURYDPM_USE_MPI
         MPI_Datatype MPIType;
         MPI_Type_contiguous(sizeof(T), MPI_BYTE, &MPIType);
         MPI_Type_commit(&MPIType);
         dataTypes_.push_back(MPIType);
 #endif
     }

Referenced by Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::createMPIType(), and initialiseMercuryMPITypes().

◆ deleteMercuryMPITypes()

void MPIContainer::deleteMercuryMPITypes ( )

inline

Deletes the MercuryMPITypes.

     {
 #ifdef MERCURYDPM_USE_MPI
         for(MPI_Datatype type : dataTypes_)
         {
             MPI_Type_free(&type);
         }
 #endif
     }

Referenced by initialiseMPI().

◆ directReceive() [1/2]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::directReceive	(	T &	t,
		int	count,
		int	from,
		int	tag
	)

inline

synchronously receive a list of scalars from another processor. if the send command has not been issued, this function will stall the program

Parameters

[in,out]	t	the data, list of scalars
[in]	count	the number of scalars to be send
[in]	from	the processor that sends the information
[in]	tag	a unique identifier that corresponds with a send command by the sending processor

     {
 #if MERCURYDPM_ASSERTS
         if (from == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Receiving data from self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Receiving zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Recv(&t, count, Detail::toMPIType(t), from, tag,communicator_, MPI_STATUS_IGNORE);
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ directReceive() [2/2]

template<typename T >

void MPIContainer::directReceive	(	T *	t,
		MercuryMPIType	type,
		int	count,
		int	from,
		int	tag
	)

inline

     {
 #if MERCURYDPM_ASSERTS
         if (from == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Receiving data to self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Receiving zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Recv(t, count, dataTypes_[type], from, tag, communicator_, MPI_STATUS_IGNORE);
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ directSend() [1/2]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::directSend	(	T &	t,
		int	count,
		int	to,
		int	tag
	)

inline

synchronously send a list of scalars to another processor. the data should be received directly or the program will stall

Parameters

[in,out]	t	the data, list of scalars
[in]	count	the number of scalars to be send
[in]	to	the processor that the data is being send to
[in]	tag	a unique identifier that corresponds with a receive command by the receiving processor

     {
 #if MERCURYDPM_ASSERTS
         if (to == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Sending data to self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Sending zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Ssend(&t, count, Detail::toMPIType(t), to, tag, communicator_);
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ directSend() [2/2]

template<typename T >

void MPIContainer::directSend	(	T *	t,
		MercuryMPIType	type,
		int	count,
		int	to,
		int	tag
	)

inline

     {
 #if MERCURYDPM_ASSERTS
         if (to == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Sending data to self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Sending zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Ssend(t,count,dataTypes_[type], to, tag, communicator_);
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ gather()

template<typename T >

void MPIContainer::gather	(	T &	send_t,
		T *	receive_t
	)

inline

Gathers a scaler from all processors to a vector of scalars on the root.

When a single processor needs to know a certain value on all processors, this function will gathers them together at the root processor in an array of the size of the communicator size

Parameters

[in,out]	send_t	the data that is being send, scalar value
[in,out]	receive_t	the data that is being received by the root, an array of scalars

     {
 #ifdef MERCURYDPM_USE_MPI
         MPI_Gather(&send_t, 1, Detail::toMPIType(send_t), receive_t, 1, Detail::toMPIType(send_t), 0, communicator_);
 #endif
     }

Referenced by DPMBase::checkParticleForInteraction(), and DPMBase::mpiIsInCommunicationZone().

◆ getNumberOfProcessors()

std::size_t MPIContainer::getNumberOfProcessors ( ) const

Get the total number of processors participating in this simulation.

Obtain the number of processors.

Returns: Returns the number of processors

 {
     return numberOfProcessors_;
 }

References numberOfProcessors_.

Referenced by CircularPeriodicBoundary::CircularPeriodicBoundary(), AngledPeriodicBoundary::copy(), CGHandler::evaluateDataFiles(), CGHandler::evaluateRestartFiles(), ParticleHandler::getNumberOfRealObjectsLocal(), MercuryBase::hGridInfo(), LeesEdwardsBoundary::LeesEdwardsBoundary(), PeriodicBoundaryHandler::preparePositionAndVelocityUpdate(), ParticleHandler::removeObject(), TimeDependentPeriodicBoundary::TimeDependentPeriodicBoundary(), and PeriodicBoundaryHandler::updateParticleStatus().

◆ getProcessorID()

std::size_t MPIContainer::getProcessorID ( )

Reduces a scalar on all processors to one scalar on a target processor.

Obtain the current processor ID.

A scalar defined on all processors is reduced to one number by an operation examples of operations are MPI::MAX, MPI::MIN and MPI::SUM, giving the maximum, minumum or the summation of the given scalars. The resulting reduced scalar is then sent to the target processor id, generally this is the root processor 0.

Parameters

[in,out]	t	Scalar that needs to be collected and reduced to one scalar
[in]	operation	Operation that is performed on the collected scalars
[in]	id	Optional input, receiving processor of the reduced scalar

AllReduces a scalar on all processors by a given MPI operation

A local scalar on all processors is reduced to one scalar as output the reduction follows the operation rule given.

Parameters

[in]	send_t	the scalar that is send to be reduced
[out]	receive_t	the reduced scalar
[in]	operation	The operation that is performed on all local numbers to reduce it to a single number

allGather takes a (different) scalar from all processors and returns a vector with all scalars

sometimes it is required to share a local scalar such as number of particles to all other processors. With allGather all processors now now the local scalar of all other processors

Parameters

[in]	send_t	The scalar that is send to all other processors
[in]	send_count	the number of scalars send to other processors
[in,out]	receive_t	A vector of scalars that contain all other scalars from other processors
[in]	receive_count	the number of scalars that is received by each processor

Get the unique identifier associated with this processor.

Returns: Returns the processor ID in the communication group

 {
     return processorID_;
 }

References processorID_.

Referenced by ParticleHandler::addGhostObject(), ParticleHandler::addObject(), CGHandler::evaluateDataFiles(), CGHandler::evaluateRestartFiles(), PeriodicBoundaryHandler::preparePositionAndVelocityUpdate(), printError(), printFatalError(), printInfo(), DPMBase::printTime(), printWarn(), and DPMBase::synchroniseParticle().

◆ initialiseMercuryMPITypes()

void MPIContainer::initialiseMercuryMPITypes ( const SpeciesHandler & speciesHandler )

Creates the MPI types required for communication of Mercury data through the MPI interface.

 {
 #ifdef MERCURYDPM_USE_MPI
     //Note: Important that the MPI type creation is done in the order given by the enum
     MPIParticle dummyParticle;
     MPIParticlePosition dummyPosition;
     MPIParticleVelocity dummyVelocity;
     MPIParticleForce dummyForce;
     createMercuryMPIType(dummyParticle, MercuryMPIType::PARTICLE);
     createMercuryMPIType(dummyPosition, MercuryMPIType::POSITION);
     createMercuryMPIType(dummyVelocity, MercuryMPIType::VELOCITY);
     createMercuryMPIType(dummyForce,    MercuryMPIType::FORCE);
     
     //Obtain the correct history force class
     //NOTE: only works for one type of interaction
     if (dataTypes_.size() == 4)
     {
         //Create a dummy interaction to get a grip on the size of the MPI interaction class
         const BaseSpecies* species = speciesHandler.getObject(0);
         BaseInteraction* emptyInteraction = species->getEmptyInteraction();
         emptyInteraction->createMPIType();
         species->deleteEmptyInteraction(emptyInteraction);
     }
 #endif
 }

References createMercuryMPIType(), BaseInteraction::createMPIType(), BaseSpecies::deleteEmptyInteraction(), FORCE, BaseSpecies::getEmptyInteraction(), BaseHandler< T >::getObject(), PARTICLE, POSITION, and VELOCITY.

Referenced by DPMBase::decompose().

◆ Instance()

static MPIContainer& MPIContainer::Instance ( )

inlinestatic

fetch the instance to be used for communication

Returns: The only instance of this class

     {
         static MPIContainer theInstance;
         return theInstance;
     }

◆ receive() [1/3]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::receive	(	T &	t,
		int	from,
		int	tag
	)

inline

asynchronously receive a scalar from some other processor.

Parameters

[in,out]	t	the data
[in]	from	the processor that sends the information
[in]	tag	an identifier for this specific receive request. This must be unique among all receive requests between the previous synchronisation step and the next one. Exactly one send request must also provide this tag and it must be done on the process specified by the 'from' parameter

     {
 #if MERCURYDPM_ASSERTS
         if (from == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Receiving data from self!");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Request request;
         MPI_Irecv(&t, 1, Detail::toMPIType(t), from, tag, communicator_, &request);
         pending_.push_back(request);
  
 #endif
     }

References FATAL, logger, and processorID_.

Referenced by ParticleHandler::addGhostObject(), PeriodicBoundaryHandler::communicateNumberOfNewParticlesAndInteractions(), PeriodicBoundaryHandler::performNewParticleTransmission(), PeriodicBoundaryHandler::preparePositionAndVelocityUpdate(), Domain::sendAndReceiveCount(), and Domain::sendAndReceiveMPIData().

◆ receive() [2/3]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::receive	(	T *	t,
		int	count,
		int	from,
		int	tag
	)

inline

Todo:: MX: type documentation. this is used to receive vectors of scalars accross

     {
 #if MERCURYDPM_ASSERTS
         if (from == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Receiving data fromself!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Receiving zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Request request;
         MPI_Irecv(&t, count, Detail::toMPIType(*t), from, tag, communicator_, &request);
         pending_.push_back(request);
  
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ receive() [3/3]

template<typename T >

void MPIContainer::receive	(	T *	t,
		MercuryMPIType	type,
		int	count,
		int	from,
		int	tag
	)

inline

asynchronously receive a list of MercuryMPIType objects from some other processor.

Parameters

[in,out]	t	the data, list of MercuryMPIType objects
[in]	type	the MPIType that is being received, for instance an MPIParticle
[in]	count	the number of objects that are being send
[in]	from	the processor that sends the information
[in]	tag	a unique identifier that corresponds with a send command by the sending processor

     {
         //std::cout << "[Process: " << processorID_ << "]: QUEUING RECEIVE REQUEST with tag: " << tag << std::endl;
 #if MERCURYDPM_ASSERTS
         if (from == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Receiving data to self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Receiving zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Request request;
         MPI_Irecv(t, count, dataTypes_[type], from, tag, communicator_, &request);
         pending_.push_back(request);
  
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ send() [1/3]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::send	(	T &	t,
		int	to,
		int	tag
	)

inline

Asynchronously send a scalar to some other processor.

Parameters

[in]	t	the data
[in]	to	the processor to recieve the information
[in]	tag	an identifier for this specific send request. This must be unique among all send requests between the previous synchronisation step and the next one. Exactly one recieve request must also provide this tag and it must be done on the process specified by the 'to' parameter

     {
 #if MERCURYDPM_ASSERTS
         if (to == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Sending data to self!");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Request request;
         MPI_Isend(&t, 1, Detail::toMPIType(t), to, tag, communicator_, &request);
         pending_.push_back(request);
  
 #endif
     }

References FATAL, logger, and processorID_.

Referenced by ParticleHandler::addGhostObject(), PeriodicBoundaryHandler::communicateNumberOfNewParticlesAndInteractions(), PeriodicBoundaryHandler::performNewParticleTransmission(), PeriodicBoundaryHandler::preparePositionAndVelocityUpdate(), Domain::sendAndReceiveCount(), and Domain::sendAndReceiveMPIData().

◆ send() [2/3]

template<typename T >

std::enable_if<std::is_scalar<T>::value, void>::type MPIContainer::send	(	T *	t,
		int	count,
		int	to,
		int	tag
	)

inline

Todo:: MX: type documentation. This one is used to send vectors of scalars across (hence the *t)

     {
 #if MERCURYDPM_ASSERTS
         if (to == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Sending data to self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Sending zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Request request;
         MPI_Isend(t, count, Detail::toMPIType(*t), to, tag, communicator_, &request);
         pending_.push_back(request);
  
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ send() [3/3]

template<typename T >

void MPIContainer::send	(	T *	t,
		MercuryMPIType	type,
		int	count,
		int	to,
		int	tag
	)

inline

asynchronously send a list of MercuryMPITypes objects to some other processor.

Parameters

[in,out]	t	the data, list of MPIType objects
[in]	type	the MPIType that is being send, for instance an MPIParticle
[in]	count	the number of objects that are being send
[in]	to	the processor that the data is send to
[in]	tag	a unique identifier that corresponds with a receive command by the receiving processor

     {
         //std::cout << "[Process: " << processorID_ << "]: QUEUING SEND REQUEST with tag: " << tag << std::endl;
 #if MERCURYDPM_ASSERTS
         if (to == processorID_)
         {
             logger(FATAL, "[MPI FATAL]: Sending data to self!");
         }
         
         if (count == 0)
         {
             logger(WARN, "[MPI ERROR]: Sending zero data");
         }
 #endif
 #ifdef MERCURYDPM_USE_MPI
         MPI_Request request;
         MPI_Isend(t, count, dataTypes_[type], to, tag, communicator_, &request);
         pending_.push_back(request);
  
  
 #endif
     }

References FATAL, logger, processorID_, and WARN.

◆ sync()

void MPIContainer::sync ( )

inline

Process all pending asynchronous communication requests before continuing.

Each processor can commit a send and receive request at any time when is is finished with computing. At some point these requests have to be resolved in order to keep order in the simulation. After all requests are resolved, a barrier ensures that all processors wait untill all requests are resolved.

     {
 #ifdef MERCURYDPM_USE_MPI
         MPI_Waitall(pending_.size(),pending_.data(),MPI_STATUSES_IGNORE);
         pending_.clear();
         MPI_Barrier(communicator_);
 #endif
     }

Referenced by ParticleHandler::addGhostObject(), Domain::addNewParticles(), Domain::addParticle(), DPMBase::decompose(), PeriodicBoundaryHandler::performNewParticleTransmission(), PeriodicBoundaryHandler::prepareNewParticleTransmission(), PeriodicBoundaryHandler::preparePositionAndVelocityUpdate(), Domain::updateStatus(), and Domain::updateVelocity().

Member Data Documentation

◆ numberOfProcessors_

int MPIContainer::numberOfProcessors_

private

The total number of processors in the communicator.

Referenced by getNumberOfProcessors(), and MPIContainer().

◆ processorID_

int MPIContainer::processorID_

private

The ID of the processor this class is running on.

Referenced by directReceive(), directSend(), getProcessorID(), MPIContainer(), receive(), and send().

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MPIContainer() [1/2]

◆ MPIContainer() [2/2]

Member Function Documentation

◆ broadcast() [1/3]

◆ broadcast() [2/3]

◆ broadcast() [3/3]

◆ createMercuryMPIType()

◆ deleteMercuryMPITypes()

◆ directReceive() [1/2]

◆ directReceive() [2/2]

◆ directSend() [1/2]

◆ directSend() [2/2]

◆ gather()

◆ getNumberOfProcessors()

◆ getProcessorID()

◆ initialiseMercuryMPITypes()

◆ Instance()

◆ receive() [1/3]

◆ receive() [2/3]

◆ receive() [3/3]

◆ send() [1/3]

◆ send() [2/3]

◆ send() [3/3]

◆ sync()

Member Data Documentation

◆ numberOfProcessors_

◆ processorID_