diff --git a/source/Applications/DLR-F16-Solid/f16-solid.cfg b/source/Applications/DLR-F16-Solid/f16-solid.cfg
index 399f2cb2f30f59fcefac3159f8a0a38b1c8a96fe..87fdc6f55b90e34cb81e700beae0a0e9565c5558 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 63a981863ce2a7bb8f1f8de1029ac07d77e56f8b..f7d8633fb4f420e4f3c51d4e8f6cbcb58dc99e40 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 89d09ed58ae4905a6e01b63b4af4f86c2efc6dc1..fd26b601e0a5873c28667136af2314abeff49319 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 1f3aeb359313c28c1d76e7d07b5ea961777d3daa..aee44aa60f0d47716f9b8b824e67d6c55352d549 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 605a1bce7a5511cf7ba49d515d1494f06211f8b6..13ee2e1d8d12ff600d522934f8b5609b26718ce7 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 f90359647037ce96a49c9d164bdddfae30d7a064..8ecd34ae1c8749d28b75560cc6b9af1ed262f6b1 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