void peanoclaw::mappings::ValidateGrid::mergeWithMaster(
const peanoclaw::Cell& workerGridCell,
peanoclaw::Vertex * const workerGridVertices,
const peano::grid::VertexEnumerator& workerEnumerator,
peanoclaw::Cell& fineGridCell,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell,
int worker,
const peanoclaw::State& workerState,
peanoclaw::State& masterState
) {
logTraceIn( "mergeWithMaster(...)" );
std::vector<PatchDescription> remoteData = PatchDescriptionHeap::getInstance().receiveData(
worker,
fineGridVerticesEnumerator.getVertexPosition(0),
fineGridVerticesEnumerator.getLevel(),
peano::heap::MasterWorkerCommunication
);
std::vector<PatchDescription>& localData = PatchDescriptionHeap::getInstance().getData(_patchDescriptionsIndex);
localData.insert(localData.end(), remoteData.begin(), remoteData.end());
logInfo("mergeWithMaster(...)", "Merged " << remoteData.size() << " patches: " << PatchDescriptionHeap::getInstance().getData(_patchDescriptionsIndex).size() << " entries.");
logTraceOut( "mergeWithMaster(...)" );
}
void peanoclaw::mappings::ValidateGrid::destroyCell(
const peanoclaw::Cell& fineGridCell,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith4Arguments( "destroyCell(...)", fineGridCell, fineGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfCell );
//TODO unterweg debug
// std::cout<< "Destroying cell " << fineGridVerticesEnumerator.getVertexPosition(0) << ", "
// << fineGridVerticesEnumerator.getCellSize()
// << ", index=" << fineGridCell.getCellDescriptionIndex()
// #ifdef Parallel
// << ", rank=" << tarch::parallel::Node::getInstance().getRank()
// #endif
// << std::endl;
_validator.deletePatchIfNotRemote(
fineGridVerticesEnumerator.getVertexPosition(0),
fineGridVerticesEnumerator.getLevel()
);
logTraceOutWith1Argument( "destroyCell(...)", fineGridCell );
}
void particles::pit::adapters::MoveParticlesAndPlot2VTKGridVisualiser_0::leaveCell(
particles::pit::Cell& fineGridCell,
particles::pit::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
particles::pit::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pit::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
#ifdef Parallel
if (fineGridCell.isLeaf() && !fineGridCell.isAssignedToRemoteRank()) {
#else
if (fineGridCell.isLeaf()) {
#endif
assertion( DIMENSIONS==2 || DIMENSIONS==3 );
int vertexIndex[TWO_POWER_D];
dfor2(i)
tarch::la::Vector<DIMENSIONS,double> currentVertexPosition = fineGridVerticesEnumerator.getVertexPosition(i);
assertion2 ( _vertex2IndexMap.find(currentVertexPosition) != _vertex2IndexMap.end(), currentVertexPosition, fineGridVertices[ fineGridVerticesEnumerator(i) ].toString() );
vertexIndex[iScalar] = _vertex2IndexMap[currentVertexPosition];
enddforx
int cellIndex;
if (DIMENSIONS==2) {
cellIndex = _cellWriter->plotQuadrangle(vertexIndex);
}
if (DIMENSIONS==3) {
cellIndex = _cellWriter->plotHexahedron(vertexIndex);
}
_cellStateWriter->plotCell(cellIndex,fineGridVerticesEnumerator.getCellFlags());
_cellNormWriterX->plotCell(cellIndex,(fineGridCell.getMyNorm())[0]);
_cellNormWriterY->plotCell(cellIndex,(fineGridCell.getMyNorm())[1]);
}
}
void particles::pit::adapters::MoveParticlesAndPlot2VTKGridVisualiser_0::beginIteration(
particles::pit::State& solverState
) {
assertion( _vtkWriter==0 );
_vtkWriter = new tarch::plotter::griddata::unstructured::vtk::VTKTextFileWriter();
_vertexWriter = _vtkWriter->createVertexWriter();
_cellWriter = _vtkWriter->createCellWriter();
_vertexTypeWriter = _vtkWriter->createVertexDataWriter(particles::pit::Vertex::Records::getInsideOutsideDomainMapping()+"/Hanging=-1" ,1);
_vertexRefinementControlWriter = _vtkWriter->createVertexDataWriter(particles::pit::Vertex::Records::getRefinementControlMapping() ,1);
_vertexAdjacentCellsHeight = _vtkWriter->createVertexDataWriter( peano::grid::getCellFlagsLegend(),1);
_cellStateWriter = _vtkWriter->createCellDataWriter( "cell-flag(>=-1=stationary,-1=parallel-boundary,<=-2=not-stationary" ,1);
_cellNormWriterX = _vtkWriter->createCellDataWriter( "Norm,X-direction" ,1);
_cellNormWriterY = _vtkWriter->createCellDataWriter( "Norm,Y-direction" ,1);
}
void particles::pidt::mappings::MoveParticles::enterCell(
particles::pidt::Cell& fineGridCell,
particles::pidt::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
particles::pidt::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pidt::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith4Arguments( "enterCell(...)", fineGridCell, fineGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfCell );
if (fineGridCell.isRefined()) {
fineGridCell.clearMaxVComponent();
}
else {
#if defined(SharedTBB) && !defined(__WIN32__)
tbb::atomic<int> numberOfParticlesMoved;
#elif defined(SharedTBB) && defined(__WIN32__)
static tarch::multicore::BooleanSemaphore semaphore;
int numberOfParticlesMoved;
#elif SharedOMP
#error not implemented yet
#else
int numberOfParticlesMoved;
#endif
numberOfParticlesMoved = 0;
pdfor2(k)
const int sourceVertexIndex = fineGridVertices[ fineGridVerticesEnumerator(k) ].getVertexIndex();
#ifdef MOVE_USES_SORTED_PARTICLES
const int resultOfOneVertex = moveParticlesOfOneVertexWithinCellIfTheyAreSorted(
sourceVertexIndex,
fineGridVerticesEnumerator
);
#else
const int resultOfOneVertex = moveParticlesOfOneVertexWithinCell(
sourceVertexIndex,
fineGridVerticesEnumerator
);
#endif
#if defined(SharedTBB) && defined(__WIN32__)
tarch::multicore::Lock lock(semaphore);
#endif
numberOfParticlesMoved += resultOfOneVertex;
endpdforx
_state.updateParticleStatisticsInLeaf(numberOfParticlesMoved,fineGridVerticesEnumerator.getCellSize());
}
logTraceOutWith1Argument( "enterCell(...)", fineGridCell );
}
void peanoclaw::mappings::ValidateGrid::destroyHangingVertex(
const peanoclaw::Vertex& fineGridVertex,
const tarch::la::Vector<DIMENSIONS,double>& fineGridX,
const tarch::la::Vector<DIMENSIONS,double>& fineGridH,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex
) {
logTraceInWith6Arguments( "destroyHangingVertex(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex );
if(tarch::la::allGreaterEquals(fineGridX, _domainOffset)
&& tarch::la::allGreaterEquals(_domainOffset+_domainSize, fineGridX)) {
_validator.findAdjacentPatches(
fineGridVertex,
fineGridX,
coarseGridVerticesEnumerator.getLevel() + 1,
#ifdef Parallel
tarch::parallel::Node::getInstance().getRank()
#else
0
#endif
);
}
logTraceOutWith1Argument( "destroyHangingVertex(...)", fineGridVertex );
}
void peanoclaw::mappings::ValidateGrid::createCell(
peanoclaw::Cell& fineGridCell,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith4Arguments( "createCell(...)", fineGridCell, fineGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfCell );
//TODO unterweg debug
logInfo("", "Creating cell " << fineGridVerticesEnumerator.getVertexPosition(0) << ", "
<< fineGridVerticesEnumerator.getCellSize()
<< ", index=" << fineGridCell.getCellDescriptionIndex()
<< ",level=" << fineGridVerticesEnumerator.getLevel()
);
logTraceOutWith1Argument( "createCell(...)", fineGridCell );
}
void peanoclaw::mappings::Cleanup::ascend(
peanoclaw::Cell * const fineGridCells,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell
) {
logTraceInWith2Arguments( "ascend(...)", coarseGridCell.toString(), coarseGridVerticesEnumerator.toString() );
// @todo Insert your code here
logTraceOut( "ascend(...)" );
}
void peanoclaw::mappings::Cleanup::prepareSendToMaster(
peanoclaw::Cell& localCell,
peanoclaw::Vertex * vertices,
const peano::grid::VertexEnumerator& verticesEnumerator,
const peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
const peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith2Arguments( "prepareSendToMaster(...)", localCell, verticesEnumerator.toString() );
// @todo Insert your code here
logTraceOut( "prepareSendToMaster(...)" );
}
void peanoclaw::mappings::Cleanup::leaveCell(
peanoclaw::Cell& fineGridCell,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith4Arguments( "leaveCell(...)", fineGridCell, fineGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfCell );
// @todo Insert your code here
logTraceOutWith1Argument( "leaveCell(...)", fineGridCell );
}
void particles::pidt::mappings::MoveParticles::leaveCell(
particles::pidt::Cell& fineGridCell,
particles::pidt::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
particles::pidt::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pidt::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith4Arguments( "leaveCell(...)", fineGridCell, fineGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfCell );
double maxVComponentInCell = 0.0;
dfor2(k)
const int sourceVertexIndex = fineGridVertices[ fineGridVerticesEnumerator(k) ].getVertexIndex();
ParticleHeap::HeapEntries& sourceVertexParticles = ParticleHeap::getInstance().getData(sourceVertexIndex);
for (
ParticleHeap::HeapEntries::iterator p = sourceVertexParticles.begin();
p!=sourceVertexParticles.end();
) {
const tarch::la::Vector<DIMENSIONS,int> newDualCellOfParticle = Vertex::getDualCellOfParticle(
fineGridVerticesEnumerator,
p->_persistentRecords._x
);
const double maxVComponentOfParticle = tarch::la::maxAbs(p->_persistentRecords._v);
maxVComponentInCell = maxVComponentInCell > maxVComponentOfParticle ? maxVComponentInCell : maxVComponentOfParticle;
const bool MoveParticleToDifferentDualCell = newDualCellOfParticle!=k;
if (MoveParticleToDifferentDualCell) {
Vertex& newVertexOfParticles = fineGridVertices[ fineGridVerticesEnumerator(newDualCellOfParticle) ];
newVertexOfParticles.particlesWereAddedToThisVertex();
const int destinationVertexIndex = newVertexOfParticles.getVertexIndex();
ParticleHeap::getInstance().getData(destinationVertexIndex).push_back(*p);
p = ParticleHeap::getInstance().getData(sourceVertexIndex).erase(p);
logDebug( "leaveCell(...)", "reassign particle " << p->toString() << " to vertex " << newDualCellOfParticle );
}
else {
p++;
}
}
enddforx
if (!fineGridCell.isRefined()) {
fineGridCell.setMaxVComponent( maxVComponentInCell );
}
logTraceOut( "leaveCell(...)" );
}
void peanoclaw::mappings::ValidateGrid::destroyVertex(
const peanoclaw::Vertex& fineGridVertex,
const tarch::la::Vector<DIMENSIONS,double>& fineGridX,
const tarch::la::Vector<DIMENSIONS,double>& fineGridH,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex
) {
logTraceInWith6Arguments( "destroyVertex(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex );
//TODO unterweg debug
// std::cout<< "Destroying vertex " << fineGridX << ", "
// << fineGridH
// << ", level=" << (coarseGridVerticesEnumerator.getLevel()+1)
// #ifdef Parallel
// << ", rank=" << tarch::parallel::Node::getInstance().getRank()
// #endif
// << fineGridVertex.toString()
// << std::endl;
//We need to call this method here, since it seems that touchVertexLastTime
//is not called in the iteration where a vertex is destroyed.
_validator.findAdjacentPatches(
fineGridVertex,
fineGridX,
coarseGridVerticesEnumerator.getLevel() + 1,
#ifdef Parallel
tarch::parallel::Node::getInstance().getRank()
#else
0
#endif
);
// if(fineGridVertex.isRemote(_state, true, true)) {
// _validator.deleteNonRemoteAdjacentPatches(
// fineGridVertex,
// fineGridX,
// coarseGridVerticesEnumerator.getLevel() + 1,
// #ifdef Parallel
// tarch::parallel::Node::getInstance().getRank()
// #else
// 0
// #endif
// );
// }
logTraceOutWith1Argument( "destroyVertex(...)", fineGridVertex );
}
void particles::pidt::mappings::MoveParticles::ascend(
particles::pidt::Cell * const fineGridCells,
particles::pidt::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
particles::pidt::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pidt::Cell& coarseGridCell
) {
logTraceIn( "ascend(...)" );
dfor3(i)
coarseGridCell.restrictMaxVComponent( fineGridCells[ fineGridVerticesEnumerator.cell(i) ] );
enddforx
logTraceOut( "ascend(...)" );
}
int particles::pidt::mappings::MoveParticles::moveParticlesOfOneVertexWithinCell(
int vertexIndex,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator
) {
#if defined(SharedTBB) && !defined(__WIN32__)
tbb::atomic<int> numberOfParticlesMoved;
#elif SharedOMP
#error not implemented yet
#else
int numberOfParticlesMoved;
#endif
numberOfParticlesMoved = 0;
ParticleHeap::HeapEntries& sourceVertexParticles = ParticleHeap::getInstance().getData(vertexIndex);
pfor(i,0,static_cast<int>(sourceVertexParticles.size()),200)
particles::pidt::records::Particle& currentParticle = sourceVertexParticles.at(i);
const bool particleHasNotBeenMovedYet =
currentParticle.getMovedParticle() != particles::pidt::records::Particle::Moved;
const bool particleIsContainedInCell = fineGridVerticesEnumerator.overlaps(
currentParticle._persistentRecords._x,
0.0
);
if (particleHasNotBeenMovedYet && particleIsContainedInCell) {
currentParticle._persistentRecords._x += (_state.getTimeStepSize() * currentParticle._persistentRecords._v);
currentParticle.setMovedParticle( particles::pidt::records::Particle::Moved );
reflectParticle(currentParticle);
numberOfParticlesMoved++;
}
endpfor
return numberOfParticlesMoved;
}
void peanoclaw::mappings::ValidateGrid::touchVertexLastTime(
peanoclaw::Vertex& fineGridVertex,
const tarch::la::Vector<DIMENSIONS,double>& fineGridX,
const tarch::la::Vector<DIMENSIONS,double>& fineGridH,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex
) {
logTraceInWith6Arguments( "touchVertexLastTime(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex );
_validator.findAdjacentPatches(
fineGridVertex,
fineGridX,
coarseGridVerticesEnumerator.getLevel() + 1,
#ifdef Parallel
tarch::parallel::Node::getInstance().getRank()
#else
0
#endif
);
logTraceOutWith1Argument( "touchVertexLastTime(...)", fineGridVertex );
}
void particles::pidt::mappings::MoveParticles::touchVertexFirstTime(
particles::pidt::Vertex& fineGridVertex,
const tarch::la::Vector<DIMENSIONS,double>& fineGridX,
const tarch::la::Vector<DIMENSIONS,double>& fineGridH,
particles::pidt::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pidt::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex
) {
logTraceInWith6Arguments( "touchVertexFirstTime(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex );
#ifdef Parallel
if (fineGridVertex.isAdjacentToRemoteRank()) {
fineGridVertex.particlesWereAddedToThisVertex();
}
else {
fineGridVertex.noParticlesWereAddedToThisVertex();
}
#else
fineGridVertex.noParticlesWereAddedToThisVertex();
#endif
const int vertexIndex = fineGridVertex.getVertexIndex();
typedef std::vector<particles::pidt::records::Particle> ParticleContainer;
ParticleContainer& sourceVertexParticles = ParticleHeap::getInstance().getData(vertexIndex);
pfor(i,0,static_cast<int>(sourceVertexParticles.size()),100)
particles::pidt::records::Particle& currentParticle = sourceVertexParticles.at(i);
assertion(
currentParticle.getMovedParticle() == particles::pidt::records::Particle::New ||
currentParticle.getMovedParticle() == particles::pidt::records::Particle::Moved
);
assertion1(
tarch::la::allGreaterEquals(currentParticle._persistentRecords._x,0.0),
currentParticle.toString()
);
assertion1(
tarch::la::allSmallerEquals(currentParticle._persistentRecords._x,1.0),
currentParticle.toString()
);
currentParticle.setMovedParticle( particles::pidt::records::Particle::NotMovedYet );
endpfor
logTraceOutWith1Argument( "touchVertexFirstTime(...)", fineGridVertex );
}
void particles::pit::myfunctions::RepresentationChange::ascend(
particles::pit::Cell * const fineGridCells,
particles::pit::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
particles::pit::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pit::Cell& coarseGridCell
) {
particles::pit::myfunctions::CoordinatesRepresentationChange::ascend(
fineGridCells,
fineGridVertices,
fineGridVerticesEnumerator,
coarseGridVertices,
coarseGridVerticesEnumerator,
coarseGridCell);
dfor3(k)
particles::pit::Cell fineGridCell = fineGridCells[ fineGridVerticesEnumerator.cell(k) ];
const tarch::la::Vector<DIMENSIONS,double> cellOffset = fineGridVerticesEnumerator.getVertexPosition(k);
const tarch::la::Vector<DIMENSIONS,double> meanVelocity = fineGridCell.getMeanVelocity();
bool isLeaf = fineGridCell.isLeaf();
const int cellIndex = fineGridCell.getCellIndex();
const int NumberOfParticles = ParticleHeap::getInstance().getData(cellIndex).size();
if( isLeaf && NumberOfParticles>1 ) {
// Compute Max-Norm
double maxRelativeError = computeMaxRelativeError( fineGridCell );
// Save maximal maxRelativeError in _globalMaxRelativeError
if (_globalMaxRelativeError < maxRelativeError) {
_globalMaxRelativeError = maxRelativeError;
}
double maxError = computeMaxError( fineGridCell );
if(_global_max_error < maxError) {
_global_max_error = maxError;
}
double maxOffset = computeMaxOffset( fineGridCell );
double minOffset = computeMinOffset( fineGridCell );
if(_globalMaxOffset < maxOffset) {
_globalMaxOffset = maxOffset;
}
// Compute RMSD
tarch::la::Vector<DIMENSIONS,double> rmsd = computeRMSD( fineGridCell );
// Computer L2-Norm
tarch::la::Vector<DIMENSIONS,double>
l2ErrorNorm = computeL2ErrorNorm( fineGridCell );
tarch::la::Vector<DIMENSIONS,double>
l2Norm = computeL2Norm( fineGridCell );
//std::cout << "ascend() l2ErrorNorm: " << l2ErrorNorm << std::endl;
// Save maximal l2ErrorNorm in _globalMaxL2ErrorNorm
for(int d = 0; d<DIMENSIONS; d++) {
if(_globalMaxL2ErrorNorm < l2ErrorNorm[d]) {
_globalMaxL2ErrorNorm = l2ErrorNorm[d];
}
}
// Add l2ErrorNorm to _globalL2ErrorNorm
_globalL2ErrorNorm += l2ErrorNorm;
// Add l2Norm to _globalL2OffsetNorm
_globalL2OffsetNorm += l2Norm;
// Don't forget to increment _globalNormAdditions to divide _globalL2Norm
//by it at the end of iteration before writing it in the file!
++_globalNormAdditions;
// Output for checking
if(VERBOSE) {
printParticlesInfo( fineGridCell, "l2ErrorNorm", l2ErrorNorm );
}
/* All computations put in output */
_maxRelativeErrorOut << maxRelativeError << " ";
_maxErrorOut << maxError << " ";
_maxOffsetOut << maxOffset << " ";
_minOffsetOut << minOffset << " ";
// Histogram process
l2_error_norm_histogram_->processHistogram(l2ErrorNorm);
max_error_norm_histogram_->processHistogram(maxError);
max_offset_norm_histogram_->processHistogram(maxOffset);
for(int d=0; d<DIMENSIONS; d++) {
_RMSDOut << rmsd[d] << " ";
_L2ErrorNormOut << l2ErrorNorm[d] << " ";
_L2NormOut << l2Norm[d] << " ";
_meanVelocityOut << meanVelocity[d] << " ";
}
/* Write coordinates of each cell near the value of the Norm(offset) */
for(int d=0; d<DIMENSIONS; d++) {
_maxRelativeErrorOut << cellOffset[d] << " ";
_maxErrorOut << cellOffset[d] << " ";
_maxOffsetOut << cellOffset[d] << " ";
_minOffsetOut << cellOffset[d] << " ";
_RMSDOut << cellOffset[d] << " ";
_L2ErrorNormOut << cellOffset[d] << " ";
_L2NormOut << cellOffset[d] << " ";
_meanVelocityOut << cellOffset[d] << " ";
}
/* Put the new line character to have one cell per line */
_maxRelativeErrorOut << std::endl;
_maxErrorOut << std::endl;
_maxOffsetOut << std::endl;
_minOffsetOut << std::endl;
_RMSDOut << std::endl;
_L2ErrorNormOut << std::endl;
_L2NormOut << std::endl;
_meanVelocityOut << std::endl;
}
enddforx
}
void peanoclaw::interSubgridCommunication::GridLevelTransfer::stepUp(
Patch* coarseSubgrid,
Patch& finePatch,
ParallelSubgrid& fineParallelSubgrid,
bool isPeanoCellLeaf,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator
) {
//Correct time intervals for virtual subgrid or going-to-be virtual subgrid
if(!finePatch.isLeaf() || !isPeanoCellLeaf) {
finePatch.switchValuesAndTimeIntervalToMinimalFineGridTimeInterval();
assertion1(tarch::la::greaterEquals(finePatch.getTimeIntervals().getTimestepSize(), 0) || !isPeanoCellLeaf, finePatch);
}
//Update fine grid time interval on next coarser patch if possible
if(coarseSubgrid != 0) {
//Patch coarsePatch(coarseCellDescriptionIndex);
coarseSubgrid->getTimeIntervals().updateMinimalFineGridTimeInterval(
finePatch.getTimeIntervals().getCurrentTime(),
finePatch.getTimeIntervals().getTimestepSize()
);
}
if(finePatch.isLeaf()) {
restrictToOverlappingVirtualSubgrids(finePatch, fineParallelSubgrid);
//TODO unterweg dissertation:
//If the patch is leaf, but the Peano cell is not, it got refined.
//Thus, the patch was not turned to a virtual patch to avoid
//restriction to this patch, which would lead to invalid data, since
//the patch is not initialized with zeros. So, the patch needs to
//be switched to refined (i.e. non-virtual) here...
if(!isPeanoCellLeaf) {
finePatch.switchToVirtual();
//Fill ghostlayer
for(int i = 0; i < TWO_POWER_D; i++) {
fineGridVertices[fineGridVerticesEnumerator(i)].fillAdjacentGhostLayers(
finePatch.getLevel(),
_useDimensionalSplitting,
_numerics,
#ifdef PEANOCLAW_USE_ASCEND_FOR_RESTRICTION
tarch::la::multiplyComponents(peano::utils::dDelinearised(i, 2).convertScalar<double>(), finePatch.getSize()) + finePatch.getPosition(),
#else
fineGridVerticesEnumerator.getVertexPosition(i),
#endif
_subgridStatistics
);
}
finePatch.switchToNonVirtual();
ParallelSubgrid parallelSubgrid(finePatch);
parallelSubgrid.markCurrentStateAsSent(false);
}
} else if (finePatch.isVirtual()) {
finalizeVirtualSubgrid(
finePatch,
fineGridVertices,
fineGridVerticesEnumerator,
isPeanoCellLeaf
);
}
//If patch wasn't refined -> look if veto for coarsening is necessary
if(!finePatch.isLeaf()) {
vetoCoarseningIfNecessary(
finePatch,
fineGridVertices,
fineGridVerticesEnumerator
);
}
//Reset time constraint for optimization of ghostlayer filling
// finePatch.resetMinimalNeighborTimeConstraint();
}
void peanoclaw::interSubgridCommunication::GridLevelTransfer::stepDown(
Patch* coarseSubgrid,
Patch& fineSubgrid,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
bool isInitializing,
bool isPeanoCellLeaf
) {
//Switch to virtual subgrid if necessary
if(shouldBecomeVirtualSubgrid(
fineSubgrid,
fineGridVertices,
fineGridVerticesEnumerator,
isInitializing,
isPeanoCellLeaf
)) {
switchToAndAddVirtualSubgrid(fineSubgrid);
} else if(fineSubgrid.isVirtual()) {
//Switch to non-virtual if still virtual
fineSubgrid.switchToNonVirtual();
}
//Prepare flags for subgrid
if(!fineSubgrid.isLeaf()) {
fineSubgrid.setWillCoarsen(peano::grid::aspects::VertexStateAnalysis::doesOneVertexCarryRefinementFlag
(
fineGridVertices,
fineGridVerticesEnumerator,
peanoclaw::records::Vertex::Erasing
)
);
}
fineSubgrid.getTimeIntervals().resetMinimalNeighborTimeConstraint();
fineSubgrid.getTimeIntervals().resetMaximalNeighborTimeInterval();
fineSubgrid.resetNeighboringGhostlayerBounds();
fineSubgrid.getTimeIntervals().resetMinimalFineGridTimeInterval();
//Get data from neighbors:
// - Ghostlayers data
// - Ghostlayer bounds
// - Neighbor times
for(int i = 0; i < TWO_POWER_D; i++) {
assertion1(fineSubgrid.getCellDescriptionIndex() != -1, fineSubgrid);
fineGridVertices[fineGridVerticesEnumerator(i)].setAdjacentCellDescriptionIndex(i, fineSubgrid.getCellDescriptionIndex());
fineGridVertices[fineGridVerticesEnumerator(i)].fillAdjacentGhostLayers(
fineGridVerticesEnumerator.getLevel(),
_useDimensionalSplitting,
_numerics,
fineGridVerticesEnumerator.getVertexPosition(peano::utils::dDelinearised(i, 2)),
_subgridStatistics,
// fineGridVerticesEnumerator.getVertexPosition(i),
i
);
}
//Data from coarse patch:
// -> Update minimal time constraint of coarse neighbors
if(coarseSubgrid != 0) {
//Patch coarsePatch(coarseCellDescriptionIndex);
if(coarseSubgrid->getTimeIntervals().shouldFineGridsSynchronize()) {
//Set time constraint of fine grid to time of coarse grid to synch
//on that time.
fineSubgrid.getTimeIntervals().updateMinimalNeighborTimeConstraint(
coarseSubgrid->getTimeIntervals().getCurrentTime() + coarseSubgrid->getTimeIntervals().getTimestepSize(),
coarseSubgrid->getCellDescriptionIndex()
);
}
}
}
void peanoclaw::interSubgridCommunication::GridLevelTransfer::finalizeVirtualSubgrid(
Patch& subgrid,
peanoclaw::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
bool isPeanoCellLeaf
) {
tarch::multicore::Lock lock(_virtualPatchListSemaphore);
assertion1(_virtualPatchDescriptionIndices.size() >= 0, subgrid.toString());
tarch::la::Vector<DIMENSIONS_PLUS_ONE, double> virtualSubgridKey = createVirtualSubgridKey(subgrid.getPosition(), subgrid.getLevel());
int virtualPatchDescriptionIndex = _virtualPatchDescriptionIndices[virtualSubgridKey];
_virtualPatchDescriptionIndices.erase(virtualSubgridKey);
// _virtualPatchTimeConstraints.erase(virtualSubgridKey);
CellDescription& virtualPatchDescription = CellDescriptionHeap::getInstance().getData(virtualPatchDescriptionIndex).at(0);
Patch virtualPatch(virtualPatchDescription);
//Assert that we're working on the correct virtual patch
assertionEquals3(subgrid.getCellDescriptionIndex(), virtualPatchDescriptionIndex, subgrid, virtualPatch, _virtualPatchDescriptionIndices.size());
assertionNumericalEquals(subgrid.getPosition(), virtualPatch.getPosition());
assertionNumericalEquals(subgrid.getSize(), virtualPatch.getSize());
assertionEquals(subgrid.getLevel(), virtualPatch.getLevel());
assertionEquals(subgrid.getUIndex(), virtualPatch.getUIndex());
// assertionEquals(finePatch.getUOldIndex(), virtualPatch.getUOldIndex());
#ifndef PEANOCLAW_USE_ASCEND_FOR_RESTRICTION
_numerics.postProcessRestriction(subgrid, !subgrid.willCoarsen());
#endif
//Fill ghostlayer
for(int i = 0; i < TWO_POWER_D; i++) {
fineGridVertices[fineGridVerticesEnumerator(i)].fillAdjacentGhostLayers(
subgrid.getLevel(),
_useDimensionalSplitting,
_numerics,
#ifdef PEANOCLAW_USE_ASCEND_FOR_RESTRICTION
tarch::la::multiplyComponents(peano::utils::dDelinearised(i, 2).convertScalar<double>(), subgrid.getSize()) + subgrid.getPosition(),
#else
fineGridVerticesEnumerator.getVertexPosition(i),
#endif
_subgridStatistics
);
}
//Switch to leaf or non-virtual
if(isPeanoCellLeaf) {
assertion1(tarch::la::greaterEquals(subgrid.getTimeIntervals().getTimestepSize(), 0.0), subgrid);
subgrid.switchToLeaf();
_numerics.update(subgrid);
ParallelSubgrid parallelSubgrid(subgrid);
parallelSubgrid.markCurrentStateAsSent(false);
} else {
if(!isPatchAdjacentToRemoteRank(
fineGridVertices,
fineGridVerticesEnumerator
)) {
subgrid.switchToNonVirtual();
}
}
assertion1(!subgrid.isVirtual()
|| isPatchAdjacentToRemoteRank(
fineGridVertices,
fineGridVerticesEnumerator),
subgrid);
}
void peanoclaw::mappings::Cleanup::createHangingVertex(
peanoclaw::Vertex& fineGridVertex,
const tarch::la::Vector<DIMENSIONS,double>& fineGridX,
const tarch::la::Vector<DIMENSIONS,double>& fineGridH,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex
) {
logTraceInWith6Arguments( "createHangingVertex(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex );
// @todo Insert your code here
logTraceOutWith1Argument( "createHangingVertex(...)", fineGridVertex );
}
void peanoclaw::mappings::ValidateGrid::createInnerVertex(
peanoclaw::Vertex& fineGridVertex,
const tarch::la::Vector<DIMENSIONS,double>& fineGridX,
const tarch::la::Vector<DIMENSIONS,double>& fineGridH,
peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfVertex
) {
logTraceInWith6Arguments( "createInnerVertex(...)", fineGridVertex, fineGridX, fineGridH, coarseGridVerticesEnumerator.toString(), coarseGridCell, fineGridPositionOfVertex );
//TODO unterweg debug
// std::cout<< "Create inner vertex " << fineGridX << ", "
// << fineGridH
// #ifdef Parallel
// << ", rank=" << tarch::parallel::Node::getInstance().getRank()
// #endif
// << std::endl;
logTraceOutWith1Argument( "createInnerVertex(...)", fineGridVertex );
}
int particles::pidt::mappings::MoveParticles::moveParticlesOfOneVertexWithinCellIfTheyAreSorted(
int vertexIndex,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator
) {
ParticleHeap::HeapEntries& sourceVertexParticles = ParticleHeap::getInstance().getData(vertexIndex);
int numberOfParticlesMoved = 0;
int biggestIndexPointingToUnmovedParticle = static_cast<int>(sourceVertexParticles.size())-1;
int smallestIndexPointingToUnmovedParticle = 0;
while (
biggestIndexPointingToUnmovedParticle>=0 &&
sourceVertexParticles.at(biggestIndexPointingToUnmovedParticle).getMovedParticle() == particles::pidt::records::Particle::Moved
) {
biggestIndexPointingToUnmovedParticle--;
}
#ifdef Asserts
for (int i=0; i<biggestIndexPointingToUnmovedParticle; i++) {
assertion3(
sourceVertexParticles.at(i).getMovedParticle() != particles::pidt::records::Particle::Moved,
i,
biggestIndexPointingToUnmovedParticle,
sourceVertexParticles.at(i).toString()
);
}
#endif
logDebug(
"moveParticlesOfOneVertexWithinCellIfTheyAreSorted(...)",
"moved index from " << static_cast<int>(sourceVertexParticles.size())-1 <<
" to " << biggestIndexPointingToUnmovedParticle <<
": " << sourceVertexParticles.at(biggestIndexPointingToUnmovedParticle).toString() <<
" with first element " << sourceVertexParticles.at(smallestIndexPointingToUnmovedParticle).toString()
);
// has to be equals as the two might just have been exchanged
while (biggestIndexPointingToUnmovedParticle >= smallestIndexPointingToUnmovedParticle) {
particles::pidt::records::Particle& currentParticle = sourceVertexParticles.at(smallestIndexPointingToUnmovedParticle);
assertion( biggestIndexPointingToUnmovedParticle>=0 );
assertion( smallestIndexPointingToUnmovedParticle>=0 );
assertion( biggestIndexPointingToUnmovedParticle<static_cast<int>(sourceVertexParticles.size()) );
assertion( smallestIndexPointingToUnmovedParticle<static_cast<int>(sourceVertexParticles.size()) );
assertion4(
currentParticle.getMovedParticle() != particles::pidt::records::Particle::Moved ||
(smallestIndexPointingToUnmovedParticle==biggestIndexPointingToUnmovedParticle),
smallestIndexPointingToUnmovedParticle,
biggestIndexPointingToUnmovedParticle,
sourceVertexParticles.at(smallestIndexPointingToUnmovedParticle).toString(),
sourceVertexParticles.at(biggestIndexPointingToUnmovedParticle).toString()
);
const bool particleIsContainedInCell = fineGridVerticesEnumerator.overlaps(
currentParticle._persistentRecords._x,
0.0
);
if (particleIsContainedInCell) {
currentParticle._persistentRecords._x += (_state.getTimeStepSize() * currentParticle._persistentRecords._v);
currentParticle.setMovedParticle( particles::pidt::records::Particle::Moved );
reflectParticle(currentParticle);
if (smallestIndexPointingToUnmovedParticle!=biggestIndexPointingToUnmovedParticle) {
particles::pidt::records::Particle tmp = currentParticle;
currentParticle = sourceVertexParticles.at(biggestIndexPointingToUnmovedParticle);
sourceVertexParticles[biggestIndexPointingToUnmovedParticle] = tmp;
}
numberOfParticlesMoved++;
biggestIndexPointingToUnmovedParticle--;
}
else {
smallestIndexPointingToUnmovedParticle++;
}
}
return numberOfParticlesMoved;
}
void particles::pit::myfunctions::CoordinatesRepresentationChange::ascend(
particles::pit::Cell * const fineGridCells,
particles::pit::Vertex * const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
particles::pit::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
particles::pit::Cell& coarseGridCell
) {
dfor3(k)
particles::pit::Cell fineGridCell = fineGridCells[ fineGridVerticesEnumerator.cell(k) ];
const tarch::la::Vector<DIMENSIONS,double> cellOffset = fineGridVerticesEnumerator.getVertexPosition(k);
const tarch::la::Vector<DIMENSIONS,double> MeanCoordinate = fineGridCell.getMeanCoordinate();
bool isLeaf = fineGridCell.isLeaf();
const int cellIndex = fineGridCell.getCellIndex();
const int NumberOfParticles = ParticleHeap::getInstance().getData(cellIndex).size();
if( isLeaf && NumberOfParticles>1 ) {
// Compute Max-Norm
double maxRelativeError = computeMaxRelativeError( fineGridCell );
// Save maximal maxRelativeError in _globalMaxRelativeError
if (_globalMaxRelativeError < maxRelativeError) {
_globalMaxRelativeError = maxRelativeError;
}
double maxError = computeMaxError( fineGridCell );
if(_global_max_error < maxError) {
_global_max_error = maxError;
}
double maxOffset = computeMaxOffset( fineGridCell );
// Compute RMSD
tarch::la::Vector<DIMENSIONS,double> rmsd = computeRMSD( fineGridCell );
// Computer L2-Norm
tarch::la::Vector<DIMENSIONS,double> l2ErrorNorm = computeL2ErrorNorm( fineGridCell );
tarch::la::Vector<DIMENSIONS,double> l2Norm = computeL2Norm( fineGridCell );
// Save maximal l2ErrorNorm in _globalMaxL2ErrorNorm
for(int d = 0; d<DIMENSIONS; d++) {
if(_globalMaxL2ErrorNorm < l2ErrorNorm[d]) {
_globalMaxL2ErrorNorm = l2ErrorNorm[d];
}
}
// Add l2Norm to _globalL2Norm
_globalL2ErrorNorm += l2ErrorNorm;
// Don't forget to increment _globalNormAdditions to divide _globalL2Norm by it
// at the end of iteration before writing it in the file!
++_globalNormAdditions;
//std::cout << "_globalNormAdditions: " << _globalNormAdditions << std::endl;
// Output for checking
//printParticlesInfo( fineGridCell, "maxError", maxError );
_maxRelativeErrorOut << maxRelativeError << " ";
_maxErrorOut << maxError << " ";
_maxOffsetOut << maxOffset << " ";
// Histogram process
l2_error_norm_histogram_->processHistogram(l2ErrorNorm);
max_error_norm_histogram_->processHistogram(maxError);
max_offset_norm_histogram_->processHistogram(maxOffset);
for(int d=0; d<DIMENSIONS; d++) {
_RMSDOut << rmsd[d] << " ";
_L2ErrorNormOut << l2ErrorNorm[d] << " ";
_L2NormOut << l2Norm[d] << " ";
_MeanCoordinateOut << MeanCoordinate[d] << " ";
}
for(int d=0; d<DIMENSIONS; d++) {
_maxRelativeErrorOut << cellOffset[d] << " ";
_maxErrorOut << cellOffset[d] << " ";
_maxOffsetOut << cellOffset[d] << " ";
_RMSDOut << cellOffset[d] << " ";
_L2ErrorNormOut << cellOffset[d] << " ";
_L2NormOut << cellOffset[d] << " ";
_MeanCoordinateOut << cellOffset[d] << " ";
}
_maxRelativeErrorOut << std::endl;
_maxErrorOut << std::endl;
_maxOffsetOut << std::endl;
_RMSDOut << std::endl;
_L2ErrorNormOut << std::endl;
_L2NormOut << std::endl;
_MeanCoordinateOut << std::endl;
}
enddforx
}
void peanoclaw::mappings::ValidateGrid::prepareSendToMaster(
peanoclaw::Cell& localCell,
peanoclaw::Vertex * vertices,
const peano::grid::VertexEnumerator& verticesEnumerator,
const peanoclaw::Vertex * const coarseGridVertices,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
const peanoclaw::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS,int>& fineGridPositionOfCell
) {
logTraceInWith2Arguments( "prepareSendToMaster(...)", localCell, verticesEnumerator.toString() );
//Assemble vector to send to master
std::vector<PatchDescription>& workerAndLocalData = PatchDescriptionHeap::getInstance().getData(_patchDescriptionsIndex);
std::vector<PatchDescription> localData = _validator.getAllPatches();
for(int i = 0; i < (int)localData.size(); i++) {
//TODO unterweg debug
// assertion(localData[i].getIsReferenced());
workerAndLocalData.push_back(localData[i]);
}
// for(size_t i = 0; i < PatchDescriptionHeap::getInstance().getData(_patchDescriptionsIndex).size(); i++) {
// //TODO unterweg debug
//// logError("", "Prepare Send to " << tarch::parallel::NodePool::getInstance().getMasterRank() << " -- " << i << ": " << PatchDescriptionHeap::getInstance().getData(_patchDescriptionsIndex)[i].toString());
// assertion(PatchDescriptionHeap::getInstance().getData(_patchDescriptionsIndex)[i].getIsReferenced());
// }
//Add non-referenced patches
// int index = 0;
// int numberOfEntries = 0;
// while(numberOfEntries < CellDescriptionHeap::getInstance().getNumberOfAllocatedEntries()) {
// if(CellDescriptionHeap::getInstance().isValidIndex(index)) {
// if(_descriptions.find(index) == _descriptions.end()) {
// //Found non-referenced patch
// CellDescription& cellDescription = CellDescriptionHeap::getInstance().getData(index).at(0);
// PatchDescription patchDescription;
// patchDescription.setPosition(cellDescription.getPosition());
// patchDescription.setSize(cellDescription.getSize());
// patchDescription.setLevel(cellDescription.getLevel());
// patchDescription.setIsRemote(cellDescription.getIsRemote());
// patchDescription.setIsReferenced(false);
// patchDescription.setCellDescriptionIndex(index);
// patchDescription.setRank(tarch::parallel::Node::getInstance().getRank());
// descriptionVector.push_back(patchDescription);
// }
// numberOfEntries++;
// }
// index++;
// }
//Send
PatchDescriptionHeap::getInstance().sendData(
_patchDescriptionsIndex,
tarch::parallel::NodePool::getInstance().getMasterRank(),
verticesEnumerator.getVertexPosition(0),
verticesEnumerator.getLevel(),
peano::heap::MasterWorkerCommunication
);
#ifdef Parallel
PatchDescriptionHeap::getInstance().finishedToSendSynchronousData();
#endif
logTraceOut( "prepareSendToMaster(...)" );
}