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); } }