void addInternalProcessor( DataProcessorGenerator3D const& generator, MultiBlock3D& actor,
std::vector<MultiBlock3D*> multiBlockArgs, plint level )
{
MultiProcessing3D<DataProcessorGenerator3D const, DataProcessorGenerator3D >
multiProcessing(generator, multiBlockArgs);
std::vector<DataProcessorGenerator3D*> const& retainedGenerators = multiProcessing.getRetainedGenerators();
std::vector<std::vector<plint> > const& atomicBlockNumbers = multiProcessing.getAtomicBlockNumbers();
for (pluint iGenerator=0; iGenerator<retainedGenerators.size(); ++iGenerator) {
std::vector<AtomicBlock3D*> extractedAtomicBlocks(multiBlockArgs.size());
for (pluint iBlock=0; iBlock<extractedAtomicBlocks.size(); ++iBlock) {
extractedAtomicBlocks[iBlock] =
&multiBlockArgs[iBlock]->getComponent(atomicBlockNumbers[iGenerator][iBlock]);
}
// It is assumed that the actor has the same distribution as block 0.
PLB_ASSERT(!atomicBlockNumbers[iGenerator].empty());
AtomicBlock3D& atomicActor = actor.getComponent(atomicBlockNumbers[iGenerator][0]);
// Delegate to the "AtomicBlock version" of addInternal.
plb::addInternalProcessor(*retainedGenerators[iGenerator], atomicActor, extractedAtomicBlocks, level);
}
// Subscribe the processor in the multi-block. This guarantees that the multi-block is aware
// of the maximal current processor level, and it instantiates the communication pattern
// for an update of envelopes after processor execution.
std::vector<MultiBlock3D*> updatedMultiBlocks;
std::vector<modif::ModifT> typeOfModification;
multiProcessing.multiBlocksWhichRequireUpdate(updatedMultiBlocks, typeOfModification);
actor.subscribeProcessor (
level,
updatedMultiBlocks, typeOfModification,
BlockDomain::usesEnvelope(generator.appliesTo()) );
actor.storeProcessor(generator, multiBlockArgs, level);
}
MultiContainerBlock3D::MultiContainerBlock3D(MultiBlock3D const& rhs, Box3D subDomain, bool crop)
: MultiBlock3D (
intersect(rhs.getMultiBlockManagement(), subDomain, crop),
rhs.getBlockCommunicator().clone(),
rhs.getCombinedStatistics().clone() )
{
allocateBlocks();
}
void MultiBlockRegistration3D::release(MultiBlock3D& block) {
std::map<id_t,MultiBlock3D*>::iterator it = multiBlocks.find(block.getId());
if (it == multiBlocks.end()) {
throw PlbLogicException("Releasing a block which is not registered.");
}
else {
uniqueId.releaseId(it->first);
multiBlocks.erase(it);
}
}
MultiBlock3D::MultiBlock3D(MultiBlock3D const& rhs, Box3D subDomain, bool crop)
: multiBlockManagement( intersect(rhs.getMultiBlockManagement(), subDomain, crop) ),
maxProcessorLevel(-1),
storedProcessors(rhs.storedProcessors),
blockCommunicator(rhs.blockCommunicator->clone()),
internalStatistics(),
combinedStatistics(rhs.combinedStatistics->clone()),
statSubscriber(*this),
statisticsOn(true),
periodicitySwitch(*this),
internalModifT(rhs.internalModifT)
{
id = multiBlockRegistration3D().announce(*this);
}
void MultiBlock3D::duplicateOverlapsAtLevelZero (
std::vector<BlockAndModif>& multiBlocks )
{
bool treatedThis = false;
for (pluint iBlock=0; iBlock<multiBlocks.size(); ++iBlock) {
MultiBlock3D* modifiedBlock = multiBlocks[iBlock].first;
modif::ModifT modificationType = multiBlocks[iBlock].second;
if (modifiedBlock==this) {
treatedThis = true;
// If it's the current multi-block we are treating, make sure
// type of modification is equal to internalModifT or stronger.
this->duplicateOverlaps(combine(modificationType, internalModifT));
}
else {
modifiedBlock->duplicateOverlaps(modificationType);
}
}
// If current multi-block has not already been treated, duplicate
// overlaps explicitly (because overlaps are expected to be duplicated
// in any case at level 0).
if (!treatedThis) {
this->duplicateOverlaps(internalModifT);
}
}
