static void checkNeighborhoodConsistency( const SetupBlockForest& forest ) {
std::vector< const SetupBlock* > blocks;
forest.getBlocks( blocks );
const int blockssize = int_c( blocks.size() );
#ifdef _OPENMP
#pragma omp parallel for schedule(static)
#endif
for( int i = 0; i < blockssize; ++i ) {
const SetupBlock* const block = blocks[uint_c(i)];
std::vector< real_t > neighborhoodSectionBlockCenters;
for( uint_t n = 0; n != 26; ++n ) {
std::vector< bool > hit( block->getNeighborhoodSectionSize(n), false );
constructNeighborhoodSectionBlockCenters( n, block->getAABB(), neighborhoodSectionBlockCenters );
WALBERLA_CHECK_EQUAL( neighborhoodSectionBlockCenters.size() % 3, uint_c(0) );
for( uint_t p = 0; p != neighborhoodSectionBlockCenters.size(); p += 3 ) {
real_t x = neighborhoodSectionBlockCenters[p];
real_t y = neighborhoodSectionBlockCenters[p+1];
real_t z = neighborhoodSectionBlockCenters[p+2];
// treat periodicity
if( x < forest.getDomain().xMin() && forest.isXPeriodic() ) x = forest.getDomain().xMax() - forest.getDomain().xMin() + x;
if( x >= forest.getDomain().xMax() && forest.isXPeriodic() ) x = forest.getDomain().xMin() - forest.getDomain().xMax() + x;
if( y < forest.getDomain().yMin() && forest.isYPeriodic() ) y = forest.getDomain().yMax() - forest.getDomain().yMin() + y;
if( y >= forest.getDomain().yMax() && forest.isYPeriodic() ) y = forest.getDomain().yMin() - forest.getDomain().yMax() + y;
if( z < forest.getDomain().zMin() && forest.isZPeriodic() ) z = forest.getDomain().zMax() - forest.getDomain().zMin() + z;
if( z >= forest.getDomain().zMax() && forest.isZPeriodic() ) z = forest.getDomain().zMin() - forest.getDomain().zMax() + z;
bool noHit = true;
for( uint_t c = 0; c != block->getNeighborhoodSectionSize(n) && noHit; ++c ) {
if( block->getNeighbor(n,c)->getAABB().contains(x,y,z) ) {
hit[c] = true;
noHit = false;
}
}
// either one neighbor must be hit OR the block is located at the border of the (non-periodic) simulation domain
if( noHit )
WALBERLA_CHECK( forest.getBlock(x,y,z) == NULL );
}
// every neighbor must be hit by at least one point
for( uint_t c = 0; c != block->getNeighborhoodSectionSize(n); ++c )
WALBERLA_CHECK( hit[c] );
neighborhoodSectionBlockCenters.clear();
}
}
}
void test(const shared_ptr< DistanceOctree< MeshType > > & distanceOctree, const MeshType & mesh, const AABB & domainAABB, Vector3<uint_t> numBlocks)
{
Vector3<real_t> blockSize(domainAABB.xSize() / real_c(numBlocks[0]),
domainAABB.ySize() / real_c(numBlocks[1]),
domainAABB.zSize() / real_c(numBlocks[2]));
real_t maxError = blockSize.min() / real_t(10);
SetupBlockForest setupBlockforest;
setupBlockforest.addRootBlockExclusionFunction(F(distanceOctree, maxError));
setupBlockforest.addWorkloadMemorySUIDAssignmentFunction(blockforest::uniformWorkloadAndMemoryAssignment);
setupBlockforest.init(domainAABB, numBlocks[0], numBlocks[1], numBlocks[2], false, false, false);
WALBERLA_LOG_DEVEL(setupBlockforest.toString());
std::vector< Vector3<real_t> > vertexPositions;
vertexPositions.reserve(mesh.n_vertices());
for (auto vIt = mesh.vertices_begin(); vIt != mesh.vertices_end(); ++vIt)
{
vertexPositions.push_back(toWalberla(mesh.point(*vIt)));
}
std::vector< const blockforest::SetupBlock* > setupBlocks;
setupBlockforest.getBlocks(setupBlocks);
// Check wether all vertices are located in allocated blocks
std::vector< Vector3<real_t> > uncoveredVertices(vertexPositions);
for (auto bIt = setupBlocks.begin(); bIt != setupBlocks.end(); ++bIt)
{
const AABB & aabb = (*bIt)->getAABB();
uncoveredVertices.erase(std::remove_if(uncoveredVertices.begin(), uncoveredVertices.end(), PointInAABB(aabb)), uncoveredVertices.end());
}
WALBERLA_CHECK(uncoveredVertices.empty(), "Not all vertices of the mesh are located in allocated blocks!");
//setupBlockforest.assignAllBlocksToRootProcess();
//setupBlockforest.writeVTKOutput( "setupblockforest" );
}
void JacobiIteration::operator()()
{
WALBERLA_LOG_PROGRESS_ON_ROOT( "Starting Jacobi iteration with a maximum number of " << iterations_ << " iterations" );
uint_t i( uint_t(0) );
while( i < iterations_ )
{
if( boundary_ )
boundary_();
communication_();
for( auto block = blocks_.begin( requiredSelectors_, incompatibleSelectors_ ); block != blocks_.end(); ++block )
jacobi_( block.get() );
if( residualNormThreshold_ > real_t(0) && residualCheckFrequency_ > uint_t(0) )
{
if( (i % residualCheckFrequency_) == uint_t(0) )
{
if( boundary_ )
boundary_();
const real_t residualNorm = residualNorm_();
WALBERLA_CHECK( math::finite(residualNorm), "Non-finite residual norm detected during the Jacobi iteration, "
"the simulation has probably diverged." );
WALBERLA_LOG_DETAIL_ON_ROOT( "Residual norm after " << (i+1) << " Jacobi iterations: " << residualNorm );
if( residualNorm < residualNormThreshold_ )
{
WALBERLA_LOG_PROGRESS_ON_ROOT( "Aborting Jacobi iteration (residual norm threshold reached):"
"\n residual norm threshold: " << residualNormThreshold_ <<
"\n residual norm: " << residualNorm );
break;
}
}
}
++i;
}
WALBERLA_LOG_PROGRESS_ON_ROOT( "Jacobi iteration finished after " << i << " iterations" );
}
