Fixed issue with boudary condition for thin wall

source/Applications.cmake

@@ -2,7 +2,7 @@
 #add_subdirectory(Applications/gridRf)
 #add_subdirectory(Applications/greenvortex)
 # add_subdirectory(Applications/micropart)
-# add_subdirectory(Applications/sphere)
+add_subdirectory(Applications/sphere)
 #add_subdirectory(Applications/vfscript)
 #add_subdirectory(Applications/reefer)
 #add_subdirectory(Applications/bananas)

source/Applications/LaminarTubeFlow/ltf.cpp

@@ -124,7 +124,9 @@ void run(string configname)
 
          //set connectors
          D3Q27InterpolationProcessorPtr iProcessor(new D3Q27IncompressibleOffsetInterpolationProcessor());
-         D3Q27SetConnectorsBlockVisitor setConnsVisitor(comm, true, D3Q27System::ENDDIR, nuLB, iProcessor);
+         //D3Q27SetConnectorsBlockVisitor setConnsVisitor(comm, true, D3Q27System::ENDDIR, nuLB, iProcessor);
+         ConnectorFactoryPtr factory(new Block3DConnectorFactory());
+         ConnectorBlockVisitor setConnsVisitor(comm, nuLB, iProcessor,factory);
          grid->accept(setConnsVisitor);
 
          //domain decomposition for threads
@@ -164,11 +166,13 @@ void run(string configname)
          kernel = LBMKernel3DPtr(new LBMKernelETD3Q27CCLB(blocknx[0], blocknx[1], blocknx[2], LBMKernelETD3Q27CCLB::NORMAL));
 
          //
-         BCProcessorPtr bcProc(new D3Q27ETBCProcessor());
+         //BCProcessorPtr bcProc(new D3Q27ETBCProcessor());
+         BCProcessorPtr bcProc(new D3Q27ETForThinWallBCProcessor());
          BoundaryConditionPtr noSlipBC;
          BoundaryConditionPtr velBC;
          BoundaryConditionPtr denBC;
-         noSlipBC = BoundaryConditionPtr(new NoSlipBoundaryCondition());
+         //noSlipBC = BoundaryConditionPtr(new NoSlipBoundaryCondition());
+         noSlipBC = BoundaryConditionPtr(new ThinWallNoSlipBoundaryCondition());
          velBC = BoundaryConditionPtr(new VelocityBoundaryCondition());
          denBC = BoundaryConditionPtr(new NonEqDensityBoundaryCondition());
          bcProc->addBC(noSlipBC);

source/Applications/pChannel/configBombadilpChannel.cfg

@@ -4,7 +4,7 @@
 
 pathname = d:/temp/pChannel
 pathGeo = d:/Projects/SFB880/GeometrienPoroeseMedien/PA80-110
-numOfThreads = 1
+numOfThreads = 4
 availMem = 4e9
 logToFile = false
 
@@ -91,6 +91,6 @@ timeAvStart = 1
 timeAvStop = 3
 
 endTime = 200000
-outTime = 1000
+outTime = 100
  
 

source/Applications/pChannel/pChannel.cpp

@@ -90,8 +90,6 @@ void run(string configname)
       //real velocity is 49.63 m/s
       double nu_LB;
 
-      BoundaryConditionProcessorPtr bcProcessor(new BoundaryConditionProcessor());
-
       Grid3DPtr grid(new Grid3D(comm));
 
       //////////////////////////////////////////////////////////////////////////
@@ -388,6 +386,8 @@ void run(string configname)
          ////set connectors
          D3Q27InterpolationProcessorPtr iProcessor(new D3Q27IncompressibleOffsetInterpolationProcessor());
          D3Q27SetConnectorsBlockVisitor setConnsVisitor(comm, true, D3Q27System::ENDDIR, nu_LB, iProcessor);
+         //ConnectorFactoryPtr factory(new Block3DConnectorFactory());
+         //ConnectorBlockVisitor setConnsVisitor(comm, nu_LB, iProcessor, factory);
          grid->accept(setConnsVisitor);
 
          //domain decomposition for threads

source/Applications/sphere/CMakeLists.txt

@@ -5,7 +5,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 ########################################################
 PROJECT(sphere)
 
-INCLUDE(${SOURCE_ROOT}/lib/IncludsList.txt) 
+INCLUDE(${SOURCE_ROOT}/IncludsList.cmake) 
 
 #################################################################
 ###   LOCAL FILES                                             ###
@@ -17,7 +17,7 @@ FILE(GLOB SPECIFIC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.h
 SET(ALL_SOURCES ${ALL_SOURCES} ${SPECIFIC_FILES})
 SOURCE_GROUP(src FILES ${SPECIFIC_FILES})
   
-SET(CAB_ADDITIONAL_LINK_LIBRARIES vfluids)
+SET(CAB_ADDITIONAL_LINK_LIBRARIES VirtualFluids)
 
 #################################################################
 ###   CREATE PROJECT                                          ###

source/Applications/sphere/config.txt

 #Ordner fr Simulationsergebnisse
-path=d:/temp/insitu_demo
+path=d:/temp/sphere
 
 #Verfgbare Arbeitsspeicher in Byte
 memory=21e9
@@ -14,7 +14,9 @@ outstep=1
 endstep=100000
 
 #Anzahl von Threads
-threads=4
+threads=1
 
 #max refierment level (1 - 5)
-level=1
+level=1
\ No newline at end of file
+
+test = true
\ No newline at end of file

source/VirtualFluids.h

@@ -104,7 +104,7 @@
 #include <BoundaryCondition/D3Q27SlipBCAdapter.h>
 #include <BoundaryCondition/D3Q27VelocityBCAdapter.h>
 
-#include <BoundaryCondition/BoundaryConditionProcessor.h>
+//#include <BoundaryCondition/BoundaryConditionProcessor.h>
 #include <BoundaryCondition/BoundaryCondition.h>
 #include <BoundaryCondition/VelocityBoundaryCondition.h>
 #include <BoundaryCondition/NonEqDensityBoundaryCondition.h>
@@ -147,7 +147,7 @@
 //#include <Grid/BoostSerializationClassExportHelper.h>
 #include <Grid/CalculationManager.h>
 #include <Grid/Calculator.h>
-#include <Grid/Calculator2.h>
+//#include <Grid/Calculator2.h>
 #include <Grid/Grid3D.h>
 #include <Grid/Grid3DSystem.h>
 #include <Interactors/D3Q27Interactor.h>

source/VirtualFluidsCore/BoundaryCondition/BCArray.cpp

+#include "BCArray.h"
+
+
+const int BCArray::SOLID = -1;
+const int BCArray::FLUID = -2;
+const int BCArray::INTERFACECF = -3;
+const int BCArray::INTERFACEFC = -4;
+const int BCArray::UNDEFINED = -5;
+
+//////////////////////////////////////////////////////////////////////////
+BCArray::BCArray() {}
+//////////////////////////////////////////////////////////////////////////
+BCArray::BCArray(std::size_t nx1, std::size_t nx2, std::size_t nx3)
+{
+   bcindexmatrix.resize(nx1, nx2, nx3, UNDEFINED);
+}
+//////////////////////////////////////////////////////////////////////////
+BCArray::BCArray(std::size_t nx1, std::size_t nx2, std::size_t nx3, int val)
+{
+   bcindexmatrix.resize(nx1, nx2, nx3, val);
+}
+//////////////////////////////////////////////////////////////////////////
+BCArray::~BCArray() {}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::resize(std::size_t nx1, std::size_t nx2, std::size_t nx3)
+{
+   bcindexmatrix.resize(nx1, nx2, nx3);
+}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::resize(std::size_t nx1, std::size_t nx2, std::size_t nx3, int val)
+{
+   bcindexmatrix.resize(nx1, nx2, nx3, val);
+}
+//////////////////////////////////////////////////////////////////////////
+bool BCArray::validIndices(std::size_t x1, std::size_t x2, std::size_t x3)  const
+{
+   if (x1 < 0 || x1 >= this->bcindexmatrix.getNX1()) return false;
+   if (x2 < 0 || x2 >= this->bcindexmatrix.getNX2()) return false;
+   if (x3 < 0 || x3 >= this->bcindexmatrix.getNX3()) return false;
+   return true;
+}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::setBC(std::size_t x1, std::size_t x2, std::size_t x3, BCClassPtr const& bc)
+{
+   if (this->hasBC(x1, x2, x3))
+   {
+      if (this->getBC(x1, x2, x3) == bc) return;
+      else                            this->deleteBC(x1, x2, x3);
+   }
+
+   //wenn keine frei gewordene BCs vorhanden
+   if (indexContainer.empty())
+   {
+      bcvector.push_back(bc);
+      bcindexmatrix(x1, x2, x3) = (int)bcvector.size() - 1;
+   }
+   else
+   {
+      int index = indexContainer.back();
+      bcindexmatrix(x1, x2, x3) = index;
+      bcvector[index] = bc;
+      indexContainer.pop_back();
+   }
+}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::setSolid(std::size_t x1, std::size_t x2, std::size_t x3)
+{
+   if (this->hasBC(x1, x2, x3)) this->deleteBC(x1, x2, x3);
+   bcindexmatrix(x1, x2, x3) = SOLID;
+}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::setFluid(std::size_t x1, std::size_t x2, std::size_t x3)
+{
+   if (this->hasBC(x1, x2, x3)) this->deleteBC(x1, x2, x3);
+   bcindexmatrix(x1, x2, x3) = FLUID;
+}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::setUndefined(std::size_t x1, std::size_t x2, std::size_t x3)
+{
+   if (this->hasBC(x1, x2, x3)) this->deleteBC(x1, x2, x3);
+   bcindexmatrix(x1, x2, x3) = UNDEFINED;
+}
+//////////////////////////////////////////////////////////////////////////
+std::size_t BCArray::getNumberOfSolidEntries() const
+{
+   const std::vector<int>& data = bcindexmatrix.getDataVector();
+   std::size_t counter = 0;
+   for (std::size_t i = 0; i < data.size(); i++)
+      if (data[i] == SOLID) counter++;
+   return counter;
+}
+//////////////////////////////////////////////////////////////////////////
+std::size_t BCArray::getNumberOfFluidEntries() const
+{
+   const std::vector<int>& data = bcindexmatrix.getDataVector();
+   std::size_t counter = 0;
+   for (std::size_t i = 0; i < data.size(); i++)
+   {
+      int tmp = data[i];
+      if (tmp == FLUID || tmp >= 0) counter++;
+   }
+   return counter;
+}
+//////////////////////////////////////////////////////////////////////////
+std::size_t BCArray::getNumberOfFluidWithoutBCEntries() const
+{
+   const std::vector<int>& data = bcindexmatrix.getDataVector();
+   std::size_t counter = 0;
+   for (std::size_t i = 0; i < data.size(); i++)
+      if (data[i] == FLUID) counter++;
+   return counter;
+}
+//////////////////////////////////////////////////////////////////////////
+std::size_t BCArray::getNumberOfBCEntries() const
+{
+   const std::vector<int>& data = bcindexmatrix.getDataVector();
+   std::size_t counter = 0;
+   for (std::size_t i = 0; i < data.size(); i++)
+      if (data[i] >= 0) counter++;
+   return counter;
+}
+//////////////////////////////////////////////////////////////////////////
+std::size_t BCArray::getNumberOfUndefinedEntries() const
+{
+   const std::vector<int>& data = bcindexmatrix.getDataVector();
+   std::size_t counter = 0;
+   for (std::size_t i = 0; i < data.size(); i++)
+      if (data[i] == UNDEFINED) counter++;
+   return counter;
+}
+//////////////////////////////////////////////////////////////////////////
+std::size_t BCArray::getBCVectorSize() const
+{
+   return this->bcvector.size();
+}
+//////////////////////////////////////////////////////////////////////////
+std::string BCArray::toString() const
+{
+   std::size_t solidCounter = 0;
+   std::size_t fluidCounter = 0;
+   std::size_t bcCounter = 0;
+   std::size_t undefCounter = 0;
+
+   for (int x1 = 0; x1 < bcindexmatrix.getNX1(); x1++)
+   {
+      for (int x2 = 0; x2 < bcindexmatrix.getNX2(); x2++)
+      {
+         for (int x3 = 0; x3 < bcindexmatrix.getNX3(); x3++)
+         {
+            if (bcindexmatrix(x1, x2, x3) >= 0) bcCounter++;
+            else if (bcindexmatrix(x1, x2, x3) == FLUID) fluidCounter++;
+            else if (bcindexmatrix(x1, x2, x3) == SOLID) solidCounter++;
+            else if (bcindexmatrix(x1, x2, x3) == UNDEFINED) undefCounter++;
+            else throw UbException(UB_EXARGS, "invalid matrixEntry");
+         }
+      }
+   }
+
+   std::size_t unrefEntriesInBcVector = 0;
+   for (std::size_t i = 0; i < bcvector.size(); i++) if (!bcvector[i]) unrefEntriesInBcVector++;
+
+   std::stringstream text;
+   text << "BCArray<" << typeid(BCClassPtr).name() << "," << typeid(int).name() << ">";
+   text << "[ entries: " << bcindexmatrix.getNX1() << "x" << bcindexmatrix.getNX2();
+   text << "x" << bcindexmatrix.getNX3() << "=";
+   text << bcindexmatrix.getNX1()*bcindexmatrix.getNX2()*bcindexmatrix.getNX3() << " ]:\n";
+   text << " - #fluid entries : " << fluidCounter << std::endl;
+   text << " - #bc    entries : " << bcCounter << std::endl;
+   text << " - #solid entries : " << solidCounter << std::endl;
+   text << " - #undef entries : " << undefCounter << std::endl;
+   text << " - bcvector-entries      : " << bcvector.size() << " (empty ones: " << unrefEntriesInBcVector << ")\n";
+   text << " - indexContainer-entries: " << indexContainer.size() << std::endl;
+
+   return text.str();
+}
+//////////////////////////////////////////////////////////////////////////
+void BCArray::deleteBCAndSetType(std::size_t x1, std::size_t x2, std::size_t x3, int type)
+   {
+      this->deleteBC(x1, x2, x3);
+
+      //matrix neuen Typ zuweisen
+      bcindexmatrix(x1, x2, x3) = type;
+   }
+//////////////////////////////////////////////////////////////////////////
+void BCArray::deleteBC(std::size_t x1, std::size_t x2, std::size_t x3)
+   {
+      //ueberpruefen, ob ueberhaupt BC vorhanden
+      int index = bcindexmatrix(x1, x2, x3);
+      if (index < 0) return;
+
+      //frei gewordenen Index in den Indexcontainer schieben
+      indexContainer.push_back(index);
+
+      //element "loeschen"
+      bcvector[index] = BCClassPtr();
+   }
\ No newline at end of file

source/VirtualFluidsCore/BoundaryCondition/BCArray.h

 #ifndef BCArray_H
 #define BCArray_H
 
+#include "D3Q27BoundaryCondition.h"
+#include "basics/container/CbArray3D.h"
+
 #include <typeinfo>
 
 #include <boost/serialization/serialization.hpp>
 #include <boost/shared_ptr.hpp>
 
+typedef boost::shared_ptr<D3Q27BoundaryCondition> BCClassPtr;
+
+class BCArray;
+typedef boost::shared_ptr<BCArray> BCArrayPtr;
+
 class BCArray
 {
 public:
-   typedef typename boost::shared_ptr<BCArray> BCArrayPtr;
-   typedef std::size_t size_type;
-   typedef int IndexType;
-
-public:
    //////////////////////////////////////////////////////////////////////////
-   BCArray() {}
+   BCArray();
+   //////////////////////////////////////////////////////////////////////////
+   BCArray(std::size_t nx1, std::size_t nx2, std::size_t nx3);
+   //////////////////////////////////////////////////////////////////////////
+   BCArray(std::size_t nx1, std::size_t nx2, std::size_t nx3, int val);
    //////////////////////////////////////////////////////////////////////////
    virtual ~BCArray();
    //////////////////////////////////////////////////////////////////////////
-   virtual inline size_type getNX1() const = 0;
+   inline std::size_t getNX1() const;
    //////////////////////////////////////////////////////////////////////////
-   virtual inline size_type getNX2() const = 0;
+   inline std::size_t getNX2() const;
    //////////////////////////////////////////////////////////////////////////
-   virtual inline size_type getNX3() const = 0;
+   inline std::size_t getNX3() const;
    //////////////////////////////////////////////////////////////////////////
-   void resize(const size_type& nx1, const size_type& nx2, const size_type& nx3) = 0;
+   void resize(std::size_t nx1, std::size_t nx2, std::size_t nx3);
    //////////////////////////////////////////////////////////////////////////
-   void resize(const size_type& nx1, const size_type& nx2, const size_type& nx3, const IndexType& val) = 0;
+   void resize(std::size_t nx1, std::size_t nx2, std::size_t nx3, int val);
    //////////////////////////////////////////////////////////////////////////
-   bool validIndices(const size_type& x1, const size_type& x2, const size_type& x3)  const = 0;
+   bool validIndices(std::size_t x1, std::size_t x2, std::size_t x3)  const;
    //////////////////////////////////////////////////////////////////////////
-   inline bool hasBC(const size_type& x1, const size_type& x2, const size_type& x3)  const = 0;
+   inline bool hasBC(std::size_t x1, std::size_t x2, std::size_t x3)  const;
    //////////////////////////////////////////////////////////////////////////
-   void setBC(const size_type& x1, const size_type& x2, const size_type& x3, BCClassPtr const& bc)
-   {
-      if( this->hasBC(x1,x2,x3) )
-      {
-         if( this->getBC(x1,x2,x3)==bc ) return;
-         else                            this->deleteBC(x1,x2,x3);
-      }
-
-      //wenn keine frei gewordene BCs vorhanden
-      if( indexContainer.empty() )
-      {
-         bcvector.push_back(bc);
-         bcindexmatrix(x1,x2,x3) = (IndexType)bcvector.size()-1;
-      }
-      else
-      {
-         IndexType index = indexContainer.back();
-         bcindexmatrix(x1,x2,x3) = index;
-         bcvector[index] = bc;
-         indexContainer.pop_back();
-      }
-   }
+   void setBC(std::size_t x1, std::size_t x2, std::size_t x3, BCClassPtr const& bc);
    //////////////////////////////////////////////////////////////////////////
-   inline IndexType getBCVectorIndex(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      return bcindexmatrix(x1,x2,x3);
-   }
+   inline int getBCVectorIndex(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   inline const BCClassPtr getBC(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      IndexType index = bcindexmatrix(x1,x2,x3);
-      if(index<0) return BCClassPtr(); //=> NULL Pointer
-
-      return bcvector[index];
-   }
+   inline const BCClassPtr getBC(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   inline BCClassPtr getBC(const size_type& x1, const size_type& x2, const size_type& x3)
-   {
-      IndexType index = bcindexmatrix(x1,x2,x3);
-      if(index<0) return BCClassPtr(); //=> NULL Pointer
-
-      return bcvector[index];
-   }
+   inline BCClassPtr getBC(std::size_t x1, std::size_t x2, std::size_t x3);
    //////////////////////////////////////////////////////////////////////////
-   void setSolid(const size_type& x1, const size_type& x2, const size_type& x3)
-   {
-      if( this->hasBC(x1,x2,x3) ) this->deleteBC(x1,x2,x3);
-      bcindexmatrix(x1,x2,x3)=SOLID;
-   }
+   void setSolid(std::size_t x1, std::size_t x2, std::size_t x3);
    //////////////////////////////////////////////////////////////////////////
-   inline bool isSolid(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      return bcindexmatrix(x1,x2,x3)==SOLID;
-   }
+   inline bool isSolid(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   void setFluid(const size_type& x1, const size_type& x2, const size_type& x3)
-   {
-      if( this->hasBC(x1,x2,x3) ) this->deleteBC(x1,x2,x3);
-      bcindexmatrix(x1,x2,x3)=FLUID;
-   }
+   void setFluid(std::size_t x1, std::size_t x2, std::size_t x3);
    //////////////////////////////////////////////////////////////////////////
    //true : FLUID or BC
    //false: UNDEFINED or SOLID
-   inline bool isFluid(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      int tmp = bcindexmatrix(x1,x2,x3);
-      return (tmp==FLUID || tmp>=0);
-   }
+   inline bool isFluid(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   inline bool isFluidWithoutBC(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      return bcindexmatrix(x1,x2,x3)==FLUID;
-   }
+   inline bool isFluidWithoutBC(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   inline bool isUndefined(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      return bcindexmatrix(x1,x2,x3)==UNDEFINED;
-   }
+   inline bool isUndefined(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   void setUndefined(const size_type& x1, const size_type& x2, const size_type& x3)
-   {
-      if( this->hasBC(x1,x2,x3) ) this->deleteBC(x1,x2,x3);
-      bcindexmatrix(x1,x2,x3)=UNDEFINED;
-   }
+   void setUndefined(std::size_t x1, std::size_t x2, std::size_t x3);
    //////////////////////////////////////////////////////////////////////////
-   inline bool isInterface(const size_type& x1, const size_type& x2, const size_type& x3) const
-   {
-      return bcindexmatrix(x1,x2,x3)==INTERFACE;
-   }
+   inline bool isInterfaceCF(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   void setInterface(const size_type& x1, const size_type& x2, const size_type& x3)
-   {
-      if( this->hasBC(x1,x2,x3) ) this->deleteBC(x1,x2,x3);
-      bcindexmatrix(x1,x2,x3)=INTERFACE;
-   }
+   void setInterfaceCF(std::size_t x1, std::size_t x2, std::size_t x3);
    //////////////////////////////////////////////////////////////////////////
-   std::size_t getNumberOfSolidEntries() const 
-   {
-      const std::vector<IndexType>& data = bcindexmatrix.getDataVector();
-      std::size_t counter = 0;
-      for(std::size_t i=0; i<data.size(); i++)
-         if(data[i]==SOLID) counter++;
-      return counter;
-   }
+   inline bool isInterfaceFC(std::size_t x1, std::size_t x2, std::size_t x3) const;
    //////////////////////////////////////////////////////////////////////////
-   std::size_t getNumberOfFluidEntries() const 
-   {
-      const std::vector<IndexType>& data = bcindexmatrix.getDataVector();
-      std::size_t counter = 0;
-      for(std::size_t i=0; i<data.size(); i++)
-      {
-         const IndexType& tmp = data[i];
-         if(tmp==FLUID || tmp>=0) counter++;
-      }
-      return counter;
-   }
+   void setInterfaceFC(std::size_t x1, std::size_t x2, std::size_t x3);
    //////////////////////////////////////////////////////////////////////////
-   std::size_t getNumberOfFluidWithoutBCEntries() const
-   {
-      const std::vector<IndexType>& data = bcindexmatrix.getDataVector();
-      std::size_t counter = 0;
-      for(std::size_t i=0; i<data.size(); i++)
-         if(data[i]==FLUID) counter++;
-      return counter;
-   }
+   std::size_t getNumberOfSolidEntries() const;
    //////////////////////////////////////////////////////////////////////////
-   std::size_t getNumberOfBCEntries() const
-   {
-      const std::vector<IndexType>& data = bcindexmatrix.getDataVector();
-      std::size_t counter = 0;
-      for(std::size_t i=0; i<data.size(); i++)
-         if(data[i]>=0) counter++;
-      return counter;
-   }
+   std::size_t getNumberOfFluidEntries() const;
    //////////////////////////////////////////////////////////////////////////
-   std::size_t getNumberOfUndefinedEntries() const
-   {
-      const std::vector<IndexType>& data = bcindexmatrix.getDataVector();
-      std::size_t counter = 0;
-      for(std::size_t i=0; i<data.size(); i++)
-         if(data[i]==UNDEFINED) counter++;
-      return counter;
-   }
+   std::size_t getNumberOfFluidWithoutBCEntries() const;
    //////////////////////////////////////////////////////////////////////////
-   std::size_t getBCVectorSize() const
-   {
-      return this->bcvector.size();
-   }
+   std::size_t getNumberOfBCEntries() const;
    //////////////////////////////////////////////////////////////////////////
-   std::string toString() const
-   {
-      std::size_t solidCounter = 0;
-      std::size_t fluidCounter = 0;
-      std::size_t bcCounter    = 0;
-      std::size_t undefCounter = 0;
-
-      for(int x1=0; x1<bcindexmatrix.getNX1(); x1++)
-      {
-         for(int x2=0; x2<bcindexmatrix.getNX2(); x2++)
-         {
-            for(int x3=0; x3<bcindexmatrix.getNX3(); x3++)
-            {
-               if(bcindexmatrix(x1,x2,x3)>=0             ) bcCounter++;
-               else if(bcindexmatrix(x1,x2,x3)==FLUID    ) fluidCounter++;
-               else if(bcindexmatrix(x1,x2,x3)==SOLID    ) solidCounter++;
-               else if(bcindexmatrix(x1,x2,x3)==UNDEFINED) undefCounter++;
-               else throw UbException(UB_EXARGS,"invalid matrixEntry");
-            }
-         }
-      }
-
-      std::size_t unrefEntriesInBcVector=0;
-      for(std::size_t i=0; i<bcvector.size(); i++) if(!bcvector[i]) unrefEntriesInBcVector++;
-
-      std::stringstream text;
-      text<<"BCArray<"<<typeid(BCClass).name()<<","<<typeid(IndexType).name()<<">";
-      text<<"[ entries: "<<bcindexmatrix.getNX1()<<"x"<<bcindexmatrix.getNX2();
-      text<<"x"<<bcindexmatrix.getNX3()<<"=";
-      text<<bcindexmatrix.getNX1()*bcindexmatrix.getNX2()*bcindexmatrix.getNX3()<<" ]:\n";
-      text<<" - #fluid entries : "<<fluidCounter<<std::endl;
-      text<<" - #bc    entries : "<<bcCounter<<std::endl;
-      text<<" - #solid entries : "<<solidCounter<<std::endl;
-      text<<" - #undef entries : "<<undefCounter<<std::endl;
-      text<<" - bcvector-entries      : "<<bcvector.size()<<" (empty ones: "<<unrefEntriesInBcVector<<")\n";
-      text<<" - indexContainer-entries: "<<indexContainer.size()<<std::endl;
-
-      return text.str();
-   }
+   std::size_t getNumberOfUndefinedEntries() const;
+   //////////////////////////////////////////////////////////////////////////
+   std::size_t getBCVectorSize() const;
+   //////////////////////////////////////////////////////////////////////////
+   std::string toString() const;
    //////////////////////////////////////////////////////////////////////////
 
-#ifdef CAB_RCF
-   template<class Archive>
-   void SF_SERIALIZE(Archive & ar)
-   {
-      ar & bcindexmatrix;
-      ar & bcvector;
-      ar & indexContainer;
-   }
-#endif //CAB_RCF
-
-   static const IndexType SOLID;     //definiton erfolgt ausserhalb!!!
-   static const IndexType FLUID;     //definiton erfolgt ausserhalb!!!
-   static const IndexType INTERFACE; //definiton erfolgt ausserhalb!!!
-   static const IndexType UNDEFINED; //definiton erfolgt ausserhalb!!!
+   static const int SOLID;     
+   static const int FLUID;     
+   static const int INTERFACECF; 
+   static const int INTERFACEFC; 
+   static const int UNDEFINED; 
 
 private:
    //////////////////////////////////////////////////////////////////////////
-   void deleteBCAndSetType(const size_type& x1, const size_type& x2, const size_type& x3, const IndexType& type)
-   {
-      this->deleteBC(x1,x2,x3);
-
-      //matrix neuen Typ zuweisen
-      bcindexmatrix(x1,x2,x3) = type;
-   }
+   void deleteBCAndSetType(std::size_t x1, std::size_t x2, std::size_t x3, int type);
    //////////////////////////////////////////////////////////////////////////
-   void deleteBC(const size_type& x1,const size_type& x2, const size_type& x3)
-   {
-      //ueberpruefen, ob ueberhaupt BC vorhanden
-      IndexType index = bcindexmatrix(x1,x2,x3);
-      if(index<0) return;
-
-      //frei gewordenen Index in den Indexcontainer schieben
-      indexContainer.push_back(index);
-
-      //element "loeschen"
-      bcvector[index] = BCClassPtr();
-   }
+   void deleteBC(std::size_t x1, std::size_t x2, std::size_t x3);
 
    friend class boost::serialization::access;
    template<class Archive>
@@ -271,19 +109,77 @@ private:
    }
 protected:
    //////////////////////////////////////////////////////////////////////////
-   //CbArray3D<IndexType,IndexerX1X2X3> bcindexmatrix;  //-1 solid // -2 fluid -...
-   CbArray3D<IndexType,IndexerX3X2X1> bcindexmatrix;
+   //-1 solid // -2 fluid -...
+   CbArray3D<int, IndexerX3X2X1> bcindexmatrix;
    std::vector<BCClassPtr> bcvector;
-   std::vector<IndexType> indexContainer;
+   std::vector<int> indexContainer;
 };
 
-template< typename BCClass , class IndexType>
-const IndexType BCArray<BCClass,IndexType>::SOLID  = -1;
-template< typename BCClass , class IndexType>
-const IndexType BCArray<BCClass,IndexType>::FLUID  = -2;
-template< typename BCClass , class IndexType> 
-const IndexType BCArray<BCClass,IndexType>::INTERFACE = -3;
-template< typename BCClass , class IndexType>
-const IndexType BCArray<BCClass,IndexType>::UNDEFINED = -4;
 
-#endif //D3Q19BCMATRIX_H
+//////////////////////////////////////////////////////////////////////////
+inline std::size_t BCArray::getNX1() const { return bcindexmatrix.getNX1(); }
+//////////////////////////////////////////////////////////////////////////
+inline std::size_t BCArray::getNX2() const { return bcindexmatrix.getNX2(); }
+//////////////////////////////////////////////////////////////////////////
+inline std::size_t BCArray::getNX3() const { return bcindexmatrix.getNX3(); }
+//////////////////////////////////////////////////////////////////////////
+inline bool BCArray::hasBC(std::size_t x1, std::size_t x2, std::size_t x3)  const
+{
+   return bcindexmatrix(x1, x2, x3) >= 0;
+}
+//////////////////////////////////////////////////////////////////////////
+inline int BCArray::getBCVectorIndex(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   return bcindexmatrix(x1, x2, x3);
+}
+//////////////////////////////////////////////////////////////////////////
+inline const BCClassPtr  BCArray::getBC(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   int index = bcindexmatrix(x1, x2, x3);
+   if (index < 0) return BCClassPtr(); //=> NULL Pointer
+
+   return bcvector[index];
+}
+//////////////////////////////////////////////////////////////////////////
+inline BCClassPtr BCArray::getBC(std::size_t x1, std::size_t x2, std::size_t x3)
+{
+   int index = bcindexmatrix(x1, x2, x3);
+   if (index < 0) return BCClassPtr(); //=> NULL Pointer
+
+   return bcvector[index];
+}
+//////////////////////////////////////////////////////////////////////////
+inline bool BCArray::isSolid(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   return bcindexmatrix(x1, x2, x3) == SOLID;
+}
+//////////////////////////////////////////////////////////////////////////
+//true : FLUID or BC
+//false: UNDEFINED or SOLID
+inline bool BCArray::isFluid(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   int tmp = bcindexmatrix(x1, x2, x3);
+   return (tmp == FLUID || tmp >= 0);
+}
+//////////////////////////////////////////////////////////////////////////
+inline bool BCArray::isFluidWithoutBC(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   return bcindexmatrix(x1, x2, x3) == FLUID;
+}
+//////////////////////////////////////////////////////////////////////////
+inline bool BCArray::isUndefined(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   return bcindexmatrix(x1, x2, x3) == UNDEFINED;
+}
+//////////////////////////////////////////////////////////////////////////
+inline bool BCArray::isInterfaceCF(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   return bcindexmatrix(x1, x2, x3) == INTERFACECF;
+}
+//////////////////////////////////////////////////////////////////////////
+inline bool BCArray::isInterfaceFC(std::size_t x1, std::size_t x2, std::size_t x3) const
+{
+   return bcindexmatrix(x1, x2, x3) == INTERFACEFC;
+}
+
+#endif 

source/VirtualFluidsCore/BoundaryCondition/BCProcessor.h

@@ -18,7 +18,6 @@ class BCProcessor
 public:
    BCProcessor();
    virtual ~BCProcessor();
-   virtual void applyBC() = 0;
    virtual void applyPreCollisionBC() = 0;
    virtual void applyPostCollisionBC() = 0;
    virtual void addBC(BoundaryConditionPtr bc) = 0;

source/VirtualFluidsCore/BoundaryCondition/BoundaryCondition.cpp

@@ -9,14 +9,12 @@ void BoundaryCondition::apply()
 {
    if (this->compressible)
    {
-      //rho0 = REAL_CAST(0.0);
       calcFeqsForDirFct = &D3Q27System::getCompFeqForDirection;
       calcMacrosFct = &D3Q27System::calcCompMacroscopicValues;
       calcFeqFct = &D3Q27System::calcCompFeq;
    }
    else
    {
-      //rho0 = REAL_CAST(1.0);
       calcFeqsForDirFct = &D3Q27System::getIncompFeqForDirection;
       calcMacrosFct = &D3Q27System::calcIncompMacroscopicValues;
       calcFeqFct = &D3Q27System::calcIncompFeq;
@@ -25,12 +23,7 @@ void BoundaryCondition::apply()
    int cbc = 0;
    int cn = 0;
    int j;
-   //int dsize = (int)distVector.size();
 
-   //for (int i = 0; i < dsize; i++)
-   //{
-   //   distributions = distVector[i];
-      //int nsize = (int)sizeVector[i] * 3 + cn;
    int nsize = (int)nodeVector.size();
 
       for (j = cn; j < nsize;)
@@ -45,22 +38,11 @@ void BoundaryCondition::apply()
          applyBC();
       }
       cn = j;
-   //}
 }
-//////////////////////////////////////////////////////////////////////////
-//void BoundaryCondition::apply()
-//{
-//}
-//////////////////////////////////////////////////////////////////////////
-void BoundaryCondition::addDistributions(EsoTwist3DPtr distributions)
-{
-   //distVector.push_back(distribution);
-   this->distributions = distributions;
-}
-//////////////////////////////////////////////////////////////////////////
-//void BoundaryCondition::addNnode(int nnode)
+////////////////////////////////////////////////////////////////////////////
+//void BoundaryCondition::addDistributions(EsoTwist3DPtr distributions)
 //{
-//   sizeVector.push_back(nnode);
+//   this->distributions = distributions;
 //}
 //////////////////////////////////////////////////////////////////////////
 void BoundaryCondition::addNode(int x1, int x2, int x3)

source/VirtualFluidsCore/BoundaryCondition/BoundaryCondition.h

@@ -29,18 +29,8 @@ public:
    BoundaryCondition();
    virtual ~BoundaryCondition() {}
    
-   //void apply(int level);
-
-   //void addDistribution(int level, EsoTwist3DPtr distribution);
-   //void addNnode(int level, int nnode);
-   //void addNode(int level, int x1, int x2, int x3);
-   //void addBcPointer(int level, D3Q27BoundaryConditionPtr bcPtr);
-   //void setCompressible(bool c);
-   //void setCollFactor(int level, double cf);
    void apply();
-
-   void addDistributions(EsoTwist3DPtr distributions);
-   //void addNnode(int nnode);
+   virtual void addDistributions(DistributionArray3DPtr distributions) = 0;
    void addNode(int x1, int x2, int x3);
    void addBcPointer(D3Q27BoundaryConditionPtr bcPtr);
    void setCompressible(bool c);
@@ -51,8 +41,6 @@ public:
 protected:
    virtual void applyBC() = 0;
    
-   //std::vector <EsoTwist3DPtr> distVector;
-   //std::vector <int> sizeVector;
    std::vector <int> nodeVector;
    std::vector <D3Q27BoundaryConditionPtr> bcVector;
 
@@ -61,8 +49,8 @@ protected:
    bool preCollision;
 
    D3Q27BoundaryConditionPtr bcPtr;
-   EsoTwist3DPtr distributions;
-   EsoTwist3DPtr distributionsTemp;
+   DistributionArray3DPtr distributions;
+   DistributionArray3DPtr distributionsTemp;
    LBMReal collFactor;
    int x1, x2, x3;
 

source/VirtualFluidsCore/BoundaryCondition/BoundaryConditionProcessor.cpp

-#include "BoundaryConditionProcessor.h"
-#include <boost/foreach.hpp>
-
-BoundaryConditionProcessor::BoundaryConditionProcessor()
-{
-
-}
-//////////////////////////////////////////////////////////////////////////
-void BoundaryConditionProcessor::addBC(BoundaryConditionPtr bc)
-{
-   BoundaryCondition::Type type = bc->getType();
-   if (bc->isPreCollision())
-   {
-      preBC.push_back(bc);
-   }
-   else
-   {
-      postBC.push_back(bc);
-   }
-}
-//////////////////////////////////////////////////////////////////////////
-BoundaryConditionPtr BoundaryConditionProcessor::getBC(BoundaryCondition::Type type)
-{
-   BOOST_FOREACH(BoundaryConditionPtr bc, preBC)
-   {
-     if (bc->getType() == type)
-     {
-        return bc;
-     }
-   }
-
-   BOOST_FOREACH(BoundaryConditionPtr bc, postBC)
-   {
-      if (bc->getType() == type)
-      {
-         return bc;
-      }
-   }
-
-   return BoundaryConditionPtr();
-}
-//////////////////////////////////////////////////////////////////////////
-void BoundaryConditionProcessor::applyPreCollisionBC()
-{
-   BOOST_FOREACH(BoundaryConditionPtr bc, preBC)
-   {
-      bc->apply();
-   }
-}
-//////////////////////////////////////////////////////////////////////////
-void BoundaryConditionProcessor::applyPostCollisionBC()
-{
-   BOOST_FOREACH(BoundaryConditionPtr bc, postBC)
-   {
-      bc->apply();
-   }
-}
-

source/VirtualFluidsCore/BoundaryCondition/BoundaryConditionProcessor.h

-#ifndef BoundaryConditionProcessor_h__
-#define BoundaryConditionProcessor_h__
-
-#include "BoundaryCondition.h"
-#include <vector>
-
-class BoundaryConditionProcessor;
-typedef boost::shared_ptr<BoundaryConditionProcessor> BoundaryConditionProcessorPtr;
-
-class BoundaryConditionProcessor
-{
-public:
-   BoundaryConditionProcessor();
-   virtual ~BoundaryConditionProcessor() {}
-
-   void addBC(BoundaryConditionPtr bc);
-   BoundaryConditionPtr getBC(BoundaryCondition::Type type);
-   void applyPreCollisionBC();
-   void applyPostCollisionBC();
-protected:
-private:
-   std::vector<BoundaryConditionPtr> preBC;
-   std::vector<BoundaryConditionPtr> postBC;
-};
-
-#endif // BoundaryConditionProcessor_h__

source/VirtualFluidsCore/BoundaryCondition/D3Q27ETBCProcessor.h

@@ -21,7 +21,7 @@ public:
    D3Q27ETBCProcessor();
    D3Q27ETBCProcessor(LBMKernel3DPtr kernel);
    virtual ~D3Q27ETBCProcessor();
-   virtual void applyBC();
+   //virtual void applyBC();
    virtual BCArray3D<D3Q27BoundaryCondition>& getBCArray();
    virtual BCProcessorPtr clone(LBMKernel3DPtr kernel);
 
@@ -34,20 +34,20 @@ protected:
    std::vector<BoundaryConditionPtr> preBC;
    std::vector<BoundaryConditionPtr> postBC;
 
-   int minX1, minX2, minX3, maxX1, maxX2, maxX3;
-   D3Q27BoundaryConditionPtr bcPtr;
-   LBMReal f[D3Q27System::ENDF+1];
-   LBMReal ftemp[D3Q27System::ENDF+1];
-   LBMReal feq[D3Q27System::ENDF+1];
-   LBMReal rho, vx1, vx2, vx3, rho0;
+   //int minX1, minX2, minX3, maxX1, maxX2, maxX3;
+   //D3Q27BoundaryConditionPtr bcPtr;
+   //LBMReal f[D3Q27System::ENDF+1];
+   //LBMReal ftemp[D3Q27System::ENDF+1];
+   //LBMReal feq[D3Q27System::ENDF+1];
+   //LBMReal rho, vx1, vx2, vx3, rho0;
 
    //void init(LBMKernel3DPtr kernel);
    BCArray3D<D3Q27BoundaryCondition> bcArray;
-   EsoTwist3DPtr distributions;
-   int ghostLayerWitdh;
-   LBMReal collFactor;
-   bool compressible;
-   EsoTwist3DPtr distributionsTemp;
+   //EsoTwist3DPtr distributions;
+   //int ghostLayerWitdh;
+   //LBMReal collFactor;
+   //bool compressible;
+   //EsoTwist3DPtr distributionsTemp;
 
    //std::vector <int> sizeVector;
    //std::vector <int> nodeVector;
@@ -66,17 +66,17 @@ private:
    {
       ar & boost::serialization::base_object<BCProcessor>(*this);
       ar & bcArray;
-      ar & distributions;
-      ar & ghostLayerWitdh;
-      ar & collFactor;
-      ar & compressible;
-      ar & minX1;
-      ar & minX2;
-      ar & minX3;
-      ar & maxX1;
-      ar & maxX2;
-      ar & maxX3;
-      ar & distributionsTemp;
+      //ar & distributions;
+      //ar & ghostLayerWitdh;
+      //ar & collFactor;
+      //ar & compressible;
+      //ar & minX1;
+      //ar & minX2;
+      //ar & minX3;
+      //ar & maxX1;
+      //ar & maxX2;
+      //ar & maxX3;
+      //ar & distributionsTemp;
       ar & preBC;
       ar & postBC;
    }

source/VirtualFluidsCore/BoundaryCondition/D3Q27ETForThinWallBCProcessor.cpp

 #include "D3Q27ETForThinWallBCProcessor.h"
 
-#include "D3Q27EsoTwist3DSplittedVector.h"
+#include "ThinWallNoSlipBoundaryCondition.h"
 
 D3Q27ETForThinWallBCProcessor::D3Q27ETForThinWallBCProcessor()
 {
@@ -9,7 +9,7 @@ D3Q27ETForThinWallBCProcessor::D3Q27ETForThinWallBCProcessor()
 //////////////////////////////////////////////////////////////////////////
 D3Q27ETForThinWallBCProcessor::D3Q27ETForThinWallBCProcessor(LBMKernel3DPtr kernel) : D3Q27ETBCProcessor(kernel)
 {
-   //distributionsTemp = EsoTwist3DPtr(new D3Q27EsoTwist3DSplittedVector(maxX1, maxX2, maxX2, -999.0));
+
 }
 //////////////////////////////////////////////////////////////////////////
 D3Q27ETForThinWallBCProcessor::~D3Q27ETForThinWallBCProcessor()
@@ -20,52 +20,17 @@ D3Q27ETForThinWallBCProcessor::~D3Q27ETForThinWallBCProcessor()
 BCProcessorPtr D3Q27ETForThinWallBCProcessor::clone(LBMKernel3DPtr kernel)
 {
    BCProcessorPtr bcProcessor(new D3Q27ETForThinWallBCProcessor(kernel));
+   BoundaryConditionPtr velocity = this->getBC(BoundaryCondition::Velocity);
+   BoundaryConditionPtr density = this->getBC(BoundaryCondition::Density);
+   BoundaryConditionPtr noSlip = this->getBC(BoundaryCondition::NoSlip);
+   BoundaryConditionPtr slip = this->getBC(BoundaryCondition::Slip);
+   if (velocity)bcProcessor->addBC(velocity->clone());
+   if (density) bcProcessor->addBC(density->clone());
+   if (noSlip)  bcProcessor->addBC(noSlip->clone());
+   if (slip)    bcProcessor->addBC(slip->clone());
    return bcProcessor;
 }
 //////////////////////////////////////////////////////////////////////////
-void D3Q27ETForThinWallBCProcessor::applyBC()
-{
-   D3Q27ETBCProcessor::applyBC();
-
-   LBMReal fReturn;
-
-   for (int x3 = minX3; x3 < maxX3; x3++)
-   {
-      for (int x2 = minX2; x2 < maxX2; x2++)
-      {
-         for (int x1 = minX1; x1 < maxX1; x1++)
-         {
-            if (!bcArray.isSolid(x1, x2, x3) && !bcArray.isUndefined(x1, x2, x3))
-            {
-               if ((bcPtr=bcArray.getBC(x1, x2, x3)) != NULL)
-               {
-                  if (bcPtr->hasNoSlipBoundary())
-                  {
-                     for (int fdir=D3Q27System::FSTARTDIR; fdir<=D3Q27System::FENDDIR; fdir++)
-                     {
-                        if (bcPtr->hasNoSlipBoundaryFlag(fdir))
-                        {
-                           switch (bcPtr->getNoSlipSecondaryOption(fdir))
-                           {
-                           case 2:
-                           {
-                              //quadratic bounce back with for thin walls
-                              const int invDir = D3Q27System::INVDIR[fdir];
-                              fReturn = distributionsTemp->getDistributionInvForDirection(x1+D3Q27System::DX1[invDir], x2+D3Q27System::DX2[invDir], x3+D3Q27System::DX3[invDir], fdir);
-                              distributions->setDistributionForDirection(fReturn, x1+D3Q27System::DX1[invDir], x2+D3Q27System::DX2[invDir], x3+D3Q27System::DX3[invDir], fdir);
-                           }
-                           break;
-                           }
-                        }
-                     }
-                  }
-               }
-            }
-         }
-      }
-   }
-}
-//////////////////////////////////////////////////////////////////////////
 void D3Q27ETForThinWallBCProcessor::applyPostCollisionBC()
 {
    D3Q27ETBCProcessor::applyPostCollisionBC();
@@ -74,7 +39,9 @@ void D3Q27ETForThinWallBCProcessor::applyPostCollisionBC()
    {
       if (bc->getType() == BoundaryCondition::NoSlip)
       {
+         boost::dynamic_pointer_cast<ThinWallNoSlipBoundaryCondition>(bc)->setPass(2); 
          bc->apply();
+         boost::dynamic_pointer_cast<ThinWallNoSlipBoundaryCondition>(bc)->setPass(1);
       }
    }
 }

source/VirtualFluidsCore/BoundaryCondition/D3Q27ETForThinWallBCProcessor.h

@@ -19,7 +19,6 @@ public:
    D3Q27ETForThinWallBCProcessor();
    D3Q27ETForThinWallBCProcessor(LBMKernel3DPtr kernel);
    virtual ~D3Q27ETForThinWallBCProcessor();
-   virtual void applyBC();
    virtual BCProcessorPtr clone(LBMKernel3DPtr kernel);
    void applyPostCollisionBC();
 protected:

source/VirtualFluidsCore/BoundaryCondition/EqDensityBoundaryCondition.cpp

@@ -17,6 +17,11 @@ BoundaryConditionPtr EqDensityBoundaryCondition::clone()
    return bc;
 }
 //////////////////////////////////////////////////////////////////////////
+void EqDensityBoundaryCondition::addDistributions(DistributionArray3DPtr distributions)
+{
+   this->distributions = distributions;
+}
+//////////////////////////////////////////////////////////////////////////
 void EqDensityBoundaryCondition::applyBC()
 {
    LBMReal f[D3Q27System::ENDF+1];