From ee161af91fc0285e6d5e086fad6b874fd23af6ea Mon Sep 17 00:00:00 2001
From: Konstantin Kutscher <kutscher@irmb.tu-bs.de>
Date: Mon, 15 Jan 2018 16:18:50 +0100
Subject: [PATCH] define in OMPCalculator
---
.../Applications/DLR-F16-Solid/f16-solid.cfg | 2 +-
source/Applications/DLR-F16-Solid/f16.cpp | 10 +-
source/VirtualFluidsCore/Grid/Grid3D.cpp | 1090 +++++++++--------
.../VirtualFluidsCore/Grid/OMPCalculator.cpp | 18 +-
.../LBM/CompressibleCumulantLBMKernel.cpp | 42 +-
source/VirtualFluidsCore/PointerDefinitions.h | 77 +-
6 files changed, 620 insertions(+), 619 deletions(-)
diff --git a/source/Applications/DLR-F16-Solid/f16-solid.cfg b/source/Applications/DLR-F16-Solid/f16-solid.cfg
index 399f2cb2f..87fdc6f55 100644
--- a/source/Applications/DLR-F16-Solid/f16-solid.cfg
+++ b/source/Applications/DLR-F16-Solid/f16-solid.cfg
@@ -10,7 +10,7 @@ zigZagTape = 2zackenbaender0.stl
pathReInit = /work/koskuche/DLR-F16_L7
stepReInit = 10000
-numOfThreads =1
+numOfThreads = 4
availMem = 15e9
logToFile = false
diff --git a/source/Applications/DLR-F16-Solid/f16.cpp b/source/Applications/DLR-F16-Solid/f16.cpp
index 63a981863..f7d8633fb 100644
--- a/source/Applications/DLR-F16-Solid/f16.cpp
+++ b/source/Applications/DLR-F16-Solid/f16.cpp
@@ -152,6 +152,7 @@ void run(string configname)
bcVisitor.addBC(outflowBCAdapter);
SPtr<LBMKernel> kernel = SPtr<LBMKernel>(new CompressibleCumulantViscosity4thLBMKernel(blockNx[0], blockNx[1], blockNx[2], CompressibleCumulantViscosity4thLBMKernel::NORMAL));
+ //SPtr<LBMKernel> kernel = SPtr<LBMKernel>(new CompressibleCumulantLBMKernel(blockNx[0], blockNx[1], blockNx[2], CompressibleCumulantLBMKernel::NORMAL));
SPtr<BCProcessor> bcProc;
bcProc = SPtr<BCProcessor>(new BCProcessor());
kernel->setBCProcessor(bcProc);
@@ -475,7 +476,7 @@ void run(string configname)
UBLOG(logINFO, "PID = "<<myid<<" Physical Memory currently used by current process: "<<Utilities::getPhysMemUsedByMe()/1073741824.0<<" GB");
}
- //Postrozess
+ //Post process
{
SPtr<UbScheduler> geoSch(new UbScheduler(1));
WriteBoundaryConditionsCoProcessor ppgeo(grid, geoSch, pathOut, WbWriterVtkXmlBinary::getInstance(), conv, comm);
@@ -554,8 +555,8 @@ void run(string configname)
SPtr<UbScheduler> stepMV(new UbScheduler(1));
//TimeseriesCoProcessor tsp1(grid, stepMV, mic1, pathOut+"/mic/mic1", comm);
- //omp_set_num_threads(2);
- SPtr<Calculator> calculator(new MPICalculator());
+ omp_set_num_threads(numOfThreads);
+ SPtr<Calculator> calculator(new OMPCalculator());
calculator->setGrid(grid);
calculator->setLastTimeStep(endTime);
calculator->setVisScheduler(stepSch);
@@ -662,7 +663,8 @@ void test_run()
calculator->setLastTimeStep(2);
calculator->setVisScheduler(stepSch);
calculator->addCoProcessor(writeMQCoProcessor);
- calculator->setVisScheduler(stepSch);
+ calculator->setVisScheduler(stepSch);
+
if (myid==0) UBLOG(logINFO, "Simulation-start");
calculator->calculate();
diff --git a/source/VirtualFluidsCore/Grid/Grid3D.cpp b/source/VirtualFluidsCore/Grid/Grid3D.cpp
index 89d09ed58..fd26b601e 100644
--- a/source/VirtualFluidsCore/Grid/Grid3D.cpp
+++ b/source/VirtualFluidsCore/Grid/Grid3D.cpp
@@ -16,25 +16,25 @@
using namespace std;
-Grid3D::Grid3D() :
- rank(0),
- bundle(0),
- orgDeltaX(1.0),
- periodicX1(false),
- periodicX2(false),
- periodicX3(false),
- timeStep(0.0),
- blockNx1(0),
- blockNx2(0),
- blockNx3(0),
- nx1(0),
- nx2(0),
- nx3(0)
+Grid3D::Grid3D() :
+ rank(0),
+ bundle(0),
+ orgDeltaX(1.0),
+ periodicX1(false),
+ periodicX2(false),
+ periodicX3(false),
+ timeStep(0.0),
+ blockNx1(0),
+ blockNx2(0),
+ blockNx3(0),
+ nx1(0),
+ nx2(0),
+ nx3(0)
{
levelSet.resize(Grid3DSystem::MAXLEVEL+1);
}
//////////////////////////////////////////////////////////////////////////
-Grid3D::Grid3D(SPtr<Communicator> comm) :
+Grid3D::Grid3D(SPtr<Communicator> comm) :
rank(0),
bundle(0),
orgDeltaX(1.0),
@@ -54,7 +54,7 @@ Grid3D::Grid3D(SPtr<Communicator> comm) :
rank = comm->getProcessID();
}
//////////////////////////////////////////////////////////////////////////
-Grid3D::Grid3D( SPtr<Communicator> comm, int blockNx1, int blockNx2, int blockNx3, int gridNx1, int gridNx2, int gridNx3 ) :
+Grid3D::Grid3D(SPtr<Communicator> comm, int blockNx1, int blockNx2, int blockNx3, int gridNx1, int gridNx2, int gridNx3) :
rank(0),
bundle(0),
orgDeltaX(1.0),
@@ -83,7 +83,7 @@ void Grid3D::addInteractor(SPtr<Interactor3D> interactor)
interactors.push_back(interactor);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::addAndInitInteractor(SPtr<Interactor3D> interactor,double timestep)
+void Grid3D::addAndInitInteractor(SPtr<Interactor3D> interactor, double timestep)
{
interactors.push_back(interactor);
interactor->initInteractor(timestep);
@@ -99,27 +99,29 @@ void Grid3D::accept(Block3DVisitor& blockVisitor)
int startLevel = blockVisitor.getStartLevel();
int stopLevel = blockVisitor.getStopLevel();
- if(startLevel < 0 || stopLevel < 0 || startLevel > Grid3DSystem::MAXLEVEL || stopLevel > Grid3DSystem::MAXLEVEL)
- throw UbException(UB_EXARGS,"not valid level!");
+ if (startLevel < 0 || stopLevel < 0 || startLevel > Grid3DSystem::MAXLEVEL || stopLevel > Grid3DSystem::MAXLEVEL)
+ throw UbException(UB_EXARGS, "not valid level!");
bool dir = startLevel < stopLevel;
- if(dir) stopLevel += 1;
+ if (dir) stopLevel += 1;
else stopLevel -= 1;
-
-// for (int l = startLevel; l!=stopLevel;)
-// {
-// std::vector<SPtr<Block3D>> blockVector;
-// getBlocks(l, blockVector);
-// int sizeb = (int)blockVector.size();
//#pragma omp parallel
-//#pragma omp for
-// for(int i = 0; i < sizeb; i++)
+// {
+// for (int l = startLevel; l!=stopLevel;)
// {
-// blockVisitor.visit(shared_from_this(), blockVector[i]);
+// std::vector<SPtr<Block3D>> blockVector;
+// getBlocks(l, blockVector);
+// int sizeb = (int)blockVector.size();
+//
+//#pragma omp for
+// for (int i = 0; i < sizeb; i++)
+// {
+// blockVisitor.visit(shared_from_this(), blockVector[i]);
+// }
+// if (dir) l++;
+// else l--;
// }
-// if (dir) l++;
-// else l--;
// }
for(int l=startLevel; l!=stopLevel;)
{
@@ -136,25 +138,25 @@ void Grid3D::accept(Block3DVisitor& blockVisitor)
//////////////////////////////////////////////////////////////////////////
void Grid3D::accept(Grid3DVisitor& gridVisitor)
{
- gridVisitor.visit( shared_from_this() );
+ gridVisitor.visit(shared_from_this());
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::accept(SPtr<Grid3DVisitor> gridVisitor)
{
- gridVisitor->visit( shared_from_this() );
+ gridVisitor->visit(shared_from_this());
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::addBlock( SPtr<Block3D> block )
+void Grid3D::addBlock(SPtr<Block3D> block)
{
if (block)
{
- this->blockIdMap.insert( std::make_pair( block->getGlobalID(), block) );
+ this->blockIdMap.insert(std::make_pair(block->getGlobalID(), block));
int level = block->getLevel();
- this->levelSet[level].insert( std::make_pair( Block3DKey( block->getX1(), block->getX2(), block->getX3() ), block) ).second;
+ this->levelSet[level].insert(std::make_pair(Block3DKey(block->getX1(), block->getX2(), block->getX3()), block)).second;
}
}
//////////////////////////////////////////////////////////////////////////
-bool Grid3D::deleteBlock( SPtr<Block3D> block )
+bool Grid3D::deleteBlock(SPtr<Block3D> block)
{
return this->deleteBlock(block->getX1(), block->getX2(), block->getX3(), block->getLevel());
}
@@ -162,16 +164,16 @@ bool Grid3D::deleteBlock( SPtr<Block3D> block )
bool Grid3D::deleteBlock(int ix1, int ix2, int ix3, int level)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2, ix3, level);
- if(block)
+ if (block)
{
this->blockIdMap.erase(block->getGlobalID());
- return this->levelSet[level].erase( Block3DKey(ix1, ix2, ix3) ) > 0;
+ return this->levelSet[level].erase(Block3DKey(ix1, ix2, ix3)) > 0;
}
else
{
return false;
}
-}
+}
//////////////////////////////////////////////////////////////////////////
void Grid3D::replaceBlock(SPtr<Block3D> block)
{
@@ -182,24 +184,24 @@ void Grid3D::replaceBlock(SPtr<Block3D> block)
}
}
//////////////////////////////////////////////////////////////////////////
-SPtr<Block3D> Grid3D::getBlock( int ix1, int ix2, int ix3, int level ) const
+SPtr<Block3D> Grid3D::getBlock(int ix1, int ix2, int ix3, int level) const
{
- if( !this->hasLevel(level) ) return SPtr<Block3D>();
+ if (!this->hasLevel(level)) return SPtr<Block3D>();
int N1 = (nx1<<level);
int N2 = (nx2<<level);
int N3 = (nx3<<level);
- if (!this->isPeriodicX1() && (ix1>N1-1 || ix1<0)) return SPtr<Block3D>();
- else if( this->isPeriodicX1() && (ix1>=N1-1 || ix1<0)) { ix1=((ix1%N1)+N1)%N1; }
- if (!this->isPeriodicX2() && (ix2>N2-1 || ix2<0)) return SPtr<Block3D>();
- else if( this->isPeriodicX2() && (ix2>=N2-1 || ix2<0)) { ix2=((ix2%N2)+N2)%N2; }
- if (!this->isPeriodicX3() && (ix3>N3-1 || ix3<0)) return SPtr<Block3D>();
- else if( this->isPeriodicX3() && (ix3>=N3-1 || ix3<0)) { ix3=((ix3%N3)+N3)%N3; }
+ if (!this->isPeriodicX1() && (ix1>N1-1 || ix1<0)) return SPtr<Block3D>();
+ else if (this->isPeriodicX1() && (ix1>=N1-1 || ix1<0)) { ix1=((ix1%N1)+N1)%N1; }
+ if (!this->isPeriodicX2() && (ix2>N2-1 || ix2<0)) return SPtr<Block3D>();
+ else if (this->isPeriodicX2() && (ix2>=N2-1 || ix2<0)) { ix2=((ix2%N2)+N2)%N2; }
+ if (!this->isPeriodicX3() && (ix3>N3-1 || ix3<0)) return SPtr<Block3D>();
+ else if (this->isPeriodicX3() && (ix3>=N3-1 || ix3<0)) { ix3=((ix3%N3)+N3)%N3; }
Block3DMap::const_iterator it;
- it = levelSet[level].find( Block3DKey(ix1,ix2,ix3) );
- if( it == levelSet[level].end() )
+ it = levelSet[level].find(Block3DKey(ix1, ix2, ix3));
+ if (it == levelSet[level].end())
return SPtr<Block3D>();
else
return it->second;
@@ -208,7 +210,7 @@ SPtr<Block3D> Grid3D::getBlock( int ix1, int ix2, int ix3, int level ) const
SPtr<Block3D> Grid3D::getBlock(int id) const
{
BlockIDMap::const_iterator it;
- if( ( it=blockIdMap.find( id ) ) == blockIdMap.end() )
+ if ((it=blockIdMap.find(id)) == blockIdMap.end())
{
return SPtr<Block3D>();
}
@@ -221,8 +223,8 @@ SPtr<Block3D> Grid3D::getBlock(int id) const
// return levelSet[level];
//}
//////////////////////////////////////////////////////////////////////////
-const Grid3D::BlockIDMap& Grid3D::getBlockIDs()
-{
+const Grid3D::BlockIDMap& Grid3D::getBlockIDs()
+{
return blockIdMap;
}
//////////////////////////////////////////////////////////////////////////
@@ -237,19 +239,19 @@ SPtr<Block3D> Grid3D::getSuperBlock(SPtr<Block3D> block)
//////////////////////////////////////////////////////////////////////////
SPtr<Block3D> Grid3D::getSuperBlock(int ix1, int ix2, int ix3, int level)
{
- if(!this->hasLevel(level)) return SPtr<Block3D>();
- if(level < 1) throw UbException(UB_EXARGS,"level <1");
-
+ if (!this->hasLevel(level)) return SPtr<Block3D>();
+ if (level < 1) throw UbException(UB_EXARGS, "level <1");
+
//from Lower Level to higher: >> 1 in x1,x2,x3
SPtr<Block3D> block;
- for(int l=level-1; l>=0; l--)
+ for (int l=level-1; l>=0; l--)
{
ix1 = ix1 >> 1;
ix2 = ix2 >> 1;
ix3 = ix3 >> 1;
block = this->getBlock(ix1, ix2, ix3, l);
- if(block) return block;
+ if (block) return block;
}
return SPtr<Block3D>();
}
@@ -265,22 +267,22 @@ void Grid3D::getSubBlocks(SPtr<Block3D> block, int levelDepth, std::vector<SPtr<
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocks(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
- if(!this->getBlock(ix1, ix2, ix3, level)) return;
- if(level > 0 && !this->getSuperBlock(ix1, ix2, ix3, level)) return;
- if(level >= Grid3DSystem::MAXLEVEL) throw UbException(UB_EXARGS,"Level bigger then MAXLEVEL");
-
- int x1[] = { ix1<<1, (ix1<<1)+1 };
- int x2[] = { ix2<<1, (ix2<<1)+1 };
- int x3[] = { ix3<<1, (ix3<<1)+1 };
+ if (!this->getBlock(ix1, ix2, ix3, level)) return;
+ if (level > 0 && !this->getSuperBlock(ix1, ix2, ix3, level)) return;
+ if (level >= Grid3DSystem::MAXLEVEL) throw UbException(UB_EXARGS, "Level bigger then MAXLEVEL");
+
+ int x1[] ={ ix1<<1, (ix1<<1)+1 };
+ int x2[] ={ ix2<<1, (ix2<<1)+1 };
+ int x3[] ={ ix3<<1, (ix3<<1)+1 };
int l = level + 1;
- for(int i=0; i<2; i++)
- for(int j=0; j<2; j++)
- for(int k=0; k<2; k++)
+ for (int i=0; i<2; i++)
+ for (int j=0; j<2; j++)
+ for (int k=0; k<2; k++)
{
SPtr<Block3D> block = this->getBlock(x1[i], x2[j], x3[k], l);
- if(block) blocks.push_back(block);
- else if(l < levelDepth) this->getSubBlocks(x1[i], x2[j], x3[k], l, levelDepth, blocks);
+ if (block) blocks.push_back(block);
+ else if (l < levelDepth) this->getSubBlocks(x1[i], x2[j], x3[k], l, levelDepth, blocks);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -288,8 +290,8 @@ bool Grid3D::expandBlock(int ix1, int ix2, int ix3, int level)
{
this->checkLevel(level);
- SPtr<Block3D> block = this->getBlock( ix1, ix2, ix3, level );
- if(!block) throw UbException(UB_EXARGS,"block(x1="+UbSystem::toString(ix1)+", x2="+UbSystem::toString(ix2)+", x3="+UbSystem::toString(ix3)+", l="+UbSystem::toString(level)+") is not exist");
+ SPtr<Block3D> block = this->getBlock(ix1, ix2, ix3, level);
+ if (!block) throw UbException(UB_EXARGS, "block(x1="+UbSystem::toString(ix1)+", x2="+UbSystem::toString(ix2)+", x3="+UbSystem::toString(ix3)+", l="+UbSystem::toString(level)+") is not exist");
//if(!block->isActive()) throw UbException(UB_EXARGS,"block(x1="+UbSystem::toString(ix1)+", x2="+UbSystem::toString(ix2)+", x3="+UbSystem::toString(ix3)+", l="+UbSystem::toString(level)+") is not active");
//da bei periodic der eigentliche block andere indizes hat:
@@ -298,7 +300,7 @@ bool Grid3D::expandBlock(int ix1, int ix2, int ix3, int level)
ix3 = block->getX3();
int l = level+1;
- if( l>Grid3DSystem::MAXLEVEL ) throw UbException(UB_EXARGS,"level > Grid3D::MAXLEVEL");
+ if (l>Grid3DSystem::MAXLEVEL) throw UbException(UB_EXARGS, "level > Grid3D::MAXLEVEL");
int west = ix1<<1;
int east = west+1;
@@ -311,13 +313,13 @@ bool Grid3D::expandBlock(int ix1, int ix2, int ix3, int level)
SPtr<Block3D> blockBSE = SPtr<Block3D>(new Block3D(east, south, bottom, l));
SPtr<Block3D> blockBNW = SPtr<Block3D>(new Block3D(west, north, bottom, l));
SPtr<Block3D> blockBNE = SPtr<Block3D>(new Block3D(east, north, bottom, l));
- SPtr<Block3D> blockTSW = SPtr<Block3D>(new Block3D(west, south, top , l));
- SPtr<Block3D> blockTSE = SPtr<Block3D>(new Block3D(east, south, top , l));
- SPtr<Block3D> blockTNW = SPtr<Block3D>(new Block3D(west, north, top , l));
- SPtr<Block3D> blockTNE = SPtr<Block3D>(new Block3D(east, north, top , l));
+ SPtr<Block3D> blockTSW = SPtr<Block3D>(new Block3D(west, south, top, l));
+ SPtr<Block3D> blockTSE = SPtr<Block3D>(new Block3D(east, south, top, l));
+ SPtr<Block3D> blockTNW = SPtr<Block3D>(new Block3D(west, north, top, l));
+ SPtr<Block3D> blockTNE = SPtr<Block3D>(new Block3D(east, north, top, l));
- if( !this->deleteBlock( ix1, ix2, ix3, level ) )
- throw UbException(UB_EXARGS,"could not delete block");
+ if (!this->deleteBlock(ix1, ix2, ix3, level))
+ throw UbException(UB_EXARGS, "could not delete block");
this->addBlock(blockBSW);
this->addBlock(blockBSE);
@@ -336,12 +338,12 @@ SPtr<Block3D> Grid3D::collapseBlock(int fix1, int fix2, int fix3, int flevel, in
using UbSystem::toString;
SPtr<Block3D> fblock = this->getBlock(fix1, fix2, fix3, flevel);
- if( flevel < 1 ) throw UbException(UB_EXARGS,"level of block ("+toString(fix1)+","+toString(fix2)+","+toString(fix3)+","+toString(flevel)+") is < 1");
- if( !fblock )
+ if (flevel < 1) throw UbException(UB_EXARGS, "level of block ("+toString(fix1)+","+toString(fix2)+","+toString(fix3)+","+toString(flevel)+") is < 1");
+ if (!fblock)
{
- throw UbException(UB_EXARGS,"specific block("+toString(fix1)+","+toString(fix2)+","+toString(fix3)+","+toString(flevel)+") doesn't exists");
+ throw UbException(UB_EXARGS, "specific block("+toString(fix1)+","+toString(fix2)+","+toString(fix3)+","+toString(flevel)+") doesn't exists");
}
- if( !fblock->isActive() ) throw UbException(UB_EXARGS,"block("+toString(fix1)+","+toString(fix2)+","+toString(fix3)+","+toString(flevel)+") is not active");
+ if (!fblock->isActive()) throw UbException(UB_EXARGS, "block("+toString(fix1)+","+toString(fix2)+","+toString(fix3)+","+toString(flevel)+") is not active");
//da bei periodic der eigentliche block andere indizes hat:
fix1 = fblock->getX1();
@@ -352,18 +354,18 @@ SPtr<Block3D> Grid3D::collapseBlock(int fix1, int fix2, int fix3, int flevel, in
int cix2 = fblock->getX2() >> 1;
int cix3 = fblock->getX3() >> 1;
- int fx1[2] = { cix1<<1, (cix1<<1)+1 };
- int fx2[2] = { cix2<<1, (cix2<<1)+1 };
- int fx3[2] = { cix3<<1, (cix3<<1)+1 };
+ int fx1[2] ={ cix1<<1, (cix1<<1)+1 };
+ int fx2[2] ={ cix2<<1, (cix2<<1)+1 };
+ int fx3[2] ={ cix3<<1, (cix3<<1)+1 };
int clevel = flevel - 1;
vector<SPtr<Block3D>> blocks;
- for(int i=0; i<2; i++)
- for(int k=0; k<2; k++)
- for(int l=0; l<2; l++)
+ for (int i=0; i<2; i++)
+ for (int k=0; k<2; k++)
+ for (int l=0; l<2; l++)
{
this->getSubBlocks(fx1[k], fx2[i], fx3[l], flevel, levelDepth, blocks);
- while(!blocks.empty())
+ while (!blocks.empty())
{
//man muss nur eine von den moeglichen acht "collapsen", die anderen werden
//dann (rekursiv) collapsed, da die schleife oben alle vier abfragt
@@ -372,35 +374,35 @@ SPtr<Block3D> Grid3D::collapseBlock(int fix1, int fix2, int fix3, int flevel, in
}
}
- vector<SPtr<Block3D>> fineBlocks(8);
- /*BSW*/fineBlocks[0] = this->getBlock( fx1[0], fx2[0], fx3[0], flevel );
- /*BSE*/fineBlocks[1] = this->getBlock( fx1[1], fx2[0], fx3[0], flevel );
- /*BNE*/fineBlocks[2] = this->getBlock( fx1[1], fx2[1], fx3[0], flevel );
- /*BNW*/fineBlocks[3] = this->getBlock( fx1[0], fx2[1], fx3[0], flevel );
- /*TSW*/fineBlocks[4] = this->getBlock( fx1[0], fx2[0], fx3[1], flevel );
- /*TSE*/fineBlocks[5] = this->getBlock( fx1[1], fx2[0], fx3[1], flevel );
- /*TNE*/fineBlocks[6] = this->getBlock( fx1[1], fx2[1], fx3[1], flevel );
- /*TNW*/fineBlocks[7] = this->getBlock( fx1[0], fx2[1], fx3[1], flevel );
+ vector<SPtr<Block3D>> fineBlocks(8);
+ /*BSW*/fineBlocks[0] = this->getBlock(fx1[0], fx2[0], fx3[0], flevel);
+ /*BSE*/fineBlocks[1] = this->getBlock(fx1[1], fx2[0], fx3[0], flevel);
+ /*BNE*/fineBlocks[2] = this->getBlock(fx1[1], fx2[1], fx3[0], flevel);
+ /*BNW*/fineBlocks[3] = this->getBlock(fx1[0], fx2[1], fx3[0], flevel);
+ /*TSW*/fineBlocks[4] = this->getBlock(fx1[0], fx2[0], fx3[1], flevel);
+ /*TSE*/fineBlocks[5] = this->getBlock(fx1[1], fx2[0], fx3[1], flevel);
+ /*TNE*/fineBlocks[6] = this->getBlock(fx1[1], fx2[1], fx3[1], flevel);
+ /*TNW*/fineBlocks[7] = this->getBlock(fx1[0], fx2[1], fx3[1], flevel);
- SPtr<Block3D> cblock = SPtr<Block3D>(new Block3D(cix1, cix2, cix3, clevel));
+ SPtr<Block3D> cblock = SPtr<Block3D>(new Block3D(cix1, cix2, cix3, clevel));
- for(int i=0; i<2; i++)
- for(int k=0; k<2; k++)
- for(int l=0; l<2; l++)
- if( !this->deleteBlock( fx1[k], fx2[i], fx3[l], flevel ) )
- throw UbException(UB_EXARGS,"could not delete block");
+ for (int i=0; i<2; i++)
+ for (int k=0; k<2; k++)
+ for (int l=0; l<2; l++)
+ if (!this->deleteBlock(fx1[k], fx2[i], fx3[l], flevel))
+ throw UbException(UB_EXARGS, "could not delete block");
- this->addBlock(cblock);
+ this->addBlock(cblock);
- return cblock;
+ return cblock;
}
//////////////////////////////////////////////////////////////////////////
// TODO: make visitor for this
void Grid3D::deleteConnectors()
{
- for(Block3DMap blockMap : levelSet)
+ for (Block3DMap blockMap : levelSet)
{
- for(Block3DMap::value_type b : blockMap)
+ for (Block3DMap::value_type b : blockMap)
{
SPtr<Block3D> block = b.second;
block->deleteConnectors();
@@ -419,29 +421,29 @@ int Grid3D::getRank() const
return rank;
}
//////////////////////////////////////////////////////////////////////////
-int Grid3D::getBundle() const
-{
- return bundle;
+int Grid3D::getBundle() const
+{
+ return bundle;
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::setBundle(int bundle)
-{
- this->bundle = bundle;
-}
+void Grid3D::setBundle(int bundle)
+{
+ this->bundle = bundle;
+}
//////////////////////////////////////////////////////////////////////////
-bool Grid3D::isPeriodicX1() const
-{
- return this->periodicX1;
+bool Grid3D::isPeriodicX1() const
+{
+ return this->periodicX1;
}
//////////////////////////////////////////////////////////////////////////
-bool Grid3D::isPeriodicX2() const
-{
- return this->periodicX2;
+bool Grid3D::isPeriodicX2() const
+{
+ return this->periodicX2;
}
//////////////////////////////////////////////////////////////////////////
-bool Grid3D::isPeriodicX3() const
-{
- return this->periodicX3;
+bool Grid3D::isPeriodicX3() const
+{
+ return this->periodicX3;
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::setPeriodicX1(bool value)
@@ -461,41 +463,41 @@ void Grid3D::setPeriodicX3(bool value)
//////////////////////////////////////////////////////////////////////////
UbTupleInt3 Grid3D::getBlockIndexes(double blockX1Coord, double blockX2Coord, double blockX3Coord) const
{
- if(!trafo)
+ if (!trafo)
{
- return makeUbTuple( (int)blockX1Coord, (int)blockX2Coord, (int)blockX3Coord );
+ return makeUbTuple((int)blockX1Coord, (int)blockX2Coord, (int)blockX3Coord);
}
- return makeUbTuple( (int)trafo->transformForwardToX1Coordinate( blockX1Coord, blockX2Coord, blockX3Coord )
- , (int)trafo->transformForwardToX2Coordinate( blockX1Coord, blockX2Coord, blockX3Coord )
- , (int)trafo->transformForwardToX3Coordinate( blockX1Coord, blockX2Coord, blockX3Coord ) );
+ return makeUbTuple((int)trafo->transformForwardToX1Coordinate(blockX1Coord, blockX2Coord, blockX3Coord)
+ , (int)trafo->transformForwardToX2Coordinate(blockX1Coord, blockX2Coord, blockX3Coord)
+ , (int)trafo->transformForwardToX3Coordinate(blockX1Coord, blockX2Coord, blockX3Coord));
}
//////////////////////////////////////////////////////////////////////////
UbTupleInt3 Grid3D::getBlockIndexes(double blockX1Coord, double blockX2Coord, double blockX3Coord, int level) const
{
- if(!trafo)
+ if (!trafo)
{
- return makeUbTuple( (int)blockX1Coord, (int)blockX2Coord, (int)blockX3Coord );
+ return makeUbTuple((int)blockX1Coord, (int)blockX2Coord, (int)blockX3Coord);
}
double dx = getDeltaX(level);
- double blockLentghX1, blockLentghX2, blockLentghX3;
+ double blockLentghX1, blockLentghX2, blockLentghX3;
blockLentghX1 = blockNx1*dx;
blockLentghX2 = blockNx2*dx;
blockLentghX3 = blockNx3*dx;
UbTupleDouble3 org = getBlockWorldCoordinates(0, 0, 0, 0);
- SPtr<CoordinateTransformation3D> trafo_temp(new CoordinateTransformation3D(val<1>(org),val<2>(org),val<3>(org),blockLentghX1,blockLentghX2,blockLentghX3));
+ SPtr<CoordinateTransformation3D> trafo_temp(new CoordinateTransformation3D(val<1>(org), val<2>(org), val<3>(org), blockLentghX1, blockLentghX2, blockLentghX3));
- if(!trafo_temp)
+ if (!trafo_temp)
{
- return makeUbTuple( (int)blockX1Coord, (int)blockX2Coord, (int)blockX3Coord );
+ return makeUbTuple((int)blockX1Coord, (int)blockX2Coord, (int)blockX3Coord);
}
- return makeUbTuple( (int)trafo_temp->transformForwardToX1Coordinate( blockX1Coord, blockX2Coord, blockX3Coord )
- , (int)trafo_temp->transformForwardToX2Coordinate( blockX1Coord, blockX2Coord, blockX3Coord )
- , (int)trafo_temp->transformForwardToX3Coordinate( blockX1Coord, blockX2Coord, blockX3Coord ) );
+ return makeUbTuple((int)trafo_temp->transformForwardToX1Coordinate(blockX1Coord, blockX2Coord, blockX3Coord)
+ , (int)trafo_temp->transformForwardToX2Coordinate(blockX1Coord, blockX2Coord, blockX3Coord)
+ , (int)trafo_temp->transformForwardToX3Coordinate(blockX1Coord, blockX2Coord, blockX3Coord));
}
//////////////////////////////////////////////////////////////////////////
@@ -504,16 +506,16 @@ UbTupleDouble3 Grid3D::getBlockLengths(const SPtr<Block3D> block) const
int level = block->getLevel();
double delta = 1.0/(double)(1<<level);
- if(!trafo) makeUbTuple<double, double, double>(delta,delta,delta);
+ if (!trafo) makeUbTuple<double, double, double>(delta, delta, delta);
- return makeUbTuple( trafo->getX1CoordinateScaling()*delta,
- trafo->getX2CoordinateScaling()*delta,
- trafo->getX3CoordinateScaling()*delta );
+ return makeUbTuple(trafo->getX1CoordinateScaling()*delta,
+ trafo->getX2CoordinateScaling()*delta,
+ trafo->getX3CoordinateScaling()*delta);
}
//////////////////////////////////////////////////////////////////////////
-UbTupleDouble6 Grid3D::getBlockOversize() const
-{
- return makeUbTuple(0.0,0.0,0.0,0.0,0.0,0.0);
+UbTupleDouble6 Grid3D::getBlockOversize() const
+{
+ return makeUbTuple(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::setCoordinateTransformator(SPtr<CoordinateTransformation3D> trafo)
@@ -521,9 +523,9 @@ void Grid3D::setCoordinateTransformator(SPtr<CoordinateTransformation3D> trafo)
this->trafo = trafo;
}
//////////////////////////////////////////////////////////////////////////
-const SPtr<CoordinateTransformation3D> Grid3D::getCoordinateTransformator() const
-{
- return this->trafo;
+const SPtr<CoordinateTransformation3D> Grid3D::getCoordinateTransformator() const
+{
+ return this->trafo;
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::setDeltaX(double dx)
@@ -536,19 +538,19 @@ void Grid3D::setDeltaX(double worldUnit, double gridUnit)
this->orgDeltaX = worldUnit/gridUnit;
}
//////////////////////////////////////////////////////////////////////////
-double Grid3D::getDeltaX(int level) const
-{
+double Grid3D::getDeltaX(int level) const
+{
double delta = this->orgDeltaX/(double)(1<<level);
- return delta;
+ return delta;
}
//////////////////////////////////////////////////////////////////////////
-double Grid3D::getDeltaX(SPtr<Block3D> block) const
-{
- return getDeltaX(block->getLevel());
+double Grid3D::getDeltaX(SPtr<Block3D> block) const
+{
+ return getDeltaX(block->getLevel());
}
//////////////////////////////////////////////////////////////////////////
-UbTupleDouble3 Grid3D::getNodeOffset(SPtr<Block3D> block) const
-{
+UbTupleDouble3 Grid3D::getNodeOffset(SPtr<Block3D> block) const
+{
double delta = this->getDeltaX(block);
return makeUbTuple(OFFSET * delta, OFFSET * delta, OFFSET * delta);
}
@@ -572,13 +574,13 @@ UbTupleInt3 Grid3D::getNodeIndexes(SPtr<Block3D> block, double nodeX1Coord, doub
UbTupleDouble3 nodeOffset = this->getNodeOffset(block);
double deltaX = getDeltaX(block);
- int ix1,ix2,ix3;
+ int ix1, ix2, ix3;
double ixx1=(abs(nodeX1Coord - val<1>(org) + val<1>(nodeOffset)) / deltaX);
double ixx2=(abs(nodeX2Coord - val<2>(org) + val<2>(nodeOffset)) / deltaX);
double ixx3=(abs(nodeX3Coord - val<3>(org) + val<3>(nodeOffset)) / deltaX);
- if (ixx1-(int)ixx1>.9999999999) ix1=(int)ixx1+1;else ix1=(int)ixx1;
- if (ixx2-(int)ixx2>.9999999999) ix2=(int)ixx2+1;else ix2=(int)ixx2;
- if (ixx3-(int)ixx3>.9999999999) ix3=(int)ixx3+1;else ix3=(int)ixx3;
+ if (ixx1-(int)ixx1>.9999999999) ix1=(int)ixx1+1; else ix1=(int)ixx1;
+ if (ixx2-(int)ixx2>.9999999999) ix2=(int)ixx2+1; else ix2=(int)ixx2;
+ if (ixx3-(int)ixx3>.9999999999) ix3=(int)ixx3+1; else ix3=(int)ixx3;
return makeUbTuple(ix1, ix2, ix3);
}
@@ -586,8 +588,8 @@ UbTupleInt3 Grid3D::getNodeIndexes(SPtr<Block3D> block, double nodeX1Coord, doub
//returns tuple with origin of block in world-coordinates
UbTupleDouble3 Grid3D::getBlockWorldCoordinates(SPtr<Block3D> block) const
{
- if(!block)
- throw UbException(UB_EXARGS,"block " + block->toString() + "is not exist");
+ if (!block)
+ throw UbException(UB_EXARGS, "block " + block->toString() + "is not exist");
int blockX1Index = block->getX1();
int blockX2Index = block->getX2();
@@ -604,11 +606,11 @@ UbTupleDouble3 Grid3D::getBlockWorldCoordinates(int blockX1Index, int blockX2Ind
double x2 = (double)blockX2Index*c1oShiftedLevel;
double x3 = (double)blockX3Index*c1oShiftedLevel;
- if(!trafo) return UbTupleDouble3( x1,x2,x3 );
+ if (!trafo) return UbTupleDouble3(x1, x2, x3);
- return UbTupleDouble3( trafo->transformBackwardToX1Coordinate( x1,x2,x3 )
- ,trafo->transformBackwardToX2Coordinate( x1,x2,x3 )
- ,trafo->transformBackwardToX3Coordinate( x1,x2,x3 ) );
+ return UbTupleDouble3(trafo->transformBackwardToX1Coordinate(x1, x2, x3)
+ , trafo->transformBackwardToX2Coordinate(x1, x2, x3)
+ , trafo->transformBackwardToX3Coordinate(x1, x2, x3));
}
//////////////////////////////////////////////////////////////////////////
//double Grid3D::getDeltaT(SPtr<Block3D> block) const
@@ -620,34 +622,34 @@ UbTupleDouble3 Grid3D::getBlockWorldCoordinates(int blockX1Index, int blockX2Ind
//////////////////////////////////////////////////////////////////////////
void Grid3D::checkLevel(int level)
{
- if(level < 0)
+ if (level < 0)
{
- throw UbException(UB_EXARGS,"l("+UbSystem::toString(level)+(string)")<0");
+ throw UbException(UB_EXARGS, "l("+UbSystem::toString(level)+(string)")<0");
}
- if(level > Grid3DSystem::MAXLEVEL)
+ if (level > Grid3DSystem::MAXLEVEL)
{
- throw UbException(UB_EXARGS,"l("+UbSystem::toString(level)+(string)")>MAXLEVEL");
+ throw UbException(UB_EXARGS, "l("+UbSystem::toString(level)+(string)")>MAXLEVEL");
}
- if(this->levelSet[level].size() == 0)
+ if (this->levelSet[level].size() == 0)
{
- throw UbException(UB_EXARGS,"levelMap for level("+UbSystem::toString(level)+(string)")==NULL");
+ throw UbException(UB_EXARGS, "levelMap for level("+UbSystem::toString(level)+(string)")==NULL");
}
}
//////////////////////////////////////////////////////////////////////////
bool Grid3D::hasLevel(int level) const
{
- if(level < 0 ) return false;
- if(level > Grid3DSystem::MAXLEVEL ) return false;
- if(this->levelSet[level].size() == 0) return false;
+ if (level < 0) return false;
+ if (level > Grid3DSystem::MAXLEVEL) return false;
+ if (this->levelSet[level].size() == 0) return false;
return true;
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::setBlockNX( int nx1, int nx2, int nx3 )
+void Grid3D::setBlockNX(int nx1, int nx2, int nx3)
{
- blockNx1 = nx1;
- blockNx2 = nx2;
- blockNx3 = nx3;
+ blockNx1 = nx1;
+ blockNx2 = nx2;
+ blockNx3 = nx3;
}
//////////////////////////////////////////////////////////////////////////
UbTupleInt3 Grid3D::getBlockNX() const
@@ -656,9 +658,9 @@ UbTupleInt3 Grid3D::getBlockNX() const
}
//////////////////////////////////////////////////////////////////////////
-SPtr<Block3D> Grid3D::getNeighborBlock( int dir, int ix1, int ix2, int ix3, int level ) const
+SPtr<Block3D> Grid3D::getNeighborBlock(int dir, int ix1, int ix2, int ix3, int level) const
{
- return this->getBlock( ix1+Grid3DSystem::EX1[dir], ix2+Grid3DSystem::EX2[dir], ix3+Grid3DSystem::EX3[dir], level );
+ return this->getBlock(ix1+Grid3DSystem::EX1[dir], ix2+Grid3DSystem::EX2[dir], ix3+Grid3DSystem::EX3[dir], level);
}
//////////////////////////////////////////////////////////////////////////
SPtr<Block3D> Grid3D::getNeighborBlock(int dir, SPtr<Block3D> block) const
@@ -667,15 +669,15 @@ SPtr<Block3D> Grid3D::getNeighborBlock(int dir, SPtr<Block3D> block) const
int x2 = block->getX2();
int x3 = block->getX3();
int level = block->getLevel();
- return this->getNeighborBlock( dir, x1, x2, x3, level);
+ return this->getNeighborBlock(dir, x1, x2, x3, level);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getAllNeighbors(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
- for(int dir=Grid3DSystem::STARTDIR; dir<=Grid3DSystem::ENDDIR; dir++)
- //for (int dir = Grid3DSystem::STARTDIR; dir<=Grid3DSystem::TS; dir++)
+ for (int dir=Grid3DSystem::STARTDIR; dir<=Grid3DSystem::ENDDIR; dir++)
+ //for (int dir = Grid3DSystem::STARTDIR; dir<=Grid3DSystem::TS; dir++)
{
- this->getNeighborBlocksForDirection(dir,ix1,ix2,ix3,level,levelDepth,blocks);
+ this->getNeighborBlocksForDirection(dir, ix1, ix2, ix3, level, levelDepth, blocks);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -684,7 +686,7 @@ void Grid3D::getAllNeighbors(SPtr<Block3D> block, int level, int levelDepth, std
int x1 = block->getX1();
int x2 = block->getX2();
int x3 = block->getX3();
- getAllNeighbors(x1,x2,x3,level,levelDepth,blocks);
+ getAllNeighbors(x1, x2, x3, level, levelDepth, blocks);
}
//////////////////////////////////////////////////////////////////////////
/**
@@ -696,13 +698,13 @@ void Grid3D::getAllNeighbors(SPtr<Block3D> block, int level, int levelDepth, std
*/
void Grid3D::getNeighborsNorth(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
- SPtr<Block3D> block = this->getBlock(ix1, ix2+1, ix3, level);
- if(block) { blocks.push_back(block); }
+ SPtr<Block3D> block = this->getBlock(ix1, ix2+1, ix3, level);
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2+1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksSouth(ix1, ix2+1, ix3, level, blocks, levelDepth);
}
@@ -710,12 +712,12 @@ void Grid3D::getNeighborsNorth(int ix1, int ix2, int ix3, int level, int levelDe
void Grid3D::getNeighborsTop(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottom(ix1, ix2, ix3+1, level, blocks, levelDepth);
}
@@ -723,12 +725,12 @@ void Grid3D::getNeighborsTop(int ix1, int ix2, int ix3, int level, int levelDept
void Grid3D::getNeighborsBottom(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTop(ix1, ix2, ix3-1, level, blocks, levelDepth);
@@ -737,12 +739,12 @@ void Grid3D::getNeighborsBottom(int ix1, int ix2, int ix3, int level, int levelD
void Grid3D::getNeighborsSouth(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2-1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2-1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksNorth(ix1, ix2-1, ix3, level, blocks, levelDepth);
@@ -750,13 +752,13 @@ void Grid3D::getNeighborsSouth(int ix1, int ix2, int ix3, int level, int levelDe
//////////////////////////////////////////////////////////////////////////
void Grid3D::getNeighborsEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
- SPtr<Block3D> block = this->getBlock(ix1+1, ix2, ix3, level);
- if(block) { blocks.push_back(block); }
+ SPtr<Block3D> block = this->getBlock(ix1+1, ix2, ix3, level);
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksWest(ix1+1, ix2, ix3, level, blocks, levelDepth);
}
@@ -764,13 +766,13 @@ void Grid3D::getNeighborsEast(int ix1, int ix2, int ix3, int level, int levelDep
void Grid3D::getNeighborsWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksEast(ix1-1, ix2, ix3, level, blocks, levelDepth);
}
@@ -780,12 +782,12 @@ void Grid3D::getNeighborsWest(int ix1, int ix2, int ix3, int level, int levelDep
void Grid3D::getNeighborsNorthEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2+1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2+1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksSouthWest(ix1+1, ix2+1, ix3, level, blocks, levelDepth);
}
@@ -793,12 +795,12 @@ void Grid3D::getNeighborsNorthEast(int ix1, int ix2, int ix3, int level, int lev
void Grid3D::getNeighborsNorthWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2+1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2+1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksSouthEast(ix1-1, ix2+1, ix3, level, blocks, levelDepth);
}
@@ -806,12 +808,12 @@ void Grid3D::getNeighborsNorthWest(int ix1, int ix2, int ix3, int level, int lev
void Grid3D::getNeighborsSouthEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2-1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2-1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksNorthWest(ix1+1, ix2-1, ix3, level, blocks, levelDepth);
}
@@ -819,12 +821,12 @@ void Grid3D::getNeighborsSouthEast(int ix1, int ix2, int ix3, int level, int lev
void Grid3D::getNeighborsSouthWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2-1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2-1, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksNorthEast(ix1-1, ix2-1, ix3, level, blocks, levelDepth);
}
@@ -834,12 +836,12 @@ void Grid3D::getNeighborsSouthWest(int ix1, int ix2, int ix3, int level, int lev
void Grid3D::getNeighborsTopEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomWest(ix1+1, ix2, ix3+1, level, blocks, levelDepth);
}
@@ -847,12 +849,12 @@ void Grid3D::getNeighborsTopEast(int ix1, int ix2, int ix3, int level, int level
void Grid3D::getNeighborsTopWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomEast(ix1-1, ix2, ix3+1, level, blocks, levelDepth);
}
@@ -860,12 +862,12 @@ void Grid3D::getNeighborsTopWest(int ix1, int ix2, int ix3, int level, int level
void Grid3D::getNeighborsTopNorth(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2+1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2+1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomSouth(ix1, ix2+1, ix3+1, level, blocks, levelDepth);
}
@@ -873,12 +875,12 @@ void Grid3D::getNeighborsTopNorth(int ix1, int ix2, int ix3, int level, int leve
void Grid3D::getNeighborsTopSouth(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2-1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2-1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomNorth(ix1, ix2-1, ix3+1, level, blocks, levelDepth);
}
@@ -888,12 +890,12 @@ void Grid3D::getNeighborsTopSouth(int ix1, int ix2, int ix3, int level, int leve
void Grid3D::getNeighborsBottomEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopWest(ix1+1, ix2, ix3-1, level, blocks, levelDepth);
}
@@ -901,12 +903,12 @@ void Grid3D::getNeighborsBottomEast(int ix1, int ix2, int ix3, int level, int le
void Grid3D::getNeighborsBottomWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopEast(ix1-1, ix2, ix3-1, level, blocks, levelDepth);
}
@@ -914,12 +916,12 @@ void Grid3D::getNeighborsBottomWest(int ix1, int ix2, int ix3, int level, int le
void Grid3D::getNeighborsBottomNorth(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2+1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2+1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopSouth(ix1, ix2+1, ix3-1, level, blocks, levelDepth);
}
@@ -927,12 +929,12 @@ void Grid3D::getNeighborsBottomNorth(int ix1, int ix2, int ix3, int level, int l
void Grid3D::getNeighborsBottomSouth(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2-1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2-1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopNorth(ix1, ix2-1, ix3-1, level, blocks, levelDepth);
}
@@ -940,12 +942,12 @@ void Grid3D::getNeighborsBottomSouth(int ix1, int ix2, int ix3, int level, int l
void Grid3D::getNeighborsTopNorthEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2+1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2+1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomSouthWest(ix1+1, ix2+1, ix3+1, level, blocks, levelDepth);
}
@@ -953,12 +955,12 @@ void Grid3D::getNeighborsTopNorthEast(int ix1, int ix2, int ix3, int level, int
void Grid3D::getNeighborsTopNorthWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2+1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2+1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomSouthEast(ix1-1, ix2+1, ix3+1, level, blocks, levelDepth);
}
@@ -966,12 +968,12 @@ void Grid3D::getNeighborsTopNorthWest(int ix1, int ix2, int ix3, int level, int
void Grid3D::getNeighborsTopSouthEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2-1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2-1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomNorthWest(ix1+1, ix2-1, ix3+1, level, blocks, levelDepth);
}
@@ -979,12 +981,12 @@ void Grid3D::getNeighborsTopSouthEast(int ix1, int ix2, int ix3, int level, int
void Grid3D::getNeighborsTopSouthWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2-1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2-1, ix3+1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksBottomNorthEast(ix1-1, ix2-1, ix3+1, level, blocks, levelDepth);
}
@@ -992,12 +994,12 @@ void Grid3D::getNeighborsTopSouthWest(int ix1, int ix2, int ix3, int level, int
void Grid3D::getNeighborsBottomNorthEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2+1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2+1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopSouthWest(ix1+1, ix2+1, ix3-1, level, blocks, levelDepth);
}
@@ -1005,12 +1007,12 @@ void Grid3D::getNeighborsBottomNorthEast(int ix1, int ix2, int ix3, int level, i
void Grid3D::getNeighborsBottomNorthWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2+1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2+1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopSouthEast(ix1-1, ix2+1, ix3-1, level, blocks, levelDepth);
}
@@ -1018,12 +1020,12 @@ void Grid3D::getNeighborsBottomNorthWest(int ix1, int ix2, int ix3, int level, i
void Grid3D::getNeighborsBottomSouthEast(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1+1, ix2-1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1+1, ix2-1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopNorthWest(ix1+1, ix2-1, ix3-1, level, blocks, levelDepth);
}
@@ -1031,38 +1033,38 @@ void Grid3D::getNeighborsBottomSouthEast(int ix1, int ix2, int ix3, int level, i
void Grid3D::getNeighborsBottomSouthWest(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1-1, ix2-1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1-1, ix2-1, ix3-1, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
this->getSubBlocksTopNorthEast(ix1-1, ix2-1, ix3-1, level, blocks, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getNeighborBlocksForDirection(int dir, int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
- switch(dir)
+ switch (dir)
{
- case Grid3DSystem::E : this->getNeighborsEast(ix1, ix2, ix3, level,levelDepth, blocks);break;
- case Grid3DSystem::W : this->getNeighborsWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::N : this->getNeighborsNorth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::S : this->getNeighborsSouth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::T : this->getNeighborsTop(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::B : this->getNeighborsBottom(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::NE : this->getNeighborsNorthEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::SW : this->getNeighborsSouthWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::SE : this->getNeighborsSouthEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::NW : this->getNeighborsNorthWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TE : this->getNeighborsTopEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BW : this->getNeighborsBottomWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BE : this->getNeighborsBottomEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TW : this->getNeighborsTopWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TN : this->getNeighborsTopNorth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BS : this->getNeighborsBottomSouth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BN : this->getNeighborsBottomNorth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TS : this->getNeighborsTopSouth(ix1, ix2, ix3, level,levelDepth, blocks); break;
+ case Grid3DSystem::E: this->getNeighborsEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::W: this->getNeighborsWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::N: this->getNeighborsNorth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::S: this->getNeighborsSouth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::T: this->getNeighborsTop(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::B: this->getNeighborsBottom(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::NE: this->getNeighborsNorthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::SW: this->getNeighborsSouthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::SE: this->getNeighborsSouthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::NW: this->getNeighborsNorthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TE: this->getNeighborsTopEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BW: this->getNeighborsBottomWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BE: this->getNeighborsBottomEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TW: this->getNeighborsTopWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TN: this->getNeighborsTopNorth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BS: this->getNeighborsBottomSouth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BN: this->getNeighborsBottomNorth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TS: this->getNeighborsTopSouth(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::TNE: this->getNeighborsTopNorthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::TNW: this->getNeighborsTopNorthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::TSE: this->getNeighborsTopSouthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
@@ -1071,28 +1073,28 @@ void Grid3D::getNeighborBlocksForDirection(int dir, int ix1, int ix2, int ix3, i
case Grid3DSystem::BNW: this->getNeighborsBottomNorthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::BSE: this->getNeighborsBottomSouthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::BSW: this->getNeighborsBottomSouthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
- default:throw UbException(UB_EXARGS,"direction "+UbSystem::toString(dir)+" is not exist");
+ default:throw UbException(UB_EXARGS, "direction "+UbSystem::toString(dir)+" is not exist");
}
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getNeighborsZero(int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
SPtr<Block3D> block = this->getBlock(ix1, ix2, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
- if(level > 0)
+ if (level > 0)
{
block = this->getSuperBlock(ix1, ix2, ix3, level);
- if(block) { blocks.push_back(block); }
+ if (block) { blocks.push_back(block); }
}
// this->getSubBlocksNull(ix1, ix2, ix3, level, blocks, levelDepth);
this->getSubBlocks(ix1, ix2, ix3, level, levelDepth, blocks);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksZero(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksZero(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1E = (ix1 << 1) + 1;
- int x1W = (ix1 << 1) ;
+ int x1W = (ix1 << 1);
int x2S = ix2 << 1;
int x2N = x2S + 1;
int x3B = ix3 << 1;
@@ -1100,60 +1102,60 @@ void Grid3D::getSubBlocksZero(int ix1, int ix2, int ix3, int level,vector<SPtr<B
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1E, x2S, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1E, x2S, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1E, x2S, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2N, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1E, x2N, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1E, x2N, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2S, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1E, x2S, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1E, x2S, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2N, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1E, x2N, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1E, x2N, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2S, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1W, x2S, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1W, x2S, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2N, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1W, x2N, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1W, x2N, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2S, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1W, x2S, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1W, x2S, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2N, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1W, x2N, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1W, x2N, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getNeighborBlocksForDirectionWithDirZero(int dir, int ix1, int ix2, int ix3, int level, int levelDepth, std::vector<SPtr<Block3D>>& blocks)
{
- switch(dir)
+ switch (dir)
{
- case Grid3DSystem::E : this->getNeighborsEast(ix1, ix2, ix3, level,levelDepth, blocks);break;
- case Grid3DSystem::W : this->getNeighborsWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::N : this->getNeighborsNorth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::S : this->getNeighborsSouth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::T : this->getNeighborsTop(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::B : this->getNeighborsBottom(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::NE : this->getNeighborsNorthEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::SW : this->getNeighborsSouthWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::SE : this->getNeighborsSouthEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::NW : this->getNeighborsNorthWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TE : this->getNeighborsTopEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BW : this->getNeighborsBottomWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BE : this->getNeighborsBottomEast(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TW : this->getNeighborsTopWest(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TN : this->getNeighborsTopNorth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BS : this->getNeighborsBottomSouth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::BN : this->getNeighborsBottomNorth(ix1, ix2, ix3, level,levelDepth, blocks); break;
- case Grid3DSystem::TS : this->getNeighborsTopSouth(ix1, ix2, ix3, level,levelDepth, blocks); break;
+ case Grid3DSystem::E: this->getNeighborsEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::W: this->getNeighborsWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::N: this->getNeighborsNorth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::S: this->getNeighborsSouth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::T: this->getNeighborsTop(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::B: this->getNeighborsBottom(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::NE: this->getNeighborsNorthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::SW: this->getNeighborsSouthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::SE: this->getNeighborsSouthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::NW: this->getNeighborsNorthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TE: this->getNeighborsTopEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BW: this->getNeighborsBottomWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BE: this->getNeighborsBottomEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TW: this->getNeighborsTopWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TN: this->getNeighborsTopNorth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BS: this->getNeighborsBottomSouth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::BN: this->getNeighborsBottomNorth(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ case Grid3DSystem::TS: this->getNeighborsTopSouth(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::TNE: this->getNeighborsTopNorthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::TNW: this->getNeighborsTopNorthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::TSE: this->getNeighborsTopSouthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
@@ -1162,12 +1164,12 @@ void Grid3D::getNeighborBlocksForDirectionWithDirZero(int dir, int ix1, int ix2,
case Grid3DSystem::BNW: this->getNeighborsBottomNorthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::BSE: this->getNeighborsBottomSouthEast(ix1, ix2, ix3, level, levelDepth, blocks); break;
case Grid3DSystem::BSW: this->getNeighborsBottomSouthWest(ix1, ix2, ix3, level, levelDepth, blocks); break;
- case Grid3DSystem::ZERO: this->getNeighborsZero(ix1, ix2, ix3, level,levelDepth, blocks);break;
- default:throw UbException(UB_EXARGS,"direction "+UbSystem::toString(dir)+" is not exist");
+ case Grid3DSystem::ZERO: this->getNeighborsZero(ix1, ix2, ix3, level, levelDepth, blocks); break;
+ default:throw UbException(UB_EXARGS, "direction "+UbSystem::toString(dir)+" is not exist");
}
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksEast(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksEast(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1 = (ix1 << 1) + 1;
int x2S = ix2 << 1;
@@ -1177,24 +1179,24 @@ void Grid3D::getSubBlocksEast(int ix1, int ix2, int ix3, int level,vector<SPtr<B
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1, x2S, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1, x2S, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1, x2S, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1, x2N, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1, x2N, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1, x2N, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1, x2S, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1, x2S, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1, x2S, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1, x2N, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksEast(x1, x2N, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksEast(x1, x2N, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksWest(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksWest(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1 = ix1 << 1;
int x2S = ix2 << 1;
@@ -1204,23 +1206,23 @@ void Grid3D::getSubBlocksWest(int ix1, int ix2, int ix3, int level,vector<SPtr<B
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1, x2S, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksWest(x1, x2S, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksWest(x1, x2S, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1, x2N, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksWest(x1, x2N, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksWest(x1, x2N, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1, x2S, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksWest(x1, x2S, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksWest(x1, x2S, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1, x2N, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksWest(x1, x2N, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksWest(x1, x2N, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksNorth(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksNorth(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1W = ix1 << 1;
int x1E = x1W + 1;
@@ -1230,23 +1232,23 @@ void Grid3D::getSubBlocksNorth(int ix1, int ix2, int ix3, int level,vector<SPtr<
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1W, x2, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksNorth(x1W, x2, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksNorth(x1W, x2, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksNorth(x1E, x2, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksNorth(x1E, x2, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksNorth(x1W, x2, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksNorth(x1W, x2, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksNorth(x1E, x2, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksNorth(x1E, x2, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksSouth(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksSouth(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1W = ix1 << 1;
int x1E = x1W + 1;
@@ -1256,23 +1258,23 @@ void Grid3D::getSubBlocksSouth(int ix1, int ix2, int ix3, int level,vector<SPtr<
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1W, x2, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksSouth(x1W, x2, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksSouth(x1W, x2, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2, x3B, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksSouth(x1E, x2, x3B, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksSouth(x1E, x2, x3B, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksSouth(x1W, x2, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksSouth(x1W, x2, x3T, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2, x3T, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksSouth(x1E, x2, x3T, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksSouth(x1E, x2, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksTop(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksTop(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1W = ix1 << 1;
int x1E = x1W + 1;
@@ -1282,23 +1284,23 @@ void Grid3D::getSubBlocksTop(int ix1, int ix2, int ix3, int level,vector<SPtr<Bl
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1W, x2N, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksTop(x1W, x2N, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksTop(x1W, x2N, x3, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2N, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksTop(x1E, x2N, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksTop(x1E, x2N, x3, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2S, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksTop(x1W, x2S, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksTop(x1W, x2S, x3, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2S, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksTop(x1E, x2S, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksTop(x1E, x2S, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getSubBlocksBottom(int ix1, int ix2, int ix3, int level,vector<SPtr<Block3D>> &blockVector, int levelDepth)
+void Grid3D::getSubBlocksBottom(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>> &blockVector, int levelDepth)
{
int x1W = ix1 << 1;
int x1E = x1W + 1;
@@ -1308,20 +1310,20 @@ void Grid3D::getSubBlocksBottom(int ix1, int ix2, int ix3, int level,vector<SPtr
int l = level + 1;
SPtr<Block3D> block = this->getBlock(x1W, x2N, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksBottom(x1W, x2N, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksBottom(x1W, x2N, x3, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2N, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksBottom(x1E, x2N, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksBottom(x1E, x2N, x3, l, blockVector, levelDepth);
block = this->getBlock(x1W, x2S, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksBottom(x1W, x2S, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksBottom(x1W, x2S, x3, l, blockVector, levelDepth);
block = this->getBlock(x1E, x2S, x3, l);
- if(block != NULL) blockVector.push_back(block);
- else if(l < levelDepth) this->getSubBlocksBottom(x1E, x2S, x3, l, blockVector,levelDepth);
+ if (block != NULL) blockVector.push_back(block);
+ else if (l < levelDepth) this->getSubBlocksBottom(x1E, x2S, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
// diagonals
@@ -1335,12 +1337,12 @@ void Grid3D::getSubBlocksNorthEast(int ix1, int ix2, int ix3, int level, vector<
int l = level + 1;
SPtr<Block3D> blockB = this->getBlock(x1, x2, x3B, l);
- if(blockB) blockVector.push_back(blockB);
- else if(l < levelDepth) this->getSubBlocksNorthEast(x1, x2, x3B, l, blockVector, levelDepth);
+ if (blockB) blockVector.push_back(blockB);
+ else if (l < levelDepth) this->getSubBlocksNorthEast(x1, x2, x3B, l, blockVector, levelDepth);
SPtr<Block3D> blockT = this->getBlock(x1, x2, x3T, l);
- if(blockT) blockVector.push_back(blockT);
- else if(l < levelDepth) this->getSubBlocksNorthEast(x1, x2, x3T, l, blockVector, levelDepth);
+ if (blockT) blockVector.push_back(blockT);
+ else if (l < levelDepth) this->getSubBlocksNorthEast(x1, x2, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksNorthWest(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1351,13 +1353,13 @@ void Grid3D::getSubBlocksNorthWest(int ix1, int ix2, int ix3, int level, vector<
int x3T = x3B+1;
int l = level + 1;
- SPtr<Block3D> blockB = this->getBlock(x1, x2,x3B, l);
- if(blockB) blockVector.push_back(blockB);
- else if(l < levelDepth) this->getSubBlocksNorthWest(x1, x2, x3B, l, blockVector, levelDepth);
+ SPtr<Block3D> blockB = this->getBlock(x1, x2, x3B, l);
+ if (blockB) blockVector.push_back(blockB);
+ else if (l < levelDepth) this->getSubBlocksNorthWest(x1, x2, x3B, l, blockVector, levelDepth);
- SPtr<Block3D> blockT = this->getBlock(x1, x2,x3T, l);
- if(blockT) blockVector.push_back(blockT);
- else if(l < levelDepth) this->getSubBlocksNorthWest(x1, x2, x3T, l, blockVector, levelDepth);
+ SPtr<Block3D> blockT = this->getBlock(x1, x2, x3T, l);
+ if (blockT) blockVector.push_back(blockT);
+ else if (l < levelDepth) this->getSubBlocksNorthWest(x1, x2, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksSouthWest(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1368,13 +1370,13 @@ void Grid3D::getSubBlocksSouthWest(int ix1, int ix2, int ix3, int level, vector<
int x3T = x3B+1;
int l = level + 1;
- SPtr<Block3D> blockB = this->getBlock(x1, x2,x3B, l);
- if(blockB) blockVector.push_back(blockB);
- else if(l < levelDepth) this->getSubBlocksSouthWest(x1, x2, x3B, l, blockVector, levelDepth);
+ SPtr<Block3D> blockB = this->getBlock(x1, x2, x3B, l);
+ if (blockB) blockVector.push_back(blockB);
+ else if (l < levelDepth) this->getSubBlocksSouthWest(x1, x2, x3B, l, blockVector, levelDepth);
- SPtr<Block3D> blockT = this->getBlock(x1, x2,x3T, l);
- if(blockT) blockVector.push_back(blockT);
- else if(l < levelDepth) this->getSubBlocksSouthWest(x1, x2, x3T, l, blockVector, levelDepth);
+ SPtr<Block3D> blockT = this->getBlock(x1, x2, x3T, l);
+ if (blockT) blockVector.push_back(blockT);
+ else if (l < levelDepth) this->getSubBlocksSouthWest(x1, x2, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksSouthEast(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1385,13 +1387,13 @@ void Grid3D::getSubBlocksSouthEast(int ix1, int ix2, int ix3, int level, vector<
int x3T = x3B+1;
int l = level + 1;
- SPtr<Block3D> blockB = this->getBlock(x1, x2,x3B, l);
- if(blockB) blockVector.push_back(blockB);
- else if(l < levelDepth) this->getSubBlocksSouthEast(x1, x2, x3B, l, blockVector, levelDepth);
+ SPtr<Block3D> blockB = this->getBlock(x1, x2, x3B, l);
+ if (blockB) blockVector.push_back(blockB);
+ else if (l < levelDepth) this->getSubBlocksSouthEast(x1, x2, x3B, l, blockVector, levelDepth);
- SPtr<Block3D> blockT = this->getBlock(x1, x2,x3T, l);
- if(blockT) blockVector.push_back(blockT);
- else if(l < levelDepth) this->getSubBlocksSouthEast(x1, x2, x3T, l, blockVector, levelDepth);
+ SPtr<Block3D> blockT = this->getBlock(x1, x2, x3T, l);
+ if (blockT) blockVector.push_back(blockT);
+ else if (l < levelDepth) this->getSubBlocksSouthEast(x1, x2, x3T, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
// diagonals
@@ -1405,12 +1407,12 @@ void Grid3D::getSubBlocksTopEast(int ix1, int ix2, int ix3, int level, vector<SP
int l = level + 1;
SPtr<Block3D> blockN = this->getBlock(x1, x2N, x3, l);
- if(blockN) blockVector.push_back(blockN);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
+ if (blockN) blockVector.push_back(blockN);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockS = this->getBlock(x1, x2S, x3, l);
- if(blockS) blockVector.push_back(blockS);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
+ if (blockS) blockVector.push_back(blockS);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksTopWest(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1422,12 +1424,12 @@ void Grid3D::getSubBlocksTopWest(int ix1, int ix2, int ix3, int level, vector<SP
int l = level + 1;
SPtr<Block3D> blockN = this->getBlock(x1, x2N, x3, l);
- if(blockN) blockVector.push_back(blockN);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
+ if (blockN) blockVector.push_back(blockN);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockS = this->getBlock(x1, x2S, x3, l);
- if(blockS) blockVector.push_back(blockS);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
+ if (blockS) blockVector.push_back(blockS);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomEast(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1439,12 +1441,12 @@ void Grid3D::getSubBlocksBottomEast(int ix1, int ix2, int ix3, int level, vector
int l = level + 1;
SPtr<Block3D> blockN = this->getBlock(x1, x2N, x3, l);
- if(blockN) blockVector.push_back(blockN);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
+ if (blockN) blockVector.push_back(blockN);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockS = this->getBlock(x1, x2S, x3, l);
- if(blockS) blockVector.push_back(blockS);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
+ if (blockS) blockVector.push_back(blockS);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomWest(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1456,12 +1458,12 @@ void Grid3D::getSubBlocksBottomWest(int ix1, int ix2, int ix3, int level, vector
int l = level + 1;
SPtr<Block3D> blockN = this->getBlock(x1, x2N, x3, l);
- if(blockN) blockVector.push_back(blockN);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
+ if (blockN) blockVector.push_back(blockN);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2N, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockS = this->getBlock(x1, x2S, x3, l);
- if(blockS) blockVector.push_back(blockS);
- else if(l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
+ if (blockS) blockVector.push_back(blockS);
+ else if (l < levelDepth) this->getSubBlocksTopEast(x1, x2S, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
@@ -1476,12 +1478,12 @@ void Grid3D::getSubBlocksTopNorth(int ix1, int ix2, int ix3, int level, vector<S
int l = level + 1;
SPtr<Block3D> blockE = this->getBlock(x1E, x2, x3, l);
- if(blockE) blockVector.push_back(blockE);
- else if(l < levelDepth) this->getSubBlocksTopNorth(x1E, x2, x3, l, blockVector, levelDepth);
+ if (blockE) blockVector.push_back(blockE);
+ else if (l < levelDepth) this->getSubBlocksTopNorth(x1E, x2, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockW = this->getBlock(x1W, x2, x3, l);
- if(blockW) blockVector.push_back(blockW);
- else if(l < levelDepth) this->getSubBlocksTopNorth(x1W, x2, x3, l, blockVector, levelDepth);
+ if (blockW) blockVector.push_back(blockW);
+ else if (l < levelDepth) this->getSubBlocksTopNorth(x1W, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksTopSouth(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1493,12 +1495,12 @@ void Grid3D::getSubBlocksTopSouth(int ix1, int ix2, int ix3, int level, vector<S
int l = level + 1;
SPtr<Block3D> blockE = this->getBlock(x1E, x2, x3, l);
- if(blockE) blockVector.push_back(blockE);
- else if(l < levelDepth) this->getSubBlocksTopSouth(x1E, x2, x3, l, blockVector, levelDepth);
+ if (blockE) blockVector.push_back(blockE);
+ else if (l < levelDepth) this->getSubBlocksTopSouth(x1E, x2, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockW = this->getBlock(x1W, x2, x3, l);
- if(blockW) blockVector.push_back(blockW);
- else if(l < levelDepth) this->getSubBlocksTopSouth(x1W, x2, x3, l, blockVector, levelDepth);
+ if (blockW) blockVector.push_back(blockW);
+ else if (l < levelDepth) this->getSubBlocksTopSouth(x1W, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomNorth(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1510,12 +1512,12 @@ void Grid3D::getSubBlocksBottomNorth(int ix1, int ix2, int ix3, int level, vecto
int l = level + 1;
SPtr<Block3D> blockE = this->getBlock(x1E, x2, x3, l);
- if(blockE) blockVector.push_back(blockE);
- else if(l < levelDepth) this->getSubBlocksBottomNorth(x1E, x2, x3, l, blockVector, levelDepth);
+ if (blockE) blockVector.push_back(blockE);
+ else if (l < levelDepth) this->getSubBlocksBottomNorth(x1E, x2, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockW = this->getBlock(x1W, x2, x3, l);
- if(blockW) blockVector.push_back(blockW);
- else if(l < levelDepth) this->getSubBlocksBottomNorth(x1W, x2, x3, l, blockVector, levelDepth);
+ if (blockW) blockVector.push_back(blockW);
+ else if (l < levelDepth) this->getSubBlocksBottomNorth(x1W, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomSouth(int ix1, int ix2, int ix3, int level, vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1527,12 +1529,12 @@ void Grid3D::getSubBlocksBottomSouth(int ix1, int ix2, int ix3, int level, vecto
int l = level + 1;
SPtr<Block3D> blockE = this->getBlock(x1E, x2, x3, l);
- if(blockE) blockVector.push_back(blockE);
- else if(l < levelDepth) this->getSubBlocksBottomSouth(x1E, x2, x3, l, blockVector, levelDepth);
+ if (blockE) blockVector.push_back(blockE);
+ else if (l < levelDepth) this->getSubBlocksBottomSouth(x1E, x2, x3, l, blockVector, levelDepth);
SPtr<Block3D> blockW = this->getBlock(x1W, x2, x3, l);
- if(blockW) blockVector.push_back(blockW);
- else if(l < levelDepth) this->getSubBlocksBottomSouth(x1W, x2, x3, l, blockVector, levelDepth);
+ if (blockW) blockVector.push_back(blockW);
+ else if (l < levelDepth) this->getSubBlocksBottomSouth(x1W, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
// space-diagonals
@@ -1545,8 +1547,8 @@ void Grid3D::getSubBlocksTopNorthEast(int ix1, int ix2, int ix3, int level, std:
int l = level + 1;
SPtr<Block3D> blockTNE = this->getBlock(x1, x2, x3, l);
- if(blockTNE) blockVector.push_back(blockTNE);
- else if(l < levelDepth) this->getSubBlocksTopNorthEast(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockTNE) blockVector.push_back(blockTNE);
+ else if (l < levelDepth) this->getSubBlocksTopNorthEast(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksTopNorthWest(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1557,8 +1559,8 @@ void Grid3D::getSubBlocksTopNorthWest(int ix1, int ix2, int ix3, int level, std:
int l = level + 1;
SPtr<Block3D> blockTNW = this->getBlock(x1, x2, x3, l);
- if(blockTNW) blockVector.push_back(blockTNW);
- else if(l < levelDepth) this->getSubBlocksTopNorthWest(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockTNW) blockVector.push_back(blockTNW);
+ else if (l < levelDepth) this->getSubBlocksTopNorthWest(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksTopSouthEast(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1569,8 +1571,8 @@ void Grid3D::getSubBlocksTopSouthEast(int ix1, int ix2, int ix3, int level, std:
int l = level + 1;
SPtr<Block3D> blockTNW = this->getBlock(x1, x2, x3, l);
- if(blockTNW) blockVector.push_back(blockTNW);
- else if(l < levelDepth) this->getSubBlocksTopSouthEast(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockTNW) blockVector.push_back(blockTNW);
+ else if (l < levelDepth) this->getSubBlocksTopSouthEast(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksTopSouthWest(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1581,8 +1583,8 @@ void Grid3D::getSubBlocksTopSouthWest(int ix1, int ix2, int ix3, int level, std:
int l = level + 1;
SPtr<Block3D> blockTSW = this->getBlock(x1, x2, x3, l);
- if(blockTSW) blockVector.push_back(blockTSW);
- else if(l < levelDepth) this->getSubBlocksTopSouthWest(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockTSW) blockVector.push_back(blockTSW);
+ else if (l < levelDepth) this->getSubBlocksTopSouthWest(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomNorthEast(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1593,8 +1595,8 @@ void Grid3D::getSubBlocksBottomNorthEast(int ix1, int ix2, int ix3, int level, s
int l = level + 1;
SPtr<Block3D> blockBNE = this->getBlock(x1, x2, x3, l);
- if(blockBNE) blockVector.push_back(blockBNE);
- else if(l < levelDepth) this->getSubBlocksBottomNorthEast(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockBNE) blockVector.push_back(blockBNE);
+ else if (l < levelDepth) this->getSubBlocksBottomNorthEast(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomNorthWest(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1605,8 +1607,8 @@ void Grid3D::getSubBlocksBottomNorthWest(int ix1, int ix2, int ix3, int level, s
int l = level + 1;
SPtr<Block3D> blockBNW = this->getBlock(x1, x2, x3, l);
- if(blockBNW) blockVector.push_back(blockBNW);
- else if(l < levelDepth) this->getSubBlocksBottomNorthWest(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockBNW) blockVector.push_back(blockBNW);
+ else if (l < levelDepth) this->getSubBlocksBottomNorthWest(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomSouthEast(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1617,8 +1619,8 @@ void Grid3D::getSubBlocksBottomSouthEast(int ix1, int ix2, int ix3, int level, s
int l = level + 1;
SPtr<Block3D> blockBSE = this->getBlock(x1, x2, x3, l);
- if(blockBSE) blockVector.push_back(blockBSE);
- else if(l < levelDepth) this->getSubBlocksBottomSouthEast(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockBSE) blockVector.push_back(blockBSE);
+ else if (l < levelDepth) this->getSubBlocksBottomSouthEast(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getSubBlocksBottomSouthWest(int ix1, int ix2, int ix3, int level, std::vector<SPtr<Block3D>>& blockVector, int levelDepth)
@@ -1629,13 +1631,13 @@ void Grid3D::getSubBlocksBottomSouthWest(int ix1, int ix2, int ix3, int level, s
int l = level + 1;
SPtr<Block3D> blockBSW = this->getBlock(x1, x2, x3, l);
- if(blockBSW) blockVector.push_back(blockBSW);
- else if(l < levelDepth) this->getSubBlocksBottomSouthWest(x1, x2, x3, l, blockVector, levelDepth);
+ if (blockBSW) blockVector.push_back(blockBSW);
+ else if (l < levelDepth) this->getSubBlocksBottomSouthWest(x1, x2, x3, l, blockVector, levelDepth);
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::getBlocks(int level, std::vector<SPtr<Block3D>>& blockVector)
{
- for(Block3DMap::value_type b : levelSet[level])
+ for (Block3DMap::value_type b : levelSet[level])
{
blockVector.push_back(b.second);
}
@@ -1643,7 +1645,7 @@ void Grid3D::getBlocks(int level, std::vector<SPtr<Block3D>>& blockVector)
//////////////////////////////////////////////////////////////////////////
void Grid3D::getBlocks(int level, int rank, std::vector<SPtr<Block3D>>& blockVector)
{
- for(Block3DMap::value_type b : levelSet[level])
+ for (Block3DMap::value_type b : levelSet[level])
{
SPtr<Block3D> block = b.second;
int blockRank = block->getRank();
@@ -1656,7 +1658,7 @@ void Grid3D::getBlocks(int level, int rank, std::vector<SPtr<Block3D>>& blockVec
//////////////////////////////////////////////////////////////////////////
void Grid3D::getBlocks(int level, int rank, bool active, std::vector<SPtr<Block3D>>& blockVector)
{
- for(Block3DMap::value_type b : levelSet[level])
+ for (Block3DMap::value_type b : levelSet[level])
{
SPtr<Block3D> block = b.second;
int blockRank = block->getRank();
@@ -1670,59 +1672,59 @@ void Grid3D::getBlocks(int level, int rank, bool active, std::vector<SPtr<Block3
//////////////////////////////////////////////////////////////////////////
int Grid3D::getFinestInitializedLevel()
{
- for(int i=Grid3DSystem::MAXLEVEL; i>=0; i--) if(this->levelSet[i].size() > 0) return(i);
+ for (int i=Grid3DSystem::MAXLEVEL; i>=0; i--) if (this->levelSet[i].size() > 0) return(i);
return(-1);
}
//////////////////////////////////////////////////////////////////////////
int Grid3D::getCoarsestInitializedLevel()
{
- for(int i=0; i<=Grid3DSystem::MAXLEVEL; i++) if(this->levelSet[i].size() > 0) return(i);
+ for (int i=0; i<=Grid3DSystem::MAXLEVEL; i++) if (this->levelSet[i].size() > 0) return(i);
return(-1);
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::setNX1(int nx1)
-{
- this->nx1 = nx1;
+void Grid3D::setNX1(int nx1)
+{
+ this->nx1 = nx1;
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::setNX2(int nx2)
-{
- this->nx2 = nx2;
+void Grid3D::setNX2(int nx2)
+{
+ this->nx2 = nx2;
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::setNX3(int nx3)
-{
- this->nx3 = nx3;
+void Grid3D::setNX3(int nx3)
+{
+ this->nx3 = nx3;
}
//////////////////////////////////////////////////////////////////////////
-int Grid3D::getNX1() const
-{
- return this->nx1;
+int Grid3D::getNX1() const
+{
+ return this->nx1;
}
//////////////////////////////////////////////////////////////////////////
-int Grid3D::getNX2() const
-{
- return this->nx2;
+int Grid3D::getNX2() const
+{
+ return this->nx2;
}
//////////////////////////////////////////////////////////////////////////
-int Grid3D::getNX3() const
+int Grid3D::getNX3() const
{
return this->nx3;
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::deleteBlocks( const std::vector<int>& ids )
+void Grid3D::deleteBlocks(const std::vector<int>& ids)
{
- for(int i : ids)
+ for (int i : ids)
{
SPtr<Block3D> block = getBlock(i);
- if(block) this->deleteBlock(block);
+ if (block) this->deleteBlock(block);
}
}
//////////////////////////////////////////////////////////////////////////
int Grid3D::getNumberOfBlocks()
{
int c = 0;
- for(Block3DMap l : levelSet)
+ for (Block3DMap l : levelSet)
{
c += (int)l.size();
}
@@ -1734,7 +1736,7 @@ int Grid3D::getNumberOfBlocks(int level)
return (int)levelSet[level].size();
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getBlocksByCuboid( double minX1, double minX2, double minX3, double maxX1, double maxX2, double maxX3, std::vector<SPtr<Block3D>>& blocks )
+void Grid3D::getBlocksByCuboid(double minX1, double minX2, double minX3, double maxX1, double maxX2, double maxX3, std::vector<SPtr<Block3D>>& blocks)
{
int coarsestLevel = this->getCoarsestInitializedLevel();
int finestLevel = this->getFinestInitializedLevel();
@@ -1743,81 +1745,81 @@ void Grid3D::getBlocksByCuboid( double minX1, double minX2, double minX3, double
//MINIMALE BLOCK-INDIZES BESTIMMEN
//
//min:
- double dMinX1 = trafo->transformForwardToX1Coordinate( minX1,minX2,minX3 )*(1<<finestLevel);
- double dMinX2 = trafo->transformForwardToX2Coordinate( minX1,minX2,minX3 )*(1<<finestLevel);
- double dMinX3 = trafo->transformForwardToX3Coordinate( minX1,minX2,minX3 )*(1<<finestLevel);
+ double dMinX1 = trafo->transformForwardToX1Coordinate(minX1, minX2, minX3)*(1<<finestLevel);
+ double dMinX2 = trafo->transformForwardToX2Coordinate(minX1, minX2, minX3)*(1<<finestLevel);
+ double dMinX3 = trafo->transformForwardToX3Coordinate(minX1, minX2, minX3)*(1<<finestLevel);
//Achtung, wenn minX1 genau auf grenze zwischen zwei bloecken -> der "kleinere" muss genommen werden,
//da beim Transformieren der "groessere" Index rauskommt
- int iMinX1 = (int)dMinX1; if( UbMath::zero(dMinX1-iMinX1) ) iMinX1-=1;
- int iMinX2 = (int)dMinX2; if( UbMath::zero(dMinX2-iMinX2) ) iMinX2-=1;
- int iMinX3 = (int)dMinX3; if( UbMath::zero(dMinX3-iMinX3) ) iMinX3-=1;
+ int iMinX1 = (int)dMinX1; if (UbMath::zero(dMinX1-iMinX1)) iMinX1-=1;
+ int iMinX2 = (int)dMinX2; if (UbMath::zero(dMinX2-iMinX2)) iMinX2-=1;
+ int iMinX3 = (int)dMinX3; if (UbMath::zero(dMinX3-iMinX3)) iMinX3-=1;
//max (hier kann die Zusatzabfrage vernachlaessigt werden):
- int iMaxX1 = (int)(trafo->transformForwardToX1Coordinate( maxX1,maxX2,maxX3 )*(1<<finestLevel));
- int iMaxX2 = (int)(trafo->transformForwardToX2Coordinate( maxX1,maxX2,maxX3 )*(1<<finestLevel));
- int iMaxX3 = (int)(trafo->transformForwardToX3Coordinate( maxX1,maxX2,maxX3 )*(1<<finestLevel));
+ int iMaxX1 = (int)(trafo->transformForwardToX1Coordinate(maxX1, maxX2, maxX3)*(1<<finestLevel));
+ int iMaxX2 = (int)(trafo->transformForwardToX2Coordinate(maxX1, maxX2, maxX3)*(1<<finestLevel));
+ int iMaxX3 = (int)(trafo->transformForwardToX3Coordinate(maxX1, maxX2, maxX3)*(1<<finestLevel));
SPtr<Block3D> block;
//set, um doppelte bloecke zu vermeiden, die u.U. bei periodic auftreten koennen
- std::set<SPtr<Block3D>> blockset;
- for(int level=coarsestLevel; level<=finestLevel; level++)
+ std::set<SPtr<Block3D>> blockset;
+ for (int level=coarsestLevel; level<=finestLevel; level++)
{
//damit bei negativen werten auch der "kleinere" genommen wird -> floor!
- int minx1 = (int)std::floor( (double)iMinX1/(1<<(finestLevel-level)) );
- int minx2 = (int)std::floor( (double)iMinX2/(1<<(finestLevel-level)) );
- int minx3 = (int)std::floor( (double)iMinX3/(1<<(finestLevel-level)) );
+ int minx1 = (int)std::floor((double)iMinX1/(1<<(finestLevel-level)));
+ int minx2 = (int)std::floor((double)iMinX2/(1<<(finestLevel-level)));
+ int minx3 = (int)std::floor((double)iMinX3/(1<<(finestLevel-level)));
int maxx1 = iMaxX1/(1<<(finestLevel-level));
int maxx2 = iMaxX2/(1<<(finestLevel-level));
int maxx3 = iMaxX3/(1<<(finestLevel-level));
- for(int ix1=minx1; ix1<=maxx1; ix1++)
- for(int ix2=minx2; ix2<=maxx2; ix2++)
- for(int ix3=minx3; ix3<=maxx3; ix3++)
- if( (block=this->getBlock(ix1,ix2,ix3,level)) )
- {
- if (block->getRank() == rank)
+ for (int ix1=minx1; ix1<=maxx1; ix1++)
+ for (int ix2=minx2; ix2<=maxx2; ix2++)
+ for (int ix3=minx3; ix3<=maxx3; ix3++)
+ if ((block=this->getBlock(ix1, ix2, ix3, level)))
{
- blockset.insert(block);
+ if (block->getRank() == rank)
+ {
+ blockset.insert(block);
+ }
}
- }
}
blocks.resize(blockset.size());
std::copy(blockset.begin(), blockset.end(), blocks.begin());
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::getBlocksByCuboid( int level, double minX1, double minX2, double minX3, double maxX1, double maxX2, double maxX3, std::vector<SPtr<Block3D>>& blocks )
+void Grid3D::getBlocksByCuboid(int level, double minX1, double minX2, double minX3, double maxX1, double maxX2, double maxX3, std::vector<SPtr<Block3D>>& blocks)
{
//////////////////////////////////////////////////////////////////////////
//MINIMALE BLOCK-INDIZES BESTIMMEN
//
//min:
- double dMinX1 = trafo->transformForwardToX1Coordinate( minX1,minX2,minX3 )*(1<<level);
- double dMinX2 = trafo->transformForwardToX2Coordinate( minX1,minX2,minX3 )*(1<<level);
- double dMinX3 = trafo->transformForwardToX3Coordinate( minX1,minX2,minX3 )*(1<<level);
+ double dMinX1 = trafo->transformForwardToX1Coordinate(minX1, minX2, minX3)*(1<<level);
+ double dMinX2 = trafo->transformForwardToX2Coordinate(minX1, minX2, minX3)*(1<<level);
+ double dMinX3 = trafo->transformForwardToX3Coordinate(minX1, minX2, minX3)*(1<<level);
//Achtung, wenn minX1 genau auf grenze zwischen zwei bloecken -> der "kleinere" muss genommen werden:
- int iMinX1 = (int)dMinX1; if( UbMath::zero(dMinX1-iMinX1) ) iMinX1-=1;
- int iMinX2 = (int)dMinX2; if( UbMath::zero(dMinX2-iMinX2) ) iMinX2-=1;
- int iMinX3 = (int)dMinX3; if( UbMath::zero(dMinX3-iMinX3) ) iMinX3-=1;
+ int iMinX1 = (int)dMinX1; if (UbMath::zero(dMinX1-iMinX1)) iMinX1-=1;
+ int iMinX2 = (int)dMinX2; if (UbMath::zero(dMinX2-iMinX2)) iMinX2-=1;
+ int iMinX3 = (int)dMinX3; if (UbMath::zero(dMinX3-iMinX3)) iMinX3-=1;
//max:
- int iMaxX1 = (int)(trafo->transformForwardToX1Coordinate( maxX1,maxX2,maxX3 )*(1<<level));
- int iMaxX2 = (int)(trafo->transformForwardToX2Coordinate( maxX1,maxX2,maxX3 )*(1<<level));
- int iMaxX3 = (int)(trafo->transformForwardToX3Coordinate( maxX1,maxX2,maxX3 )*(1<<level));
+ int iMaxX1 = (int)(trafo->transformForwardToX1Coordinate(maxX1, maxX2, maxX3)*(1<<level));
+ int iMaxX2 = (int)(trafo->transformForwardToX2Coordinate(maxX1, maxX2, maxX3)*(1<<level));
+ int iMaxX3 = (int)(trafo->transformForwardToX3Coordinate(maxX1, maxX2, maxX3)*(1<<level));
//set, um doppelte bloecke zu vermeiden, die u.U. bei periodic auftreten koennen
- std::set<SPtr<Block3D>> blockset;
+ std::set<SPtr<Block3D>> blockset;
SPtr<Block3D> block;
- for(int ix1=iMinX1; ix1<=iMaxX1; ix1++)
- for(int ix2=iMinX2; ix2<=iMaxX2; ix2++)
- for(int ix3=iMinX3; ix3<=iMaxX3; ix3++)
- if( (block=this->getBlock(ix1,ix2,ix3,level)) )
+ for (int ix1=iMinX1; ix1<=iMaxX1; ix1++)
+ for (int ix2=iMinX2; ix2<=iMaxX2; ix2++)
+ for (int ix3=iMinX3; ix3<=iMaxX3; ix3++)
+ if ((block=this->getBlock(ix1, ix2, ix3, level)))
{
if (block->getRank() == rank)
{
@@ -1837,7 +1839,7 @@ void Grid3D::calcStartCoordinatesAndDelta(SPtr<Block3D> block, double& worldX1,
worldX3 = block->getX3()/(float)(1<<blocklevel);
deltaX = (double)1.0/(double)(this->blockNx1*(double)(1<<blocklevel));
- if(this->trafo)
+ if (this->trafo)
{
double x1tmp = worldX1, x2tmp = worldX2, x3tmp = worldX3;
worldX1 = this->trafo->transformBackwardToX1Coordinate(x1tmp, x2tmp, x3tmp);
@@ -1854,7 +1856,7 @@ void Grid3D::calcStartCoordinatesWithOutOverlap(SPtr<Block3D> block, double& wor
worldX2 = block->getX2()/(float)(1<<blocklevel);
worldX3 = block->getX3()/(float)(1<<blocklevel);
- if(this->trafo)
+ if (this->trafo)
{
double x1tmp = worldX1, x2tmp = worldX2, x3tmp = worldX3;
worldX1 = this->trafo->transformBackwardToX1Coordinate(x1tmp, x2tmp, x3tmp);
@@ -1863,7 +1865,7 @@ void Grid3D::calcStartCoordinatesWithOutOverlap(SPtr<Block3D> block, double& wor
}
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::setTimeStep( double step )
+void Grid3D::setTimeStep(double step)
{
timeStep = step;
}
@@ -1873,15 +1875,15 @@ double Grid3D::getTimeStep() const
return timeStep;
}
//////////////////////////////////////////////////////////////////////////
-void Grid3D::fillExtentWithBlocks( UbTupleInt3 minInd, UbTupleInt3 maxInd )
+void Grid3D::fillExtentWithBlocks(UbTupleInt3 minInd, UbTupleInt3 maxInd)
{
- for(int x3 = val<3>(minInd); x3 < val<3>(maxInd); x3++)
+ for (int x3 = val<3>(minInd); x3 < val<3>(maxInd); x3++)
{
- for(int x2 = val<2>(minInd); x2 < val<2>(maxInd); x2++)
+ for (int x2 = val<2>(minInd); x2 < val<2>(maxInd); x2++)
{
- for(int x1 = val<1>(minInd); x1 < val<1>(maxInd); x1++)
+ for (int x1 = val<1>(minInd); x1 < val<1>(maxInd); x1++)
{
- SPtr<Block3D> block( new Block3D(x1,x2,x3,0) );
+ SPtr<Block3D> block(new Block3D(x1, x2, x3, 0));
this->addBlock(block);
}
}
@@ -1933,33 +1935,33 @@ void Grid3D::deleteBlockIDs()
//////////////////////////////////////////////////////////////////////////
void Grid3D::renumberBlockIDs()
{
- deleteBlockIDs();
+ deleteBlockIDs();
- int startLevel = getCoarsestInitializedLevel();
- int stopLevel = getFinestInitializedLevel();
- int counter = 0;
+ int startLevel = getCoarsestInitializedLevel();
+ int stopLevel = getFinestInitializedLevel();
+ int counter = 0;
- for (int l = startLevel; l <= stopLevel; l++)
- {
- std::vector<SPtr<Block3D>> blockVector;
- getBlocks(l, blockVector);
- for(SPtr<Block3D> block : blockVector)
- {
- block->setGlobalID(counter);
- blockIdMap.insert(std::make_pair(counter, block));
- Block3D::setMaxGlobalID(counter);
- counter++;
- }
- }
+ for (int l = startLevel; l <= stopLevel; l++)
+ {
+ std::vector<SPtr<Block3D>> blockVector;
+ getBlocks(l, blockVector);
+ for (SPtr<Block3D> block : blockVector)
+ {
+ block->setGlobalID(counter);
+ blockIdMap.insert(std::make_pair(counter, block));
+ Block3D::setMaxGlobalID(counter);
+ counter++;
+ }
+ }
}
//////////////////////////////////////////////////////////////////////////
void Grid3D::updateDistributedBlocks(SPtr<Communicator> comm)
{
-
+
std::vector<int> blocks;
-
+
if (comm->isRoot())
{
int startLevel = getCoarsestInitializedLevel();
@@ -1969,7 +1971,7 @@ void Grid3D::updateDistributedBlocks(SPtr<Communicator> comm)
{
std::vector<SPtr<Block3D>> blockVector;
getBlocks(l, blockVector);
- for(SPtr<Block3D> block : blockVector)
+ for (SPtr<Block3D> block : blockVector)
{
blocks.push_back(block->getX1());
blocks.push_back(block->getX2());
@@ -1979,7 +1981,7 @@ void Grid3D::updateDistributedBlocks(SPtr<Communicator> comm)
}
}
}
-
+
comm->broadcast(blocks);
if (!comm->isRoot())
diff --git a/source/VirtualFluidsCore/Grid/OMPCalculator.cpp b/source/VirtualFluidsCore/Grid/OMPCalculator.cpp
index 1f3aeb359..aee44aa60 100644
--- a/source/VirtualFluidsCore/Grid/OMPCalculator.cpp
+++ b/source/VirtualFluidsCore/Grid/OMPCalculator.cpp
@@ -12,8 +12,10 @@
#include <UbException.h>
#ifdef _OPENMP
-#include <omp.h>
+ #include <omp.h>
#endif
+#define OMP_SCHEDULE dynamic
+
//#define TIMING
#include "Block3DConnector.h"
@@ -157,7 +159,7 @@ void OMPCalculator::calculateBlocks(int startLevel, int maxInitLevel, int calcSt
//call LBM kernel
int size = (int)blocks[level].size();
#ifdef _OPENMP
-#pragma omp for schedule(dynamic)
+#pragma omp for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
@@ -204,7 +206,7 @@ void OMPCalculator::swapDistributions(int startLevel, int maxInitLevel)
{
int size = (int)blocks[level].size();
#ifdef _OPENMP
-#pragma omp for schedule(dynamic)
+#pragma omp for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
@@ -218,7 +220,7 @@ void OMPCalculator::connectorsPrepareLocal(std::vector< SPtr<Block3DConnector> >
{
int size = (int)connectors.size();
#ifdef _OPENMP
-#pragma omp parallel for schedule(dynamic)
+#pragma omp parallel for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
@@ -231,7 +233,7 @@ void OMPCalculator::connectorsSendLocal(std::vector< SPtr<Block3DConnector> >& c
{
int size = (int)connectors.size();
#ifdef _OPENMP
-#pragma omp parallel for schedule(dynamic)
+#pragma omp parallel for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
@@ -244,7 +246,7 @@ void OMPCalculator::connectorsReceiveLocal(std::vector< SPtr<Block3DConnector> >
{
int size = (int)connectors.size();
#ifdef _OPENMP
-#pragma omp parallel for schedule(dynamic)
+#pragma omp parallel for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
@@ -310,7 +312,7 @@ void OMPCalculator::applyPreCollisionBC(int startLevel, int maxInitLevel)
{
int size = (int)blocks[level].size();
#ifdef _OPENMP
-#pragma omp parallel for
+#pragma omp parallel for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
@@ -326,7 +328,7 @@ void OMPCalculator::applyPostCollisionBC(int startLevel, int maxInitLevel)
{
int size = (int)blocks[level].size();
#ifdef _OPENMP
-#pragma omp parallel for
+#pragma omp parallel for schedule(OMP_SCHEDULE)
#endif
for (int i =0; i<size; i++)
{
diff --git a/source/VirtualFluidsCore/LBM/CompressibleCumulantLBMKernel.cpp b/source/VirtualFluidsCore/LBM/CompressibleCumulantLBMKernel.cpp
index 605a1bce7..13ee2e1d8 100644
--- a/source/VirtualFluidsCore/LBM/CompressibleCumulantLBMKernel.cpp
+++ b/source/VirtualFluidsCore/LBM/CompressibleCumulantLBMKernel.cpp
@@ -665,29 +665,29 @@ void CompressibleCumulantLBMKernel::collideAll()
//relax
//////////////////////////////////////////////////////////////////////////
//das ist der limiter
- wadjust = Oxyz+(one-Oxyz)*abs(mfbbb)/(abs(mfbbb)+qudricLimitD);
- mfbbb += wadjust * (-mfbbb);
- wadjust = OxyyPxzz+(one-OxyyPxzz)*abs(mxxyPyzz)/(abs(mxxyPyzz)+qudricLimitP);
- mxxyPyzz += wadjust * (-mxxyPyzz);
- wadjust = OxyyMxzz+(one-OxyyMxzz)*abs(mxxyMyzz)/(abs(mxxyMyzz)+qudricLimitM);
- mxxyMyzz += wadjust * (-mxxyMyzz);
- wadjust = OxyyPxzz+(one-OxyyPxzz)*abs(mxxzPyyz)/(abs(mxxzPyyz)+qudricLimitP);
- mxxzPyyz += wadjust * (-mxxzPyyz);
- wadjust = OxyyMxzz+(one-OxyyMxzz)*abs(mxxzMyyz)/(abs(mxxzMyyz)+qudricLimitM);
- mxxzMyyz += wadjust * (-mxxzMyyz);
- wadjust = OxyyPxzz+(one-OxyyPxzz)*abs(mxyyPxzz)/(abs(mxyyPxzz)+qudricLimitP);
- mxyyPxzz += wadjust * (-mxyyPxzz);
- wadjust = OxyyMxzz+(one-OxyyMxzz)*abs(mxyyMxzz)/(abs(mxyyMxzz)+qudricLimitM);
- mxyyMxzz += wadjust * (-mxyyMxzz);
+ //wadjust = Oxyz+(one-Oxyz)*abs(mfbbb)/(abs(mfbbb)+qudricLimitD);
+ //mfbbb += wadjust * (-mfbbb);
+ //wadjust = OxyyPxzz+(one-OxyyPxzz)*abs(mxxyPyzz)/(abs(mxxyPyzz)+qudricLimitP);
+ //mxxyPyzz += wadjust * (-mxxyPyzz);
+ //wadjust = OxyyMxzz+(one-OxyyMxzz)*abs(mxxyMyzz)/(abs(mxxyMyzz)+qudricLimitM);
+ //mxxyMyzz += wadjust * (-mxxyMyzz);
+ //wadjust = OxyyPxzz+(one-OxyyPxzz)*abs(mxxzPyyz)/(abs(mxxzPyyz)+qudricLimitP);
+ //mxxzPyyz += wadjust * (-mxxzPyyz);
+ //wadjust = OxyyMxzz+(one-OxyyMxzz)*abs(mxxzMyyz)/(abs(mxxzMyyz)+qudricLimitM);
+ //mxxzMyyz += wadjust * (-mxxzMyyz);
+ //wadjust = OxyyPxzz+(one-OxyyPxzz)*abs(mxyyPxzz)/(abs(mxyyPxzz)+qudricLimitP);
+ //mxyyPxzz += wadjust * (-mxyyPxzz);
+ //wadjust = OxyyMxzz+(one-OxyyMxzz)*abs(mxyyMxzz)/(abs(mxyyMxzz)+qudricLimitM);
+ //mxyyMxzz += wadjust * (-mxyyMxzz);
//////////////////////////////////////////////////////////////////////////
//ohne limiter
- //mfbbb += OxyyMxzz * (-mfbbb);
- //mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
- //mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
- //mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
- //mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
- //mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
- //mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
+ mfbbb += OxyyMxzz * (-mfbbb);
+ mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
+ mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
+ mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
+ mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
+ mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
+ mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
//////////////////////////////////////////////////////////////////////////
//// linear combinations back
diff --git a/source/VirtualFluidsCore/PointerDefinitions.h b/source/VirtualFluidsCore/PointerDefinitions.h
index f90359647..8ecd34ae1 100644
--- a/source/VirtualFluidsCore/PointerDefinitions.h
+++ b/source/VirtualFluidsCore/PointerDefinitions.h
@@ -5,54 +5,49 @@
#ifndef SHARED_POINTER_H
#define SHARED_POINTER_H
-//#define useStdSmartPointer
+#define useStdSmartPointer
+
+#ifdef useStdSmartPointer
+ #include <memory>
+ #define smartPointerNamespace std
+#endif
+
+
+template <class T>
+using SPtr = smartPointerNamespace::shared_ptr<T>;
+
+template <class T>
+using WPtr = smartPointerNamespace::weak_ptr<T>;
+
+//template <class T>
+//using UPtr = smartPointerNamespace::unique_ptr<T>;
+
+template <class T>
+using enableSharedFromThis = smartPointerNamespace::enable_shared_from_this<T>;
+
+#define dynamicPointerCast smartPointerNamespace::dynamic_pointer_cast
+
+template <class T>
+using RPtr = T*;
+
+#endif
-//#ifdef useStdSmartPointer
//#ifndef VF_BOOST
-// #include <memory>
-// #define smartPointerNamespace std
+// #include <memory>
+// #define smartPointerNamespace std
//#else
-// #include <boost/enable_shared_from_this.hpp>
-// #include <boost/pointer_cast.hpp>
-// #include <boost/shared_ptr.hpp>
-// #define smartPointerNamespace boost
+// #include <boost/enable_shared_from_this.hpp>
+// #include <boost/pointer_cast.hpp>
+// #include <boost/shared_ptr.hpp>
+// #define smartPointerNamespace boost
//#endif
//
+//#define SPtr smartPointerNamespace::shared_ptr
//
-//template <class T>
-//using SPtr = smartPointerNamespace::shared_ptr<T>;
-//
-//template <class T>
-//using WPtr = smartPointerNamespace::weak_ptr<T>;
-//
-////template <class T>
-////using UPtr = smartPointerNamespace::unique_ptr<T>;
+//#define WPtr smartPointerNamespace::weak_ptr
//
-//template <class T>
-//using enableSharedFromThis = smartPointerNamespace::enable_shared_from_this<T>;
+//#define enableSharedFromThis smartPointerNamespace::enable_shared_from_this
//
//#define dynamicPointerCast smartPointerNamespace::dynamic_pointer_cast
-//
-//template <class T>
-//using RPtr = T*;
-//
-//#endif
-#ifndef VF_BOOST
- #include <memory>
- #define smartPointerNamespace std
-#else
- #include <boost/enable_shared_from_this.hpp>
- #include <boost/pointer_cast.hpp>
- #include <boost/shared_ptr.hpp>
- #define smartPointerNamespace boost
-#endif
-
-#define SPtr smartPointerNamespace::shared_ptr
-
-#define WPtr smartPointerNamespace::weak_ptr
-
-#define enableSharedFromThis smartPointerNamespace::enable_shared_from_this
-
-#define dynamicPointerCast smartPointerNamespace::dynamic_pointer_cast
-#endif
\ No newline at end of file
+//#endif
\ No newline at end of file
--
GitLab