void applyProcessingFunctional(DotProcessingFunctional2D* functional, DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks) { executeDataProcessor( DotProcessorGenerator2D(functional, dotList), atomicBlocks ); }
void executeDataProcessor( ReductiveDataProcessorGenerator3D& generator, MultiBlock3D& object ) { std::vector<MultiBlock3D*> objects(1); objects[0] = &object; executeDataProcessor(generator, objects); }
void executeDataProcessor( ReductiveDataProcessorGenerator3D& generator, std::vector<MultiGrid3D*> multiGrids, plint referenceLevel ) { if(multiGrids.empty()) return; plint numLevels = (plint)multiGrids[0]->getNumLevels(); std::vector<int> dimensionsX, dimensionsT; generator.getDimensionsX(dimensionsX); generator.getDimensionsT(dimensionsT); std::vector<ReductiveDataProcessorGenerator3D*> localGenerators(numLevels); std::vector<BlockStatistics*> localStatistics(numLevels); for (plint iLevel=0; iLevel<numLevels; ++iLevel) { int dxScale = (int)referenceLevel - (int)iLevel; int dtScale = dxScale; // TODO: here, we assume convective scaling; general case could be considered. localGenerators[iLevel] = generator.clone(); plint boxRescaleFactor = util::roundToInt(util::twoToThePowerPlint(std::abs(referenceLevel-iLevel))); if (dxScale < 0) generator.divide(boxRescaleFactor); else generator.multiply(boxRescaleFactor); std::vector<MultiBlock3D*> localBlocks(multiGrids.size()); for (plint iBlock=0; iBlock<(plint)localBlocks.size(); ++iBlock) { localBlocks[iBlock] = &multiGrids[iBlock]->getComponent(iLevel); } executeDataProcessor(*localGenerators[iLevel], localBlocks); std::vector<double> scales(dimensionsX.size()); for (pluint iScale=0; iScale<scales.size(); ++iScale) { scales[iScale] = scaleToReference(dxScale, dimensionsX[iScale], dtScale, dimensionsT[iScale]); } localGenerators[iLevel]->getStatistics().rescale(scales); localStatistics[iLevel] = &(localGenerators[iLevel]->getStatistics()); } combine(localStatistics, generator.getStatistics()); }
/// Execute a data processor over several MultiGrid3D void executeDataProcessor( DataProcessorGenerator3D const& generator, std::vector<MultiGrid3D*> multiGrids, plint referenceLevel ) { if(multiGrids.empty()) return; for (plint iLevel=0; iLevel<(plint)multiGrids[0]->getNumLevels(); ++iLevel) { std::auto_ptr<DataProcessorGenerator3D> localGenerator(generator.clone()); int dxScale = (int)referenceLevel - (int)iLevel; int dtScale = dxScale; // TODO: here, we assume convective scaling; general case should be considered. plint boxRescaleFactor = util::roundToInt(util::twoToThePowerPlint(std::abs(referenceLevel-iLevel))); if (dxScale < 0) // if we go to a coarser grid localGenerator->divide(boxRescaleFactor); else // otherwise we go to a finer grid localGenerator->multiply(boxRescaleFactor); localGenerator->setscale(dxScale,dtScale); std::vector<MultiBlock3D*> localBlocks(multiGrids.size()); for (plint iBlock=0; iBlock<(plint)localBlocks.size(); ++iBlock) { localBlocks[iBlock] = &multiGrids[iBlock]->getComponent(iLevel); } executeDataProcessor(*localGenerator, localBlocks); } }
/// Execute a data processor over a single multiGrid3D void executeDataProcessor( DataProcessorGenerator3D const& generator, MultiGrid3D& object, plint referenceLevel ) { std::vector<MultiGrid3D*> blocks; blocks.push_back(&object); executeDataProcessor(generator,blocks,referenceLevel); }
void executeDataProcessor( DataProcessorGenerator2D const& generator, MultiBlock2D& object ) { std::vector<MultiBlock2D*> objects(1); objects[0] = &object; executeDataProcessor(generator, objects); }
void executeDataProcessor( DataProcessorGenerator3D const& generator, MultiBlock3D& object1, MultiBlock3D& object2 ) { std::vector<MultiBlock3D*> objects(2); objects[0] = &object1; objects[1] = &object2; executeDataProcessor(generator, objects); }
void executeDataProcessor( ReductiveDataProcessorGenerator2D& generator, MultiBlock2D& object1, MultiBlock2D& object2 ) { std::vector<MultiBlock2D*> objects(2); objects[0] = &object1; objects[1] = &object2; executeDataProcessor(generator, objects); }
void executeDataProcessor( ReductiveDataProcessorGenerator3D& generator, MultiGrid3D& object1, MultiGrid3D& object2, plint referenceLevel ) { std::vector<MultiGrid3D*> blocks; blocks.push_back(&object1); blocks.push_back(&object2); executeDataProcessor(generator,blocks,referenceLevel); }
void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D& functional, Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks) { // Let the generator get off with a clone of the functional (because the generator // owns its functional, whereas we still need our copy afterwards to get at the // reducted values). ReductiveBoxProcessorGenerator2D generator(functional.clone(), domain); executeDataProcessor(generator, atomicBlocks); // Recover reducted values from the generator's functional. functional.getStatistics() = generator.getFunctional().getStatistics(); }
void applyProcessingFunctional(BoundedBoxProcessingFunctional2D* functional, Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks, plint boundaryWidth ) { std::vector<BoxProcessorGenerator2D*> generators; functional -> getGenerators(domain, boundaryWidth, generators); delete functional; for (pluint iGen=0; iGen<generators.size(); ++iGen) { executeDataProcessor( *generators[iGen], atomicBlocks ); delete generators[iGen]; } }
void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D& functional, Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks, plint boundaryWidth ) { std::vector<ReductiveBoxProcessorGenerator2D*> generators; functional.getGenerators(domain, boundaryWidth, generators); std::vector<BlockStatistics const*> individualStatistics(generators.size()); for (pluint iGen=0; iGen<generators.size(); ++iGen) { executeDataProcessor( *generators[iGen], atomicBlocks ); individualStatistics[iGen] = &(generators[iGen]->getStatistics()); } SerialCombinedStatistics().combine(individualStatistics, functional.getStatistics()); for (pluint iGen=0; iGen<generators.size(); ++iGen) { delete generators[iGen]; } }
void applyProcessingFunctional(BoxProcessingFunctional2D* functional, Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks) { executeDataProcessor( BoxProcessorGenerator2D(functional, domain), atomicBlocks ); }