void SerialBlockCommunicator2D::copyOverlap (
Overlap2D const& overlap,
MultiBlock2D const& fromMultiBlock, MultiBlock2D& toMultiBlock,
modif::ModifT whichData ) const
{
MultiBlockManagement2D const& fromManagement = fromMultiBlock.getMultiBlockManagement();
MultiBlockManagement2D const& toManagement = toMultiBlock.getMultiBlockManagement();
plint fromEnvelopeWidth = fromManagement.getEnvelopeWidth();
plint toEnvelopeWidth = toManagement.getEnvelopeWidth();
SparseBlockStructure2D const& fromSparseBlock = fromManagement.getSparseBlockStructure();
SparseBlockStructure2D const& toSparseBlock = toManagement.getSparseBlockStructure();
plint originalId = overlap.getOriginalId();
plint overlapId = overlap.getOverlapId();
SmartBulk2D originalBulk(fromSparseBlock, fromEnvelopeWidth, originalId);
SmartBulk2D overlapBulk(toSparseBlock, toEnvelopeWidth, overlapId);
Box2D originalCoords(originalBulk.toLocal(overlap.getOriginalCoordinates()));
Box2D overlapCoords(overlapBulk.toLocal(overlap.getOverlapCoordinates()));
PLB_PRECONDITION(originalCoords.x1-originalCoords.x0 == overlapCoords.x1-overlapCoords.x0);
PLB_PRECONDITION(originalCoords.y1-originalCoords.y0 == overlapCoords.y1-overlapCoords.y0);
AtomicBlock2D const* originalBlock = &fromMultiBlock.getComponent(originalId);
AtomicBlock2D* overlapBlock = &toMultiBlock.getComponent(overlapId);
plint deltaX = originalCoords.x0 - overlapCoords.x0;
plint deltaY = originalCoords.y0 - overlapCoords.y0;
overlapBlock -> getDataTransfer().attribute(overlapCoords, deltaX, deltaY,
*originalBlock, whichData);
}
void ParallelBlockCommunicator2D::communicate (
CommunicationStructure2D& communication,
MultiBlock2D const& originMultiBlock,
MultiBlock2D& destinationMultiBlock, modif::ModifT whichData ) const
{
bool staticMessage = whichData == modif::staticVariables;
// 1. Non-blocking receives.
communication.recvComm.startBeingReceptive(staticMessage);
// 2. Non-blocking sends.
for (unsigned iSend=0; iSend<communication.sendPackage.size(); ++iSend) {
CommunicationInfo2D const& info = communication.sendPackage[iSend];
AtomicBlock2D const& fromBlock = originMultiBlock.getComponent(info.fromBlockId);
fromBlock.getDataTransfer().send (
info.fromDomain, communication.sendComm.getSendBuffer(info.toProcessId),
whichData );
communication.sendComm.acceptMessage(info.toProcessId, staticMessage);
}
// 3. Local copies which require no communication.
for (unsigned iSendRecv=0; iSendRecv<communication.sendRecvPackage.size(); ++iSendRecv) {
CommunicationInfo2D const& info = communication.sendRecvPackage[iSendRecv];
AtomicBlock2D const& fromBlock = originMultiBlock.getComponent(info.fromBlockId);
AtomicBlock2D& toBlock = destinationMultiBlock.getComponent(info.toBlockId);
plint deltaX = info.fromDomain.x0 - info.toDomain.x0;
plint deltaY = info.fromDomain.y0 - info.toDomain.y0;
toBlock.getDataTransfer().attribute (
info.toDomain, deltaX, deltaY, fromBlock,
whichData, info.absoluteOffset );
}
// 4. Finalize the receives.
for (unsigned iRecv=0; iRecv<communication.recvPackage.size(); ++iRecv) {
CommunicationInfo2D const& info = communication.recvPackage[iRecv];
AtomicBlock2D& toBlock = destinationMultiBlock.getComponent(info.toBlockId);
toBlock.getDataTransfer().receive (
info.toDomain,
communication.recvComm.receiveMessage(info.fromProcessId, staticMessage),
whichData, info.absoluteOffset );
}
// 5. Finalize the sends.
communication.sendComm.finalize(staticMessage);
}
void dumpData( MultiBlock2D& multiBlock, bool dynamicContent,
std::vector<plint>& offset, std::vector<plint>& myBlockIds,
std::vector<std::vector<char> >& data )
{
MultiBlockManagement2D const& management = multiBlock.getMultiBlockManagement();
std::map<plint,Box2D> const& bulks = management.getSparseBlockStructure().getBulks();
plint numBlocks = (plint) bulks.size();
std::map<plint,plint> toContiguousId;
std::map<plint,Box2D>::const_iterator it = bulks.begin();
plint pos = 0;
for (; it != bulks.end(); ++it) {
toContiguousId[it->first] = pos;
++pos;
}
std::vector<plint> const& myBlocks = management.getLocalInfo().getBlocks();
myBlockIds.resize(myBlocks.size());
data.resize(myBlocks.size());
std::vector<plint> blockSize(numBlocks);
std::fill(blockSize.begin(), blockSize.end(), 0);
for (pluint iBlock=0; iBlock<myBlocks.size(); ++iBlock) {
plint blockId = myBlocks[iBlock];
SmartBulk2D bulk(management, blockId);
Box2D localBulk(bulk.toLocal(bulk.getBulk()));
AtomicBlock2D const& block = multiBlock.getComponent(blockId);
modif::ModifT typeOfVariables = dynamicContent ? modif::dataStructure : modif::staticVariables;
block.getDataTransfer().send(localBulk, data[iBlock], typeOfVariables);
plint contiguousId = toContiguousId[blockId];
myBlockIds[iBlock] = contiguousId;
blockSize[contiguousId] = (plint)data[iBlock].size();
}
#ifdef PLB_MPI_PARALLEL
global::mpi().allReduceVect(blockSize, MPI_SUM);
#endif
offset.resize(numBlocks);
std::partial_sum(blockSize.begin(), blockSize.end(), offset.begin());
}
