diff --git a/.gitignore b/.gitignore
index 3b236ea5bdd793ed34603010c520fa1f1a43e34b..2cd1b6c40ac02c00572ac151db5431348513e44a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,7 @@ pythonbindings/pymuparser/bindings*
# simulation results
output/
logs/
+reference_data/
# grid
.grid/
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 1cff49512e8325e7dad10f60d5b88c3a90f30420..a8cd26dfbd5a7d726be6665bcbb4f245a5e3c42b 100755
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -92,7 +92,7 @@ msvc_17:
- git --version
- $env:Path += ";C:\Program Files\CMake\bin\"
- cmake --version
- - $env:Path += ";C:\Program Files\Microsoft Visual Studio\2022\Enterprise\MSBuild\Current\Bin"
+ - $env:Path += ";C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin"
- MSBuild.exe -version
script:
@@ -178,6 +178,7 @@ gcc_9_unit_tests:
script:
- ctest
+ - ctest --rerun-failed --output-on-failure
###############################################################################
msvc_17_unit_tests:
diff --git a/CMake/cmake_config_files/HUSSEIN.config.cmake b/CMake/cmake_config_files/HUSSEIN.config.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9878edaaffb28ab04646493faa58eb18c05f7df9
--- /dev/null
+++ b/CMake/cmake_config_files/HUSSEIN.config.cmake
@@ -0,0 +1,14 @@
+#################################################################################
+# VirtualFluids MACHINE FILE
+# Responsible: Hussein Alihussein
+# OS: Windows 10
+#################################################################################
+
+#################################################################################
+# BOOST
+#################################################################################
+SET(BOOST_VERSION "1.76.0")
+SET(BOOST_ROOT "C:/Users/hussein/Documents/VirtualFluids/boost_1_76_0")
+SET(BOOST_DIR ${BOOST_ROOT})
+SET(BOOST_LIBRARYDIR ${BOOST_ROOT}"/stageMSVC64/lib")
+#################################################################################
diff --git a/apps/cpu/Applications.cmake b/apps/cpu/Applications.cmake
index 68dfeb3ed7687da74d49a35337b0bae92798e80d..3c71d51344030980071addc6f9831a74d0daa53c 100644
--- a/apps/cpu/Applications.cmake
+++ b/apps/cpu/Applications.cmake
@@ -83,4 +83,6 @@ ENDIF()
#add_subdirectory(Applications/OrganPipe)
#add_subdirectory(Applications/LidDrivenCavity)
-
+if(BUILD_USE_BOOST)
+ add_subdirectory(${APPS_ROOT_CPU}/TPMSRow)
+endif()
diff --git a/apps/cpu/TPMSRow/CMakeLists.txt b/apps/cpu/TPMSRow/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ea54915ed2eb339e0e6e71c9d40c638120e58fa
--- /dev/null
+++ b/apps/cpu/TPMSRow/CMakeLists.txt
@@ -0,0 +1,10 @@
+PROJECT(TPMSRow)
+
+vf_add_library(BUILDTYPE binary PRIVATE_LINK VirtualFluidsCore muparser basics ${MPI_CXX_LIBRARIES} FILES TPMSRow.cpp )
+
+vf_get_library_name (library_name)
+#target_include_dires(${library_name} PRIVATE ${APPS_ROOT_CPU})
+#target_include_dires(${library_name} PRIVATE "/cluster/lib/boost/1.63.0/gcc")
+target_include_directories(${library_name} PRIVATE ${APPS_ROOT_CPU})
+#target_include_directories(${library_name} PRIVATE "/cluster/lib/boost/1.63.0/gcc/include/")
+
diff --git a/apps/cpu/TPMSRow/TPMSRow.cfg b/apps/cpu/TPMSRow/TPMSRow.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..095b0bb32836969bca0ff86b4a31b20e70c72f2a
--- /dev/null
+++ b/apps/cpu/TPMSRow/TPMSRow.cfg
@@ -0,0 +1,34 @@
+pathname = E:\SimulationsResults\TPMSRow
+#pathname = C:\temp\TPMSRow
+#pathname = /mnt/c/temp/TPMSRow
+numOfThreads = 1
+availMem = 15e10
+refineLevel = 0
+
+#Grid
+length =0.025 0.01 0.01
+blocknx = 25 50 50
+#dx =0.000050000000000000000000000000000000
+dx=0.0001
+#Geometry
+UnitEdgeLength=0.01
+TPMSL = 0.01 0.01 0.01
+TPMSOrigin = 0 0 0
+gridCubeOrigin = -0.005 0 0
+
+#Simulation
+nu = 0.0001523579766536965
+Re = 6563.489631218715
+Re0 = 6563.489631218715
+
+timeAvStart = 300
+timeAvStop = 1500
+
+beginTime = 0
+outTime = 100
+endTime = 200
+logToFile = false
+newStart = true
+restartStep = 1200000
+cpStart = 1200000
+cpStep = 1200000
diff --git a/apps/cpu/TPMSRow/TPMSRow.cpp b/apps/cpu/TPMSRow/TPMSRow.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6369340273cc21c666c1d049ad063a7ae0b8015e
--- /dev/null
+++ b/apps/cpu/TPMSRow/TPMSRow.cpp
@@ -0,0 +1,513 @@
+#include <iostream>
+#include <string>
+
+//#include <boost/pointer_cast.hpp>
+
+#include "VirtualFluids.h"
+
+using namespace std;
+using namespace vf::lbm::dir;
+using namespace vf::lbm::constant;
+
+void run(string configname)
+{
+ try {
+ vf::basics::ConfigurationFile config;
+ config.load(configname);
+
+ string pathname = config.getValue<string>("pathname");
+ int numOfThreads = config.getValue<int>("numOfThreads");
+ vector<int> blocknx = config.getVector<int>("blocknx");
+ double beginTime = config.getValue<double>("beginTime");
+ double endTime = config.getValue<double>("endTime");
+ double outTime = config.getValue<double>("outTime");
+ double availMem = config.getValue<double>("availMem");
+ double nu = config.getValue<double>("nu");
+ double dx = config.getValue<double>("dx");
+ double UnitEdgeLength = config.getValue<double>("UnitEdgeLength");
+ double Re = config.getValue<double>("Re");
+ double Re0 = config.getValue<double>("Re0");
+ //double rhoIn = config.getValue<double>("rhoIn");
+ //string geometry = config.getValue<string>("geometry");
+ vector<double> length = config.getVector<double>("length");
+ //vector<double> FunnelL = config.getVector<double>("FunnelL");
+ //vector<double> FunnelOrigin = config.getVector<double>("FunnelOrigin");
+
+ double timeAvStart = config.getValue<double>("timeAvStart");
+ double timeAvStop = config.getValue<double>("timeAvStop");
+
+ vector<double> TPMSL = config.getVector<double>("TPMSL");
+ vector<double> TPMSOrigin = config.getVector<double>("TPMSOrigin");
+ vector<double> gridCubeOrigin = config.getVector<double>("gridCubeOrigin");
+ int refineLevel = config.getValue<int>("refineLevel");
+ bool logToFile = config.getValue<bool>("logToFile");
+ double restartStep = config.getValue<double>("restartStep");
+ double cpStart = config.getValue<double>("cpStart");
+ double cpStep = config.getValue<double>("cpStep");
+ bool newStart = config.getValue<bool>("newStart");
+
+ //SPtr<Communicator> comm = MPICommunicator::getInstance();
+ SPtr<vf::mpi::Communicator> comm = vf::mpi::MPICommunicator::getInstance();
+ int myid = comm->getProcessID();
+ //int numOfProcesses = comm->getNumberOfProcesses();
+
+ if (logToFile) {
+#if defined(__unix__)
+ if (myid == 0) {
+ const char *str = pathname.c_str();
+ mkdir(str, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+ }
+#endif
+
+ if (myid == 0) {
+ stringstream logFilename;
+ logFilename << pathname + "/logfile" + UbSystem::toString(UbSystem::getTimeStamp()) + ".txt";
+ UbLog::output_policy::setStream(logFilename.str());
+ }
+ }
+ //dx = 1. / 100. / 112.;
+ double vx = Re * nu / (UnitEdgeLength / dx);
+
+ SPtr<LBMUnitConverter> conv = SPtr<LBMUnitConverter>(new LBMUnitConverter());
+
+ //UbSystem::makeDirectory(pathname);
+ //UbSystem::makeDirectory(pathname+ "/mig");
+ //UbSystem::makeDirectory(pathname+ "/geo");
+ //UbSystem::makeDirectory(pathname+ "/blocks/blocks_");
+
+
+ ////////////////////////////////////////////////////////////////////////
+ // BC Adapter
+ // BCAdapterPtr gradientAdapter(new VelocityBCAdapter(true, true, true, pdxC, pdyC, pdzC, 0.0,
+ // BCFunction::INFCONST));
+ // gradientAdapter->setBcAlgorithm(BCAlgorithmPtr(new FluxBCAlgorithm()));
+ // BCAdapterPtr cubeNoslipAdapter(new NoSlipBCAdapter(1));
+ SPtr<BCAdapter> tpmsNoslipAdapter(new NoSlipBCAdapter());
+ //SPtr<BCAdapter> funnelNoslipAdapter(new NoSlipBCAdapter(1));
+
+ // SPtr<BCAdapter> xMinApr(new DensityBCAdapter(0.0000001));
+ SPtr<BCAdapter> xMinApr(new DensityBCAdapter());
+ // SPtr<BCAdapter> xMinApr(new VelocityBCAdapter(vx, 0., BCFunction::INFCONST, 0., 0., BCFunction::INFCONST,
+ // 0.,0., BCFunction::INFCONST));
+
+ SPtr<BCAdapter> xMaxApr(new DensityBCAdapter(0.));
+ //SPtr<BCAdapter> yMinApr(new NoSlipBCAdapter(1));
+ //SPtr<BCAdapter> yMaxApr(new NoSlipBCAdapter(1));
+ SPtr<BCAdapter> zMinApr(new NoSlipBCAdapter());
+ SPtr<BCAdapter> zMaxApr(new NoSlipBCAdapter());
+
+ //SPtr<BCAdapter> zMinFunnelApr(new NoSlipBCAdapter(1));
+ //SPtr<BCAdapter> zMaxFunnelApr(new NoSlipBCAdapter(1));
+
+ //tpmsNoslipAdapter->setBcAlgorithm(BCAlgorithmPtr(new NoSlipBCAlgorithm()));
+ //tpmsNoslipAdapter->setBcAlgorithm(SPtr<BCAlgorithm>(new ThinWallNoSlipBCAlgorithm()));
+
+ tpmsNoslipAdapter->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+ //funnelNoslipAdapter->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+
+ //xMinApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NonEqDensityBCAlgorithm()));
+ // xMinApr->setBcAlgorithm(SPtr<BCAlgorithm>(new VelocityBCAlgorithm()));
+ xMinApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NonReflectingInflowBCAlgorithm()));
+ // xMinApr->setBcAlgorithm(SPtr<BCAlgorithm>(new VelocityWithDensityBCAlgorithm()));
+ //xMaxApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NonEqDensityBCAlgorithm()));
+ xMaxApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NonReflectingOutflowBCAlgorithmWithRelaxation()));
+ //yMinApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+ //yMaxApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+ zMinApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+ zMaxApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+
+ //zMinFunnelApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+ //zMaxFunnelApr->setBcAlgorithm(SPtr<BCAlgorithm>(new NoSlipBCAlgorithm()));
+
+ ////////////////////////////////////////////////////////////////////////
+ // BC visitor
+ BoundaryConditionsBlockVisitor bcVisitor;
+ // bcVisitor.addBC(cubeNoslipAdapter);
+ bcVisitor.addBC(tpmsNoslipAdapter);
+ //bcVisitor.addBC(funnelNoslipAdapter);
+ bcVisitor.addBC(xMinApr);
+ bcVisitor.addBC(xMaxApr);
+ //bcVisitor.addBC(yMinApr);
+ //bcVisitor.addBC(yMaxApr);
+ bcVisitor.addBC(zMinApr);
+ bcVisitor.addBC(zMaxApr);
+ //bcVisitor.addBC(zMinFunnelApr);
+ //bcVisitor.addBC(zMaxFunnelApr);
+
+ ////////////////////////////////////////////////////////////////////////
+ //spnonge layer
+ //mu::Parser spongeLayer;
+ //spongeLayer.SetExpr("x1>=(sizeX-sizeSP)/dx ? (sizeX/dx-(x1+1))/sizeSP/dx/2.0 + 0.5 : 1.0");
+ //spongeLayer.DefineConst("sizeX", length[0]);
+ //spongeLayer.DefineConst("sizeSP", 0.005);
+ //spongeLayer.DefineConst("dx", dx);
+
+ ////////////////////////////////////////////////////////////////////////
+ // grid, kernel and BCProcessor
+ SPtr<Grid3D> grid(new Grid3D(comm));
+ SPtr<LBMKernel> kernel;
+ //kernel = SPtr<LBMKernel>(new IncompressibleCumulantLBMKernel());
+ kernel = SPtr<LBMKernel>(new CompressibleCumulantLBMKernel());
+ //kernel = SPtr<LBMKernel>(new IncompressibleCumulantWithSpongeLayerLBMKernel());
+ //kernel->setWithSpongeLayer(true);
+ //kernel->setSpongeLayer(spongeLayer);
+ // kernel = ;
+ // kernel = SPtr<LBMKernel>(new CumulantK17LBMKernel());
+ // mu::Parser fctForcingX1;
+ // fctForcingX1.SetExpr("Fx2");
+ // fctForcingX1.DefineConst("Fx2", 5e-4);
+ // kernel->setForcingX1(fctForcingX1);
+ // kernel->setWithForcing(true);
+ //
+ // SPtr<ThinWallBCProcessor> bcProc(new ThinWallBCProcessor());
+ SPtr<BCProcessor> bcProc(new BCProcessor());
+ kernel->setBCProcessor(bcProc);
+
+
+ SPtr<Grid3DVisitor> metisVisitor(new MetisPartitioningGridVisitor(
+ comm, MetisPartitioningGridVisitor::LevelIntersected, DIR_00M, MetisPartitioner::RECURSIVE));
+
+ //////////////////////////////////////////////////////////////////////////
+ // restart
+ SPtr<UbScheduler> mSch(new UbScheduler(cpStep, cpStart));
+ SPtr<MPIIOMigrationCoProcessor> migCoProcessor(
+ new MPIIOMigrationCoProcessor(grid, mSch,metisVisitor, pathname + "/mig", comm));
+ migCoProcessor->setLBMKernel(kernel);
+ migCoProcessor->setBCProcessor(bcProc);
+ //////////////////////////////////////////////////////////////////////////
+
+ if (newStart) {
+ GbImplicitSurfacePtr tpms;
+ // tpms = GbImplicitSurfacePtr(new GbImplicitSurface(0, 0, 0, TPMSL[0], TPMSL[1], TPMSL[2], UnitEdgeLength,
+ // dx));
+ tpms = GbImplicitSurfacePtr(new GbImplicitSurface(TPMSOrigin[0], TPMSOrigin[1], TPMSOrigin[2],
+ TPMSOrigin[0] + TPMSL[0],
+ TPMSOrigin[1] + TPMSL[1],
+ TPMSOrigin[2] + TPMSL[2],
+ UnitEdgeLength, dx, 2.5e-4));
+
+ // for (int i = 0; i < 12; i++)
+ // {
+ // cout << tpms->evaluateImplicitFunction(0.002, 0.002, i/1000., 1.)<<endl;
+ // }
+
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(tpms.get(), pathname + "/geo/tpms", WbWriterVtkXmlBinary::getInstance());
+
+
+ //SPtr<GbTriFaceMesh3D> funnel;
+ //SPtr<GbTriFaceMesh3D> funnel(new GbTriFaceMesh3D());
+ //funnel->readMeshFromSTLFileBinary(geometry, true);
+
+
+
+ //funnel = SPtr<GbTriFaceMesh3D>(GbTriFaceMesh3DCreator::getInstance()->readMeshFromSTLFile2(geometry, "tpmsMeshBody", GbTriFaceMesh3D::KDTREE_SAHPLIT, false));
+ // funnel->rotate(0.,180,0.);
+
+ //funnel->translate(-funnel->getX1Minimum() - funnel->getLengthX1(),
+ //tpms->getX2Centroid() - funnel->getX2Centroid(),
+ //tpms->getX3Centroid() - funnel->getX3Centroid());
+ //if (myid == 0)
+ //GbSystem3D::writeGeoObject(funnel.get(), pathname + "/geo/funnel", WbWriterVtkXmlBinary::getInstance());
+
+ double g_minX1 = gridCubeOrigin[0];
+ double g_minX2 = gridCubeOrigin[1];
+ double g_minX3 = gridCubeOrigin[2];
+
+ double g_maxX1 = gridCubeOrigin[0] + length[0];
+ double g_maxX2 = gridCubeOrigin[1] + length[1];
+ double g_maxX3 = gridCubeOrigin[2] + length[2];
+
+ SPtr<GbObject3D> gridCube(new GbCuboid3D(g_minX1, g_minX2, g_minX3, g_maxX1, g_maxX2, g_maxX3));
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(gridCube.get(), pathname + "/geo/gridCube",
+ WbWriterVtkXmlBinary::getInstance());
+
+
+ SPtr<GbCuboid3D> spongecube(new GbCuboid3D(TPMSOrigin[0] + TPMSL[0], g_minX2 - dx, g_minX3 - dx,
+ g_maxX1 + dx, g_maxX2 + dx, g_maxX3 + dx));
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(spongecube.get(), pathname + "/geo/spongecube",
+ WbWriterVtkXmlBinary::getInstance());
+ if (myid == 0) {
+ // UBLOG(logINFO,"rho = " << rhoLB );
+ UBLOG(logINFO, "nu = " << nu);
+ UBLOG(logINFO, "Re = " << Re);
+ UBLOG(logINFO, "vx = " << vx);
+ UBLOG(logINFO, "dx = " << dx);
+ UBLOG(logINFO, "Preprocess - start");
+ }
+
+ grid->setDeltaX(dx);
+ grid->setBlockNX(blocknx[0], blocknx[1], blocknx[2]);
+ grid->setPeriodicX1(false);
+ grid->setPeriodicX2(true);
+ grid->setPeriodicX3(false);
+
+ GenBlocksGridVisitor genBlocks(gridCube);
+ grid->accept(genBlocks);
+
+ SPtr<CoProcessor> ppblocks(new WriteBlocksCoProcessor(grid, SPtr<UbScheduler>(new UbScheduler(1)), pathname,
+ WbWriterVtkXmlBinary::getInstance(), comm));
+
+ ppblocks->process(0);
+
+ // GbObject3DPtr solidcube(new GbCuboid3D(0, g_minX2, g_minX3, TPMSL[0], g_maxX2, g_maxX3));
+ // if (myid == 0) GbSystem3D::writeGeoObject(solidcube.get(), pathname + "/geo/solidcube",
+ // WbWriterVtkXmlBinary::getInstance());
+
+ GbCuboid3DPtr xMin(
+ new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_minX3 - dx, g_minX1, g_maxX2 + dx, g_maxX3 + dx));
+
+ /*GbCuboid3DPtr yMin(
+ new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_minX3 - dx, g_maxX1, g_minX2, g_maxX3 + dx));
+ GbCuboid3DPtr yMax(
+ new GbCuboid3D(g_minX1 - dx, g_maxX2, g_minX3 - dx, g_maxX1 + dx, g_maxX2 + dx, g_maxX3 + dx));*/
+
+ /* GbCuboid3DPtr zMinFunnel(
+ new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_minX3 - dx, g_maxX1, g_maxX2 + dx, g_minX3));
+ GbCuboid3DPtr zMaxFunnel(
+ new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_maxX3, g_maxX1 + dx, g_maxX2 + dx, g_maxX3 + dx));*/
+
+ //g_minX1 = 0.;
+ // g_minX2 = -length[1] / 2.0;
+ // g_minX3 = -length[2] / 2.0;
+
+ //g_maxX1 = TPMSL[0];
+ // g_maxX2 = length[1] / 2.0;
+ // g_maxX3 -= TPMSL[2] / 2.0;
+
+ GbCuboid3DPtr xMax(new GbCuboid3D(g_maxX1 , g_minX2 - dx, g_minX3 - dx, g_maxX1 + dx, g_maxX2 + dx,
+ g_maxX3 + dx));
+
+ //GbCuboid3DPtr zMin(new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_minX3 - dx, 1.1 * g_maxX1, g_maxX2 + dx,
+ // g_minX3 + 0.5 * (length[2] - TPMSL[2])));
+ //GbCuboid3DPtr zMax(new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_maxX3 - 0.5 * (length[2] - TPMSL[2]),
+ // 1.1 * g_maxX1, g_maxX2 + dx, g_maxX3));
+
+ GbCuboid3DPtr zMin(new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_minX3 - dx, g_maxX1 + dx, g_maxX2 + dx, g_minX3));
+ GbCuboid3DPtr zMax(new GbCuboid3D(g_minX1 - dx, g_minX2 - dx, g_maxX3, g_maxX1 + dx, g_maxX2 + dx, g_maxX3 + dx));
+
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(xMin.get(), pathname + "/geo/xMin", WbWriterVtkXmlBinary::getInstance());
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(xMax.get(), pathname + "/geo/xMax", WbWriterVtkXmlBinary::getInstance());
+ /* if (myid == 0)
+ GbSystem3D::writeGeoObject(yMin.get(), pathname + "/geo/yMin", WbWriterVtkXmlBinary::getInstance());
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(yMax.get(), pathname + "/geo/yMax", WbWriterVtkXmlBinary::getInstance());*/
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(zMin.get(), pathname + "/geo/zMin", WbWriterVtkXmlBinary::getInstance());
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(zMax.get(), pathname + "/geo/zMax", WbWriterVtkXmlBinary::getInstance());
+
+ /* if (myid == 0)
+ GbSystem3D::writeGeoObject(zMinFunnel.get(), pathname + "/geo/zMinFunnel",
+ WbWriterVtkXmlBinary::getInstance());
+ if (myid == 0)
+ GbSystem3D::writeGeoObject(zMaxFunnel.get(), pathname + "/geo/zMaxFunnel",
+ WbWriterVtkXmlBinary::getInstance());*/
+
+ // D3Q27InteractorPtr cubeInt = D3Q27InteractorPtr(new D3Q27Interactor(solidcube, grid, cubeNoslipAdapter,
+ // Interactor3D::SOLID));
+ SPtr<D3Q27Interactor> tpmsInt = SPtr<D3Q27Interactor>(
+ new D3Q27Interactor(tpms, grid, tpmsNoslipAdapter, Interactor3D::SOLID, Interactor3D::POINTS));
+ //SPtr<Interactor3D> funnelInt = SPtr<D3Q27TriFaceMeshInteractor>(
+ //new D3Q27TriFaceMeshInteractor(funnel, grid, funnelNoslipAdapter, Interactor3D::SOLID));
+ // D3Q27TriFaceMeshInteractorPtr tpmsInt = D3Q27TriFaceMeshInteractorPtr(new
+ // D3Q27TriFaceMeshInteractor(tpms, grid, tpmsNoslipAdapter, Interactor3D::SOLID));
+ // tpmsInt->setQs2(0);
+
+ SPtr<D3Q27Interactor> xMinInt = SPtr<D3Q27Interactor>(
+ new D3Q27Interactor(xMin, grid, xMinApr, Interactor3D::SOLID, Interactor3D::POINTS));
+ SPtr<D3Q27Interactor> xMaxInt = SPtr<D3Q27Interactor>(
+ new D3Q27Interactor(xMax, grid, xMaxApr, Interactor3D::SOLID, Interactor3D::POINTS));
+ /* SPtr<D3Q27Interactor> yMinInt =
+ SPtr<D3Q27Interactor>(new D3Q27Interactor(yMin, grid, yMinApr, Interactor3D::SOLID));
+ SPtr<D3Q27Interactor> yMaxInt =
+ SPtr<D3Q27Interactor>(new D3Q27Interactor(yMax, grid, yMaxApr, Interactor3D::SOLID));*/
+ SPtr<D3Q27Interactor> zMinInt = SPtr<D3Q27Interactor>(
+ new D3Q27Interactor(zMin, grid, zMinApr, Interactor3D::SOLID, Interactor3D::POINTS));
+ SPtr<D3Q27Interactor> zMaxInt = SPtr<D3Q27Interactor>(
+ new D3Q27Interactor(zMax, grid, zMaxApr, Interactor3D::SOLID, Interactor3D::POINTS));
+
+ /*SPtr<D3Q27Interactor> zMinFunnelInt =
+ SPtr<D3Q27Interactor>(new D3Q27Interactor(zMinFunnel, grid, zMinFunnelApr, Interactor3D::SOLID));
+ SPtr<D3Q27Interactor> zMaxFunnelInt =
+ SPtr<D3Q27Interactor>(new D3Q27Interactor(zMaxFunnel, grid, zMaxFunnelApr, Interactor3D::SOLID));*/
+
+ // return;
+
+ InteractorsHelper intHelper(grid, metisVisitor,false);
+
+ //intHelper.addInteractor(cubeInt);
+ //intHelper.addInteractor(zMinFunnelInt);
+ //intHelper.addInteractor(zMaxFunnelInt);
+ //intHelper.addInteractor(funnelInt);
+
+ intHelper.addInteractor(tpmsInt);
+ intHelper.addInteractor(zMinInt);
+ intHelper.addInteractor(zMaxInt);
+
+ intHelper.addInteractor(xMinInt);
+ intHelper.addInteractor(xMaxInt);
+ //intHelper.addInteractor(yMinInt);
+ //intHelper.addInteractor(yMaxInt);
+
+
+ intHelper.selectBlocks();
+ // intHelper.selectBlocks2();
+
+
+ // domain decomposition for threads
+ PQueuePartitioningGridVisitor pqPartVisitor(numOfThreads);
+ grid->accept(pqPartVisitor);
+
+ ppblocks->process(0);
+ ppblocks.reset();
+
+ //////////////////////////////////////////////////////////////////////////
+ unsigned long long numberOfBlocks = (unsigned long long)grid->getNumberOfBlocks();
+ int ghostLayer = 3;
+ unsigned long long numberOfNodesPerBlock =
+ (unsigned long long)(blocknx[0]) * (unsigned long long)(blocknx[1]) * (unsigned long long)(blocknx[2]);
+ unsigned long long numberOfNodes = numberOfBlocks * numberOfNodesPerBlock;
+ unsigned long long numberOfNodesPerBlockWithGhostLayer =
+ numberOfBlocks * (blocknx[0] + ghostLayer) * (blocknx[1] + ghostLayer) * (blocknx[2] + ghostLayer);
+ double needMemAll =
+ double(numberOfNodesPerBlockWithGhostLayer * (27 * sizeof(double) + sizeof(int) + sizeof(float) * 4));
+ double needMem = needMemAll / double(comm->getNumberOfProcesses());
+
+ if (myid == 0) {
+ UBLOG(logINFO, "Number of blocks = " << numberOfBlocks);
+ UBLOG(logINFO, "Number of nodes = " << numberOfNodes);
+ int minInitLevel = grid->getCoarsestInitializedLevel();
+ int maxInitLevel = grid->getFinestInitializedLevel();
+ for (int level = minInitLevel; level <= maxInitLevel; level++) {
+ int nobl = grid->getNumberOfBlocks(level);
+ UBLOG(logINFO, "Number of blocks for level " << level << " = " << nobl);
+ UBLOG(logINFO, "Number of nodes for level " << level << " = " << nobl * numberOfNodesPerBlock);
+ }
+ UBLOG(logINFO, "Necessary memory = " << needMemAll << " bytes");
+ UBLOG(logINFO, "Necessary memory per process = " << needMem << " bytes");
+ UBLOG(logINFO, "Available memory per process = " << availMem << " bytes");
+ }
+ //////////////////////////////////////////////////////////////////////////
+
+ SetKernelBlockVisitor kernelVisitor(kernel, nu, availMem, needMem);
+ grid->accept(kernelVisitor);
+
+ // if (refineLevel > 0)
+ // {
+ // SetUndefinedNodesBlockVisitor undefNodesVisitor;
+ // grid->accept(undefNodesVisitor);
+ // }
+
+ intHelper.setBC();
+
+ SpongeLayerBlockVisitor spongeLayerVisitor(spongecube, kernel, nu, DIR_P00);
+ grid->accept(spongeLayerVisitor);
+
+ grid->accept(bcVisitor);
+
+ // initialization of distributions
+ InitDistributionsBlockVisitor initVisitor;
+ //initVisitor.setVx1(0.001);
+ // initVisitor.setVx1(uLB);
+ grid->accept(initVisitor);
+
+ // boundary conditions grid
+ {
+ SPtr<UbScheduler> geoSch(new UbScheduler(1));
+ SPtr<CoProcessor> ppgeo(new WriteBoundaryConditionsCoProcessor(grid, geoSch, pathname, WbWriterVtkXmlBinary::getInstance(), comm));
+ ppgeo->process(0);
+ ppgeo.reset();
+ }
+ if (myid == 0)
+ UBLOG(logINFO, "Preprocess - end");
+ }
+ else
+ {
+ if (myid == 0) {
+ UBLOG(logINFO, "Parameters:");
+ //UBLOG(logINFO, "uLb = " << uLB);
+ //UBLOG(logINFO, "rho = " << rhoLB);
+ //UBLOG(logINFO, "nuLb = " << nuLB);
+ UBLOG(logINFO, "Re = " << Re);
+ UBLOG(logINFO, "dx = " << dx);
+ UBLOG(logINFO, "number of levels = " << refineLevel + 1);
+ UBLOG(logINFO, "numOfThreads = " << numOfThreads);
+ UBLOG(logINFO, "path = " << pathname);
+ }
+
+ migCoProcessor->restart((int)restartStep);
+ grid->setTimeStep(restartStep);
+
+ if (myid == 0)
+ UBLOG(logINFO, "Restart - end");
+ }
+ // set connectors
+ SPtr<InterpolationProcessor> iProcessor(new CompressibleOffsetInterpolationProcessor());
+ //SetConnectorsBlockVisitor setConnsVisitor(comm, true, D3Q27System::ENDDIR, nu, iProcessor);
+ OneDistributionSetConnectorsBlockVisitor setConnsVisitor(comm);
+ grid->accept(setConnsVisitor);
+
+
+
+
+ SPtr<UbScheduler> visSch(new UbScheduler(outTime/*,beginTime,endTime*/));
+ SPtr<CoProcessor> pp(new WriteMacroscopicQuantitiesCoProcessor(grid, visSch, pathname, WbWriterVtkXmlBinary::getInstance(), conv, comm));
+
+ SPtr<UbScheduler> tavSch(new UbScheduler(100, timeAvStart, timeAvStop));
+ SPtr<TimeAveragedValuesCoProcessor> tav(new TimeAveragedValuesCoProcessor(grid, pathname, WbWriterVtkXmlBinary::getInstance(), tavSch, comm,
+ TimeAveragedValuesCoProcessor::Density | TimeAveragedValuesCoProcessor::Velocity | TimeAveragedValuesCoProcessor::Fluctuations));
+ tav->setWithGhostLayer(true);
+
+ SPtr<UbScheduler> nuSch(new UbScheduler(100, 0, endTime / 2));
+ mu::Parser fnu;
+ fnu.SetExpr("(L*u/T)*(((T-2*t)/Re0)+(2*t/Re))");
+ fnu.DefineConst("Re0", Re0);
+ fnu.DefineConst("Re", Re);
+ fnu.DefineConst("T", endTime);
+ fnu.DefineConst("L", (UnitEdgeLength / dx));
+ fnu.DefineConst("u", vx);
+ SPtr<CoProcessor> nupr(new DecreaseViscosityCoProcessor(grid, nuSch, &fnu, comm));
+
+ SPtr<UbScheduler> nupsSch(new UbScheduler(100, 100, 100000000));
+ SPtr<CoProcessor> npr(new NUPSCounterCoProcessor(grid, nupsSch, numOfThreads, comm));
+
+ //omp_set_num_threads(numOfThreads);
+ numOfThreads = 1;
+ SPtr<UbScheduler> stepGhostLayer(visSch);
+ SPtr<Calculator> calculator(new BasicCalculator(grid, stepGhostLayer, int(endTime)));
+
+ //calculator->addCoProcessor(nupr);
+ calculator->addCoProcessor(npr);
+ calculator->addCoProcessor(pp);
+ calculator->addCoProcessor(migCoProcessor);
+ calculator->addCoProcessor(tav);
+
+ if (myid == 0)
+ UBLOG(logINFO, "Simulation-start");
+ calculator->calculate();
+ if (myid == 0)
+ UBLOG(logINFO, "Simulation-end");
+ } catch (std::exception &e) {
+ cerr << e.what() << endl << flush;
+ } catch (std::string &s) {
+ cerr << s << endl;
+ } catch (...) {
+ cerr << "unknown exception" << endl;
+ }
+}
+int main(int argc, char *argv[])
+{
+ //Sleep(25000);
+ if (argv != NULL) {
+ if (argv[1] != NULL) {
+ run(string(argv[1]));
+ } else {
+ cout << "Configuration file is missing!" << endl;
+ }
+ }
+}
diff --git a/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp b/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp
index 97ccf92dc72e253d5f38f88353ba564320e8fd65..cdf82c32ef982dec19df49ae347e5601017a538b 100644
--- a/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp
+++ b/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp
@@ -13,10 +13,10 @@ std::shared_ptr<NumericalTestGridReader> NumericalTestGridReader::getNewInstance
return std::shared_ptr<NumericalTestGridReader>(new NumericalTestGridReader(para, initialCondition, cudaManager));
}
-void NumericalTestGridReader::setInitalNodeValues(const int numberOfNodes, const int level) const
+void NumericalTestGridReader::setInitalNodeValues(uint numberOfNodes, int level) const
{
initialCondition->init(level);
- for (int j = 0; j <= numberOfNodes; j++){
+ for (uint j = 0; j <= numberOfNodes; j++){
para->getParH(level)->velocityX[j] = initialCondition->getInitVX(j, level);
para->getParH(level)->velocityY[j] = initialCondition->getInitVY(j, level);
para->getParH(level)->velocityZ[j] = initialCondition->getInitVZ(j, level);
diff --git a/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h b/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h
index b766e4bab7e0f2667d35f416b9130bea657c823c..84f5d72705db06349f0b31a42eb99ded45bb0e1d 100644
--- a/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h
+++ b/apps/gpu/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h
@@ -13,8 +13,8 @@ public:
static std::shared_ptr<NumericalTestGridReader> getNewInstance(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<CudaMemoryManager> cudaManager);
protected:
- void setInitalNodeValues(const int numberOfNodes, const int level) const;
-
+ virtual void setInitalNodeValues(uint numberOfNodes, int level) const override;
+
private:
NumericalTestGridReader(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<CudaMemoryManager> cudaManager);
diff --git a/pythonbindings/CMakeLists.txt b/pythonbindings/CMakeLists.txt
index 815a4b59cf6c3e4e5ac4a7a72a5bd4e374d64c96..037b68baf53d5da8a1ccd20155cb0e7be483176b 100644
--- a/pythonbindings/CMakeLists.txt
+++ b/pythonbindings/CMakeLists.txt
@@ -7,12 +7,13 @@ endif()
project(VirtualFluidsPython LANGUAGES ${PYFLUIDS_LANGUAGES})
pybind11_add_module(python_bindings MODULE src/VirtualFluids.cpp)
+target_compile_definitions(python_bindings PUBLIC VF_DOUBLE_ACCURACY)
set_target_properties( python_bindings PROPERTIES
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/pythonbindings/pyfluids
OUTPUT_NAME "bindings")
-target_link_libraries(python_bindings PRIVATE basics logger mpi)
+target_link_libraries(python_bindings PRIVATE basics logger mpi lbm)
IF(BUILD_VF_GPU)
set_source_files_properties(src/VirtualFluids.cpp PROPERTIES LANGUAGE CUDA)
@@ -20,12 +21,12 @@ IF(BUILD_VF_GPU)
target_include_directories(python_bindings PRIVATE ${VF_THIRD_DIR}/cuda_samples/)
target_compile_definitions(python_bindings PRIVATE VF_GPU_PYTHONBINDINGS)
- target_link_libraries(python_bindings PRIVATE GridGenerator VirtualFluids_GPU lbm)
+ target_link_libraries(python_bindings PRIVATE GridGenerator VirtualFluids_GPU)
ENDIF()
IF(BUILD_VF_CPU)
target_compile_definitions(python_bindings PRIVATE VF_METIS VF_MPI VF_CPU_PYTHONBINDINGS)
- target_link_libraries(python_bindings PRIVATE simulationconfig VirtualFluidsCore muparser lbm)
+ target_link_libraries(python_bindings PRIVATE simulationconfig VirtualFluidsCore muparser)
# include bindings for muparsers
pybind11_add_module(pymuparser MODULE src/muParser.cpp)
diff --git a/pythonbindings/src/cpu/submodules/boundaryconditions.cpp b/pythonbindings/src/cpu/submodules/boundaryconditions.cpp
index ac9ec8605dec51e8374c850b1c1b58314674c426..d7cd0b578a52c369923db0e31b01200f0389c9eb 100644
--- a/pythonbindings/src/cpu/submodules/boundaryconditions.cpp
+++ b/pythonbindings/src/cpu/submodules/boundaryconditions.cpp
@@ -77,14 +77,14 @@ namespace boundaryconditions
bc_class<VelocityBCAdapter, VelocityBCAlgorithm>(bcModule, "VelocityBoundaryCondition")
.def(py::init())
- .def(py::init<bool &, bool &, bool &, mu::Parser &, double &, double &>(),
+ .def(py::init<bool &, bool &, bool &, mu::Parser &, real &, real &>(),
"vx1"_a, "vx2"_a, "vx3"_a,
"function"_a, "start_time"_a, "end_time"_a)
- .def(py::init<bool &, bool &, bool &, mu::Parser &, mu::Parser &, mu::Parser &, double &, double &>(),
+ .def(py::init<bool &, bool &, bool &, mu::Parser &, mu::Parser &, mu::Parser &, real &, real &>(),
"vx1"_a, "vx2"_a, "vx3"_a,
"function_vx1"_a, "function_vx2"_a, "function_vx2"_a,
"start_time"_a, "end_time"_a)
- .def(py::init<double &, double &, double &, double &, double &, double &, double &, double &, double &>(),
+ .def(py::init<real &, real &, real &, real &, real &, real &, real &, real &, real &>(),
"vx1"_a, "vx1_start_time"_a, "vx1_end_time"_a,
"vx2"_a, "vx2_start_time"_a, "vx2_end_time"_a,
"vx3"_a, "vx3_start_time"_a, "vx3_end_time"_a);
diff --git a/pythonbindings/src/cpu/submodules/kernel.cpp b/pythonbindings/src/cpu/submodules/kernel.cpp
index b00d86579540a299e4bf3ed47bc09d4386f420a2..2f2effa7ef28600e67fb2e2954409a0963df1f37 100644
--- a/pythonbindings/src/cpu/submodules/kernel.cpp
+++ b/pythonbindings/src/cpu/submodules/kernel.cpp
@@ -55,7 +55,7 @@ namespace kernel
.def_readwrite("forcing_in_x1", &LBMKernelConfiguration::forcingX1)
.def_readwrite("forcing_in_x2", &LBMKernelConfiguration::forcingX2)
.def_readwrite("forcing_in_x3", &LBMKernelConfiguration::forcingX3)
- .def("set_forcing", [](LBMKernelConfiguration &kernelConfig, double x1, double x2, double x3)
+ .def("set_forcing", [](LBMKernelConfiguration &kernelConfig, real x1, real x2, real x3)
{
kernelConfig.forcingX1 = x1;
kernelConfig.forcingX2 = x2;
diff --git a/regression-tests/driven_cavity_test.sh b/regression-tests/driven_cavity_test.sh
index 7f799facb4459ddafcd8b210a5477954af1444cb..b8998e309a4553cba96c015c83d45e35274e3e56 100755
--- a/regression-tests/driven_cavity_test.sh
+++ b/regression-tests/driven_cavity_test.sh
@@ -18,7 +18,7 @@ PATH_TO_DIR=output/DrivenCavity
# set the path to the reference data.
# `regression-tests/reference_data` is fix `regression_tests/gpu/DrivenCavity_2Levels` must match the structure in https://github.com/irmb/test_data:
-PATH_TO_REFERENCE_DIR=regression-tests/reference_data/regression_tests/gpu/DrivenCavity_2Levels
+PATH_TO_REFERENCE_DIR=reference_data/regression_tests/gpu/DrivenCavity_2Levels
# execute fieldcompare (A more comprehensive manual can be found here https://gitlab.com/dglaeser/fieldcompare)
fieldcompare dir $PATH_TO_DIR $PATH_TO_REFERENCE_DIR --include-files "*.vtu"
diff --git a/regression-tests/driven_cavity_uniform_test.sh b/regression-tests/driven_cavity_uniform_test.sh
index 95e2bab635d3a6a73fb514a1f67902083c98e5d3..ae47c98af85252fb61aeb5fb7e4315692ab4b866 100755
--- a/regression-tests/driven_cavity_uniform_test.sh
+++ b/regression-tests/driven_cavity_uniform_test.sh
@@ -19,7 +19,7 @@ PATH_TO_DIR=output/DrivenCavity_uniform
# set the path to the reference data.
# `regression-tests/reference_data` is fix `regression_tests/gpu/DrivenCavity_uniform_2022_12_16` must match the structure in https://github.com/irmb/test_data:
-PATH_TO_REFERENCE_DIR=regression-tests/reference_data/regression_tests/gpu/DrivenCavity_uniform
+PATH_TO_REFERENCE_DIR=reference_data/regression_tests/gpu/DrivenCavity_uniform
# execute fieldcompare (A more comprehensive manual can be found here https://gitlab.com/dglaeser/fieldcompare)
fieldcompare dir $PATH_TO_DIR $PATH_TO_REFERENCE_DIR --include-files "*.vtu"
diff --git a/regression-tests/reference_data b/regression-tests/reference_data
deleted file mode 160000
index 794c3f838577d2b1f4db22c19861cbf0fed4fee6..0000000000000000000000000000000000000000
--- a/regression-tests/reference_data
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 794c3f838577d2b1f4db22c19861cbf0fed4fee6
diff --git a/regression-tests/regression-tests.sh b/regression-tests/regression-tests.sh
index 9f5dc8cf758b380709fcc9ad8020d1335f760f64..e4cb07c63369cd1c1743e7e223812830caafe02f 100755
--- a/regression-tests/regression-tests.sh
+++ b/regression-tests/regression-tests.sh
@@ -6,8 +6,8 @@
# 1. Cloning the reference data from github
-mkdir -p regression-tests/reference_data
-git clone https://github.com/irmb/test_data regression-tests/reference_data
+rm -r reference_data && mkdir -p reference_data
+git clone https://github.com/irmb/test_data reference_data
# 2. set up the python environnement
# by cloning our meshio patch and fieldcompare into a venv
diff --git a/src/basics/CMakeLists.txt b/src/basics/CMakeLists.txt
index 7f871424b2c6849d2c0f6e8d277b17214fa5cd9c..14e1760fe3cb6f9b1e122f4adc5adbfb3e30b5c7 100644
--- a/src/basics/CMakeLists.txt
+++ b/src/basics/CMakeLists.txt
@@ -21,4 +21,8 @@ IF(MSVC)
target_compile_definitions(${library_name} PUBLIC NOMINMAX) # Disable Min/Max-Macros
ENDIF(MSVC)
+if(BUILD_USE_BOOST)
+ target_link_libraries(${library_name} PRIVATE Boost::boost)
+endif()
+
vf_add_tests()
diff --git a/src/basics/geometry3d/GbImplicitSurface.cpp b/src/basics/geometry3d/GbImplicitSurface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dec5717341d0f55e2b34b3e87d4f15e2b077f8c
--- /dev/null
+++ b/src/basics/geometry3d/GbImplicitSurface.cpp
@@ -0,0 +1,446 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file GbImplicitSurface.cpp
+//! \ingroup geometry3d
+//! \author Hussein Alihussein
+//=======================================================================================
+
+#include <GbImplicitSurface.h>
+
+#ifdef BUILD_USE_BOOST
+
+#include <basics/utilities/UbMath.h>
+
+#include <geometry3d/GbSystem3D.h>
+#include <geometry3d/GbTriangle3D.h>
+
+#include <boost/math/tools/roots.hpp>
+
+
+using namespace std;
+using boost::math::tools::bisect;
+
+/*=======================================================*/
+// ObObjectCreator* GbImplicitSurface::getCreator()
+// {
+// GbObject3DCreator instance;
+// return &instance;
+// }
+/*=======================================================*/
+// Konstruktor
+GbImplicitSurface::GbImplicitSurface() //: GbObject3D()
+{
+
+}
+/*=======================================================*/
+// Konstruktor
+GbImplicitSurface::GbImplicitSurface(const double& x1a, const double& x2a, const double& x3a, const double& x1b, const double& x2b, const double& x3b, const double& edgeLength, const double& dx, const double& thickness) :GbObject3D()
+{
+ this->p1 = new GbPoint3D(x1a, x2a, x3a);
+ this->p2 = new GbPoint3D(x1b, x2b, x3b);
+ this->p1->addObserver(this);
+ this->p2->addObserver(this);
+
+ this->p3 = new GbPoint3D(x1a, x2a, x3a);
+ this->p4 = new GbPoint3D(x1b, x2b, x3b);
+ this->p3->addObserver(this);
+ this->p4->addObserver(this);
+
+ this->edgeLength = edgeLength;
+ this->dx = dx;
+ this->thickness = thickness;
+}
+/*=======================================================*/
+// Konstruktor
+//GbImplicitSurface::GbImplicitSurface(
+// const double& x1a, const double& x2a, const double& x3a,
+// const double& x1b, const double& x2b, const double& x3b,
+//
+// const double& x1c, const double& x2c, const double& x3c,
+// const double& x1d, const double& x2d, const double& x3d,
+//
+// const double& edgeLength, const double& dx) :GbObject3D()
+//{
+// this->p1 = new GbPoint3D(x1a, x2a, x3a);
+// this->p2 = new GbPoint3D(x1b, x2b, x3b);
+//
+// this->p3 = new GbPoint3D(x1c, x2c, x3c);
+// this->p4 = new GbPoint3D(x1d, x2d, x3d);
+//
+// this->edgeLength = edgeLength;
+// this->dx = dx;
+//}
+GbImplicitSurface::GbImplicitSurface(GbImplicitSurface * imp)
+{
+}
+/*=======================================================*/
+// Destruktor
+GbImplicitSurface::~GbImplicitSurface()
+{
+ if (this->p1)
+ this->p1->removeObserver(this);
+ if (this->p2)
+ this->p2->removeObserver(this);
+ if (this->p3)
+ this->p3->removeObserver(this);
+ if (this->p4)
+ this->p4->removeObserver(this);
+}
+/*=======================================================*/
+struct TerminationCondition {
+ bool operator() (double min, double max) {
+ return abs(min - max) <= 10e-10;
+ }
+};
+/*============================================M-===========*/
+struct FunctionToApproximate {
+ double x, y, z;
+ double dir1, dir2, dir3, L;
+ double operator() (double q) {
+ return sin(2.*M_PI / L*(x + q*dir1))*cos(2.*M_PI / L*(y + q*dir2)) + sin(2.*M_PI / L*(y + q*dir2))*cos(2.*M_PI / L*(z + q*dir3)) + sin(2.*M_PI / L*(z + q*dir3))*cos(2.*M_PI / L*(x + q*dir1));
+ }
+};
+/*=======================================================*/
+struct FunctionGyroidThirdOrder {
+ double x, y, z;
+ double dir1, dir2, dir3, L;
+ double h;
+
+ double t17, t3, t2, t18, t20, t8, t13, t5, t9, t6, t11, t14;
+ double f300, f210, f201, f120, f102, f030, f021, f012, f003, f200, f110, f101, f020, f011, f002, f100, f010, f001, f000;
+
+ double repeatedTerm, repeatedTermRoot;
+ double T1, T2, T3, T4, T5, T6, T7, T8, T9, Gyroidh;
+
+ double operator() (double q) {
+ //sins and cosines combinations
+ t2 = sin((2. * M_PI*(x+q*dir1)) / L)*sin((2. * M_PI*(y+q*dir2)) / L);
+ t3 = sin((2. * M_PI*(x+q*dir1)) / L)*sin((2. * M_PI*(z+q*dir3)) / L);
+ t5 = cos((2. * M_PI*(y+q*dir2)) / L)*sin((2. * M_PI*(x+q*dir1)) / L);
+ t6 = cos((2. * M_PI*(z+q*dir3)) / L)*sin((2. * M_PI*(x+q*dir1)) / L);
+ t8 = sin((2. * M_PI*(y+q*dir2)) / L)*sin((2. * M_PI*(z+q*dir3)) / L);
+ t9 = cos((2. * M_PI*(x+q*dir1)) / L)*sin((2. * M_PI*(y+q*dir2)) / L);
+ t11 = cos((2. * M_PI*(z+q*dir3)) / L)*sin((2. * M_PI*(y+q*dir2)) / L);
+ t13 = cos((2. * M_PI*(x+q*dir1)) / L)*sin((2. * M_PI*(z+q*dir3)) / L);
+ t14 = cos((2. * M_PI*(y+q*dir2)) / L)*sin((2. * M_PI*(z+q*dir3)) / L);
+ t17 = cos((2. * M_PI*(x+q*dir1)) / L)*cos((2. * M_PI*(y+q*dir2)) / L);
+ t18 = cos((2. * M_PI*(x+q*dir1)) / L)*cos((2. * M_PI*(z+q*dir3)) / L);
+ t20 = cos((2. * M_PI*(y+q*dir2)) / L)*cos((2. * M_PI*(z+q*dir3)) / L);
+
+ //Gyroid third order derivatives
+ f300 = (8. * pow(M_PI, 3.)*(-t17 + t3)) / pow(L, 3.);
+ f210 = (8. * pow(M_PI, 3.)*t2) / pow(L, 3.);
+ f201 = (-8. * pow(M_PI, 3.)*t18) / pow(L, 3.);
+ f120 = (-8. * pow(M_PI, 3.)*t17) / pow(L, 3.);
+ f102 = (8. * pow(M_PI, 3.)*t3) / pow(L, 3.);
+ f030 = (8. * pow(M_PI, 3.)*(t2 - t20)) / pow(L, 3.);
+ f021 = (8. * pow(M_PI, 3.)*t8) / pow(L, 3.);
+ f012 = (-8. * pow(M_PI, 3.)*t20) / pow(L, 3.);
+ f003 = (8. * pow(M_PI, 3.)*(-t18 + t8)) / pow(L, 3.);
+
+ //Gyroid second order derivatives
+ f200 = (-4. * pow(M_PI, 2.)*(t13 + t5)) / pow(L, 2.);
+ f110 = (-4. * pow(M_PI, 2.)*t9) / pow(L, 2.);
+ f101 = (-4. * pow(M_PI, 2.)*t6) / pow(L, 2.);
+ f020 = (-4. * pow(M_PI, 2.)*(t11 + t5)) / pow(L, 2.);
+ f011 = (-4. * pow(M_PI, 2.)*t14) / pow(L, 2.);
+ f002 = (-4. * pow(M_PI, 2.)*(t11 + t13)) / pow(L, 2.);
+
+ //Gyroid first order derivatives
+ f100 = (2. * M_PI*(t17 - t3)) / L;
+ f010 = (2. * M_PI*(-t2 + t20)) / L;
+ f001 = (2. * M_PI*(t18 - t8)) / L;
+
+ //Gyroid
+ f000 = t11 + t13 + t5;
+
+ repeatedTerm = f100*f100 + f010*f010 + f001*f001;
+ repeatedTermRoot = sqrt(repeatedTerm);
+
+ T1 = f001*f002 + f010*f011 + f100*f101;
+ T2 = f001*f011 + f010*f020 + f100*f110;
+ T3 = f001*f101 + f010*f110 + f100*f200;
+ T4 = f002*f011 + f001*f012 + f011*f020 + f010*f021 + f101*f110;
+ T5 = f002*f101 + f001*f102 + f011*f110 + f101*f200 + f100*f201;
+ T6 = f011*f101 + f020*f110 + f010*f120 + f110*f200 + f100*f210;
+ T7 = f001*f002*h + f010*f011*h + f100*f101*h;
+ T8 = f001*f011*h + f010*f020*h + f100*f110*h;
+ T9 = f001*f101*h + f010*f110*h + f100*f200*h;
+
+
+ Gyroidh = 2 * h*sqrt(pow(f001 - (T1*h) / (2.*repeatedTermRoot), 2) + pow(f010 - (T2*h) / (2.*repeatedTermRoot), 2) + pow(f100 - (T3*h) / (2.*repeatedTermRoot), 2))
+ - (3 * h*sqrt(pow(f001 - (T1*h) / (3.*repeatedTermRoot), 2) + pow(f010 - (T2*h) / (3.*repeatedTermRoot), 2) + pow(f100 - (T3*h) / (3.*repeatedTermRoot), 2))) / 2.
+ - (3 * h*sqrt(pow(f001 - (T1*h) / (3.*repeatedTermRoot) + (h*((T7 - 3 * f001*repeatedTermRoot)*
+ (4 * pow(T1, 2)*h - 4 * (pow(f002, 2) + f001*f003 + pow(f011, 2) + f010*f012 + pow(f101, 2) + f100*f102)*h*repeatedTerm + 12 * f002*pow(repeatedTerm, 1.5)) +
+ (T8 - 3 * f010*repeatedTermRoot)*(4 * T1*T2*h - 4 * (T4)*h*repeatedTerm + 12 * f011*pow(repeatedTerm, 1.5)) +
+ (T9 - 3 * f100*repeatedTermRoot)*(4 * T1*T3*h - 4 * (T5)*h*repeatedTerm + 12 * f101*pow(repeatedTerm, 1.5)))) /
+ (108.*sqrt(pow(f001 - (T1*h) / (3.*repeatedTermRoot), 2) + pow(f010 - (T2*h) / (3.*repeatedTermRoot), 2) + pow(f100 - (T3*h) / (3.*repeatedTermRoot), 2))*
+ pow(repeatedTerm, 2)), 2) + pow(f010 - (T2*h) / (3.*repeatedTermRoot) +
+ (h*((T7 - 3 * f001*repeatedTermRoot)*(4 * T1*T2*h - 4 * (T4)*h*repeatedTerm + 12 * f011*pow(repeatedTerm, 1.5)) +
+ (T8 - 3 * f010*repeatedTermRoot)*(4 * pow(T2, 2)*h - 4 * (pow(f011, 2) + pow(f020, 2) + f001*f021 + f010*f030 + pow(f110, 2) + f100*f120)*h*repeatedTerm + 12 * f020*pow(repeatedTerm, 1.5)) +
+ (T9 - 3 * f100*repeatedTermRoot)*(4 * T2*T3*h - 4 * (T6)*h*repeatedTerm + 12 * f110*pow(repeatedTerm, 1.5)))) /
+ (108.*sqrt(pow(f001 - (T1*h) / (3.*repeatedTermRoot), 2) + pow(f010 - (T2*h) / (3.*repeatedTermRoot), 2) + pow(f100 - (T3*h) / (3.*repeatedTermRoot), 2))*
+ pow(repeatedTerm, 2)), 2) + pow(f100 - (T3*h) / (3.*repeatedTermRoot) +
+ (h*((T7 - 3 * f001*repeatedTermRoot)*(4 * T1*T3*h - 4 * (T5)*h*repeatedTerm + 12 * f101*pow(repeatedTerm, 1.5)) +
+ (T8 - 3 * f010*repeatedTermRoot)*(4 * T2*T3*h - 4 * (T6)*h*repeatedTerm + 12 * f110*pow(repeatedTerm, 1.5)) +
+ (T9 - 3 * f100*repeatedTermRoot)*(4 * pow(T3, 2)*h - 4 * (pow(f101, 2) + pow(f110, 2) + pow(f200, 2) + f001*f201 + f010*f210 + f100*f300)*h*repeatedTerm + 12 * f200*pow(repeatedTerm, 1.5)))) /
+ (108.*sqrt(pow(f001 - (T1*h) / (3.*repeatedTermRoot), 2) + pow(f010 - (T2*h) / (3.*repeatedTermRoot), 2) + pow(f100 - (T3*h) / (3.*repeatedTermRoot), 2))*
+ pow(repeatedTerm, 2)), 2))) / 2. + f000;
+
+ return Gyroidh;
+ }
+};
+/*==========================================================*/
+bool GbImplicitSurface::isPointInGbObject3D(const double& x1, const double& x2, const double& x3)
+{
+ //double f = sin(2.*M_PI*x1/edgeLength)*cos(2.*M_PI*x2 / edgeLength) + sin(2.*M_PI*x2 / edgeLength)*cos(2.*M_PI*x3 / edgeLength) + sin(2.*M_PI*x3 / edgeLength)*cos(2.*M_PI*x1 / edgeLength);
+ //evaluateImplicitFunction(x1,x2,x3, 0., 0., 0.)
+ double f1 = evaluateImplicitFunction(x1, x2, x3, 1.);
+ double f2 = evaluateImplicitFunction(x1, x2, x3, -1.);
+ // if (f < 10.0E-15 && f > -10.0E-15)
+ //if (fabs(f) <= 10e-15)
+ //if (f <= 0)
+ if (f1 <= 0. && f2 >= 0.)
+{
+ return true;
+}
+else
+{
+ return false;
+}
+}
+
+/*==========================================================*/
+double GbImplicitSurface::getIntersectionRaytraceFactor(const double& x1, const double& x2, const double& x3, const double& rx1, const double& rx2, const double& rx3)
+{
+ double from = 0; // The solution must lie in the interval [from, to], additionally f(from) <= 0 && f(to) >= 0
+ double to = dx*sqrt(rx1*rx1+ rx2*rx2+ rx3*rx3);
+ FunctionGyroidThirdOrder f;
+ //FunctionToApproximate f;
+ f.x =x1 ;
+ f.y =x2 ;
+ f.z =x3 ;
+ f.dir1 = rx1;
+ f.dir2 = rx2;
+ f.dir3 = rx3;
+ f.L = edgeLength;
+ f.h = thickness;
+ if (f(from)*f(to)<0)
+ {
+ std::pair<double, double> result = bisect(f, from, to, TerminationCondition());
+ double root = (result.first + result.second) / 2;
+ return root;
+ }
+ f.h = -thickness;
+ if (f(from)*f(to) < 0)
+ {
+ std::pair<double, double> result = bisect(f, from, to, TerminationCondition());
+ double root = (result.first + result.second) / 2;
+ return root;
+ }
+ else
+ {
+ return 999;
+ }
+
+}
+/*=======================================================*/
+double GbImplicitSurface::evaluateImplicitFunction(const double& x1, const double& x2, const double& x3, const double& position)
+{
+ double to = 0.;
+ FunctionGyroidThirdOrder f;
+ f.x = x1;
+ f.y = x2;
+ f.z = x3;
+ f.dir1 = 0.;
+ f.dir2 = 0.;
+ f.dir3 = 0.;
+ f.L = edgeLength;
+ f.h = position*thickness;
+ return f(to);
+}
+/*=======================================================*/
+double GbImplicitSurface::getX1Centroid()
+{
+ return (0.5*(p1->x1 + p2->x1));
+}
+/*=======================================================*/
+double GbImplicitSurface::getX1Minimum()
+{
+ return (this->p1->x1 < this->p2->x1 ? this->p1->x1 : this->p2->x1);
+}
+/*=======================================================*/
+double GbImplicitSurface::getX1Maximum()
+{
+ return (this->p1->x1 > this->p2->x1 ? this->p1->x1 : this->p2->x1);
+}
+/*=======================================================*/
+double GbImplicitSurface::getX2Centroid()
+{
+ return (0.5*(p1->x2 + p2->x2));
+}
+/*=======================================================*/
+double GbImplicitSurface::getX2Minimum()
+{
+ return (this->p1->x2 < this->p2->x2 ? this->p1->x2 : this->p2->x2);
+}
+/*=======================================================*/
+double GbImplicitSurface::getX2Maximum()
+{
+ return (this->p1->x2 > this->p2->x2 ? this->p1->x2 : this->p2->x2);
+}
+/*=======================================================*/
+double GbImplicitSurface::getX3Centroid()
+{
+ return (0.5*(p1->x3 + p2->x3));
+}
+/*=======================================================*/
+double GbImplicitSurface::getX3Minimum()
+{
+ return (this->p1->x3 < this->p2->x3 ? this->p1->x3 : this->p2->x3);
+}
+/*=======================================================*/
+double GbImplicitSurface::getX3Maximum()
+{
+ return (this->p1->x3 > this->p2->x3 ? this->p1->x3 : this->p2->x3);
+}
+/*=======================================================*/
+bool GbImplicitSurface::isCellInsideGbObject3D(const double& x1a, const double& x2a, const double& x3a, const double& x1b, const double& x2b, const double& x3b)
+{
+ if (this->isPointInGbObject3D(x1a, x2a, x3a)
+ && this->isPointInGbObject3D(x1b, x2a, x3a)
+ && this->isPointInGbObject3D(x1b, x2b, x3a)
+ && this->isPointInGbObject3D(x1a, x2b, x3a)
+ && this->isPointInGbObject3D(x1a, x2a, x3b)
+ && this->isPointInGbObject3D(x1b, x2a, x3b)
+ && this->isPointInGbObject3D(x1b, x2b, x3b)
+ && this->isPointInGbObject3D(x1a, x2b, x3b))
+ {
+ return true;
+ }
+ return false;
+}
+/*=======================================================*/
+bool GbImplicitSurface::isCellInsideOrCuttingGbObject3D(const double& x1a, const double& x2a, const double& x3a, const double& x1b, const double& x2b, const double& x3b)
+{
+ if ((this->isPointInGbObject3D(x1a, x2a, x3a) == false)
+ && (this->isPointInGbObject3D(x1b, x2a, x3a) == false)
+ && (this->isPointInGbObject3D(x1b, x2b, x3a) == false)
+ && (this->isPointInGbObject3D(x1a, x2b, x3a) == false)
+ && (this->isPointInGbObject3D(x1a, x2a, x3b) == false)
+ && (this->isPointInGbObject3D(x1b, x2a, x3b) == false)
+ && (this->isPointInGbObject3D(x1b, x2b, x3b) == false)
+ && (this->isPointInGbObject3D(x1a, x2b, x3b) == false))
+ {
+ return false;
+ }
+ return true;
+}
+/*=======================================================*/
+bool GbImplicitSurface::isCellCuttingGbObject3D(const double& x1a, const double& x2a, const double& x3a, const double& x1b, const double& x2b, const double& x3b)
+{
+ if (!this->isCellInsideGbObject3D(x1a, x2a, x3a, x1b, x2b, x3b)
+ && this->isCellInsideOrCuttingGbObject3D(x1a, x2a, x3a, x1b, x2b, x3b))
+ {
+ return true;
+ }
+ return false;
+}
+/*=======================================================*/
+void GbImplicitSurface::addSurfaceTriangleSet(vector<UbTupleFloat3>& nodes, vector<UbTupleInt3>& triangles)
+{
+ /*0*/nodes.push_back(makeUbTuple((float)getX1Minimum(), (float)getX2Minimum(), (float)getX3Minimum()));
+ /*1*/nodes.push_back(makeUbTuple((float)getX1Maximum(), (float)getX2Minimum(), (float)getX3Minimum()));
+ /*2*/nodes.push_back(makeUbTuple((float)getX1Maximum(), (float)getX2Maximum(), (float)getX3Minimum()));
+ /*3.*/nodes.push_back(makeUbTuple((float)getX1Minimum(), (float)getX2Maximum(), (float)getX3Minimum()));
+
+ /*4*/nodes.push_back(makeUbTuple((float)getX1Minimum(), (float)getX2Minimum(), (float)getX3Maximum()));
+ /*5*/nodes.push_back(makeUbTuple((float)getX1Maximum(), (float)getX2Minimum(), (float)getX3Maximum()));
+ /*6*/nodes.push_back(makeUbTuple((float)getX1Maximum(), (float)getX2Maximum(), (float)getX3Maximum()));
+ /*7*/nodes.push_back(makeUbTuple((float)getX1Minimum(), (float)getX2Maximum(), (float)getX3Maximum()));
+
+ //"unten"
+ triangles.push_back(makeUbTuple(0, 1, 2));
+ triangles.push_back(makeUbTuple(0, 2, 3));
+ //"oben"
+ triangles.push_back(makeUbTuple(4, 5, 6));
+ triangles.push_back(makeUbTuple(4, 6, 7));
+ //"links"
+ triangles.push_back(makeUbTuple(0, 3, 7));
+ triangles.push_back(makeUbTuple(0, 7, 4));
+ //"rechts"
+ triangles.push_back(makeUbTuple(1, 2, 6));
+ triangles.push_back(makeUbTuple(1, 6, 5));
+ //"hinten"
+ triangles.push_back(makeUbTuple(3, 2, 7));
+ triangles.push_back(makeUbTuple(2, 7, 6));
+ //"vorne"
+ triangles.push_back(makeUbTuple(0, 1, 5));
+ triangles.push_back(makeUbTuple(0, 5, 4));
+}
+/*==========================================================*/
+void GbImplicitSurface::objectChanged(UbObservable *changedObject)
+{
+ GbPoint3D *point = dynamic_cast<GbPoint3D *>(changedObject);
+ if (!point || (this->p1 != point && this->p2 != point && this->p3 != point && this->p4 != point))
+ return;
+
+ this->notifyObserversObjectChanged();
+}
+/*==========================================================*/
+void GbImplicitSurface::objectWillBeDeleted(UbObservable *objectForDeletion)
+{
+ if (this->p1) {
+ UbObservable *observedObj = dynamic_cast<UbObservable *>(this->p1);
+ if (objectForDeletion == observedObj) {
+ this->p1 = NULL;
+ }
+ }
+ if (this->p2) {
+ UbObservable *observedObj = dynamic_cast<UbObservable *>(this->p2);
+ if (objectForDeletion == observedObj) {
+ this->p2 = NULL;
+ }
+ }
+ if (this->p3) {
+ UbObservable *observedObj = dynamic_cast<UbObservable *>(this->p3);
+ if (objectForDeletion == observedObj) {
+ this->p3 = NULL;
+ }
+ }
+ if (this->p4) {
+ UbObservable *observedObj = dynamic_cast<UbObservable *>(this->p4);
+ if (objectForDeletion == observedObj) {
+ this->p4 = NULL;
+ }
+ }
+ // ACHTUNG: eigentlich muessten in allen methoden von GbLine if abfragen fuer NULL pointer hin... toDo
+}
+
+#endif
diff --git a/src/basics/geometry3d/GbImplicitSurface.h b/src/basics/geometry3d/GbImplicitSurface.h
new file mode 100644
index 0000000000000000000000000000000000000000..a72c9442eca57d3bdd99887c8e5692afec939e1d
--- /dev/null
+++ b/src/basics/geometry3d/GbImplicitSurface.h
@@ -0,0 +1,161 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file GbImplicitSurface.cpp
+//! \ingroup geometry3d
+//! \author Hussein Alihussein
+//=======================================================================================
+#ifndef GbImplicitSurface_H
+#define GbImplicitSurface_H
+
+#ifdef BUILD_USE_BOOST
+
+#include <vector>
+
+#include <GbPoint3D.h>
+#include <basics/utilities/UbObserver.h>
+#include <basics/utilities/UbMath.h>
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <math.h>
+
+class GbLine3D;
+class GbObject3DCreator;
+
+#include <PointerDefinitions.h>
+class GbImplicitSurface;
+using GbImplicitSurfacePtr = SPtr<GbImplicitSurface>;
+
+
+class GbImplicitSurface : public GbObject3D, public UbObserver
+{
+public:
+ GbImplicitSurface();
+ GbImplicitSurface(const double& x1a, const double& x2a, const double& x3a, const double& x1b, const double& x2b, const double& x3b, const double& edgeLength, const double& dx, const double& thickness=0);
+
+ GbImplicitSurface(const double & x1a, const double & x2a, const double & x3a, const double & x1b, const double & x2b, const double & x3b, const double & x1c, const double & x2c, const double & x3c, const double & x1d, const double & x2d, const double & x3d, const double & edgeLength, const double & dx);
+ //GbImplicitSurface(const double& minX1, const double& minX2, const double& minX3, const double& maxX1, const double& maxX2, const double& maxX3);
+ GbImplicitSurface(GbImplicitSurface *imp);
+ ~GbImplicitSurface();
+
+ GbImplicitSurface* clone() override { return new GbImplicitSurface(this); }
+ void finalize() override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+
+
+
+ double getX1Centroid() override;
+ double getX1Minimum() override;
+ double getX1Maximum() override;
+ double getX2Centroid()override;
+ double getX2Minimum() override;
+ double getX2Maximum() override;
+ double getX3Centroid()override;
+ double getX3Minimum() override;
+ double getX3Maximum() override;
+ void setCenterCoordinates(const double &x1, const double &x2, const double &x3) override {throw UbException(UB_EXARGS, "finalize() - not implemented");
+ }
+
+ void translate(const double& x1, const double& x2, const double& x3) override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+ void rotate(const double& rx1, const double& rx2, const double& rx3) override{ throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+ void scale(const double& sx1, const double& sx2, const double& sx3) override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+
+ double getLengthX1();
+ double getLengthX2();
+ double getLengthX3();
+
+ bool isPointInGbObject3D(const double &x1p, const double &x2p, const double &x3p, bool &pointinboundary) override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+ bool isPointInGbObject3D(const double &x1p, const double &x2p, const double &x3p) override;
+ bool isCellInsideGbObject3D(const double &x1a, const double &x2a, const double &x3a, const double &x1b,
+ const double &x2b, const double &x3b) override;
+ bool isCellCuttingGbObject3D(const double &x1a, const double &x2a, const double &x3a, const double &x1b,
+ const double &x2b, const double &x3b) override;
+ bool isCellInsideOrCuttingGbObject3D(const double &x1a, const double &x2a, const double &x3a, const double &x1b,
+ const double &x2b, const double &x3b) override;
+ double getCellVolumeInsideGbObject3D(const double &x1a, const double &x2a, const double &x3a, const double &x1b,
+ const double &x2b, const double &x3b) override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+
+ GbPoint3D *calculateInterSectionPoint3D(GbPoint3D &point1, GbPoint3D &point2);
+ //GbImplicitSurface* createClippedRectangle3D(const double& x1a,const double& x2a,const double& x3a,const double& x1b,const double& x2b,const double& x3b);
+ GbLine3D *createClippedLine3D (GbPoint3D &point1, GbPoint3D &point2) override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+
+ std::vector<GbTriangle3D *> getSurfaceTriangleSet() override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+
+ void addSurfaceTriangleSet(std::vector<UbTupleFloat3> &nodes, std::vector<UbTupleInt3> &triangles) override;
+
+ bool hasRaytracing() override { return true; }
+
+ /*|r| must be 1! einheitsvector!!*/
+ double getIntersectionRaytraceFactor (const double& x1, const double& x2, const double& x3, const double& rx1, const double& rx2, const double& rx3) override;
+
+ double evaluateImplicitFunction(const double & x1, const double & x2, const double & x3, const double & position);
+
+ double getDistance(const double& x1p, const double& x2p, const double& x3p)
+ {
+ throw UbException(UB_EXARGS, "not implemented");
+
+ // falls punkt innerhalt ist: minimalen abstand ausrechnen
+ if (this->isPointInGbObject3D(x1p, x2p, x3p))
+ {
+ double x1Dist = UbMath::min(std::abs(x1p - this->getX1Minimum()), std::abs(x1p - this->getX1Maximum()));
+ double x2Dist = UbMath::min(std::abs(x2p - this->getX2Minimum()), std::abs(x2p - this->getX2Maximum()));
+ double x3Dist = UbMath::min(std::abs(x3p - this->getX3Minimum()), std::abs(x3p - this->getX3Maximum()));
+
+ return UbMath::min(x1Dist, x2Dist, x3Dist);
+ }
+ else
+ {
+
+ }
+ }
+
+ std::string toString() override { throw UbException(UB_EXARGS, "finalize() - not implemented"); }
+
+
+ // virtuelle Methoden von UbObserver
+ void objectChanged(UbObservable *changedObject) override;
+ void objectWillBeDeleted(UbObservable *objectForDeletion) override;
+
+ using GbObject3D::isPointInGbObject3D; //Grund: dadurch muss man hier isPointInGbObject3D(GbPoint3D*) nicht ausprogrammieren, welche sonst hier "ueberdeckt" waere
+
+
+protected:
+ GbPoint3D* p1;
+ GbPoint3D* p2;
+ GbPoint3D* p3;
+ GbPoint3D* p4;
+ double edgeLength;
+ double dx;
+ double thickness;
+private:
+};
+
+
+
+#endif
+#endif
diff --git a/src/cpu/VirtualFluids.h b/src/cpu/VirtualFluids.h
index 8aed1556b058c8420d79eab32646ae10112ec288..1ee4c7e78aded0e11ea723769d4515f0f1ec846d 100644
--- a/src/cpu/VirtualFluids.h
+++ b/src/cpu/VirtualFluids.h
@@ -121,6 +121,8 @@
#include <BoundaryConditions/NoSlipBCAlgorithm.h>
#include <BoundaryConditions/NonEqDensityBCAlgorithm.h>
#include <BoundaryConditions/NonReflectingOutflowBCAlgorithm.h>
+#include <BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.h>
+#include <BoundaryConditions/NonReflectingInflowBCAlgorithm.h>
#include <BoundaryConditions/SlipBCAdapter.h>
#include <BoundaryConditions/SlipBCAlgorithm.h>
#include <BoundaryConditions/ThinWallBCProcessor.h>
@@ -204,6 +206,8 @@
#include <CoProcessors/ShearStressCoProcessor.h>
#include <CoProcessors/TimeseriesCoProcessor.h>
#include <CoProcessors/TurbulenceIntensityCoProcessor.h>
+#include <CoProcessors/TimeAveragedValuesCoProcessor.h>
+
//#include <CoProcessors/MeanValuesCoProcessor.h>
#include <CoProcessors/InSituCatalystCoProcessor.h>
#include <CoProcessors/LineTimeSeriesCoProcessor.h>
@@ -265,6 +269,7 @@
#include <geometry3d/GbCylinder3D.h>
#include <geometry3d/GbHalfSpace3D.h>
#include <geometry3d/GbHalfSpaceKrischan3D.h>
+#include <geometry3d/GbImplicitSurface.h>
#include <geometry3d/GbLine3D.h>
#include <geometry3d/GbMeshTools3D.h>
#include <geometry3d/GbObject3D.h>
diff --git a/src/cpu/VirtualFluidsCore/BoundaryConditions/BCAlgorithm.h b/src/cpu/VirtualFluidsCore/BoundaryConditions/BCAlgorithm.h
index fa964f96b4f05801b0dc4afc48d19a68c5b1c133..f182546b0740cbff6b66b3849e2c67e42de1a98d 100644
--- a/src/cpu/VirtualFluidsCore/BoundaryConditions/BCAlgorithm.h
+++ b/src/cpu/VirtualFluidsCore/BoundaryConditions/BCAlgorithm.h
@@ -69,9 +69,9 @@ public:
static const char RheologyPowellEyringModelNoSlipBCAlgorithm = 18;
static const char RheologyBinghamModelVelocityBCAlgorithm = 19;
static const char MultiphaseNoSlipBCAlgorithm = 20;
- static const char MultiphaseVelocityBCAlgorithm = 21;
-
-
+ static const char MultiphaseVelocityBCAlgorithm = 21;
+ static const char NonReflectingInflowBCAlgorithm = 22;
+ static const char NonReflectingOutflowBCAlgorithmWithRelaxation = 23;
public:
BCAlgorithm() = default;
diff --git a/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingInflowBCAlgorithm.cpp b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingInflowBCAlgorithm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..078e8bfb4c574b9a6fe90a5bd569d2969237eb66
--- /dev/null
+++ b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingInflowBCAlgorithm.cpp
@@ -0,0 +1,341 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file NonReflectingInflowBCAlgorithm.cpp
+//! \ingroup BoundarConditions
+//! \author Hussein Alihussein
+//=======================================================================================
+#include "NonReflectingInflowBCAlgorithm.h"
+
+#include "BoundaryConditions.h"
+#include "D3Q27System.h"
+#include "DistributionArray3D.h"
+
+NonReflectingInflowBCAlgorithm::NonReflectingInflowBCAlgorithm()
+{
+ BCAlgorithm::type = BCAlgorithm::NonReflectingInflowBCAlgorithm;
+ BCAlgorithm::preCollision = true;
+}
+//////////////////////////////////////////////////////////////////////////
+NonReflectingInflowBCAlgorithm::~NonReflectingInflowBCAlgorithm() = default;
+//////////////////////////////////////////////////////////////////////////
+SPtr<BCAlgorithm> NonReflectingInflowBCAlgorithm::clone()
+{
+ SPtr<BCAlgorithm> bc(new NonReflectingInflowBCAlgorithm());
+ return bc;
+}
+//////////////////////////////////////////////////////////////////////////
+void NonReflectingInflowBCAlgorithm::addDistributions(SPtr<DistributionArray3D> distributions)
+{
+ this->distributions = distributions;
+}
+//////////////////////////////////////////////////////////////////////////
+void NonReflectingInflowBCAlgorithm::applyBC()
+{
+ using namespace vf::lbm::dir;
+ using namespace D3Q27System;
+ // using namespace UbMath;
+ using namespace vf::lbm::constant;
+
+ LBMReal f[ENDF + 1];
+ LBMReal ftemp[ENDF + 1];
+
+ int nx1 = x1;
+ int nx2 = x2;
+ int nx3 = x3;
+ int direction = -1;
+
+ // flag points in direction of fluid
+ if (bcPtr->hasDensityBoundaryFlag(DIR_P00)) {
+ nx1 += 1;
+ direction = DIR_P00;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_M00)) {
+ nx1 -= 1;
+ direction = DIR_M00;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_0P0)) {
+ nx2 += 1;
+ direction = DIR_0P0;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_0M0)) {
+ nx2 -= 1;
+ direction = DIR_0M0;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_00P)) {
+ nx3 += 1;
+ direction = DIR_00P;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_00M)) {
+ nx3 -= 1;
+ direction = DIR_00M;
+ } else
+ UB_THROW(UbException(UB_EXARGS, "Danger...no orthogonal BC-Flag on density boundary..."));
+
+ distributions->getDistribution(f, x1, x2, x3);
+ distributions->getDistribution(ftemp, nx1, nx2, nx3);
+
+ LBMReal rho, vx1, vx2, vx3;
+ calcMacrosFct(f, rho, vx1, vx2, vx3);
+ //vx1 = 0.;
+ LBMReal BCVeloWeight = 0.5;
+ // LBMReal velocity = 0.004814077025232405;
+ // LBMReal velocity = 0.00057735;
+ //LBMReal velocity = 0.04;
+ // LBMReal velocity = 0.01;
+ // LBMReal velocity = 1./112.;
+ // LBMReal velocity = 1./126.;
+ LBMReal velocity = 1./200.;
+ // LBMReal velocity = 0.005;
+ //LBMReal delf =(-velocity+vx1)*0.5 ;
+ LBMReal delf;
+
+ switch (direction) {
+ case DIR_P00:
+ delf = (-velocity + vx1) * BCVeloWeight;
+ // delf = (-velocity ) * BCVeloWeight;
+ f[DIR_P00] = ftemp[DIR_P00] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P00] - delf* WEIGTH[DIR_P00];
+ f[DIR_PP0] = ftemp[DIR_PP0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PP0]- delf* WEIGTH[DIR_PP0];
+ f[DIR_PM0] = ftemp[DIR_PM0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PM0]- delf* WEIGTH[DIR_PM0];
+ f[DIR_P0P] = ftemp[DIR_P0P] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P0P]- delf* WEIGTH[DIR_P0P];
+ f[DIR_P0M] = ftemp[DIR_P0M] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P0M]- delf* WEIGTH[DIR_P0M];
+ f[DIR_PPP] = ftemp[DIR_PPP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PPP]- delf* WEIGTH[DIR_PPP];
+ f[DIR_PMP] = ftemp[DIR_PMP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PMP]- delf* WEIGTH[DIR_PMP];
+ f[DIR_PPM] = ftemp[DIR_PPM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PPM]- delf* WEIGTH[DIR_PPM];
+ f[DIR_PMM] = ftemp[DIR_PMM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PMM]- delf* WEIGTH[DIR_PMM];
+ //f[DIR_P00] = (ftemp[DIR_P00] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P00]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_M00] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_M00] +
+ // velocity*(6)*WEIGTH[DIR_P00]/* bcPtr->getBoundaryVelocity(INVDIR[DIR_M00])*/) *
+ // (BCVeloWeight) ;
+ //f[DIR_PP0] = (ftemp[DIR_PP0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PP0]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_MM0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_MM0] +
+ // velocity * (6) * WEIGTH[DIR_PP0] /*bcPtr->getBoundaryVelocity(INVDIR[DIR_MM0])*/) *
+ // (BCVeloWeight);
+ //f[DIR_PM0] = (ftemp[DIR_PM0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PM0]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_MP0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_MP0] +
+ // velocity*(6)*WEIGTH[DIR_PP0]/* bcPtr->getBoundaryVelocity(INVDIR[DIR_MP0])*/) *
+ // (BCVeloWeight);
+ //f[DIR_P0P] = (ftemp[DIR_P0P] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P0P]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_M0M] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_M0M] +
+ // velocity*(6)*WEIGTH[DIR_P0P]/* bcPtr->getBoundaryVelocity(INVDIR[DIR_M0M])*/) *
+ // (BCVeloWeight);
+ //f[DIR_P0M] = (ftemp[DIR_P0M] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P0M])*
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_M0P] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_M0P] +
+ // velocity*(6)*WEIGTH[DIR_P0M]/* bcPtr->getBoundaryVelocity(INVDIR[DIR_M0P])*/) *
+ // (BCVeloWeight);
+ //f[DIR_PPP] = (ftemp[DIR_PPP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PPP])*
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_MMM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_MMM] +
+ // velocity * (6) * WEIGTH[DIR_PPP] /* bcPtr->getBoundaryVelocity(INVDIR[DIR_MMM])*/) *
+ // (BCVeloWeight);
+ //f[DIR_PMP] = (ftemp[DIR_PMP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PMP]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_MPM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_MPM] +
+ // velocity * (6) * WEIGTH[DIR_PPP] /*bcPtr->getBoundaryVelocity(INVDIR[DIR_MPM])*/) *
+ // (BCVeloWeight);
+ //f[DIR_PPM] = (ftemp[DIR_PPM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PPM]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_MMP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_MMP] +
+ // velocity * (6) * WEIGTH[DIR_PPP] /* bcPtr->getBoundaryVelocity(INVDIR[DIR_MMP])*/) *
+ // (BCVeloWeight);
+ //f[DIR_PMM] = (ftemp[DIR_PMM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PMM]) *
+ // (1 - BCVeloWeight) +
+ // (ftemp[DIR_MPP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_MPP] +
+ // velocity * (6) * WEIGTH[DIR_PPP] /* bcPtr->getBoundaryVelocity(INVDIR[DIR_MPP])*/) *
+ // (BCVeloWeight);
+
+ distributions->setDistributionInvForDirection(f[DIR_P00], x1 + DX1[DIR_M00], x2 + DX2[DIR_M00], x3 + DX3[DIR_M00], DIR_M00);
+ distributions->setDistributionInvForDirection(f[DIR_PP0], x1 + DX1[DIR_MM0], x2 + DX2[DIR_MM0], x3 + DX3[DIR_MM0], DIR_MM0);
+ distributions->setDistributionInvForDirection(f[DIR_PM0], x1 + DX1[DIR_MP0], x2 + DX2[DIR_MP0], x3 + DX3[DIR_MP0], DIR_MP0);
+ distributions->setDistributionInvForDirection(f[DIR_P0P], x1 + DX1[DIR_M0M], x2 + DX2[DIR_M0M], x3 + DX3[DIR_M0M], DIR_M0M);
+ distributions->setDistributionInvForDirection(f[DIR_P0M], x1 + DX1[DIR_M0P], x2 + DX2[DIR_M0P], x3 + DX3[DIR_M0P], DIR_M0P);
+ distributions->setDistributionInvForDirection(f[DIR_PPP], x1 + DX1[DIR_MMM], x2 + DX2[DIR_MMM], x3 + DX3[DIR_MMM], DIR_MMM);
+ distributions->setDistributionInvForDirection(f[DIR_PMP], x1 + DX1[DIR_MPM], x2 + DX2[DIR_MPM], x3 + DX3[DIR_MPM], DIR_MPM);
+ distributions->setDistributionInvForDirection(f[DIR_PPM], x1 + DX1[DIR_MMP], x2 + DX2[DIR_MMP], x3 + DX3[DIR_MMP], DIR_MMP);
+ distributions->setDistributionInvForDirection(f[DIR_PMM], x1 + DX1[DIR_MPP], x2 + DX2[DIR_MPP], x3 + DX3[DIR_MPP], DIR_MPP);
+ break;
+ case DIR_M00:
+ delf = (-velocity - vx1) * BCVeloWeight;
+ f[DIR_M00] = ftemp[DIR_M00] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_M00] -
+ delf * WEIGTH[DIR_M00];
+ f[DIR_MP0] = ftemp[DIR_MP0] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MP0] -
+ delf * WEIGTH[DIR_MP0];
+ f[DIR_MM0] = ftemp[DIR_MM0] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MM0] -
+ delf * WEIGTH[DIR_MM0];
+ f[DIR_M0P] = ftemp[DIR_M0P] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_M0P] -
+ delf * WEIGTH[DIR_M0P];
+ f[DIR_M0M] = ftemp[DIR_M0M] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_M0M] -
+ delf * WEIGTH[DIR_M0M];
+ f[DIR_MPP] = ftemp[DIR_MPP] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MPP] -
+ delf * WEIGTH[DIR_MPP];
+ f[DIR_MMP] = ftemp[DIR_MMP] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MMP] -
+ delf * WEIGTH[DIR_MMP];
+ f[DIR_MPM] = ftemp[DIR_MPM] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MPM] -
+ delf * WEIGTH[DIR_MPM];
+ f[DIR_MMM] = ftemp[DIR_MMM] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MMM] -
+ delf * WEIGTH[DIR_MMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_M00], x1 + DX1[DIR_P00], x2 + DX2[DIR_P00], x3 + DX3[DIR_P00], DIR_P00);
+ distributions->setDistributionInvForDirection(f[DIR_MP0], x1 + DX1[DIR_PM0], x2 + DX2[DIR_PM0], x3 + DX3[DIR_PM0], DIR_PM0);
+ distributions->setDistributionInvForDirection(f[DIR_MM0], x1 + DX1[DIR_PP0], x2 + DX2[DIR_PP0], x3 + DX3[DIR_PP0], DIR_PP0);
+ distributions->setDistributionInvForDirection(f[DIR_M0P], x1 + DX1[DIR_P0M], x2 + DX2[DIR_P0M], x3 + DX3[DIR_P0M], DIR_P0M);
+ distributions->setDistributionInvForDirection(f[DIR_M0M], x1 + DX1[DIR_P0P], x2 + DX2[DIR_P0P], x3 + DX3[DIR_P0P], DIR_P0P);
+ distributions->setDistributionInvForDirection(f[DIR_MPP], x1 + DX1[DIR_PMM], x2 + DX2[DIR_PMM], x3 + DX3[DIR_PMM], DIR_PMM);
+ distributions->setDistributionInvForDirection(f[DIR_MMP], x1 + DX1[DIR_PPM], x2 + DX2[DIR_PPM], x3 + DX3[DIR_PPM], DIR_PPM);
+ distributions->setDistributionInvForDirection(f[DIR_MPM], x1 + DX1[DIR_PMP], x2 + DX2[DIR_PMP], x3 + DX3[DIR_PMP], DIR_PMP);
+ distributions->setDistributionInvForDirection(f[DIR_MMM], x1 + DX1[DIR_PPP], x2 + DX2[DIR_PPP], x3 + DX3[DIR_PPP], DIR_PPP);
+ break;
+ case DIR_0P0:
+ delf = (-velocity + vx2) * BCVeloWeight;
+ f[DIR_0P0] = ftemp[DIR_0P0] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_0P0] -
+ delf * WEIGTH[DIR_0P0];
+ f[DIR_PP0] = ftemp[DIR_PP0] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_PP0] -
+ delf * WEIGTH[DIR_PP0];
+ f[DIR_MP0] = ftemp[DIR_MP0] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_MP0] -
+ delf * WEIGTH[DIR_MP0];
+ f[DIR_0PP] = ftemp[DIR_0PP] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_0PP] -
+ delf * WEIGTH[DIR_0PP];
+ f[DIR_0PM] = ftemp[DIR_0PM] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_0PM] -
+ delf * WEIGTH[DIR_0PM];
+ f[DIR_PPP] = ftemp[DIR_PPP] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_PPP] -
+ delf * WEIGTH[DIR_PPP];
+ f[DIR_MPP] = ftemp[DIR_MPP] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_MPP] -
+ delf * WEIGTH[DIR_MPP];
+ f[DIR_PPM] = ftemp[DIR_PPM] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_PPM] -
+ delf * WEIGTH[DIR_PPM];
+ f[DIR_MPM] = ftemp[DIR_MPM] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_MPM] -
+ delf * WEIGTH[DIR_MPM];
+
+ distributions->setDistributionInvForDirection(f[DIR_0P0], x1 + DX1[DIR_0M0], x2 + DX2[DIR_0M0], x3 + DX3[DIR_0M0], DIR_0M0);
+ distributions->setDistributionInvForDirection(f[DIR_PP0], x1 + DX1[DIR_MM0], x2 + DX2[DIR_MM0], x3 + DX3[DIR_MM0], DIR_MM0);
+ distributions->setDistributionInvForDirection(f[DIR_MP0], x1 + DX1[DIR_PM0], x2 + DX2[DIR_PM0], x3 + DX3[DIR_PM0], DIR_PM0);
+ distributions->setDistributionInvForDirection(f[DIR_0PP], x1 + DX1[DIR_0MM], x2 + DX2[DIR_0MM], x3 + DX3[DIR_0MM], DIR_0MM);
+ distributions->setDistributionInvForDirection(f[DIR_0PM], x1 + DX1[DIR_0MP], x2 + DX2[DIR_0MP], x3 + DX3[DIR_0MP], DIR_0MP);
+ distributions->setDistributionInvForDirection(f[DIR_PPP], x1 + DX1[DIR_MMM], x2 + DX2[DIR_MMM], x3 + DX3[DIR_MMM], DIR_MMM);
+ distributions->setDistributionInvForDirection(f[DIR_MPP], x1 + DX1[DIR_PMM], x2 + DX2[DIR_PMM], x3 + DX3[DIR_PMM], DIR_PMM);
+ distributions->setDistributionInvForDirection(f[DIR_PPM], x1 + DX1[DIR_MMP], x2 + DX2[DIR_MMP], x3 + DX3[DIR_MMP], DIR_MMP);
+ distributions->setDistributionInvForDirection(f[DIR_MPM], x1 + DX1[DIR_PMP], x2 + DX2[DIR_PMP], x3 + DX3[DIR_PMP], DIR_PMP);
+ break;
+ case DIR_0M0:
+ delf = (-velocity - vx2) * BCVeloWeight;
+ f[DIR_0M0] = ftemp[DIR_0M0] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_0M0] -
+ delf * WEIGTH[DIR_0M0];
+ f[DIR_PM0] = ftemp[DIR_PM0] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_PM0] -
+ delf * WEIGTH[DIR_PM0];
+ f[DIR_MM0] = ftemp[DIR_MM0] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_MM0] -
+ delf * WEIGTH[DIR_MM0];
+ f[DIR_0MP] = ftemp[DIR_0MP] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_0MP] -
+ delf * WEIGTH[DIR_0MP];
+ f[DIR_0MM] = ftemp[DIR_0MM] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_0MM] -
+ delf * WEIGTH[DIR_0MM];
+ f[DIR_PMP] = ftemp[DIR_PMP] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_PMP] -
+ delf * WEIGTH[DIR_PMP];
+ f[DIR_MMP] = ftemp[DIR_MMP] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_MMP] -
+ delf * WEIGTH[DIR_MMP];
+ f[DIR_PMM] = ftemp[DIR_PMM] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_PMM] -
+ delf * WEIGTH[DIR_PMM];
+ f[DIR_MMM] = ftemp[DIR_MMM] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_MMM] -
+ delf * WEIGTH[DIR_MMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_0M0], x1 + DX1[DIR_0P0], x2 + DX2[DIR_0P0], x3 + DX3[DIR_0P0], DIR_0P0);
+ distributions->setDistributionInvForDirection(f[DIR_PM0], x1 + DX1[DIR_MP0], x2 + DX2[DIR_MP0], x3 + DX3[DIR_MP0], DIR_MP0);
+ distributions->setDistributionInvForDirection(f[DIR_MM0], x1 + DX1[DIR_PP0], x2 + DX2[DIR_PP0], x3 + DX3[DIR_PP0], DIR_PP0);
+ distributions->setDistributionInvForDirection(f[DIR_0MP], x1 + DX1[DIR_0PM], x2 + DX2[DIR_0PM], x3 + DX3[DIR_0PM], DIR_0PM);
+ distributions->setDistributionInvForDirection(f[DIR_0MM], x1 + DX1[DIR_0PP], x2 + DX2[DIR_0PP], x3 + DX3[DIR_0PP], DIR_0PP);
+ distributions->setDistributionInvForDirection(f[DIR_PMP], x1 + DX1[DIR_MPM], x2 + DX2[DIR_MPM], x3 + DX3[DIR_MPM], DIR_MPM);
+ distributions->setDistributionInvForDirection(f[DIR_MMP], x1 + DX1[DIR_PPM], x2 + DX2[DIR_PPM], x3 + DX3[DIR_PPM], DIR_PPM);
+ distributions->setDistributionInvForDirection(f[DIR_PMM], x1 + DX1[DIR_MPP], x2 + DX2[DIR_MPP], x3 + DX3[DIR_MPP], DIR_MPP);
+ distributions->setDistributionInvForDirection(f[DIR_MMM], x1 + DX1[DIR_PPP], x2 + DX2[DIR_PPP], x3 + DX3[DIR_PPP], DIR_PPP);
+ break;
+ case DIR_00P:
+ delf = (-velocity + vx3) * BCVeloWeight;
+ f[DIR_00P] = ftemp[DIR_00P] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_00P] -
+ delf * WEIGTH[DIR_00P];
+ f[DIR_P0P] = ftemp[DIR_P0P] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_P0P] -
+ delf * WEIGTH[DIR_P0P];
+ f[DIR_M0P] = ftemp[DIR_M0P] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_M0P] -
+ delf * WEIGTH[DIR_M0P];
+ f[DIR_0PP] = ftemp[DIR_0PP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_0PP] -
+ delf * WEIGTH[DIR_0PP];
+ f[DIR_0MP] = ftemp[DIR_0MP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_0MP] -
+ delf * WEIGTH[DIR_0MP];
+ f[DIR_PPP] = ftemp[DIR_PPP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_PPP] -
+ delf * WEIGTH[DIR_PPP];
+ f[DIR_MPP] = ftemp[DIR_MPP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_MPP] -
+ delf * WEIGTH[DIR_MPP];
+ f[DIR_PMP] = ftemp[DIR_PMP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_PMP] -
+ delf * WEIGTH[DIR_PMP];
+ f[DIR_MMP] = ftemp[DIR_MMP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_MMP] -
+ delf * WEIGTH[DIR_MMP];
+
+ distributions->setDistributionInvForDirection(f[DIR_00P], x1 + DX1[DIR_00M], x2 + DX2[DIR_00M], x3 + DX3[DIR_00M], DIR_00M);
+ distributions->setDistributionInvForDirection(f[DIR_P0P], x1 + DX1[DIR_M0M], x2 + DX2[DIR_M0M], x3 + DX3[DIR_M0M], DIR_M0M);
+ distributions->setDistributionInvForDirection(f[DIR_M0P], x1 + DX1[DIR_P0M], x2 + DX2[DIR_P0M], x3 + DX3[DIR_P0M], DIR_P0M);
+ distributions->setDistributionInvForDirection(f[DIR_0PP], x1 + DX1[DIR_0MM], x2 + DX2[DIR_0MM], x3 + DX3[DIR_0MM], DIR_0MM);
+ distributions->setDistributionInvForDirection(f[DIR_0MP], x1 + DX1[DIR_0PM], x2 + DX2[DIR_0PM], x3 + DX3[DIR_0PM], DIR_0PM);
+ distributions->setDistributionInvForDirection(f[DIR_PPP], x1 + DX1[DIR_MMM], x2 + DX2[DIR_MMM], x3 + DX3[DIR_MMM], DIR_MMM);
+ distributions->setDistributionInvForDirection(f[DIR_MPP], x1 + DX1[DIR_PMM], x2 + DX2[DIR_PMM], x3 + DX3[DIR_PMM], DIR_PMM);
+ distributions->setDistributionInvForDirection(f[DIR_PMP], x1 + DX1[DIR_MPM], x2 + DX2[DIR_MPM], x3 + DX3[DIR_MPM], DIR_MPM);
+ distributions->setDistributionInvForDirection(f[DIR_MMP], x1 + DX1[DIR_PPM], x2 + DX2[DIR_PPM], x3 + DX3[DIR_PPM], DIR_PPM);
+ break;
+ case DIR_00M:
+ delf = (-velocity - vx3) * BCVeloWeight;
+ f[DIR_00M] = ftemp[DIR_00M] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_00M] -
+ delf * WEIGTH[DIR_00M];
+ f[DIR_P0M] = ftemp[DIR_P0M] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_P0M] -
+ delf * WEIGTH[DIR_P0M];
+ f[DIR_M0M] = ftemp[DIR_M0M] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_M0M] -
+ delf * WEIGTH[DIR_M0M];
+ f[DIR_0PM] = ftemp[DIR_0PM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_0PM] -
+ delf * WEIGTH[DIR_0PM];
+ f[DIR_0MM] = ftemp[DIR_0MM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_0MM] -
+ delf * WEIGTH[DIR_0MM];
+ f[DIR_PPM] = ftemp[DIR_PPM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_PPM] -
+ delf * WEIGTH[DIR_PPM];
+ f[DIR_MPM] = ftemp[DIR_MPM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_MPM] -
+ delf * WEIGTH[DIR_MPM];
+ f[DIR_PMM] = ftemp[DIR_PMM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_PMM] -
+ delf * WEIGTH[DIR_PMM];
+ f[DIR_MMM] = ftemp[DIR_MMM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_MMM] -
+ delf * WEIGTH[DIR_MMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_00M], x1 + DX1[DIR_00P], x2 + DX2[DIR_00P], x3 + DX3[DIR_00P], DIR_00P);
+ distributions->setDistributionInvForDirection(f[DIR_P0M], x1 + DX1[DIR_M0P], x2 + DX2[DIR_M0P], x3 + DX3[DIR_M0P], DIR_M0P);
+ distributions->setDistributionInvForDirection(f[DIR_M0M], x1 + DX1[DIR_P0P], x2 + DX2[DIR_P0P], x3 + DX3[DIR_P0P], DIR_P0P);
+ distributions->setDistributionInvForDirection(f[DIR_0PM], x1 + DX1[DIR_0MP], x2 + DX2[DIR_0MP], x3 + DX3[DIR_0MP], DIR_0MP);
+ distributions->setDistributionInvForDirection(f[DIR_0MM], x1 + DX1[DIR_0PP], x2 + DX2[DIR_0PP], x3 + DX3[DIR_0PP], DIR_0PP);
+ distributions->setDistributionInvForDirection(f[DIR_PPM], x1 + DX1[DIR_MMP], x2 + DX2[DIR_MMP], x3 + DX3[DIR_MMP], DIR_MMP);
+ distributions->setDistributionInvForDirection(f[DIR_MPM], x1 + DX1[DIR_PMP], x2 + DX2[DIR_PMP], x3 + DX3[DIR_PMP], DIR_PMP);
+ distributions->setDistributionInvForDirection(f[DIR_PMM], x1 + DX1[DIR_MPP], x2 + DX2[DIR_MPP], x3 + DX3[DIR_MPP], DIR_MPP);
+ distributions->setDistributionInvForDirection(f[DIR_MMM], x1 + DX1[DIR_PPP], x2 + DX2[DIR_PPP], x3 + DX3[DIR_PPP], DIR_PPP);
+ break;
+ default:
+ UB_THROW(
+ UbException(UB_EXARGS, "It isn't implemented non reflecting density boundary for this direction!"));
+ }
+}
diff --git a/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingInflowBCAlgorithm.h b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingInflowBCAlgorithm.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f3e87ce3fff371fbec30dbbe90721bd5ff975cc
--- /dev/null
+++ b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingInflowBCAlgorithm.h
@@ -0,0 +1,50 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file NonReflectingInflowBCAlgorithm.h
+//! \ingroup BoundarConditions
+//! \author Hussein Alihussein
+//=======================================================================================
+#ifndef NonReflectingInflowBCAlgorithm_h__
+#define NonReflectingInflowBCAlgorithm_h__
+
+#include "BCAlgorithm.h"
+#include <PointerDefinitions.h>
+
+class DistributionArray3D;
+
+class NonReflectingInflowBCAlgorithm : public BCAlgorithm
+{
+public:
+ NonReflectingInflowBCAlgorithm();
+ ~NonReflectingInflowBCAlgorithm() override;
+ SPtr<BCAlgorithm> clone() override;
+ void addDistributions(SPtr<DistributionArray3D> distributions) override;
+ void applyBC() override;
+};
+#endif // NonReflectingDensityBCAlgorithm_h__
diff --git a/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.cpp b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce2c5a6268fd8d1a69d4c56a6ddbebe2df587b6c
--- /dev/null
+++ b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.cpp
@@ -0,0 +1,233 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file NonReflectingOutflowBCAlgorithmWithRelaxation.cpp
+//! \ingroup BoundarConditions
+//! \author Konstantin Kutscher, Hussein Alihussein
+//=======================================================================================
+#include "NonReflectingOutflowBCAlgorithmWithRelaxation.h"
+
+#include "BoundaryConditions.h"
+#include "D3Q27System.h"
+#include "DistributionArray3D.h"
+
+NonReflectingOutflowBCAlgorithmWithRelaxation::NonReflectingOutflowBCAlgorithmWithRelaxation()
+{
+ BCAlgorithm::type = BCAlgorithm::NonReflectingOutflowBCAlgorithmWithRelaxation;
+ BCAlgorithm::preCollision = true;
+}
+//////////////////////////////////////////////////////////////////////////
+NonReflectingOutflowBCAlgorithmWithRelaxation::~NonReflectingOutflowBCAlgorithmWithRelaxation() = default;
+//////////////////////////////////////////////////////////////////////////
+SPtr<BCAlgorithm> NonReflectingOutflowBCAlgorithmWithRelaxation::clone()
+{
+ SPtr<BCAlgorithm> bc(new NonReflectingOutflowBCAlgorithmWithRelaxation());
+ return bc;
+}
+//////////////////////////////////////////////////////////////////////////
+void NonReflectingOutflowBCAlgorithmWithRelaxation::addDistributions(SPtr<DistributionArray3D> distributions)
+{
+ this->distributions = distributions;
+}
+//////////////////////////////////////////////////////////////////////////
+void NonReflectingOutflowBCAlgorithmWithRelaxation::applyBC()
+{
+ using namespace vf::lbm::dir;
+
+ using namespace D3Q27System;
+ // using namespace UbMath;
+ using namespace vf::lbm::constant;
+
+ LBMReal f[ENDF + 1];
+ LBMReal ftemp[ENDF + 1];
+
+ int nx1 = x1;
+ int nx2 = x2;
+ int nx3 = x3;
+ int direction = -1;
+
+ // flag points in direction of fluid
+ if (bcPtr->hasDensityBoundaryFlag(DIR_P00)) {
+ nx1 += 1;
+ direction = DIR_P00;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_M00)) {
+ nx1 -= 1;
+ direction = DIR_M00;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_0P0)) {
+ nx2 += 1;
+ direction = DIR_0P0;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_0M0)) {
+ nx2 -= 1;
+ direction = DIR_0M0;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_00P)) {
+ nx3 += 1;
+ direction = DIR_00P;
+ } else if (bcPtr->hasDensityBoundaryFlag(DIR_00M)) {
+ nx3 -= 1;
+ direction = DIR_00M;
+ } else
+ UB_THROW(UbException(UB_EXARGS, "Danger...no orthogonal BC-Flag on density boundary..."));
+
+ distributions->getDistribution(f, x1, x2, x3);
+ distributions->getDistribution(ftemp, nx1, nx2, nx3);
+
+ LBMReal rho, vx1, vx2, vx3;
+ calcMacrosFct(f, rho, vx1, vx2, vx3);
+ LBMReal delf = rho*0.01;
+ switch (direction) {
+ case DIR_P00:
+ f[DIR_P00] = ftemp[DIR_P00] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P00] - delf* WEIGTH[DIR_P00];
+ f[DIR_PP0] = ftemp[DIR_PP0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PP0]- delf* WEIGTH[DIR_PP0];
+ f[DIR_PM0] = ftemp[DIR_PM0] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PM0]- delf* WEIGTH[DIR_PM0];
+ f[DIR_P0P] = ftemp[DIR_P0P] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P0P]- delf* WEIGTH[DIR_P0P];
+ f[DIR_P0M] = ftemp[DIR_P0M] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_P0M]- delf* WEIGTH[DIR_P0M];
+ f[DIR_PPP] = ftemp[DIR_PPP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PPP]- delf* WEIGTH[DIR_PPP];
+ f[DIR_PMP] = ftemp[DIR_PMP] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PMP]- delf* WEIGTH[DIR_PMP];
+ f[DIR_PPM] = ftemp[DIR_PPM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PPM]- delf* WEIGTH[DIR_PPM];
+ f[DIR_PMM] = ftemp[DIR_PMM] * (one_over_sqrt3 + vx1) + (1.0 - one_over_sqrt3 - vx1) * f[DIR_PMM]- delf* WEIGTH[DIR_PMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_P00], x1 + DX1[DIR_M00], x2 + DX2[DIR_M00], x3 + DX3[DIR_M00], DIR_M00);
+ distributions->setDistributionInvForDirection(f[DIR_PP0], x1 + DX1[DIR_MM0], x2 + DX2[DIR_MM0], x3 + DX3[DIR_MM0], DIR_MM0);
+ distributions->setDistributionInvForDirection(f[DIR_PM0], x1 + DX1[DIR_MP0], x2 + DX2[DIR_MP0], x3 + DX3[DIR_MP0], DIR_MP0);
+ distributions->setDistributionInvForDirection(f[DIR_P0P], x1 + DX1[DIR_M0M], x2 + DX2[DIR_M0M], x3 + DX3[DIR_M0M], DIR_M0M);
+ distributions->setDistributionInvForDirection(f[DIR_P0M], x1 + DX1[DIR_M0P], x2 + DX2[DIR_M0P], x3 + DX3[DIR_M0P], DIR_M0P);
+ distributions->setDistributionInvForDirection(f[DIR_PPP], x1 + DX1[DIR_MMM], x2 + DX2[DIR_MMM], x3 + DX3[DIR_MMM], DIR_MMM);
+ distributions->setDistributionInvForDirection(f[DIR_PMP], x1 + DX1[DIR_MPM], x2 + DX2[DIR_MPM], x3 + DX3[DIR_MPM], DIR_MPM);
+ distributions->setDistributionInvForDirection(f[DIR_PPM], x1 + DX1[DIR_MMP], x2 + DX2[DIR_MMP], x3 + DX3[DIR_MMP], DIR_MMP);
+ distributions->setDistributionInvForDirection(f[DIR_PMM], x1 + DX1[DIR_MPP], x2 + DX2[DIR_MPP], x3 + DX3[DIR_MPP], DIR_MPP);
+ break;
+ case DIR_M00:
+ f[DIR_M00] = ftemp[DIR_M00] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_M00]- delf* WEIGTH[DIR_M00];
+ f[DIR_MP0] = ftemp[DIR_MP0] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MP0]- delf* WEIGTH[DIR_MP0];
+ f[DIR_MM0] = ftemp[DIR_MM0] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MM0]- delf* WEIGTH[DIR_MM0];
+ f[DIR_M0P] = ftemp[DIR_M0P] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_M0P]- delf* WEIGTH[DIR_M0P];
+ f[DIR_M0M] = ftemp[DIR_M0M] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_M0M]- delf* WEIGTH[DIR_M0M];
+ f[DIR_MPP] = ftemp[DIR_MPP] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MPP]- delf* WEIGTH[DIR_MPP];
+ f[DIR_MMP] = ftemp[DIR_MMP] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MMP]- delf* WEIGTH[DIR_MMP];
+ f[DIR_MPM] = ftemp[DIR_MPM] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MPM]- delf* WEIGTH[DIR_MPM];
+ f[DIR_MMM] = ftemp[DIR_MMM] * (one_over_sqrt3 - vx1) + (1.0 - one_over_sqrt3 + vx1) * f[DIR_MMM]- delf* WEIGTH[DIR_MMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_M00], x1 + DX1[DIR_P00], x2 + DX2[DIR_P00], x3 + DX3[DIR_P00], DIR_P00);
+ distributions->setDistributionInvForDirection(f[DIR_MP0], x1 + DX1[DIR_PM0], x2 + DX2[DIR_PM0], x3 + DX3[DIR_PM0], DIR_PM0);
+ distributions->setDistributionInvForDirection(f[DIR_MM0], x1 + DX1[DIR_PP0], x2 + DX2[DIR_PP0], x3 + DX3[DIR_PP0], DIR_PP0);
+ distributions->setDistributionInvForDirection(f[DIR_M0P], x1 + DX1[DIR_P0M], x2 + DX2[DIR_P0M], x3 + DX3[DIR_P0M], DIR_P0M);
+ distributions->setDistributionInvForDirection(f[DIR_M0M], x1 + DX1[DIR_P0P], x2 + DX2[DIR_P0P], x3 + DX3[DIR_P0P], DIR_P0P);
+ distributions->setDistributionInvForDirection(f[DIR_MPP], x1 + DX1[DIR_PMM], x2 + DX2[DIR_PMM], x3 + DX3[DIR_PMM], DIR_PMM);
+ distributions->setDistributionInvForDirection(f[DIR_MMP], x1 + DX1[DIR_PPM], x2 + DX2[DIR_PPM], x3 + DX3[DIR_PPM], DIR_PPM);
+ distributions->setDistributionInvForDirection(f[DIR_MPM], x1 + DX1[DIR_PMP], x2 + DX2[DIR_PMP], x3 + DX3[DIR_PMP], DIR_PMP);
+ distributions->setDistributionInvForDirection(f[DIR_MMM], x1 + DX1[DIR_PPP], x2 + DX2[DIR_PPP], x3 + DX3[DIR_PPP], DIR_PPP);
+ break;
+ case DIR_0P0:
+ f[DIR_0P0] = ftemp[DIR_0P0] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_0P0]- delf* WEIGTH[DIR_0P0];
+ f[DIR_PP0] = ftemp[DIR_PP0] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_PP0]- delf* WEIGTH[DIR_PP0];
+ f[DIR_MP0] = ftemp[DIR_MP0] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_MP0]- delf* WEIGTH[DIR_MP0];
+ f[DIR_0PP] = ftemp[DIR_0PP] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_0PP]- delf* WEIGTH[DIR_0PP];
+ f[DIR_0PM] = ftemp[DIR_0PM] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_0PM]- delf* WEIGTH[DIR_0PM];
+ f[DIR_PPP] = ftemp[DIR_PPP] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_PPP]- delf* WEIGTH[DIR_PPP];
+ f[DIR_MPP] = ftemp[DIR_MPP] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_MPP]- delf* WEIGTH[DIR_MPP];
+ f[DIR_PPM] = ftemp[DIR_PPM] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_PPM]- delf* WEIGTH[DIR_PPM];
+ f[DIR_MPM] = ftemp[DIR_MPM] * (one_over_sqrt3 + vx2) + (1.0 - one_over_sqrt3 - vx2) * f[DIR_MPM]- delf* WEIGTH[DIR_MPM];
+
+ distributions->setDistributionInvForDirection(f[DIR_0P0], x1 + DX1[DIR_0M0], x2 + DX2[DIR_0M0], x3 + DX3[DIR_0M0], DIR_0M0);
+ distributions->setDistributionInvForDirection(f[DIR_PP0], x1 + DX1[DIR_MM0], x2 + DX2[DIR_MM0], x3 + DX3[DIR_MM0], DIR_MM0);
+ distributions->setDistributionInvForDirection(f[DIR_MP0], x1 + DX1[DIR_PM0], x2 + DX2[DIR_PM0], x3 + DX3[DIR_PM0], DIR_PM0);
+ distributions->setDistributionInvForDirection(f[DIR_0PP], x1 + DX1[DIR_0MM], x2 + DX2[DIR_0MM], x3 + DX3[DIR_0MM], DIR_0MM);
+ distributions->setDistributionInvForDirection(f[DIR_0PM], x1 + DX1[DIR_0MP], x2 + DX2[DIR_0MP], x3 + DX3[DIR_0MP], DIR_0MP);
+ distributions->setDistributionInvForDirection(f[DIR_PPP], x1 + DX1[DIR_MMM], x2 + DX2[DIR_MMM], x3 + DX3[DIR_MMM], DIR_MMM);
+ distributions->setDistributionInvForDirection(f[DIR_MPP], x1 + DX1[DIR_PMM], x2 + DX2[DIR_PMM], x3 + DX3[DIR_PMM], DIR_PMM);
+ distributions->setDistributionInvForDirection(f[DIR_PPM], x1 + DX1[DIR_MMP], x2 + DX2[DIR_MMP], x3 + DX3[DIR_MMP], DIR_MMP);
+ distributions->setDistributionInvForDirection(f[DIR_MPM], x1 + DX1[DIR_PMP], x2 + DX2[DIR_PMP], x3 + DX3[DIR_PMP], DIR_PMP);
+ break;
+ case DIR_0M0:
+ f[DIR_0M0] = ftemp[DIR_0M0] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_0M0]- delf* WEIGTH[DIR_0M0];
+ f[DIR_PM0] = ftemp[DIR_PM0] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_PM0]- delf* WEIGTH[DIR_PM0];
+ f[DIR_MM0] = ftemp[DIR_MM0] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_MM0]- delf* WEIGTH[DIR_MM0];
+ f[DIR_0MP] = ftemp[DIR_0MP] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_0MP]- delf* WEIGTH[DIR_0MP];
+ f[DIR_0MM] = ftemp[DIR_0MM] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_0MM]- delf* WEIGTH[DIR_0MM];
+ f[DIR_PMP] = ftemp[DIR_PMP] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_PMP]- delf* WEIGTH[DIR_PMP];
+ f[DIR_MMP] = ftemp[DIR_MMP] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_MMP]- delf* WEIGTH[DIR_MMP];
+ f[DIR_PMM] = ftemp[DIR_PMM] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_PMM]- delf* WEIGTH[DIR_PMM];
+ f[DIR_MMM] = ftemp[DIR_MMM] * (one_over_sqrt3 - vx2) + (1.0 - one_over_sqrt3 + vx2) * f[DIR_MMM]- delf* WEIGTH[DIR_MMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_0M0], x1 + DX1[DIR_0P0], x2 + DX2[DIR_0P0], x3 + DX3[DIR_0P0], DIR_0P0);
+ distributions->setDistributionInvForDirection(f[DIR_PM0], x1 + DX1[DIR_MP0], x2 + DX2[DIR_MP0], x3 + DX3[DIR_MP0], DIR_MP0);
+ distributions->setDistributionInvForDirection(f[DIR_MM0], x1 + DX1[DIR_PP0], x2 + DX2[DIR_PP0], x3 + DX3[DIR_PP0], DIR_PP0);
+ distributions->setDistributionInvForDirection(f[DIR_0MP], x1 + DX1[DIR_0PM], x2 + DX2[DIR_0PM], x3 + DX3[DIR_0PM], DIR_0PM);
+ distributions->setDistributionInvForDirection(f[DIR_0MM], x1 + DX1[DIR_0PP], x2 + DX2[DIR_0PP], x3 + DX3[DIR_0PP], DIR_0PP);
+ distributions->setDistributionInvForDirection(f[DIR_PMP], x1 + DX1[DIR_MPM], x2 + DX2[DIR_MPM], x3 + DX3[DIR_MPM], DIR_MPM);
+ distributions->setDistributionInvForDirection(f[DIR_MMP], x1 + DX1[DIR_PPM], x2 + DX2[DIR_PPM], x3 + DX3[DIR_PPM], DIR_PPM);
+ distributions->setDistributionInvForDirection(f[DIR_PMM], x1 + DX1[DIR_MPP], x2 + DX2[DIR_MPP], x3 + DX3[DIR_MPP], DIR_MPP);
+ distributions->setDistributionInvForDirection(f[DIR_MMM], x1 + DX1[DIR_PPP], x2 + DX2[DIR_PPP], x3 + DX3[DIR_PPP], DIR_PPP);
+ break;
+ case DIR_00P:
+ f[DIR_00P] = ftemp[DIR_00P] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_00P]- delf* WEIGTH[DIR_00P];
+ f[DIR_P0P] = ftemp[DIR_P0P] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_P0P]- delf* WEIGTH[DIR_P0P];
+ f[DIR_M0P] = ftemp[DIR_M0P] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_M0P]- delf* WEIGTH[DIR_M0P];
+ f[DIR_0PP] = ftemp[DIR_0PP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_0PP]- delf* WEIGTH[DIR_0PP];
+ f[DIR_0MP] = ftemp[DIR_0MP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_0MP]- delf* WEIGTH[DIR_0MP];
+ f[DIR_PPP] = ftemp[DIR_PPP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_PPP]- delf* WEIGTH[DIR_PPP];
+ f[DIR_MPP] = ftemp[DIR_MPP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_MPP]- delf* WEIGTH[DIR_MPP];
+ f[DIR_PMP] = ftemp[DIR_PMP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_PMP]- delf* WEIGTH[DIR_PMP];
+ f[DIR_MMP] = ftemp[DIR_MMP] * (one_over_sqrt3 + vx3) + (1.0 - one_over_sqrt3 - vx3) * f[DIR_MMP]- delf* WEIGTH[DIR_MMP];
+
+ distributions->setDistributionInvForDirection(f[DIR_00P], x1 + DX1[DIR_00M], x2 + DX2[DIR_00M], x3 + DX3[DIR_00M], DIR_00M);
+ distributions->setDistributionInvForDirection(f[DIR_P0P], x1 + DX1[DIR_M0M], x2 + DX2[DIR_M0M], x3 + DX3[DIR_M0M], DIR_M0M);
+ distributions->setDistributionInvForDirection(f[DIR_M0P], x1 + DX1[DIR_P0M], x2 + DX2[DIR_P0M], x3 + DX3[DIR_P0M], DIR_P0M);
+ distributions->setDistributionInvForDirection(f[DIR_0PP], x1 + DX1[DIR_0MM], x2 + DX2[DIR_0MM], x3 + DX3[DIR_0MM], DIR_0MM);
+ distributions->setDistributionInvForDirection(f[DIR_0MP], x1 + DX1[DIR_0PM], x2 + DX2[DIR_0PM], x3 + DX3[DIR_0PM], DIR_0PM);
+ distributions->setDistributionInvForDirection(f[DIR_PPP], x1 + DX1[DIR_MMM], x2 + DX2[DIR_MMM], x3 + DX3[DIR_MMM], DIR_MMM);
+ distributions->setDistributionInvForDirection(f[DIR_MPP], x1 + DX1[DIR_PMM], x2 + DX2[DIR_PMM], x3 + DX3[DIR_PMM], DIR_PMM);
+ distributions->setDistributionInvForDirection(f[DIR_PMP], x1 + DX1[DIR_MPM], x2 + DX2[DIR_MPM], x3 + DX3[DIR_MPM], DIR_MPM);
+ distributions->setDistributionInvForDirection(f[DIR_MMP], x1 + DX1[DIR_PPM], x2 + DX2[DIR_PPM], x3 + DX3[DIR_PPM], DIR_PPM);
+ break;
+ case DIR_00M:
+ f[DIR_00M] = ftemp[DIR_00M] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_00M]- delf* WEIGTH[DIR_00M];
+ f[DIR_P0M] = ftemp[DIR_P0M] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_P0M]- delf* WEIGTH[DIR_P0M];
+ f[DIR_M0M] = ftemp[DIR_M0M] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_M0M]- delf* WEIGTH[DIR_M0M];
+ f[DIR_0PM] = ftemp[DIR_0PM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_0PM]- delf* WEIGTH[DIR_0PM];
+ f[DIR_0MM] = ftemp[DIR_0MM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_0MM]- delf* WEIGTH[DIR_0MM];
+ f[DIR_PPM] = ftemp[DIR_PPM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_PPM]- delf* WEIGTH[DIR_PPM];
+ f[DIR_MPM] = ftemp[DIR_MPM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_MPM]- delf* WEIGTH[DIR_MPM];
+ f[DIR_PMM] = ftemp[DIR_PMM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_PMM]- delf* WEIGTH[DIR_PMM];
+ f[DIR_MMM] = ftemp[DIR_MMM] * (one_over_sqrt3 - vx3) + (1.0 - one_over_sqrt3 + vx3) * f[DIR_MMM]- delf* WEIGTH[DIR_MMM];
+
+ distributions->setDistributionInvForDirection(f[DIR_00M], x1 + DX1[DIR_00P], x2 + DX2[DIR_00P], x3 + DX3[DIR_00P], DIR_00P);
+ distributions->setDistributionInvForDirection(f[DIR_P0M], x1 + DX1[DIR_M0P], x2 + DX2[DIR_M0P], x3 + DX3[DIR_M0P], DIR_M0P);
+ distributions->setDistributionInvForDirection(f[DIR_M0M], x1 + DX1[DIR_P0P], x2 + DX2[DIR_P0P], x3 + DX3[DIR_P0P], DIR_P0P);
+ distributions->setDistributionInvForDirection(f[DIR_0PM], x1 + DX1[DIR_0MP], x2 + DX2[DIR_0MP], x3 + DX3[DIR_0MP], DIR_0MP);
+ distributions->setDistributionInvForDirection(f[DIR_0MM], x1 + DX1[DIR_0PP], x2 + DX2[DIR_0PP], x3 + DX3[DIR_0PP], DIR_0PP);
+ distributions->setDistributionInvForDirection(f[DIR_PPM], x1 + DX1[DIR_MMP], x2 + DX2[DIR_MMP], x3 + DX3[DIR_MMP], DIR_MMP);
+ distributions->setDistributionInvForDirection(f[DIR_MPM], x1 + DX1[DIR_PMP], x2 + DX2[DIR_PMP], x3 + DX3[DIR_PMP], DIR_PMP);
+ distributions->setDistributionInvForDirection(f[DIR_PMM], x1 + DX1[DIR_MPP], x2 + DX2[DIR_MPP], x3 + DX3[DIR_MPP], DIR_MPP);
+ distributions->setDistributionInvForDirection(f[DIR_MMM], x1 + DX1[DIR_PPP], x2 + DX2[DIR_PPP], x3 + DX3[DIR_PPP], DIR_PPP);
+ break;
+ default:
+ UB_THROW(
+ UbException(UB_EXARGS, "It isn't implemented non reflecting density boundary for this direction!"));
+ }
+}
diff --git a/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.h b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.h
new file mode 100644
index 0000000000000000000000000000000000000000..97badb60dbe84e0b7a4a3fa82b950649e0a12d93
--- /dev/null
+++ b/src/cpu/VirtualFluidsCore/BoundaryConditions/NonReflectingOutflowBCAlgorithmWithRelaxation.h
@@ -0,0 +1,50 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file NonReflectingOutflowBCAlgorithmWithRelaxation.h
+//! \ingroup BoundarConditions
+//! \author Konstantin Kutscher, Hussein Alihussein
+//=======================================================================================
+#ifndef NonReflectingOutflowBCAlgorithmWithRelaxation_h__
+#define NonReflectingOutflowBCAlgorithmWithRelaxation_h__
+
+#include "BCAlgorithm.h"
+#include <PointerDefinitions.h>
+
+class DistributionArray3D;
+
+class NonReflectingOutflowBCAlgorithmWithRelaxation : public BCAlgorithm
+{
+public:
+ NonReflectingOutflowBCAlgorithmWithRelaxation();
+ ~NonReflectingOutflowBCAlgorithmWithRelaxation() override;
+ SPtr<BCAlgorithm> clone() override;
+ void addDistributions(SPtr<DistributionArray3D> distributions) override;
+ void applyBC() override;
+};
+#endif // NonReflectingDensityBCAlgorithm_h__
diff --git a/src/cpu/pythonbindings/CMakeLists.txt b/src/cpu/pythonbindings/CMakeLists.txt
deleted file mode 100644
index 3b4e7e5a1506899710dc03ea275c0d4ac1cff66d..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-project(VirtualFluidsPython)
-
-pybind11_add_module(pyfluids src/VirtualfluidsModule.cpp)
-pybind11_add_module(pymuparser src/muParser.cpp)
-
-# TODO: Move this to MuParser CMakeLists.txt
-set_target_properties(muparser PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-target_compile_definitions(pyfluids PRIVATE VF_METIS VF_MPI)
-target_compile_definitions(pymuparser PRIVATE VF_METIS VF_MPI)
-
-target_link_libraries(pyfluids PRIVATE simulationconfig VirtualFluidsCore muparser basics)
-target_link_libraries(pymuparser PRIVATE muparser)
-
-target_include_directories(pyfluids PRIVATE ${CMAKE_SOURCE_DIR}/src/)
-target_include_directories(pyfluids PRIVATE ${CMAKE_BINARY_DIR})
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/VirtualfluidsModule.cpp b/src/cpu/pythonbindings/src/VirtualfluidsModule.cpp
deleted file mode 100644
index 564dc1838d48a92340fa5491779177b299bcb270..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/VirtualfluidsModule.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <pybind11/pybind11.h>
-#include "submodules/boundaryconditions.cpp"
-#include "submodules/simulationconfig.cpp"
-#include "submodules/geometry.cpp"
-#include "submodules/kernel.cpp"
-#include "submodules/simulationparameters.cpp"
-#include "submodules/writer.cpp"
-
-namespace py_bindings
-{
- namespace py = pybind11;
-
- PYBIND11_MODULE(pyfluids, m)
- {
- boundaryconditions::makeModule(m);
- simulation::makeModule(m);
- geometry::makeModule(m);
- kernel::makeModule(m);
- parameters::makeModule(m);
- writer::makeModule(m);
- }
-}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp b/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp
deleted file mode 100644
index 3bff7bc069ca20fe1c0cf3d1847b9714e0381505..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <BoundaryConditions/DensityBCAdapter.h>
-#include <BoundaryConditions/NonReflectingOutflowBCAlgorithm.h>
-#include <BoundaryConditions/BCAdapter.h>
-#include <BoundaryConditions/NoSlipBCAdapter.h>
-#include <BoundaryConditions/VelocityBCAdapter.h>
-#include <BoundaryConditions/NoSlipBCAlgorithm.h>
-#include <BoundaryConditions/VelocityBCAlgorithm.h>
-#include <BoundaryConditions/HighViscosityNoSlipBCAlgorithm.h>
-
-namespace boundaryconditions
-{
- namespace py = pybind11;
- using namespace py::literals;
-
- template<class adapter, class algorithm,
- class = std::enable_if_t<std::is_base_of<BCAdapter, adapter>::value>,
- class = std::enable_if_t<std::is_base_of<BCAlgorithm, algorithm>::value>>
- class PyBoundaryCondition : public adapter
- {
- public:
- template<typename ...Args>
- PyBoundaryCondition(Args &&... args) : adapter(std::forward<Args>(args)...)
- {
- this->setBcAlgorithm(std::make_shared<algorithm>());
- }
- };
-
- template<class adapter, class algorithm>
- using bc_class = py::class_<PyBoundaryCondition<adapter, algorithm>, BCAdapter,
- std::shared_ptr<PyBoundaryCondition<adapter, algorithm>>>;
-
- void makeModule(py::module_ &parentModule)
- {
- py::module_ bcModule = parentModule.def_submodule("boundaryconditions");
-
- auto _ = py::class_<BCAdapter, std::shared_ptr<BCAdapter>>(bcModule, "BCAdapter");
-
- bc_class<NoSlipBCAdapter, NoSlipBCAlgorithm>(bcModule, "NoSlipBoundaryCondition")
- .def(py::init());
-
- bc_class<NoSlipBCAdapter, HighViscosityNoSlipBCAlgorithm>(bcModule, "HighViscosityNoSlipBoundaryCondition")
- .def(py::init());
-
- bc_class<VelocityBCAdapter, VelocityBCAlgorithm>(bcModule, "VelocityBoundaryCondition")
- .def(py::init())
- .def(py::init<bool &, bool &, bool &, mu::Parser &, double &, double &>(),
- "vx1"_a, "vx2"_a, "vx3"_a,
- "function"_a, "start_time"_a, "end_time"_a)
- .def(py::init<bool &, bool &, bool &, mu::Parser &, mu::Parser &, mu::Parser &, double &, double &>(),
- "vx1"_a, "vx2"_a, "vx3"_a,
- "function_vx1"_a, "function_vx2"_a, "function_vx2"_a,
- "start_time"_a, "end_time"_a)
- .def(py::init<double &, double &, double &, double &, double &, double &, double &, double &, double &>(),
- "vx1"_a, "vx1_start_time"_a, "vx1_end_time"_a,
- "vx2"_a, "vx2_start_time"_a, "vx2_end_time"_a,
- "vx3"_a, "vx3_start_time"_a, "vx3_end_time"_a);
-
- bc_class<DensityBCAdapter, NonReflectingOutflowBCAlgorithm>(bcModule, "NonReflectingOutflow")
- .def(py::init());
- }
-
-}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/geometry.cpp b/src/cpu/pythonbindings/src/submodules/geometry.cpp
deleted file mode 100644
index b7ff4dd761258d41687589d2dd89c3479093753e..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/submodules/geometry.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <geometry3d/GbPoint3D.h>
-#include <geometry3d/GbObject3D.h>
-#include <geometry3d/GbCuboid3D.h>
-#include <geometry3d/GbLine3D.h>
-#include <Interactors/Interactor3D.h>
-
-
-namespace geometry
-{
- namespace py = pybind11;
-
- template<class GeoObject>
- using py_geometry = py::class_<GeoObject, GbObject3D, std::shared_ptr<GeoObject>>;
-
- std::string GbPoint3D_repr_(const GbPoint3D &instance)
- {
- std::ostringstream stream;
- stream << "<GbPoint3D"
- << " x1: " << instance.getX1Coordinate()
- << " x2: " << instance.getX2Coordinate()
- << " x3: " << instance.getX3Coordinate() << ">";
-
- return stream.str();
- }
-
- void makeModule(py::module_ &parentModule)
- {
- py::module geometry = parentModule.def_submodule("geometry");
-
- py::class_<GbObject3D, std::shared_ptr<GbObject3D>>(geometry, "GbObject3D");
-
- py_geometry<GbPoint3D>(geometry, "GbPoint3D")
- .def(py::init())
- .def(py::init<double &, double &, double &>())
- .def(py::init<GbPoint3D *>())
- .def_property("x1", &GbPoint3D::getX1Coordinate, &GbPoint3D::setX1)
- .def_property("x2", &GbPoint3D::getX2Coordinate, &GbPoint3D::setX2)
- .def_property("x3", &GbPoint3D::getX3Coordinate, &GbPoint3D::setX3)
- .def("get_distance", &GbPoint3D::getDistance)
- .def("__repr__", &GbPoint3D_repr_);
-
- py_geometry<GbCuboid3D>(geometry, "GbCuboid3D")
- .def(py::init())
- .def(py::init<double &, double &, double &, double &, double &, double &>())
- .def(py::init<GbPoint3D *, GbPoint3D *>())
- .def(py::init<GbCuboid3D *>())
- .def_property("point1", &GbCuboid3D::getPoint1, &GbCuboid3D::setPoint1)
- .def_property("point2", &GbCuboid3D::getPoint2, &GbCuboid3D::setPoint2)
- .def("__repr__", [&](GbCuboid3D &instance)
- {
- std::ostringstream stream;
- stream << "<GbCuboid3D" << std::endl
- << "point1: " << GbPoint3D_repr_(instance.getPoint1()) << std::endl
- << "point2: " << GbPoint3D_repr_(instance.getPoint2()) << ">";
- return stream.str();
- });
-
- py_geometry<GbLine3D>(geometry, "GbLine3D")
- .def(py::init())
- .def(py::init<GbPoint3D *, GbPoint3D *>())
- .def(py::init<GbLine3D>())
- .def_property("point1", &GbLine3D::getPoint1, &GbLine3D::setPoint1)
- .def_property("point2", &GbLine3D::getPoint2, &GbLine3D::setPoint2)
- .def("__repr__", [&](GbLine3D &instance)
- {
- std::ostringstream stream;
- stream << "<GbLine3D" << std::endl
- << "point1: " << GbPoint3D_repr_(instance.getPoint1()) << std::endl
- << "point2: " << GbPoint3D_repr_(instance.getPoint2()) << ">";
- return stream.str();
- });
-
-
- py::class_<Interactor3D, std::shared_ptr<Interactor3D>>(geometry, "State")
- .def_readonly_static("SOLID", &Interactor3D::SOLID)
- .def_readonly_static("INVERSESOLID", &Interactor3D::INVERSESOLID)
- .def_readonly_static("TIMEDEPENDENT", &Interactor3D::TIMEDEPENDENT)
- .def_readonly_static("FLUID", &Interactor3D::FLUID)
- .def_readonly_static("MOVEABLE", &Interactor3D::MOVEABLE)
- .def_readonly_static("CHANGENOTNECESSARY", &Interactor3D::CHANGENOTNECESSARY);
- }
-
-}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/kernel.cpp b/src/cpu/pythonbindings/src/submodules/kernel.cpp
deleted file mode 100644
index fb291790632cc2041410f60a14fca8d966283343..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/submodules/kernel.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <memory>
-#include <pybind11/pybind11.h>
-#include <simulationconfig/KernelFactory.h>
-#include <simulationconfig/KernelConfigStructs.h>
-
-namespace kernel
-{
- namespace py = pybind11;
-
- void makeModule(py::module_ &parentModule)
- {
- py::module kernelModule = parentModule.def_submodule("kernel");
-
- py::enum_<KernelFactory::KernelType>(kernelModule, "KernelType")
- .value("BGK", KernelFactory::BGK)
- .value("CompressibleCumulantFourthOrderViscosity",
- KernelFactory::COMPRESSIBLE_CUMULANT_4TH_ORDER_VISCOSITY);
-
- py::class_<LBMKernelConfiguration, std::shared_ptr<LBMKernelConfiguration>>(kernelModule, "LBMKernel")
- .def(py::init<KernelFactory::KernelType>())
- .def_readwrite("type", &LBMKernelConfiguration::kernelType)
- .def_readwrite("use_forcing", &LBMKernelConfiguration::useForcing)
- .def_readwrite("forcing_in_x1", &LBMKernelConfiguration::forcingX1)
- .def_readwrite("forcing_in_x2", &LBMKernelConfiguration::forcingX2)
- .def_readwrite("forcing_in_x3", &LBMKernelConfiguration::forcingX3)
- .def("set_forcing", [](LBMKernelConfiguration &kernelConfig, double x1, double x2, double x3)
- {
- kernelConfig.forcingX1 = x1;
- kernelConfig.forcingX2 = x2;
- kernelConfig.forcingX3 = x3;
- })
- .def("__repr__", [](LBMKernelConfiguration &kernelConfig)
- {
- std::ostringstream stream;
- stream << "<" << kernelConfig.kernelType << std::endl
- << "Use forcing: " << kernelConfig.useForcing << std::endl
- << "Forcing in x1: " << kernelConfig.forcingX1 << std::endl
- << "Forcing in x2: " << kernelConfig.forcingX2 << std::endl
- << "Forcing in x3: " << kernelConfig.forcingX3 << ">" << std::endl;
-
- return stream.str();
- });
- }
-
-}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/simulationconfig.cpp b/src/cpu/pythonbindings/src/submodules/simulationconfig.cpp
deleted file mode 100644
index 60af4e36af4dca67e9262dd9f5ee1f46d5b7bb58..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/submodules/simulationconfig.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <simulationconfig/Simulation.h>
-
-namespace simulation
-{
- namespace py = pybind11;
-
- void makeModule(py::module_ &parentModule)
- {
- py::class_<Simulation, std::shared_ptr<Simulation>>(parentModule, "Simulation")
- .def(py::init())
- .def("set_writer", &Simulation::setWriterConfiguration)
- .def("set_grid_parameters", &Simulation::setGridParameters)
- .def("set_physical_parameters", &Simulation::setPhysicalParameters)
- .def("set_runtime_parameters", &Simulation::setRuntimeParameters)
- .def("set_kernel_config", &Simulation::setKernelConfiguration)
- .def("add_object", &Simulation::addObject)
- .def("add_bc_adapter", &Simulation::addBCAdapter)
- .def("run_simulation", &Simulation::run);
- }
-
-}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp b/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp
deleted file mode 100644
index acc272f2ee412cfbafd9007b4b18610cfd0a1e9b..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <complex>
-#include <simulationconfig/SimulationParameters.h>
-
-namespace parameters
-{
- namespace py = pybind11;
-
- void makeModule(py::module_ &parentModule)
- {
- py::module parametersModule = parentModule.def_submodule("parameters");
-
- py::class_<PhysicalParameters, std::shared_ptr<PhysicalParameters>>(parametersModule, "PhysicalParameters")
- .def(py::init())
- .def_readwrite("bulk_viscosity_factor", &PhysicalParameters::bulkViscosityFactor,
- "The viscosity of the fluid will be multiplied with this factor to calculate its bulk viscosity. Default is 1.0")
- .def_readwrite("lattice_viscosity", &PhysicalParameters::latticeViscosity, "Lattice viscosity");
-
- py::class_<GridParameters, std::shared_ptr<GridParameters>>(parametersModule, "GridParameters")
- .def(py::init())
- .def_readwrite("node_distance", &GridParameters::nodeDistance)
- .def_readwrite("reference_direction_index", &GridParameters::referenceDirectionIndex)
- .def_readwrite("number_of_nodes_per_direction", &GridParameters::numberOfNodesPerDirection)
- .def_readwrite("blocks_per_direction", &GridParameters::blocksPerDirection)
- .def_readwrite("periodic_boundary_in_x1", &GridParameters::periodicBoundaryInX1)
- .def_readwrite("periodic_boundary_in_x2", &GridParameters::periodicBoundaryInX2)
- .def_readwrite("periodic_boundary_in_x3", &GridParameters::periodicBoundaryInX3)
- .def_property_readonly("bounding_box", &GridParameters::boundingBox);
-
- py::class_<BoundingBox, std::shared_ptr<BoundingBox>>(parametersModule, "BoundingBox")
- .def_readonly("min_x1", &BoundingBox::minX1)
- .def_readonly("min_x2", &BoundingBox::minX2)
- .def_readonly("min_x3", &BoundingBox::minX3)
- .def_readonly("max_x1", &BoundingBox::maxX1)
- .def_readonly("max_x2", &BoundingBox::maxX2)
- .def_readonly("max_x3", &BoundingBox::maxX3)
- .def("__repr__", [](BoundingBox &self)
- {
- std::ostringstream stream;
- stream << "<BoundingBox" << std::endl
- << "min x1: " << self.minX1 << std::endl
- << "min x2: " << self.minX2 << std::endl
- << "min x3: " << self.minX3 << std::endl
- << "max x1: " << self.maxX1 << std::endl
- << "max x2: " << self.maxX2 << std::endl
- << "max x3: " << self.maxX3 << std::endl << ">";
-
- return stream.str();
- });
-
- py::class_<RuntimeParameters, std::shared_ptr<RuntimeParameters>>(parametersModule, "RuntimeParameters")
- .def(py::init())
- .def_readwrite("number_of_timesteps", &RuntimeParameters::numberOfTimeSteps)
- .def_readwrite("timestep_log_interval", &RuntimeParameters::timeStepLogInterval)
- .def_readwrite("number_of_threads", &RuntimeParameters::numberOfThreads);
-
- }
-}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/writer.cpp b/src/cpu/pythonbindings/src/submodules/writer.cpp
deleted file mode 100644
index d5ec527a27caf63d9a3066c51e1f675b307fe0b2..0000000000000000000000000000000000000000
--- a/src/cpu/pythonbindings/src/submodules/writer.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <simulationconfig/WriterConfiguration.h>
-
-namespace writer
-{
- namespace py = pybind11;
-
- void makeModule(py::module_ &parentModule)
- {
- py::module writerModule = parentModule.def_submodule("writer");
-
- py::enum_<OutputFormat>(writerModule, "OutputFormat")
- .value("ASCII", OutputFormat::ASCII)
- .value("BINARY", OutputFormat::BINARY);
-
- py::class_<WriterConfiguration>(writerModule, "Writer")
- .def(py::init())
- .def_readwrite("output_path", &WriterConfiguration::outputPath)
- .def_readwrite("output_format", &WriterConfiguration::outputFormat);
- }
-}
\ No newline at end of file
diff --git a/src/cpu/simulationconfig/CMakeLists.txt b/src/cpu/simulationconfig/CMakeLists.txt
index 95ee969a049fd65cfadc6cc95d814e788a02aa8e..f0659f67a2af8d40a20991be42b4b49e1cab8ff1 100644
--- a/src/cpu/simulationconfig/CMakeLists.txt
+++ b/src/cpu/simulationconfig/CMakeLists.txt
@@ -1,7 +1,7 @@
project(simulationconfig)
-vf_add_library(NAME simulationconfig PUBLIC_LINK VirtualFluidsCore basics muparser)
+vf_add_library(NAME simulationconfig PUBLIC_LINK VirtualFluidsCore basics muparser lbm)
set_target_properties(simulationconfig PROPERTIES POSITION_INDEPENDENT_CODE ON)
diff --git a/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h b/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h
index 88e621a3fe00a522b23fda4101e84d39305e80a2..f346ea6cdbc8dffe164ddda2bff5808886160092 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h
@@ -2,14 +2,14 @@
#define VIRTUALFLUIDSPYTHONBINDINGS_KERNELCONFIGSTRUCTS_H
#include <string>
-#include <LBM/LBMSystem.h>
+#include <basics/Core/DataTypes.h>
struct LBMKernelConfiguration {
KernelFactory::KernelType kernelType;
bool useForcing = false;
- LBMReal forcingX1{};
- LBMReal forcingX2{};
- LBMReal forcingX3{};
+ real forcingX1{};
+ real forcingX2{};
+ real forcingX3{};
explicit LBMKernelConfiguration(KernelFactory::KernelType kernelType) : kernelType(kernelType)
{
diff --git a/src/cpu/simulationconfig/src/Simulation.cpp b/src/cpu/simulationconfig/src/Simulation.cpp
index 1fc777192d7b707ee28c1e1d2e8ae20d61df455b..098f913d61a87b0dd2692faad07de691ca7e04a1 100644
--- a/src/cpu/simulationconfig/src/Simulation.cpp
+++ b/src/cpu/simulationconfig/src/Simulation.cpp
@@ -33,6 +33,8 @@
#include <simulationconfig/SimulationParameters.h>
#include <simulationconfig/Simulation.h>
+#include <lbm/constants/D3Q27.h>
+
Simulation::Simulation()
{
diff --git a/src/gpu/VirtualFluids_GPU/Calculation/Cp.cpp b/src/gpu/VirtualFluids_GPU/Calculation/Cp.cpp
index 9ee4cb917cdbf76dddf988b4456d5d611c9a11e0..bb20d25bbc6b82e1d2b3dddd8a2f732a384cdb6d 100644
--- a/src/gpu/VirtualFluids_GPU/Calculation/Cp.cpp
+++ b/src/gpu/VirtualFluids_GPU/Calculation/Cp.cpp
@@ -230,16 +230,16 @@ void excludeGridInterfaceNodesForMirror(Parameter* para, int lev)
//define bool vector for nodes outside the interface
for (unsigned int it = 0; it < para->getParH(lev + 1)->numberOfPointsCpTop; it++)
{
- for (unsigned int ifit = 0; ifit < para->getParH((int)lev)->K_CF; ifit++)
+ for (unsigned int ifit = 0; ifit < para->getParH((int)lev)->coarseToFine.numberOfCells; ifit++)
{
- if ((para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH((int)lev)->intCF.ICellCFF[ifit]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->intCF.ICellCFF[ifit]]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborY[para->getParH((int)lev)->intCF.ICellCFF[ifit]]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH((int)lev)->intCF.ICellCFF[ifit]]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborY[para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->intCF.ICellCFF[ifit]]]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->intCF.ICellCFF[ifit]]]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH(lev + 1)->neighborY[para->getParH((int)lev)->intCF.ICellCFF[ifit]]]) ||
- (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH(lev + 1)->neighborY[para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->intCF.ICellCFF[ifit]]]]))
+ if ((para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborY[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborY[para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH(lev + 1)->neighborY[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]]) ||
+ (para->getParH(lev + 1)->cpTopIndex[it] == (int)para->getParH(lev + 1)->neighborZ[para->getParH(lev + 1)->neighborY[para->getParH(lev + 1)->neighborX[para->getParH((int)lev)->coarseToFine.fineCellIndices[ifit]]]]))
{
para->getParH(lev + 1)->isOutsideInterface.push_back(false);
tempBool = false;
@@ -256,9 +256,9 @@ void excludeGridInterfaceNodesForMirror(Parameter* para, int lev)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
for (unsigned int it = 0; it < para->getParH((int)lev)->numberOfPointsCpTop; it++)
{
- for (unsigned int ifit = 0; ifit < para->getParH((int)lev)->K_FC; ifit++)
+ for (unsigned int ifit = 0; ifit < para->getParH((int)lev)->fineToCoarse.numberOfCells; ifit++)
{
- if (para->getParH((int)lev)->cpTopIndex[it] == (int)para->getParH((int)lev)->intFC.ICellFCC[ifit])
+ if (para->getParH((int)lev)->cpTopIndex[it] == (int)para->getParH((int)lev)->fineToCoarse.coarseCellIndices[ifit])
{
para->getParH((int)lev)->isOutsideInterface.push_back(false);
tempBool = false;
diff --git a/src/gpu/VirtualFluids_GPU/Calculation/RefinementStrategy.cpp b/src/gpu/VirtualFluids_GPU/Calculation/RefinementStrategy.cpp
index b8ca4e9c2020e17cd0192267ac5d931b510afc3a..f1c9bb8e53f81a554091a5e230ba09556b084167 100644
--- a/src/gpu/VirtualFluids_GPU/Calculation/RefinementStrategy.cpp
+++ b/src/gpu/VirtualFluids_GPU/Calculation/RefinementStrategy.cpp
@@ -42,7 +42,7 @@ void RefinementAndExchange_streams_exchangeInterface::operator()(UpdateGrid27 *u
//!
//! 1. Interpolation fine to coarse for nodes which are at the border of the gpus/processes
//!
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFCBorder, para->getParD(level)->offFC, CudaStreamIndex::SubDomainBorder);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarseBorder, para->getParD(level)->neighborFineToCoarse, CudaStreamIndex::SubDomainBorder);
//! 2. prepare the exchange between gpus (collect the send nodes for communication in a buffer on the gpu) and trigger bulk kernel execution when finished
//!
@@ -53,8 +53,8 @@ void RefinementAndExchange_streams_exchangeInterface::operator()(UpdateGrid27 *u
//! 3. launch the bulk kernels for both interpolation processes (fine to coarse and coarse to fine)
//!
para->getStreamManager()->waitOnStartBulkKernelEvent(CudaStreamIndex::Bulk);
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFCBulk, para->getParD(level)->offFCBulk, CudaStreamIndex::SubDomainBorder);
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCFBulk, para->getParD(level)->offCFBulk, CudaStreamIndex::SubDomainBorder);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarseBulk, para->getParD(level)->neighborFineToCoarseBulk, CudaStreamIndex::SubDomainBorder);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFineBulk, para->getParD(level)->neighborCoarseToFineBulk, CudaStreamIndex::SubDomainBorder);
//! 4. exchange information between GPUs (only nodes which are part of the interpolation)
//!
@@ -62,7 +62,7 @@ void RefinementAndExchange_streams_exchangeInterface::operator()(UpdateGrid27 *u
// 5. interpolation fine to coarse for nodes which are at the border of the gpus/processes
//!
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCFBorder, para->getParD(level)->offCF, CudaStreamIndex::SubDomainBorder);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFineBorder, para->getParD(level)->neighborCoarseToFine, CudaStreamIndex::SubDomainBorder);
cudaDeviceSynchronize();
}
@@ -73,7 +73,7 @@ void RefinementAndExchange_streams_exchangeAllNodes::operator()(UpdateGrid27 *up
//!
//! 1. interpolation fine to coarse for nodes which are at the border of the gpus/processes
//!
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFCBorder, para->getParD(level)->offFC, CudaStreamIndex::SubDomainBorder);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarseBorder, para->getParD(level)->neighborFineToCoarse, CudaStreamIndex::SubDomainBorder);
//! 2. prepare the exchange between gpus (collect the send nodes for communication in a buffer on the gpu) and trigger bulk kernel execution when finished
//!
@@ -84,8 +84,8 @@ void RefinementAndExchange_streams_exchangeAllNodes::operator()(UpdateGrid27 *up
//! 3. launch the bulk kernels for both interpolation processes (fine to coarse and coarse to fine)
//!
para->getStreamManager()->waitOnStartBulkKernelEvent(CudaStreamIndex::Bulk);
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFCBulk, para->getParD(level)->offFCBulk, CudaStreamIndex::SubDomainBorder);
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCFBulk, para->getParD(level)->offCFBulk, CudaStreamIndex::SubDomainBorder);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarseBulk, para->getParD(level)->neighborFineToCoarseBulk, CudaStreamIndex::SubDomainBorder);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFineBulk, para->getParD(level)->neighborCoarseToFineBulk, CudaStreamIndex::SubDomainBorder);
//! 4. exchange information between GPUs (all nodes)
//!
@@ -93,7 +93,7 @@ void RefinementAndExchange_streams_exchangeAllNodes::operator()(UpdateGrid27 *up
// 5. interpolation fine to coarse for nodes which are at the border of the gpus/processes
//!
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCFBorder, para->getParD(level)->offCF, CudaStreamIndex::SubDomainBorder);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFineBorder, para->getParD(level)->neighborCoarseToFine, CudaStreamIndex::SubDomainBorder);
cudaDeviceSynchronize();
}
@@ -104,14 +104,14 @@ void RefinementAndExchange_noStreams_exchangeInterface::operator()(UpdateGrid27
//!
//! 1. interpolation fine to coarse
//!
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFC, para->getParD(level)->offFC, CudaStreamIndex::Legacy);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarse, para->getParD(level)->neighborFineToCoarse, CudaStreamIndex::Legacy);
//! 2. exchange information between GPUs (only nodes which are part of the interpolation)
//!
updateGrid->exchangeMultiGPU_noStreams_withPrepare(level, true);
//! 3. interpolation coarse to fine
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCF, para->getParD(level)->offCF, CudaStreamIndex::Legacy);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFine, para->getParD(level)->neighborCoarseToFine, CudaStreamIndex::Legacy);
}
void RefinementAndExchange_noStreams_exchangeAllNodes::operator()(UpdateGrid27 *updateGrid, Parameter *para, int level)
@@ -120,14 +120,14 @@ void RefinementAndExchange_noStreams_exchangeAllNodes::operator()(UpdateGrid27 *
//!
//! 1. interpolation fine to coarse
//!
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFC, para->getParD(level)->offFC, CudaStreamIndex::Legacy);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarse, para->getParD(level)->neighborFineToCoarse, CudaStreamIndex::Legacy);
//! 2. exchange information between GPUs (all nodes)
//!
updateGrid->exchangeMultiGPU_noStreams_withPrepare(level, false);
//! 3. interpolation coarse to fine
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCF, para->getParD(level)->offCF, CudaStreamIndex::Legacy);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFine, para->getParD(level)->neighborCoarseToFine, CudaStreamIndex::Legacy);
}
void Refinement_noExchange::operator()(UpdateGrid27 *updateGrid, Parameter *para, int level)
@@ -136,7 +136,7 @@ void Refinement_noExchange::operator()(UpdateGrid27 *updateGrid, Parameter *para
//!
//! 1. interpolation fine to coarse
//!
- updateGrid->fineToCoarse(level, ¶->getParD(level)->intFC, para->getParD(level)->offFC, CudaStreamIndex::Legacy);
+ updateGrid->fineToCoarse(level, ¶->getParD(level)->fineToCoarse, para->getParD(level)->neighborFineToCoarse, CudaStreamIndex::Legacy);
//! 2. interpolation coarse to fine
- updateGrid->coarseToFine(level, ¶->getParD(level)->intCF, para->getParD(level)->offCF, CudaStreamIndex::Legacy);
+ updateGrid->coarseToFine(level, ¶->getParD(level)->coarseToFine, para->getParD(level)->neighborCoarseToFine, CudaStreamIndex::Legacy);
}
diff --git a/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp b/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
index 4136614dfbfc9e0d2fc1bf7f4b01624f94eabb6f..a2b1039afca4eaa3fcd75e28cae16cb5f68f6c9b 100644
--- a/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
+++ b/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
@@ -328,9 +328,9 @@ void UpdateGrid27::preCollisionBC(int level, unsigned int t)
//////////////////////////////////////////////////////////////////////////////////
}
-void UpdateGrid27::fineToCoarse(int level, InterpolationCellFC* icellFC, OffFC &offFC, CudaStreamIndex streamIndex)
+void UpdateGrid27::fineToCoarse(int level, InterpolationCells* fineToCoarse, ICellNeigh &neighborFineToCoarse, CudaStreamIndex streamIndex)
{
- gridScalingKernelManager->runFineToCoarseKernelLB(level, icellFC, offFC, streamIndex);
+ gridScalingKernelManager->runFineToCoarseKernelLB(level, fineToCoarse, neighborFineToCoarse, streamIndex);
if (para->getDiffOn()) {
if (para->getStreamManager()->streamIsRegistered(streamIndex)) {
@@ -341,9 +341,9 @@ void UpdateGrid27::fineToCoarse(int level, InterpolationCellFC* icellFC, OffFC &
}
}
-void UpdateGrid27::coarseToFine(int level, InterpolationCellCF* icellCF, OffCF &offCF, CudaStreamIndex streamIndex)
+void UpdateGrid27::coarseToFine(int level, InterpolationCells* coarseToFine, ICellNeigh &neighborCoarseToFine, CudaStreamIndex streamIndex)
{
- this->gridScalingKernelManager->runCoarseToFineKernelLB(level, icellCF, offCF, streamIndex);
+ this->gridScalingKernelManager->runCoarseToFineKernelLB(level, coarseToFine, neighborCoarseToFine, streamIndex);
if (para->getDiffOn())
{
diff --git a/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.h b/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.h
index 8ce2cf5bfd72f9f53cdb35bc92502ee9ca0d3ad8..9c6ff48725f4e17121de0a1a8681d0bafcfb58ee 100644
--- a/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.h
+++ b/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.h
@@ -38,8 +38,8 @@ private:
void preCollisionBC(int level, unsigned int t);
void collisionPorousMedia(int level);
- void fineToCoarse(int level, InterpolationCellFC* icellFC, OffFC &offFC, CudaStreamIndex streamIndex);
- void coarseToFine(int level, InterpolationCellCF* icellCF, OffCF &offCF, CudaStreamIndex streamIndex);
+ void fineToCoarse(int level, InterpolationCells* fineToCoarse, ICellNeigh &neighborFineToCoarse, CudaStreamIndex streamIndex);
+ void coarseToFine(int level, InterpolationCells* coarseToFine, ICellNeigh &neighborCoarseToFine, CudaStreamIndex streamIndex);
void prepareExchangeMultiGPU(int level, CudaStreamIndex streamIndex);
void prepareExchangeMultiGPUAfterFtoC(int level, CudaStreamIndex streamIndex);
diff --git a/src/gpu/VirtualFluids_GPU/Communication/ExchangeData27.cpp b/src/gpu/VirtualFluids_GPU/Communication/ExchangeData27.cpp
index 00a7b45668e2050467f3d1122455dc74d0ad4f1c..bdd747ee856cb88e3c46ee93a0fedd394707a074 100644
--- a/src/gpu/VirtualFluids_GPU/Communication/ExchangeData27.cpp
+++ b/src/gpu/VirtualFluids_GPU/Communication/ExchangeData27.cpp
@@ -777,7 +777,7 @@ void exchangePreCollDataADXGPU27(Parameter* para, vf::gpu::Communicator& comm, C
//copy Device to Host
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsX(level, "send")); i++)
{
- GetSendFsPreDev27(para->getParD(level)->distributionsAD27.f[0],
+ GetSendFsPreDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->sendProcessNeighborADX[i].f[0],
para->getParD(level)->sendProcessNeighborADX[i].index,
para->getParD(level)->sendProcessNeighborADX[i].numberOfNodes,
@@ -838,7 +838,7 @@ void exchangePreCollDataADXGPU27(Parameter* para, vf::gpu::Communicator& comm, C
{
cudaMemoryManager->cudaCopyProcessNeighborADXFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
- SetRecvFsPreDev27(para->getParD(level)->distributionsAD27.f[0],
+ SetRecvFsPreDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->recvProcessNeighborADX[i].f[0],
para->getParD(level)->recvProcessNeighborADX[i].index,
para->getParD(level)->recvProcessNeighborADX[i].numberOfNodes,
@@ -858,7 +858,7 @@ void exchangePostCollDataADXGPU27(Parameter* para, vf::gpu::Communicator& comm,
//copy Device to Host
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsX(level, "send")); i++)
{
- GetSendFsPostDev27(para->getParD(level)->distributionsAD27.f[0],
+ GetSendFsPostDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->sendProcessNeighborADX[i].f[0],
para->getParD(level)->sendProcessNeighborADX[i].index,
para->getParD(level)->sendProcessNeighborADX[i].numberOfNodes,
@@ -919,7 +919,7 @@ void exchangePostCollDataADXGPU27(Parameter* para, vf::gpu::Communicator& comm,
{
cudaMemoryManager->cudaCopyProcessNeighborADXFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
- SetRecvFsPostDev27(para->getParD(level)->distributionsAD27.f[0],
+ SetRecvFsPostDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->recvProcessNeighborADX[i].f[0],
para->getParD(level)->recvProcessNeighborADX[i].index,
para->getParD(level)->recvProcessNeighborADX[i].numberOfNodes,
@@ -946,7 +946,7 @@ void exchangePreCollDataADYGPU27(Parameter* para, vf::gpu::Communicator& comm, C
//copy Device to Host
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsY(level, "send")); i++)
{
- GetSendFsPreDev27(para->getParD(level)->distributionsAD27.f[0],
+ GetSendFsPreDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->sendProcessNeighborADY[i].f[0],
para->getParD(level)->sendProcessNeighborADY[i].index,
para->getParD(level)->sendProcessNeighborADY[i].numberOfNodes,
@@ -1007,7 +1007,7 @@ void exchangePreCollDataADYGPU27(Parameter* para, vf::gpu::Communicator& comm, C
{
cudaMemoryManager->cudaCopyProcessNeighborADYFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
- SetRecvFsPreDev27(para->getParD(level)->distributionsAD27.f[0],
+ SetRecvFsPreDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->recvProcessNeighborADY[i].f[0],
para->getParD(level)->recvProcessNeighborADY[i].index,
para->getParD(level)->recvProcessNeighborADY[i].numberOfNodes,
@@ -1027,7 +1027,7 @@ void exchangePostCollDataADYGPU27(Parameter* para, vf::gpu::Communicator& comm,
//copy Device to Host
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsY(level, "send")); i++)
{
- GetSendFsPostDev27(para->getParD(level)->distributionsAD27.f[0],
+ GetSendFsPostDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->sendProcessNeighborADY[i].f[0],
para->getParD(level)->sendProcessNeighborADY[i].index,
para->getParD(level)->sendProcessNeighborADY[i].numberOfNodes,
@@ -1088,7 +1088,7 @@ void exchangePostCollDataADYGPU27(Parameter* para, vf::gpu::Communicator& comm,
{
cudaMemoryManager->cudaCopyProcessNeighborADYFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
- SetRecvFsPostDev27(para->getParD(level)->distributionsAD27.f[0],
+ SetRecvFsPostDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->recvProcessNeighborADY[i].f[0],
para->getParD(level)->recvProcessNeighborADY[i].index,
para->getParD(level)->recvProcessNeighborADY[i].numberOfNodes,
@@ -1115,7 +1115,7 @@ void exchangePreCollDataADZGPU27(Parameter* para, vf::gpu::Communicator& comm, C
//copy Device to Host
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsZ(level, "send")); i++)
{
- GetSendFsPreDev27(para->getParD(level)->distributionsAD27.f[0],
+ GetSendFsPreDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->sendProcessNeighborADZ[i].f[0],
para->getParD(level)->sendProcessNeighborADZ[i].index,
para->getParD(level)->sendProcessNeighborADZ[i].numberOfNodes,
@@ -1176,7 +1176,7 @@ void exchangePreCollDataADZGPU27(Parameter* para, vf::gpu::Communicator& comm, C
{
cudaMemoryManager->cudaCopyProcessNeighborADZFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
- SetRecvFsPreDev27(para->getParD(level)->distributionsAD27.f[0],
+ SetRecvFsPreDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->recvProcessNeighborADZ[i].f[0],
para->getParD(level)->recvProcessNeighborADZ[i].index,
para->getParD(level)->recvProcessNeighborADZ[i].numberOfNodes,
@@ -1196,7 +1196,7 @@ void exchangePostCollDataADZGPU27(Parameter* para, vf::gpu::Communicator& comm,
//copy Device to Host
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsZ(level, "send")); i++)
{
- GetSendFsPostDev27(para->getParD(level)->distributionsAD27.f[0],
+ GetSendFsPostDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->sendProcessNeighborADZ[i].f[0],
para->getParD(level)->sendProcessNeighborADZ[i].index,
para->getParD(level)->sendProcessNeighborADZ[i].numberOfNodes,
@@ -1257,7 +1257,7 @@ void exchangePostCollDataADZGPU27(Parameter* para, vf::gpu::Communicator& comm,
{
cudaMemoryManager->cudaCopyProcessNeighborADZFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
- SetRecvFsPostDev27(para->getParD(level)->distributionsAD27.f[0],
+ SetRecvFsPostDev27(para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->recvProcessNeighborADZ[i].f[0],
para->getParD(level)->recvProcessNeighborADZ[i].index,
para->getParD(level)->recvProcessNeighborADZ[i].numberOfNodes,
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp
index a1c8554cc4e262e9f1eca4204aed4ffcfd4c3a87..647ab169b22dfd5973bb6ee6bbf80745ca647241 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp
@@ -165,25 +165,13 @@ void GridReader::allocArrays_OffsetScale()
AnzahlKnotenGesFC += tempFC;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //size + memsize CF
- para->getParH(i)->K_CF = tempCF;
- para->getParD(i)->K_CF = para->getParH(i)->K_CF;
- para->getParH(i)->intCF.kCF = para->getParH(i)->K_CF;
- para->getParD(i)->intCF.kCF = para->getParH(i)->K_CF;
- para->getParH(i)->mem_size_kCF = sizeof(unsigned int)* para->getParH(i)->K_CF;
- para->getParD(i)->mem_size_kCF = sizeof(unsigned int)* para->getParD(i)->K_CF;
- para->getParH(i)->mem_size_kCF_off = sizeof(real)* para->getParH(i)->K_CF;
- para->getParD(i)->mem_size_kCF_off = sizeof(real)* para->getParD(i)->K_CF;
+ //size CF
+ para->getParH(i)->coarseToFine.numberOfCells = tempCF;
+ para->getParD(i)->coarseToFine.numberOfCells = para->getParH(i)->coarseToFine.numberOfCells;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //size + memsize FC
- para->getParH(i)->K_FC = tempFC;
- para->getParD(i)->K_FC = para->getParH(i)->K_FC;
- para->getParH(i)->intFC.kFC = para->getParH(i)->K_FC;
- para->getParD(i)->intFC.kFC = para->getParH(i)->K_FC;
- para->getParH(i)->mem_size_kFC = sizeof(unsigned int)* para->getParH(i)->K_FC;
- para->getParD(i)->mem_size_kFC = sizeof(unsigned int)* para->getParD(i)->K_FC;
- para->getParH(i)->mem_size_kFC_off = sizeof(real)* para->getParH(i)->K_FC;
- para->getParD(i)->mem_size_kFC_off = sizeof(real)* para->getParD(i)->K_FC;
+ //size FC
+ para->getParH(i)->fineToCoarse.numberOfCells = tempFC;
+ para->getParD(i)->fineToCoarse.numberOfCells = para->getParH(i)->fineToCoarse.numberOfCells;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//alloc
cudaMemoryManager->cudaAllocInterfaceCF(i);
@@ -192,12 +180,12 @@ void GridReader::allocArrays_OffsetScale()
cudaMemoryManager->cudaAllocInterfaceOffFC(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//init
- obj_offCF->initArrayOffset(para->getParH(i)->offCF.xOffCF, para->getParH(i)->offCF.yOffCF, para->getParH(i)->offCF.zOffCF, i);
- obj_offFC->initArrayOffset(para->getParH(i)->offFC.xOffFC, para->getParH(i)->offFC.yOffFC, para->getParH(i)->offFC.zOffFC, i);
- obj_scaleCFC->initScale(para->getParH(i)->intCF.ICellCFC, i);
- obj_scaleCFF->initScale(para->getParH(i)->intCF.ICellCFF, i);
- obj_scaleFCC->initScale(para->getParH(i)->intFC.ICellFCC, i);
- obj_scaleFCF->initScale(para->getParH(i)->intFC.ICellFCF, i);
+ obj_offCF->initArrayOffset(para->getParH(i)->neighborCoarseToFine.x, para->getParH(i)->neighborCoarseToFine.y, para->getParH(i)->neighborCoarseToFine.z, i);
+ obj_offFC->initArrayOffset(para->getParH(i)->neighborFineToCoarse.x, para->getParH(i)->neighborFineToCoarse.y, para->getParH(i)->neighborFineToCoarse.z, i);
+ obj_scaleCFC->initScale(para->getParH(i)->coarseToFine.coarseCellIndices, i);
+ obj_scaleCFF->initScale(para->getParH(i)->coarseToFine.fineCellIndices, i);
+ obj_scaleFCC->initScale(para->getParH(i)->fineToCoarse.coarseCellIndices, i);
+ obj_scaleFCF->initScale(para->getParH(i)->fineToCoarse.fineCellIndices, i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy
cudaMemoryManager->cudaCopyInterfaceCF(i);
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
index c2f86721de26d516ed60f497a65d1d46a34aa182..533382211dfba6c2d1ad88b1c75ef89e32beec0f 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
@@ -1179,25 +1179,13 @@ void GridGenerator::allocArrays_OffsetScale()
std::cout << "number of nodes FC level " << level << " : " << numberOfNodesPerLevelFC << std::endl;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //size + memsize CF
- para->getParH(level)->K_CF = numberOfNodesPerLevelCF;
- para->getParD(level)->K_CF = para->getParH(level)->K_CF;
- para->getParH(level)->intCF.kCF = para->getParH(level)->K_CF;
- para->getParD(level)->intCF.kCF = para->getParH(level)->K_CF;
- para->getParH(level)->mem_size_kCF = sizeof(uint)* para->getParH(level)->K_CF;
- para->getParD(level)->mem_size_kCF = sizeof(uint)* para->getParD(level)->K_CF;
- para->getParH(level)->mem_size_kCF_off = sizeof(real)* para->getParH(level)->K_CF;
- para->getParD(level)->mem_size_kCF_off = sizeof(real)* para->getParD(level)->K_CF;
+ //size CF
+ para->getParH(level)->coarseToFine.numberOfCells = numberOfNodesPerLevelCF;
+ para->getParD(level)->coarseToFine.numberOfCells = para->getParH(level)->coarseToFine.numberOfCells;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //size + memsize FC
- para->getParH(level)->K_FC = numberOfNodesPerLevelFC;
- para->getParD(level)->K_FC = para->getParH(level)->K_FC;
- para->getParH(level)->intFC.kFC = para->getParH(level)->K_FC;
- para->getParD(level)->intFC.kFC = para->getParH(level)->K_FC;
- para->getParH(level)->mem_size_kFC = sizeof(uint)* para->getParH(level)->K_FC;
- para->getParD(level)->mem_size_kFC = sizeof(uint)* para->getParD(level)->K_FC;
- para->getParH(level)->mem_size_kFC_off = sizeof(real)* para->getParH(level)->K_FC;
- para->getParD(level)->mem_size_kFC_off = sizeof(real)* para->getParD(level)->K_FC;
+ //size FC
+ para->getParH(level)->fineToCoarse.numberOfCells = numberOfNodesPerLevelFC;
+ para->getParD(level)->fineToCoarse.numberOfCells = para->getParH(level)->fineToCoarse.numberOfCells;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//alloc
cudaMemoryManager->cudaAllocInterfaceCF(level);
@@ -1206,9 +1194,9 @@ void GridGenerator::allocArrays_OffsetScale()
cudaMemoryManager->cudaAllocInterfaceOffFC(level);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//init
- builder->getOffsetCF(para->getParH(level)->offCF.xOffCF, para->getParH(level)->offCF.yOffCF, para->getParH(level)->offCF.zOffCF, level);
- builder->getOffsetFC(para->getParH(level)->offFC.xOffFC, para->getParH(level)->offFC.yOffFC, para->getParH(level)->offFC.zOffFC, level);
- builder->getGridInterfaceIndices(para->getParH(level)->intCF.ICellCFC, para->getParH(level)->intCF.ICellCFF, para->getParH(level)->intFC.ICellFCC, para->getParH(level)->intFC.ICellFCF, level);
+ builder->getOffsetCF(para->getParH(level)->neighborCoarseToFine.x, para->getParH(level)->neighborCoarseToFine.y, para->getParH(level)->neighborCoarseToFine.z, level);
+ builder->getOffsetFC(para->getParH(level)->neighborFineToCoarse.x, para->getParH(level)->neighborFineToCoarse.y, para->getParH(level)->neighborFineToCoarse.z, level);
+ builder->getGridInterfaceIndices(para->getParH(level)->coarseToFine.coarseCellIndices, para->getParH(level)->coarseToFine.fineCellIndices, para->getParH(level)->fineToCoarse.coarseCellIndices, para->getParH(level)->fineToCoarse.fineCellIndices, level);
if (para->getUseStreams() || para->getNumprocs() > 1) {
// split fine-to-coarse indices into border and bulk
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.cpp
index 4cd8769407220ec97030489585009d435a6cce8e..696254c44e0fe1150ded8566650483878377928c 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.cpp
@@ -333,7 +333,7 @@ void IndexRearrangementForStreams::reorderSendIndicesForCommAfterFtoC(
{
VF_LOG_INFO("Reorder send indices for communication after fine to coarse: level: {} direction: {}", level,
direction);
- if (para->getParH(level)->intCF.kCF == 0 || para->getParH(level)->intFC.kFC == 0)
+ if (para->getParH(level)->coarseToFine.numberOfCells == 0 || para->getParH(level)->fineToCoarse.numberOfCells == 0)
VF_LOG_CRITICAL("reorderSendIndicesForCommAfterFtoC(): para->getParH(level)->intCF needs to be initialized "
"before calling this function");
@@ -342,19 +342,19 @@ void IndexRearrangementForStreams::reorderSendIndicesForCommAfterFtoC(
std::vector<int> sendIndicesOther;
uint numberOfSendIndices = builder->getNumberOfSendIndices(direction, level);
- // iCellFCC
+ // coarse cells of interpolation fine to coarse (iCellFCC)
for (uint posInSendIndices = 0; posInSendIndices < numberOfSendIndices; posInSendIndices++) {
sparseIndexSend = sendIndices[posInSendIndices];
- if (isSparseIndexInICellFCC(para->getParH(level)->intFC.kFC, sparseIndexSend, level)) {
+ if (isSparseIndexInCoarseIndexForFtoC(para->getParH(level)->fineToCoarse.numberOfCells, sparseIndexSend, level)) {
addUniqueIndexToCommunicationVectors(sendIndicesAfterFtoC, sparseIndexSend,
sendIndicesForCommAfterFtoCPositions, posInSendIndices);
}
}
- // iCellCFC
- std::vector<uint> nodesCFC;
- aggregateNodesInICellCFC(level, nodesCFC);
- for (auto sparseIndex : nodesCFC)
+ // coarse cells of interpolation coarse to fine (iCellCFC)
+ std::vector<uint> coarseCellsForCtoF;
+ aggregateCoarseNodesForCtoF(level, coarseCellsForCtoF);
+ for (auto sparseIndex : coarseCellsForCtoF)
findIfSparseIndexIsInSendIndicesAndAddToCommVectors(sparseIndex, sendIndices, numberOfSendIndices,
sendIndicesAfterFtoC, sendIndicesForCommAfterFtoCPositions);
@@ -378,27 +378,27 @@ void IndexRearrangementForStreams::reorderSendIndicesForCommAfterFtoC(
}
}
-bool IndexRearrangementForStreams::isSparseIndexInICellFCC(uint sizeOfICellFCC, int sparseIndex, int level) const
+bool IndexRearrangementForStreams::isSparseIndexInCoarseIndexForFtoC(uint numberOfCoarseNodesForFtoC, int sparseIndex, int level) const
{
- for (uint j = 0; j < sizeOfICellFCC; j++) {
+ for (uint j = 0; j < numberOfCoarseNodesForFtoC; j++) {
if (sparseIndex < 0)
return false;
- if (para->getParH(level)->intFC.ICellFCC[j] == (uint)sparseIndex) {
+ if (para->getParH(level)->fineToCoarse.coarseCellIndices[j] == (uint)sparseIndex) {
return true;
}
}
return false;
}
-void IndexRearrangementForStreams::aggregateNodesInICellCFC(int level, std::vector<uint> &nodesCFC) const
+void IndexRearrangementForStreams::aggregateCoarseNodesForCtoF(int level, std::vector<uint> &nodesCFC) const
{
uint sparseIndex;
uint *neighborX = para->getParH(level)->neighborX;
uint *neighborY = para->getParH(level)->neighborY;
uint *neighborZ = para->getParH(level)->neighborZ;
- for (uint x = 0; x < para->getParH(level)->intCF.kCF; x++) {
- sparseIndex = para->getParH(level)->intCF.ICellCFC[x];
+ for (uint x = 0; x < para->getParH(level)->coarseToFine.numberOfCells; x++) {
+ sparseIndex = para->getParH(level)->coarseToFine.coarseCellIndices[x];
nodesCFC.push_back(sparseIndex);
nodesCFC.push_back(neighborX[sparseIndex]);
nodesCFC.push_back(neighborY[sparseIndex]);
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.h b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.h
index e6753e21be43a4f004d812cca8b9adafa501ffe8..014c725e30c58921e783810a8332ff0865e7938c 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.h
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.h
@@ -89,12 +89,12 @@ protected:
//! \param sendIndicesForCommAfterFtoCPositions stores each sendIndex's positions before reordering
void reorderSendIndicesForCommAfterFtoC(int *sendIndices, int &numberOfSendNodesAfterFtoC, int direction,
int level, std::vector<uint> &sendIndicesForCommAfterFtoCPositions) const;
- //! \brief Check if a sparse index occurs in the ICellFCC
- bool isSparseIndexInICellFCC(uint sizeOfICellFCC, int sparseIndexSend, int level) const;
+ //! \brief Check if a sparse index occurs in the coarse nodes for the interpolation from fine to coarse
+ bool isSparseIndexInCoarseIndexForFtoC(uint numberOfCoarseNodesForFtoC, int sparseIndexSend, int level) const;
//! \brief Aggregate all nodes in the coarse cells for the interpolation in coarse to fine
//! \details For the coarse cells in the interpolation from coarse to fine only one node is stored. This methods
//! looks for the other nodes of each cell and puts them into vector. Duplicate nodes are only stored once.
- void aggregateNodesInICellCFC(int level, std::vector<uint> &nodesCFC) const;
+ void aggregateCoarseNodesForCtoF(int level, std::vector<uint> &nodesCFC) const;
//! \brief Add index to sendIndicesAfterFtoC and sendIndicesForCommAfterFtoCPositions, but omit indices which are already in sendIndicesAfterFtoC
void addUniqueIndexToCommunicationVectors(std::vector<int> &sendIndicesAfterFtoC, int &sparseIndexSend,
std::vector<unsigned int> &sendIndicesForCommAfterFtoCPositions,
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreamsTest.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreamsTest.cpp
index 7bf534013ab68ba6a58fb3f33ca4ae03610cc12d..289b1607dd6acd47a88594a2b0a4497cdf6e7649 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreamsTest.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreamsTest.cpp
@@ -86,10 +86,10 @@ struct SendIndicesForCommAfterFtoCX {
const int numberOfProcessNeighbors = 1;
const int indexOfProcessNeighbor = 0;
- std::vector<uint> iCellCFC = { 8, 10, 12 };
- std::vector<uint> iCellFCC = { 14, 16, 18 };
- const uint kCF = (uint)iCellCFC.size();
- const uint kFC = (uint)iCellFCC.size();
+ std::vector<uint> interpolationCellCoarseToFineCoarse = { 8, 10, 12 };
+ std::vector<uint> interpolationCellFineToCoarseCoarse = { 14, 16, 18 };
+ const uint numNodesCtoF = (uint)interpolationCellCoarseToFineCoarse.size();
+ const uint numNodesFtoC = (uint)interpolationCellFineToCoarseCoarse.size();
uint neighborX[18] = { 0u };
uint neighborY[18] = { 0u };
uint neighborZ[18] = { 0u };
@@ -106,14 +106,14 @@ struct SendIndicesForCommAfterFtoCX {
class IndexRearrangementForStreamsTest_reorderSendIndices : public testing::Test
{
protected:
- SendIndicesForCommAfterFtoCX si;
+ SendIndicesForCommAfterFtoCX sendIndices;
SPtr<Parameter> para;
std::unique_ptr<IndexRearrangementForStreams> testSubject;
void act()
{
- testSubject->reorderSendIndicesForCommAfterFtoCX(si.direction, si.level, si.indexOfProcessNeighbor,
- si.sendIndicesForCommAfterFtoCPositions);
+ testSubject->reorderSendIndicesForCommAfterFtoCX(sendIndices.direction, sendIndices.level, sendIndices.indexOfProcessNeighbor,
+ sendIndices.sendIndicesForCommAfterFtoCPositions);
};
private:
@@ -124,21 +124,21 @@ private:
SPtr<GridImpDouble> grid =
GridImpDouble::makeShared(nullptr, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, Distribution(), 1);
std::shared_ptr<LevelGridBuilderDouble> builder = std::make_shared<LevelGridBuilderDouble>(grid);
- builder->setNumberOfSendIndices((uint)si.sendIndices.size());
+ builder->setNumberOfSendIndices((uint)sendIndices.sendIndices.size());
- para = testingVF::createParameterForLevel(si.level);
+ para = testingVF::createParameterForLevel(sendIndices.level);
- para->getParH(si.level)->intFC.kFC = si.kFC;
- para->getParH(si.level)->intFC.ICellFCC = &(si.iCellFCC.front());
- para->getParH(si.level)->intCF.ICellCFC = &(si.iCellCFC.front());
- para->getParH(si.level)->intCF.kCF = si.kCF;
- para->getParH(si.level)->neighborX = si.neighborX;
- para->getParH(si.level)->neighborY = si.neighborY;
- para->getParH(si.level)->neighborZ = si.neighborZ;
+ para->getParH(sendIndices.level)->fineToCoarse.numberOfCells = sendIndices.numNodesFtoC;
+ para->getParH(sendIndices.level)->fineToCoarse.coarseCellIndices = &(sendIndices.interpolationCellFineToCoarseCoarse.front());
+ para->getParH(sendIndices.level)->coarseToFine.coarseCellIndices = &(sendIndices.interpolationCellCoarseToFineCoarse.front());
+ para->getParH(sendIndices.level)->coarseToFine.numberOfCells = sendIndices.numNodesCtoF;
+ para->getParH(sendIndices.level)->neighborX = sendIndices.neighborX;
+ para->getParH(sendIndices.level)->neighborY = sendIndices.neighborY;
+ para->getParH(sendIndices.level)->neighborZ = sendIndices.neighborZ;
- para->setNumberOfProcessNeighborsX(si.numberOfProcessNeighbors, si.level, "send");
- para->getParH(si.level)->sendProcessNeighborX[si.indexOfProcessNeighbor].index = si.sendIndices.data();
- para->initProcessNeighborsAfterFtoCX(si.level);
+ para->setNumberOfProcessNeighborsX(sendIndices.numberOfProcessNeighbors, sendIndices.level, "send");
+ para->getParH(sendIndices.level)->sendProcessNeighborX[sendIndices.indexOfProcessNeighbor].index = sendIndices.sendIndices.data();
+ para->initProcessNeighborsAfterFtoCX(sendIndices.level);
testSubject = std::make_unique<IndexRearrangementForStreams>(
IndexRearrangementForStreams(para, builder, vf::gpu::Communicator::getInstance()));
@@ -149,14 +149,14 @@ TEST_F(IndexRearrangementForStreamsTest_reorderSendIndices, reorderSendIndicesFo
{
act();
- EXPECT_THAT(si.sendIndicesForCommAfterFtoCPositions.size(),
- testing::Eq(si.sendIndicesForCommAfterFtoCPositions_expected.size()));
- EXPECT_THAT(si.sendIndicesForCommAfterFtoCPositions, testing::Eq(si.sendIndicesForCommAfterFtoCPositions_expected));
+ EXPECT_THAT(sendIndices.sendIndicesForCommAfterFtoCPositions.size(),
+ testing::Eq(sendIndices.sendIndicesForCommAfterFtoCPositions_expected.size()));
+ EXPECT_THAT(sendIndices.sendIndicesForCommAfterFtoCPositions, testing::Eq(sendIndices.sendIndicesForCommAfterFtoCPositions_expected));
- EXPECT_THAT(para->getParH(si.level)->sendProcessNeighborsAfterFtoCX[si.indexOfProcessNeighbor].numberOfNodes,
- testing::Eq(si.numberOfSendNodesAfterFtoC_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(si.level)->sendProcessNeighborX[si.indexOfProcessNeighbor].index,
- si.sendProcessNeighborX_expected))
+ EXPECT_THAT(para->getParH(sendIndices.level)->sendProcessNeighborsAfterFtoCX[sendIndices.indexOfProcessNeighbor].numberOfNodes,
+ testing::Eq(sendIndices.numberOfSendNodesAfterFtoC_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(sendIndices.level)->sendProcessNeighborX[sendIndices.indexOfProcessNeighbor].index,
+ sendIndices.sendProcessNeighborX_expected))
<< "sendProcessNeighborX[].index does not match the expected vector";
}
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.cpp
index 347ab362d1f6b28a6c2b46f2e885085f955fb34e..f3717b58fca0e81e23be100eb8d15371703f8010 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.cpp
@@ -14,77 +14,77 @@ void InterpolationCellGrouper::splitFineToCoarseIntoBorderAndBulk(uint level) co
{
this->reorderFineToCoarseIntoBorderAndBulk(level);
- parDs[level]->intFCBorder.kFC = parHs[level]->intFCBorder.kFC;
- parDs[level]->intFCBulk.kFC = parHs[level]->intFCBulk.kFC;
- parDs[level]->intFCBorder.ICellFCC = parDs[level]->intFC.ICellFCC;
- parDs[level]->intFCBulk.ICellFCC = parDs[level]->intFCBorder.ICellFCC + parDs[level]->intFCBorder.kFC;
- parDs[level]->intFCBorder.ICellFCF = parDs[level]->intFC.ICellFCF;
- parDs[level]->intFCBulk.ICellFCF = parDs[level]->intFCBorder.ICellFCF + parDs[level]->intFCBorder.kFC;
- parDs[level]->offFCBulk.xOffFC = parDs[level]->offFC.xOffFC + parDs[level]->intFCBorder.kFC;
- parDs[level]->offFCBulk.yOffFC = parDs[level]->offFC.yOffFC + parDs[level]->intFCBorder.kFC;
- parDs[level]->offFCBulk.zOffFC = parDs[level]->offFC.zOffFC + parDs[level]->intFCBorder.kFC;
+ parDs[level]->fineToCoarseBorder.numberOfCells = parHs[level]->fineToCoarseBorder.numberOfCells;
+ parDs[level]->fineToCoarseBulk.numberOfCells = parHs[level]->fineToCoarseBulk.numberOfCells;
+ parDs[level]->fineToCoarseBorder.coarseCellIndices = parDs[level]->fineToCoarse.coarseCellIndices;
+ parDs[level]->fineToCoarseBulk.coarseCellIndices = parDs[level]->fineToCoarseBorder.coarseCellIndices + parDs[level]->fineToCoarseBorder.numberOfCells;
+ parDs[level]->fineToCoarseBorder.fineCellIndices = parDs[level]->fineToCoarse.fineCellIndices;
+ parDs[level]->fineToCoarseBulk.fineCellIndices = parDs[level]->fineToCoarseBorder.fineCellIndices + parDs[level]->fineToCoarseBorder.numberOfCells;
+ parDs[level]->neighborFineToCoarseBulk.x = parDs[level]->neighborFineToCoarse.x + parDs[level]->fineToCoarseBorder.numberOfCells;
+ parDs[level]->neighborFineToCoarseBulk.y = parDs[level]->neighborFineToCoarse.y + parDs[level]->fineToCoarseBorder.numberOfCells;
+ parDs[level]->neighborFineToCoarseBulk.z = parDs[level]->neighborFineToCoarse.z + parDs[level]->fineToCoarseBorder.numberOfCells;
}
void InterpolationCellGrouper::reorderFineToCoarseIntoBorderAndBulk(uint level) const
{
// create some local variables for better readability
- uint *iCellFccAll = parHs[level]->intFC.ICellFCC;
- uint *iCellFcfAll = parHs[level]->intFC.ICellFCF;
+ uint *fineToCoarseCoarseAll = parHs[level]->fineToCoarse.coarseCellIndices;
+ uint *fineToCoarseFineAll = parHs[level]->fineToCoarse.fineCellIndices;
auto grid = this->builder->getGrid(level);
- std::vector<uint> iCellFccBorderVector;
- std::vector<uint> iCellFccBulkVector;
- std::vector<uint> iCellFcfBorderVector;
- std::vector<uint> iCellFcfBulkVector;
- std::vector<real> xOffFCBorderVector;
- std::vector<real> yOffFCBorderVector;
- std::vector<real> zOffFCBorderVector;
- std::vector<real> xOffFCBulkVector;
- std::vector<real> yOffFCBulkVector;
- std::vector<real> zOffFCBulkVector;
-
- // fill border and bulk vectors with iCellFCs
- for (uint i = 0; i < parHs[level]->intFC.kFC; i++)
- if (grid->isSparseIndexInFluidNodeIndicesBorder(iCellFccAll[i])) {
- iCellFccBorderVector.push_back(iCellFccAll[i]);
- iCellFcfBorderVector.push_back(iCellFcfAll[i]);
- xOffFCBorderVector.push_back(parHs[level]->offFC.xOffFC[i]);
- yOffFCBorderVector.push_back(parHs[level]->offFC.yOffFC[i]);
- zOffFCBorderVector.push_back(parHs[level]->offFC.zOffFC[i]);
+ std::vector<uint> fineToCoarseCoarseBorderVector;
+ std::vector<uint> fineToCoarseCoarseBulkVector;
+ std::vector<uint> fineToCoarseFineBorderVector;
+ std::vector<uint> fineToCoarseFineBulkVector;
+ std::vector<real> neighborXBorder;
+ std::vector<real> neighborYBorder;
+ std::vector<real> neighborZBorder;
+ std::vector<real> neighborXBulk;
+ std::vector<real> neighborYBulk;
+ std::vector<real> neighborZBulk;
+
+ // fill border and bulk vectors with interpolation cells fine to coarse
+ for (uint i = 0; i < parHs[level]->fineToCoarse.numberOfCells; i++)
+ if (grid->isSparseIndexInFluidNodeIndicesBorder(fineToCoarseCoarseAll[i])) {
+ fineToCoarseCoarseBorderVector.push_back(fineToCoarseCoarseAll[i]);
+ fineToCoarseFineBorderVector.push_back(fineToCoarseFineAll[i]);
+ neighborXBorder.push_back(parHs[level]->neighborFineToCoarse.x[i]);
+ neighborYBorder.push_back(parHs[level]->neighborFineToCoarse.y[i]);
+ neighborZBorder.push_back(parHs[level]->neighborFineToCoarse.z[i]);
} else {
- iCellFccBulkVector.push_back(iCellFccAll[i]);
- iCellFcfBulkVector.push_back(iCellFcfAll[i]);
- xOffFCBulkVector.push_back(parHs[level]->offFC.xOffFC[i]);
- yOffFCBulkVector.push_back(parHs[level]->offFC.yOffFC[i]);
- zOffFCBulkVector.push_back(parHs[level]->offFC.zOffFC[i]);
+ fineToCoarseCoarseBulkVector.push_back(fineToCoarseCoarseAll[i]);
+ fineToCoarseFineBulkVector.push_back(fineToCoarseFineAll[i]);
+ neighborXBulk.push_back(parHs[level]->neighborFineToCoarse.x[i]);
+ neighborYBulk.push_back(parHs[level]->neighborFineToCoarse.y[i]);
+ neighborZBulk.push_back(parHs[level]->neighborFineToCoarse.z[i]);
}
// set new sizes and pointers
- parHs[level]->intFCBorder.ICellFCC = iCellFccAll;
- parHs[level]->intFCBorder.ICellFCF = iCellFcfAll;
- parHs[level]->intFCBorder.kFC = (uint)iCellFccBorderVector.size();
- parHs[level]->intFCBulk.kFC = (uint)iCellFccBulkVector.size();
- parHs[level]->intFCBulk.ICellFCC = iCellFccAll + parHs[level]->intFCBorder.kFC;
- parHs[level]->intFCBulk.ICellFCF = iCellFcfAll + parHs[level]->intFCBorder.kFC;
- parHs[level]->offFCBulk.xOffFC = parHs[level]->offFC.xOffFC + parHs[level]->intFCBorder.kFC;
- parHs[level]->offFCBulk.yOffFC = parHs[level]->offFC.yOffFC + parHs[level]->intFCBorder.kFC;
- parHs[level]->offFCBulk.zOffFC = parHs[level]->offFC.zOffFC + parHs[level]->intFCBorder.kFC;
+ parHs[level]->fineToCoarseBorder.coarseCellIndices = fineToCoarseCoarseAll;
+ parHs[level]->fineToCoarseBorder.fineCellIndices = fineToCoarseFineAll;
+ parHs[level]->fineToCoarseBorder.numberOfCells = (uint)fineToCoarseCoarseBorderVector.size();
+ parHs[level]->fineToCoarseBulk.numberOfCells = (uint)fineToCoarseCoarseBulkVector.size();
+ parHs[level]->fineToCoarseBulk.coarseCellIndices = fineToCoarseCoarseAll + parHs[level]->fineToCoarseBorder.numberOfCells;
+ parHs[level]->fineToCoarseBulk.fineCellIndices = fineToCoarseFineAll + parHs[level]->fineToCoarseBorder.numberOfCells;
+ parHs[level]->neighborFineToCoarseBulk.x = parHs[level]->neighborFineToCoarse.x + parHs[level]->fineToCoarseBorder.numberOfCells;
+ parHs[level]->neighborFineToCoarseBulk.y = parHs[level]->neighborFineToCoarse.y + parHs[level]->fineToCoarseBorder.numberOfCells;
+ parHs[level]->neighborFineToCoarseBulk.z = parHs[level]->neighborFineToCoarse.z + parHs[level]->fineToCoarseBorder.numberOfCells;
// copy the created vectors to the memory addresses of the old arrays
// this is inefficient :(
- for (uint i = 0; i < (uint)iCellFccBorderVector.size(); i++) {
- iCellFccAll[i] = iCellFccBorderVector[i];
- iCellFcfAll[i] = iCellFcfBorderVector[i];
- parHs[level]->offFC.xOffFC[i] = xOffFCBorderVector[i];
- parHs[level]->offFC.yOffFC[i] = yOffFCBorderVector[i];
- parHs[level]->offFC.zOffFC[i] = zOffFCBorderVector[i];
+ for (uint i = 0; i < (uint)fineToCoarseCoarseBorderVector.size(); i++) {
+ fineToCoarseCoarseAll[i] = fineToCoarseCoarseBorderVector[i];
+ fineToCoarseFineAll[i] = fineToCoarseFineBorderVector[i];
+ parHs[level]->neighborFineToCoarse.x[i] = neighborXBorder[i];
+ parHs[level]->neighborFineToCoarse.y[i] = neighborYBorder[i];
+ parHs[level]->neighborFineToCoarse.z[i] = neighborZBorder[i];
}
- for (uint i = 0; i < (uint)iCellFccBulkVector.size(); i++) {
- parHs[level]->intFCBulk.ICellFCC[i] = iCellFccBulkVector[i];
- parHs[level]->intFCBulk.ICellFCF[i] = iCellFcfBulkVector[i];
- parHs[level]->offFCBulk.xOffFC[i] = xOffFCBulkVector[i];
- parHs[level]->offFCBulk.yOffFC[i] = yOffFCBulkVector[i];
- parHs[level]->offFCBulk.zOffFC[i] = zOffFCBulkVector[i];
+ for (uint i = 0; i < (uint)fineToCoarseCoarseBulkVector.size(); i++) {
+ parHs[level]->fineToCoarseBulk.coarseCellIndices[i] = fineToCoarseCoarseBulkVector[i];
+ parHs[level]->fineToCoarseBulk.fineCellIndices[i] = fineToCoarseFineBulkVector[i];
+ parHs[level]->neighborFineToCoarseBulk.x[i] = neighborXBulk[i];
+ parHs[level]->neighborFineToCoarseBulk.y[i] = neighborYBulk[i];
+ parHs[level]->neighborFineToCoarseBulk.z[i] = neighborZBulk[i];
}
}
@@ -92,42 +92,42 @@ void InterpolationCellGrouper::splitCoarseToFineIntoBorderAndBulk(uint level) co
{
this->reorderCoarseToFineIntoBorderAndBulk(level);
- parDs[level]->intCFBorder.kCF = parHs[level]->intCFBorder.kCF;
- parDs[level]->intCFBulk.kCF = parHs[level]->intCFBulk.kCF;
- parDs[level]->intCFBorder.ICellCFC = parDs[level]->intCF.ICellCFC;
- parDs[level]->intCFBulk.ICellCFC = parDs[level]->intCFBorder.ICellCFC + parDs[level]->intCFBorder.kCF;
- parDs[level]->intCFBorder.ICellCFF = parDs[level]->intCF.ICellCFF;
- parDs[level]->intCFBulk.ICellCFF = parDs[level]->intCFBorder.ICellCFF + parDs[level]->intCFBorder.kCF;
- parDs[level]->offCFBulk.xOffCF = parDs[level]->offCF.xOffCF + parDs[level]->intCFBorder.kCF;
- parDs[level]->offCFBulk.yOffCF = parDs[level]->offCF.yOffCF + parDs[level]->intCFBorder.kCF;
- parDs[level]->offCFBulk.zOffCF = parDs[level]->offCF.zOffCF + parDs[level]->intCFBorder.kCF;
+ parDs[level]->coarseToFineBorder.numberOfCells = parHs[level]->coarseToFineBorder.numberOfCells;
+ parDs[level]->coarseToFineBulk.numberOfCells = parHs[level]->coarseToFineBulk.numberOfCells;
+ parDs[level]->coarseToFineBorder.coarseCellIndices = parDs[level]->coarseToFine.coarseCellIndices;
+ parDs[level]->coarseToFineBulk.coarseCellIndices = parDs[level]->coarseToFineBorder.coarseCellIndices + parDs[level]->coarseToFineBorder.numberOfCells;
+ parDs[level]->coarseToFineBorder.fineCellIndices = parDs[level]->coarseToFine.fineCellIndices;
+ parDs[level]->coarseToFineBulk.fineCellIndices = parDs[level]->coarseToFineBorder.fineCellIndices + parDs[level]->coarseToFineBorder.numberOfCells;
+ parDs[level]->neighborCoarseToFineBulk.x = parDs[level]->neighborCoarseToFine.x + parDs[level]->coarseToFineBorder.numberOfCells;
+ parDs[level]->neighborCoarseToFineBulk.y = parDs[level]->neighborCoarseToFine.y + parDs[level]->coarseToFineBorder.numberOfCells;
+ parDs[level]->neighborCoarseToFineBulk.z = parDs[level]->neighborCoarseToFine.z + parDs[level]->coarseToFineBorder.numberOfCells;
}
void InterpolationCellGrouper::reorderCoarseToFineIntoBorderAndBulk(uint level) const
{
// create some local variables for better readability
- uint *iCellCfcAll = parHs[level]->intCF.ICellCFC;
- uint *iCellCffAll = parHs[level]->intCF.ICellCFF;
+ uint *coarseToFineCoarseAll = parHs[level]->coarseToFine.coarseCellIndices;
+ uint *coarseToFineFineAll = parHs[level]->coarseToFine.fineCellIndices;
uint *neighborX = this->parHs[level]->neighborX;
uint *neighborY = this->parHs[level]->neighborY;
uint *neighborZ = this->parHs[level]->neighborZ;
auto grid = this->builder->getGrid(level);
- std::vector<uint> iCellCfcBorderVector;
- std::vector<uint> iCellCfcBulkVector;
- std::vector<uint> iCellCffBorderVector;
- std::vector<uint> iCellCffBulkVector;
- std::vector<real> xOffCFBorderVector;
- std::vector<real> yOffCFBorderVector;
- std::vector<real> zOffCFBorderVector;
- std::vector<real> xOffCFBulkVector;
- std::vector<real> yOffCFBulkVector;
- std::vector<real> zOffCFBulkVector;
+ std::vector<uint> coarseToFineCoarseBorderVector;
+ std::vector<uint> coarseToFineCoarseBulkVector;
+ std::vector<uint> coarseToFineFineBorderVector;
+ std::vector<uint> coarseToFineFineBulkVector;
+ std::vector<real> neighborXBorder;
+ std::vector<real> neighborYBorder;
+ std::vector<real> neighborZBorder;
+ std::vector<real> neighborXBulk;
+ std::vector<real> neighborYBulk;
+ std::vector<real> neighborZBulk;
uint sparseIndexOfICellBSW;
- // fill border and bulk vectors with iCellCFs
- for (uint i = 0; i < parHs[level]->intCF.kCF; i++) {
- sparseIndexOfICellBSW = iCellCfcAll[i];
+ // fill border and bulk vectors with interpolation cells coarse to fine
+ for (uint i = 0; i < parHs[level]->coarseToFine.numberOfCells; i++) {
+ sparseIndexOfICellBSW = coarseToFineCoarseAll[i];
if (grid->isSparseIndexInFluidNodeIndicesBorder(sparseIndexOfICellBSW) ||
grid->isSparseIndexInFluidNodeIndicesBorder(neighborX[sparseIndexOfICellBSW]) ||
@@ -138,45 +138,45 @@ void InterpolationCellGrouper::reorderCoarseToFineIntoBorderAndBulk(uint level)
grid->isSparseIndexInFluidNodeIndicesBorder(neighborZ[neighborY[sparseIndexOfICellBSW]]) ||
grid->isSparseIndexInFluidNodeIndicesBorder(neighborZ[neighborY[neighborX[sparseIndexOfICellBSW]]])) {
- iCellCfcBorderVector.push_back(iCellCfcAll[i]);
- iCellCffBorderVector.push_back(iCellCffAll[i]);
- xOffCFBorderVector.push_back(parHs[level]->offCF.xOffCF[i]);
- yOffCFBorderVector.push_back(parHs[level]->offCF.yOffCF[i]);
- zOffCFBorderVector.push_back(parHs[level]->offCF.zOffCF[i]);
+ coarseToFineCoarseBorderVector.push_back(coarseToFineCoarseAll[i]);
+ coarseToFineFineBorderVector.push_back(coarseToFineFineAll[i]);
+ neighborXBorder.push_back(parHs[level]->neighborCoarseToFine.x[i]);
+ neighborYBorder.push_back(parHs[level]->neighborCoarseToFine.y[i]);
+ neighborZBorder.push_back(parHs[level]->neighborCoarseToFine.z[i]);
} else {
- iCellCfcBulkVector.push_back(iCellCfcAll[i]);
- iCellCffBulkVector.push_back(iCellCffAll[i]);
- xOffCFBulkVector.push_back(parHs[level]->offCF.xOffCF[i]);
- yOffCFBulkVector.push_back(parHs[level]->offCF.yOffCF[i]);
- zOffCFBulkVector.push_back(parHs[level]->offCF.zOffCF[i]);
+ coarseToFineCoarseBulkVector.push_back(coarseToFineCoarseAll[i]);
+ coarseToFineFineBulkVector.push_back(coarseToFineFineAll[i]);
+ neighborXBulk.push_back(parHs[level]->neighborCoarseToFine.x[i]);
+ neighborYBulk.push_back(parHs[level]->neighborCoarseToFine.y[i]);
+ neighborZBulk.push_back(parHs[level]->neighborCoarseToFine.z[i]);
}
}
// set new sizes and pointers
- parHs[level]->intCFBorder.ICellCFC = parHs[level]->intCF.ICellCFC;
- parHs[level]->intCFBorder.ICellCFF = parHs[level]->intCF.ICellCFF;
- parHs[level]->intCFBorder.kCF = (uint)iCellCfcBorderVector.size();
- parHs[level]->intCFBulk.kCF = (uint)iCellCfcBulkVector.size();
- parHs[level]->intCFBulk.ICellCFC = parHs[level]->intCF.ICellCFC + parHs[level]->intCFBorder.kCF;
- parHs[level]->intCFBulk.ICellCFF = parHs[level]->intCF.ICellCFF + parHs[level]->intCFBorder.kCF;
- parHs[level]->offCFBulk.xOffCF = parHs[level]->offCF.xOffCF + parHs[level]->intCFBorder.kCF;
- parHs[level]->offCFBulk.yOffCF = parHs[level]->offCF.yOffCF + parHs[level]->intCFBorder.kCF;
- parHs[level]->offCFBulk.zOffCF = parHs[level]->offCF.zOffCF + parHs[level]->intCFBorder.kCF;
+ parHs[level]->coarseToFineBorder.coarseCellIndices = parHs[level]->coarseToFine.coarseCellIndices;
+ parHs[level]->coarseToFineBorder.fineCellIndices = parHs[level]->coarseToFine.fineCellIndices;
+ parHs[level]->coarseToFineBorder.numberOfCells = (uint)coarseToFineCoarseBorderVector.size();
+ parHs[level]->coarseToFineBulk.numberOfCells = (uint)coarseToFineCoarseBulkVector.size();
+ parHs[level]->coarseToFineBulk.coarseCellIndices = parHs[level]->coarseToFine.coarseCellIndices + parHs[level]->coarseToFineBorder.numberOfCells;
+ parHs[level]->coarseToFineBulk.fineCellIndices = parHs[level]->coarseToFine.fineCellIndices + parHs[level]->coarseToFineBorder.numberOfCells;
+ parHs[level]->neighborCoarseToFineBulk.x = parHs[level]->neighborCoarseToFine.x + parHs[level]->coarseToFineBorder.numberOfCells;
+ parHs[level]->neighborCoarseToFineBulk.y = parHs[level]->neighborCoarseToFine.y + parHs[level]->coarseToFineBorder.numberOfCells;
+ parHs[level]->neighborCoarseToFineBulk.z = parHs[level]->neighborCoarseToFine.z + parHs[level]->coarseToFineBorder.numberOfCells;
// copy the created vectors to the memory addresses of the old arrays
// this is inefficient :(
- for (uint i = 0; i < (uint)iCellCfcBorderVector.size(); i++) {
- parHs[level]->intCFBorder.ICellCFC[i] = iCellCfcBorderVector[i];
- parHs[level]->intCFBorder.ICellCFF[i] = iCellCffBorderVector[i];
- parHs[level]->offCF.xOffCF[i] = xOffCFBorderVector[i];
- parHs[level]->offCF.yOffCF[i] = yOffCFBorderVector[i];
- parHs[level]->offCF.zOffCF[i] = zOffCFBorderVector[i];
+ for (uint i = 0; i < (uint)coarseToFineCoarseBorderVector.size(); i++) {
+ parHs[level]->coarseToFineBorder.coarseCellIndices[i] = coarseToFineCoarseBorderVector[i];
+ parHs[level]->coarseToFineBorder.fineCellIndices[i] = coarseToFineFineBorderVector[i];
+ parHs[level]->neighborCoarseToFine.x[i] = neighborXBorder[i];
+ parHs[level]->neighborCoarseToFine.y[i] = neighborYBorder[i];
+ parHs[level]->neighborCoarseToFine.z[i] = neighborZBorder[i];
}
- for (uint i = 0; i < (uint)iCellCfcBulkVector.size(); i++) {
- parHs[level]->intCFBulk.ICellCFC[i] = iCellCfcBulkVector[i];
- parHs[level]->intCFBulk.ICellCFF[i] = iCellCffBulkVector[i];
- parHs[level]->offCFBulk.xOffCF[i] = xOffCFBulkVector[i];
- parHs[level]->offCFBulk.yOffCF[i] = yOffCFBulkVector[i];
- parHs[level]->offCFBulk.zOffCF[i] = zOffCFBulkVector[i];
+ for (uint i = 0; i < (uint)coarseToFineCoarseBulkVector.size(); i++) {
+ parHs[level]->coarseToFineBulk.coarseCellIndices[i] = coarseToFineCoarseBulkVector[i];
+ parHs[level]->coarseToFineBulk.fineCellIndices[i] = coarseToFineFineBulkVector[i];
+ parHs[level]->neighborCoarseToFineBulk.x[i] = neighborXBulk[i];
+ parHs[level]->neighborCoarseToFineBulk.y[i] = neighborYBulk[i];
+ parHs[level]->neighborCoarseToFineBulk.z[i] = neighborZBulk[i];
}
}
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.h b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.h
index 5471194f643e044a7c2cdca1db45017b9d3a1022..600b31aef4ff99080a8e580a24625b35463990ac 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.h
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouper.h
@@ -54,14 +54,14 @@ protected:
//////////////////////////////////////////////////////////////////////////
//! \brief This function reorders the arrays of CFC/CFF indices and sets the pointers and sizes of the new
- //! subarrays: \details The coarse cells for interpolation from coarse to fine (iCellCFC) are divided into two
- //! subgroups: border and bulk. The fine cells (iCellCFF) are reordered accordingly. The offset cells (xOffCF,
+ //! subarrays: \details The coarse cells for interpolation from coarse to fine (coarseToFineCoarse) are divided into two
+ //! subgroups: border and bulk. The fine cells (coarseToFineFine) are reordered accordingly. The offset cells (xOffCF,
//! yOffCF, zOffCF) must be reordered in the same way.
void reorderCoarseToFineIntoBorderAndBulk(uint level) const;
//! \brief This function reorders the arrays of FCC/FCF indices and return pointers and sizes of the new subarrays:
- //! \details The coarse cells for interpolation from fine to coarse (iCellFCC) are divided into two subgroups:
- //! border and bulk. The fine cells (iCellFCF) are reordered accordingly. The offset cells (xOffFC,
+ //! \details The coarse cells for interpolation from fine to coarse (fineToCoarseCoarse) are divided into two subgroups:
+ //! border and bulk. The fine cells (fineToCoarseFine) are reordered accordingly. The offset cells (xOffFC,
//! yOffFC, zOffFC) must be reordered in the same way.
void reorderFineToCoarseIntoBorderAndBulk(uint level) const;
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouperTest.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouperTest.cpp
index 664552b2f47542cc6ae3d4940c2b74ede1beff91..8fa9a8a71ee5e60a129d06dffa09b8247766b88c 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouperTest.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/InterpolationCellGrouperTest.cpp
@@ -62,37 +62,37 @@ public:
}
};
-struct CFBorderBulk {
+struct CoarseToFineBorderBulk {
// data to work on
std::vector<uint> fluidNodeIndicesBorder = { 10, 11, 12, 13, 14, 15, 16 };
- std::vector<uint> iCellCFC = { 1, 11, 3, 13, 5, 15, 7 };
- std::vector<uint> iCellCFF = { 2, 12, 4, 14, 6, 16, 8 };
- const uint sizeOfICellCf = (uint)iCellCFC.size();
+ std::vector<uint> intCtoFcoarse = { 1, 11, 3, 13, 5, 15, 7 };
+ std::vector<uint> fineCellIndices = { 2, 12, 4, 14, 6, 16, 8 };
+ const uint sizeOfInterpolationCoarseToFine = (uint)intCtoFcoarse.size();
uint neighborX[17] = { 0u };
uint neighborY[17] = { 0u };
uint neighborZ[17] = { 0u };
const int level = 0;
- std::vector<real> offsetCFx = { 1, 11, 3, 13, 5, 15, 7 };
- std::vector<real> offsetCFy = { 101, 111, 103, 113, 105, 115, 107 };
- std::vector<real> offsetCFz = { 1001, 1011, 1003, 1013, 1005, 1015, 1007 };
+ std::vector<real> neighborCFx = { 1, 11, 3, 13, 5, 15, 7 };
+ std::vector<real> neighborCFy = { 101, 111, 103, 113, 105, 115, 107 };
+ std::vector<real> neighborCFz = { 1001, 1011, 1003, 1013, 1005, 1015, 1007 };
// expected data
- std::vector<uint> iCellCfcBorder_expected = { 11, 13, 15 };
- std::vector<uint> iCellCfcBulk_expected = { 1, 3, 5, 7 };
- std::vector<uint> iCellCffBorder_expected = { 12, 14, 16 };
- std::vector<uint> iCellCffBulk_expected = { 2, 4, 6, 8 };
- std::vector<real> offsetCFx_Border_expected = { 11, 13, 15 };
- std::vector<real> offsetCFx_Bulk_expected = { 1, 3, 5, 7 };
- std::vector<real> offsetCFy_Border_expected = { 111, 113, 115 };
- std::vector<real> offsetCFy_Bulk_expected = { 101, 103, 105, 107 };
- std::vector<real> offsetCFz_Border_expected = { 1011, 1013, 1015 };
- std::vector<real> offsetCFz_Bulk_expected = { 1001, 1003, 1005, 1007 };
+ std::vector<uint> intCtoFcoarseBorder_expected = { 11, 13, 15 };
+ std::vector<uint> intCtoFcoarseBulk_expected = { 1, 3, 5, 7 };
+ std::vector<uint> fineCellIndicesBorder_expected = { 12, 14, 16 };
+ std::vector<uint> fineCellIndicesBulk_expected = { 2, 4, 6, 8 };
+ std::vector<real> neighborCFx_Border_expected = { 11, 13, 15 };
+ std::vector<real> neighborCFx_Bulk_expected = { 1, 3, 5, 7 };
+ std::vector<real> neighborCFy_Border_expected = { 111, 113, 115 };
+ std::vector<real> neighborCFy_Bulk_expected = { 101, 103, 105, 107 };
+ std::vector<real> neighborCFz_Border_expected = { 1011, 1013, 1015 };
+ std::vector<real> neighborCFz_Bulk_expected = { 1001, 1003, 1005, 1007 };
};
class InterpolationCellGrouperTest_IndicesCFBorderBulkTest : public testing::Test
{
protected:
- CFBorderBulk cf;
+ CoarseToFineBorderBulk cf;
SPtr<Parameter> para;
std::unique_ptr<InterpolationCellGrouper> testSubject;
@@ -105,15 +105,15 @@ private:
std::shared_ptr<LevelGridBuilderDouble> builder = std::make_shared<LevelGridBuilderDouble>(grid);
para = testingVF::createParameterForLevel(cf.level);
- para->getParH(cf.level)->intCF.ICellCFC = &(cf.iCellCFC.front());
- para->getParH(cf.level)->intCF.ICellCFF = &(cf.iCellCFF.front());
+ para->getParH(cf.level)->coarseToFine.coarseCellIndices = &(cf.intCtoFcoarse.front());
+ para->getParH(cf.level)->coarseToFine.fineCellIndices = &(cf.fineCellIndices.front());
para->getParH(cf.level)->neighborX = cf.neighborX;
para->getParH(cf.level)->neighborY = cf.neighborY;
para->getParH(cf.level)->neighborZ = cf.neighborZ;
- para->getParH(cf.level)->intCF.kCF = cf.sizeOfICellCf;
- para->getParH(cf.level)->offCF.xOffCF = &(cf.offsetCFx.front());
- para->getParH(cf.level)->offCF.yOffCF = &(cf.offsetCFy.front());
- para->getParH(cf.level)->offCF.zOffCF = &(cf.offsetCFz.front());
+ para->getParH(cf.level)->coarseToFine.numberOfCells = cf.sizeOfInterpolationCoarseToFine;
+ para->getParH(cf.level)->neighborCoarseToFine.x = &(cf.neighborCFx.front());
+ para->getParH(cf.level)->neighborCoarseToFine.y = &(cf.neighborCFy.front());
+ para->getParH(cf.level)->neighborCoarseToFine.z = &(cf.neighborCFz.front());
return std::make_unique<InterpolationCellGrouper>(para->getParHallLevels(), para->getParDallLevels(), builder);
};
@@ -128,65 +128,65 @@ TEST_F(InterpolationCellGrouperTest_IndicesCFBorderBulkTest, splitCoarseToFineIn
{
testSubject->splitCoarseToFineIntoBorderAndBulk(cf.level);
- EXPECT_THAT(para->getParH(cf.level)->intCFBorder.kCF + para->getParH(cf.level)->intCFBulk.kCF,
- testing::Eq(cf.sizeOfICellCf))
+ EXPECT_THAT(para->getParH(cf.level)->coarseToFineBorder.numberOfCells + para->getParH(cf.level)->coarseToFineBulk.numberOfCells,
+ testing::Eq(cf.sizeOfInterpolationCoarseToFine))
<< "The number of interpolation cells from coarse to fine changed during reordering.";
// check coarse to fine border (coarse nodes)
- EXPECT_THAT(para->getParH(cf.level)->intCFBorder.kCF, testing::Eq((uint)cf.iCellCfcBorder_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->intCFBorder.ICellCFC, cf.iCellCfcBorder_expected))
- << "intCFBorder.ICellCFC does not match the expected border vector";
+ EXPECT_THAT(para->getParH(cf.level)->coarseToFineBorder.numberOfCells, testing::Eq((uint)cf.intCtoFcoarseBorder_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->coarseToFineBorder.coarseCellIndices, cf.intCtoFcoarseBorder_expected))
+ << "coarseToFineBorder.intCtoFcoarse does not match the expected border vector";
// check coarse to fine border (fine nodes)
- EXPECT_THAT(para->getParH(cf.level)->intCFBorder.kCF, testing::Eq((uint)cf.iCellCffBorder_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->intCFBorder.ICellCFF, cf.iCellCffBorder_expected))
- << "intCFBorder.ICellCFF does not match the expected border vector";
+ EXPECT_THAT(para->getParH(cf.level)->coarseToFineBorder.numberOfCells, testing::Eq((uint)cf.fineCellIndicesBorder_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->coarseToFineBorder.fineCellIndices, cf.fineCellIndicesBorder_expected))
+ << "coarseToFineBorder.fineCellIndices does not match the expected border vector";
// check coarse to fine bulk (coarse nodes)
- EXPECT_THAT(para->getParH(cf.level)->intCFBulk.kCF, testing::Eq((uint)cf.iCellCfcBulk_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->intCFBulk.ICellCFC, cf.iCellCfcBulk_expected))
- << "intCFBulk.ICellCFC does not match the expected bulk vector";
+ EXPECT_THAT(para->getParH(cf.level)->coarseToFineBulk.numberOfCells, testing::Eq((uint)cf.intCtoFcoarseBulk_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->coarseToFineBulk.coarseCellIndices, cf.intCtoFcoarseBulk_expected))
+ << "coarseToFineBulk.intCtoFcoarse does not match the expected bulk vector";
// check coarse to fine bulk (fine nodes)
- EXPECT_THAT(para->getParH(cf.level)->intCFBulk.kCF, testing::Eq((uint)cf.iCellCffBulk_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->intCFBulk.ICellCFF, cf.iCellCffBulk_expected))
- << "intCFBulk.ICellCFF does not match the expected bulk vector";
-
- // check offset cells
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->offCF.xOffCF, cf.offsetCFx_Border_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->offCFBulk.xOffCF, cf.offsetCFx_Bulk_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->offCF.yOffCF, cf.offsetCFy_Border_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->offCFBulk.yOffCF, cf.offsetCFy_Bulk_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->offCF.zOffCF, cf.offsetCFz_Border_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->offCFBulk.zOffCF, cf.offsetCFz_Bulk_expected));
+ EXPECT_THAT(para->getParH(cf.level)->coarseToFineBulk.numberOfCells, testing::Eq((uint)cf.fineCellIndicesBulk_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->coarseToFineBulk.fineCellIndices, cf.fineCellIndicesBulk_expected))
+ << "coarseToFineBulk.fineCellIndices does not match the expected bulk vector";
+
+ // check neighbor cells
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->neighborCoarseToFine.x, cf.neighborCFx_Border_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->neighborCoarseToFineBulk.x, cf.neighborCFx_Bulk_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->neighborCoarseToFine.y, cf.neighborCFy_Border_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->neighborCoarseToFineBulk.y, cf.neighborCFy_Bulk_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->neighborCoarseToFine.z, cf.neighborCFz_Border_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(cf.level)->neighborCoarseToFineBulk.z, cf.neighborCFz_Bulk_expected));
}
-struct FCBorderBulk {
+struct FineToCoarseBorderBulk {
// data to work on
std::vector<uint> fluidNodeIndicesBorder = { 110, 111, 112, 113, 114, 115, 116 };
- std::vector<uint> iCellFCC = { 11, 111, 13, 113, 15, 115, 17 };
- std::vector<uint> iCellFCF = { 12, 112, 14, 114, 16, 116, 18 };
- const uint sizeOfICellFC = (uint)iCellFCC.size();
+ std::vector<uint> coarseCellIndices = { 11, 111, 13, 113, 15, 115, 17 };
+ std::vector<uint> fineCellIndices = { 12, 112, 14, 114, 16, 116, 18 };
+ const uint sizeOfIntFineToCoarse = (uint)coarseCellIndices.size();
const int level = 1;
- std::vector<real> offsetFCx = { 11, 111, 13, 113, 15, 115, 17 };
- std::vector<real> offsetFCy = { 1101, 1111, 1103, 1113, 1105, 1115, 1107 };
- std::vector<real> offsetFCz = { 11001, 11011, 11003, 11013, 11005, 11015, 11007 };
+ std::vector<real> neighborx = { 11, 111, 13, 113, 15, 115, 17 };
+ std::vector<real> neighbory = { 1101, 1111, 1103, 1113, 1105, 1115, 1107 };
+ std::vector<real> neighborz = { 11001, 11011, 11003, 11013, 11005, 11015, 11007 };
// expected data
- std::vector<uint> iCellFccBorder_expected = { 111, 113, 115 };
- std::vector<uint> iCellFccBulk_expected = { 11, 13, 15, 17 };
- std::vector<uint> iCellFcfBorder_expected = { 112, 114, 116 };
- std::vector<uint> iCellFcfBulk_expected = { 12, 14, 16, 18 };
- std::vector<real> offsetFCx_Border_expected = { 111, 113, 115 };
- std::vector<real> offsetFCx_Bulk_expected = { 11, 13, 15, 17 };
- std::vector<real> offsetFCy_Border_expected = { 1111, 1113, 1115 };
- std::vector<real> offsetFCy_Bulk_expected = { 1101, 1103, 1105, 1107 };
- std::vector<real> offsetFCz_Border_expected = { 11011, 11013, 11015 };
- std::vector<real> offsetFCz_Bulk_expected = { 11001, 11003, 11005, 11007 };
+ std::vector<uint> coarseCellIndicesBorder_expected = { 111, 113, 115 };
+ std::vector<uint> coarseCellIndicesBulk_expected = { 11, 13, 15, 17 };
+ std::vector<uint> fineCellIndicesBorder_expected = { 112, 114, 116 };
+ std::vector<uint> fineCellIndicesBulk_expected = { 12, 14, 16, 18 };
+ std::vector<real> neighborx_Border_expected = { 111, 113, 115 };
+ std::vector<real> neighborx_Bulk_expected = { 11, 13, 15, 17 };
+ std::vector<real> neighbory_Border_expected = { 1111, 1113, 1115 };
+ std::vector<real> neighbory_Bulk_expected = { 1101, 1103, 1105, 1107 };
+ std::vector<real> neighborz_Border_expected = { 11011, 11013, 11015 };
+ std::vector<real> neighborz_Bulk_expected = { 11001, 11003, 11005, 11007 };
};
class InterpolationCellGrouperTest_IndicesFCBorderBulkTest : public testing::Test
{
protected:
- FCBorderBulk fc;
+ FineToCoarseBorderBulk fc;
SPtr<Parameter> para;
std::unique_ptr<InterpolationCellGrouper> testSubject;
@@ -199,12 +199,12 @@ private:
std::shared_ptr<LevelGridBuilderDouble> builder = std::make_shared<LevelGridBuilderDouble>(grid);
para = testingVF::createParameterForLevel(fc.level);
- para->getParH(fc.level)->intFC.ICellFCC = &(fc.iCellFCC.front());
- para->getParH(fc.level)->intFC.ICellFCF = &(fc.iCellFCF.front());
- para->getParH(fc.level)->intFC.kFC = fc.sizeOfICellFC;
- para->getParH(fc.level)->offFC.xOffFC = &(fc.offsetFCx.front());
- para->getParH(fc.level)->offFC.yOffFC = &(fc.offsetFCy.front());
- para->getParH(fc.level)->offFC.zOffFC = &(fc.offsetFCz.front());
+ para->getParH(fc.level)->fineToCoarse.coarseCellIndices = &(fc.coarseCellIndices.front());
+ para->getParH(fc.level)->fineToCoarse.fineCellIndices = &(fc.fineCellIndices.front());
+ para->getParH(fc.level)->fineToCoarse.numberOfCells = fc.sizeOfIntFineToCoarse;
+ para->getParH(fc.level)->neighborFineToCoarse.x = &(fc.neighborx.front());
+ para->getParH(fc.level)->neighborFineToCoarse.y = &(fc.neighbory.front());
+ para->getParH(fc.level)->neighborFineToCoarse.z = &(fc.neighborz.front());
return std::make_unique<InterpolationCellGrouper>(para->getParHallLevels(), para->getParDallLevels(), builder);
};
@@ -219,33 +219,33 @@ TEST_F(InterpolationCellGrouperTest_IndicesFCBorderBulkTest, splitFineToCoarseIn
{
testSubject->splitFineToCoarseIntoBorderAndBulk(fc.level);
- EXPECT_THAT(para->getParH(fc.level)->intFCBorder.kFC + para->getParH(fc.level)->intFCBulk.kFC,
- testing::Eq(fc.sizeOfICellFC))
+ EXPECT_THAT(para->getParH(fc.level)->fineToCoarseBorder.numberOfCells + para->getParH(fc.level)->fineToCoarseBulk.numberOfCells,
+ testing::Eq(fc.sizeOfIntFineToCoarse))
<< "The number of interpolation cells from coarse to fine changed during reordering.";
// check coarse to fine border (coarse nodes)
- EXPECT_THAT(para->getParH(fc.level)->intFCBorder.kFC, testing::Eq((uint)fc.iCellFccBorder_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->intFCBorder.ICellFCC, fc.iCellFccBorder_expected))
- << "intFCBorder.ICellFCC does not match the expected border vector";
+ EXPECT_THAT(para->getParH(fc.level)->fineToCoarseBorder.numberOfCells, testing::Eq((uint)fc.coarseCellIndicesBorder_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->fineToCoarseBorder.coarseCellIndices, fc.coarseCellIndicesBorder_expected))
+ << "fineToCoarseBorder.coarseCellIndices does not match the expected border vector";
// check coarse to fine border (fine nodes)
- EXPECT_THAT(para->getParH(fc.level)->intFCBorder.kFC, testing::Eq((uint)fc.iCellFcfBorder_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->intFCBorder.ICellFCF, fc.iCellFcfBorder_expected))
- << "intFCBorder.ICellFCF does not match the expected border vector";
+ EXPECT_THAT(para->getParH(fc.level)->fineToCoarseBorder.numberOfCells, testing::Eq((uint)fc.fineCellIndicesBorder_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->fineToCoarseBorder.fineCellIndices, fc.fineCellIndicesBorder_expected))
+ << "fineToCoarseBorder.fineCellIndices does not match the expected border vector";
// check coarse to fine bulk (coarse nodes)
- EXPECT_THAT(para->getParH(fc.level)->intFCBulk.kFC, testing::Eq((uint)fc.iCellFccBulk_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->intFCBulk.ICellFCC, fc.iCellFccBulk_expected))
- << "intFCBulk.ICellFCC does not match the expected bulk vector";
+ EXPECT_THAT(para->getParH(fc.level)->fineToCoarseBulk.numberOfCells, testing::Eq((uint)fc.coarseCellIndicesBulk_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->fineToCoarseBulk.coarseCellIndices, fc.coarseCellIndicesBulk_expected))
+ << "fineToCoarseBulk.coarseCellIndices does not match the expected bulk vector";
// check coarse to fine bulk (fine nodes)
- EXPECT_THAT(para->getParH(fc.level)->intFCBulk.kFC, testing::Eq((uint)fc.iCellFcfBulk_expected.size()));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->intFCBulk.ICellFCF, fc.iCellFcfBulk_expected))
- << "intFCBulk.ICellFCF does not match the expected bulk vector";
-
- // check offset cells
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->offFC.xOffFC, fc.offsetFCx_Border_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->offFCBulk.xOffFC, fc.offsetFCx_Bulk_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->offFC.yOffFC, fc.offsetFCy_Border_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->offFCBulk.yOffFC, fc.offsetFCy_Bulk_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->offFC.zOffFC, fc.offsetFCz_Border_expected));
- EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->offFCBulk.zOffFC, fc.offsetFCz_Bulk_expected));
+ EXPECT_THAT(para->getParH(fc.level)->fineToCoarseBulk.numberOfCells, testing::Eq((uint)fc.fineCellIndicesBulk_expected.size()));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->fineToCoarseBulk.fineCellIndices, fc.fineCellIndicesBulk_expected))
+ << "fineToCoarseBulk.fineCellIndices does not match the expected bulk vector";
+
+ // check neighbor cells
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->neighborFineToCoarse.x, fc.neighborx_Border_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->neighborFineToCoarseBulk.x, fc.neighborx_Bulk_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->neighborFineToCoarse.y, fc.neighbory_Border_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->neighborFineToCoarseBulk.y, fc.neighbory_Bulk_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->neighborFineToCoarse.z, fc.neighborz_Border_expected));
+ EXPECT_TRUE(vectorsAreEqual(para->getParH(fc.level)->neighborFineToCoarseBulk.z, fc.neighborz_Bulk_expected));
}
diff --git a/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.cpp b/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.cpp
index 49a6887ef2e462aba190023d334caa0012e2254e..297e2ac9c05fd225811f40439a26e0b3b4ce4811 100644
--- a/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.cpp
+++ b/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.cpp
@@ -3,13 +3,13 @@
void GridScalingFactory::setScalingFactory(const GridScalingFactory::GridScaling gridScalingType)
{
- this->gridScaling = gridScalingType;
+ this->gridScalingType = gridScalingType;
}
-gridScalingFC GridScalingFactory::getGridScalingFC(bool hasTurbulentViscosity) const
+gridScaling GridScalingFactory::getGridScalingFC(bool hasTurbulentViscosity) const
{
// for descriptions of the scaling types refer to the header
- switch (gridScaling) {
+ switch (gridScalingType) {
case GridScaling::ScaleRhoSq:
return ScaleFC_RhoSq_comp_27;
break;
@@ -22,10 +22,10 @@ gridScalingFC GridScalingFactory::getGridScalingFC(bool hasTurbulentViscosity) c
}
}
-gridScalingCF GridScalingFactory::getGridScalingCF(bool hasTurbulentViscosity) const
+gridScaling GridScalingFactory::getGridScalingCF(bool hasTurbulentViscosity) const
{
// for descriptions of the scaling types refer to the header
- switch (gridScaling) {
+ switch (gridScalingType) {
case GridScaling::ScaleRhoSq:
return ScaleCF_RhoSq_comp_27;
break;
diff --git a/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.h b/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.h
index d760240c2c5ed429799cd89e57704464515a92f5..f8729b0ed9df784eb8d409b6ea97a0ab0f9cbb5a 100644
--- a/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.h
+++ b/src/gpu/VirtualFluids_GPU/Factories/GridScalingFactory.h
@@ -42,8 +42,7 @@ struct LBMSimulationParameter;
class Parameter;
struct CUstream_st;
-using gridScalingFC = std::function<void(LBMSimulationParameter *, LBMSimulationParameter *, ICellFC *, OffFC&, CUstream_st *stream)>;
-using gridScalingCF = std::function<void(LBMSimulationParameter *, LBMSimulationParameter *, ICellCF *, OffCF&, CUstream_st *stream)>;
+using gridScaling = std::function<void(LBMSimulationParameter *, LBMSimulationParameter *, ICells *, ICellNeigh&, CUstream_st *stream)>;
class GridScalingFactory
{
@@ -59,11 +58,11 @@ public:
void setScalingFactory(const GridScalingFactory::GridScaling gridScalingType);
- [[nodiscard]] gridScalingFC getGridScalingFC(bool hasTurbulentViscosity) const;
- [[nodiscard]] gridScalingCF getGridScalingCF(bool hasTurbulentViscosity) const;
+ [[nodiscard]] gridScaling getGridScalingFC(bool hasTurbulentViscosity) const;
+ [[nodiscard]] gridScaling getGridScalingCF(bool hasTurbulentViscosity) const;
private:
- GridScaling gridScaling = GridScaling::NotSpecified;
+ GridScaling gridScalingType = GridScaling::NotSpecified;
};
#endif
diff --git a/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.cpp b/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.cpp
index ec435f0647ba973dbb405aefad069b285e09d6b5..9a0eae2282ca0abf11c77e6e8503c2a5b2bcc0b7 100644
--- a/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.cpp
+++ b/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.cpp
@@ -1,11 +1,11 @@
#include "FindInterface/FindInterface.h"
-void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
+void interpolation(InterpolationCells &intCF, InterpolationCells &intFC,
unsigned int LxCoarse, unsigned int LyCoarse, unsigned int LzCoarse,
unsigned int LxFine, unsigned int LyFine, unsigned int LzFine,
unsigned int dNx, unsigned int dNy, unsigned int dNz,
unsigned int *kCoarse, unsigned int *kFine, bool* needInterface,
- OffsetCF &offCF, OffsetFC &offFC)
+ InterpolationCellNeighbor &offCF, InterpolationCellNeighbor &offFC)
{
unsigned int iC,iF,jC,jF,hC,hF;
unsigned int posCSWB, posFSWB;
@@ -13,8 +13,8 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
real xOff = (real)0.0f;
real yOff = (real)0.0f;
real zOff = (real)0.0f;
- intCF.kCF = 0;
- intFC.kFC = 0;
+ intCF.numberOfCells = 0;
+ intFC.numberOfCells = 0;
///////////////////////////////////////////////////////////////////////////
//Defines
@@ -125,12 +125,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
}
////////////////////////// fine->coarse ////////////////////////////
@@ -142,12 +142,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -166,12 +166,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
}
////////////////////////// fine->coarse ////////////////////////////
@@ -183,12 +183,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -207,12 +207,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
}
////////////////////////// fine->coarse ////////////////////////////
@@ -224,12 +224,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -248,12 +248,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
}
////////////////////////// fine->coarse ////////////////////////////
@@ -265,12 +265,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -289,12 +289,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
}
////////////////////////// fine->coarse ////////////////////////////
@@ -306,12 +306,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] =xOff;
- offFC.yOffFC[intFC.kFC] =yOff;
- offFC.zOffFC[intFC.kFC] =zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] =xOff;
+ offFC.y[intFC.numberOfCells] =yOff;
+ offFC.z[intFC.numberOfCells] =zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -330,12 +330,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
}
////////////////////////// fine->coarse ////////////////////////////
@@ -347,12 +347,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -401,12 +401,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -427,12 +427,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_E]==false)
{
@@ -443,12 +443,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_N]==false)
@@ -460,12 +460,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -506,12 +506,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -532,12 +532,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_E]==false)
{
@@ -548,12 +548,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_S]==false)
@@ -565,12 +565,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -611,12 +611,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -637,12 +637,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_E]==false)
{
@@ -653,12 +653,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_T]==false)
@@ -670,12 +670,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -716,12 +716,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -742,12 +742,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_E]==false)
{
@@ -758,12 +758,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_B]==false)
@@ -775,12 +775,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -821,12 +821,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -847,12 +847,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_W]==false)
{
@@ -863,12 +863,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_N]==false)
@@ -880,12 +880,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -926,12 +926,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -952,12 +952,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_W]==false)
{
@@ -968,12 +968,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_S]==false)
@@ -985,12 +985,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1031,12 +1031,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -1057,12 +1057,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_W]==false)
{
@@ -1073,12 +1073,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_T]==false)
@@ -1090,12 +1090,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1136,12 +1136,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -1162,12 +1162,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_W]==false)
{
@@ -1178,12 +1178,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[INTERFACE_B]==false)
@@ -1195,12 +1195,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1241,12 +1241,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -1267,12 +1267,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[ INTERFACE_N]==false)
{
@@ -1283,12 +1283,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[ INTERFACE_T]==false)
@@ -1300,12 +1300,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1346,12 +1346,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -1372,12 +1372,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[ INTERFACE_N]==false)
{
@@ -1388,12 +1388,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[ INTERFACE_B]==false)
@@ -1405,12 +1405,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1451,12 +1451,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -1477,12 +1477,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[ INTERFACE_S]==false)
{
@@ -1493,12 +1493,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[ INTERFACE_T]==false)
@@ -1510,12 +1510,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1556,12 +1556,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
}
//////////////////////////////////////////////////////////////////////////
@@ -1582,12 +1582,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[ INTERFACE_S]==false)
{
@@ -1598,12 +1598,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
else if (needInterface[ INTERFACE_B]==false)
@@ -1615,12 +1615,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
{
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
}
@@ -1665,12 +1665,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -1691,12 +1691,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_E]==false)
{
@@ -1706,12 +1706,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_N]==false)
{
@@ -1721,12 +1721,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_T]==false)
{
@@ -1736,12 +1736,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_N]==false))
{
@@ -1751,12 +1751,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -1766,12 +1766,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_N]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -1781,12 +1781,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -1822,12 +1822,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -1848,12 +1848,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_E]==false)
{
@@ -1863,12 +1863,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_N]==false)
{
@@ -1878,12 +1878,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_B]==false)
{
@@ -1893,12 +1893,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_N]==false))
{
@@ -1908,12 +1908,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -1923,12 +1923,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_N]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -1938,12 +1938,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -1979,12 +1979,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -2005,12 +2005,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_E]==false)
{
@@ -2020,12 +2020,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_S]==false)
{
@@ -2035,12 +2035,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_T]==false)
{
@@ -2050,12 +2050,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_S]==false))
{
@@ -2065,12 +2065,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -2080,12 +2080,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_S]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -2095,12 +2095,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -2136,12 +2136,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -2162,12 +2162,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_E]==false)
{
@@ -2177,12 +2177,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_S]==false)
{
@@ -2192,12 +2192,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_B]==false)
{
@@ -2207,12 +2207,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_S]==false))
{
@@ -2222,12 +2222,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_E]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -2237,12 +2237,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_S]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -2252,12 +2252,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -2293,12 +2293,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -2319,12 +2319,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_W]==false)
{
@@ -2334,12 +2334,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_N]==false)
{
@@ -2349,12 +2349,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_T]==false)
{
@@ -2364,12 +2364,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_N]==false))
{
@@ -2379,12 +2379,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -2394,12 +2394,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_N]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -2409,12 +2409,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -2450,12 +2450,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -2476,12 +2476,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_W]==false)
{
@@ -2491,12 +2491,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_N]==false)
{
@@ -2506,12 +2506,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_B]==false)
{
@@ -2521,12 +2521,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_N]==false))
{
@@ -2536,12 +2536,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -2551,12 +2551,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_N]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -2566,12 +2566,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -2607,12 +2607,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -2633,12 +2633,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_W]==false)
{
@@ -2648,12 +2648,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_S]==false)
{
@@ -2663,12 +2663,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_T]==false)
{
@@ -2678,12 +2678,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_S]==false))
{
@@ -2693,12 +2693,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -2708,12 +2708,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_S]==false) && (needInterface[INTERFACE_T]==false))
{
@@ -2723,12 +2723,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
@@ -2764,12 +2764,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
//////////////////////////////////////////////////////////////////////////
posCSWB=vectorPosition(iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine , LyFine);
- intCF.ICellCFC[intCF.kCF] = kCoarse[posCSWB];
- intCF.ICellCFF[intCF.kCF] = kFine[posFSWB];
- offCF.xOffCF[intCF.kCF] = xOff;
- offCF.yOffCF[intCF.kCF] = yOff;
- offCF.zOffCF[intCF.kCF] = zOff;
- intCF.kCF++;
+ intCF.coarseCellIndices[intCF.numberOfCells] = kCoarse[posCSWB];
+ intCF.fineCellIndices[intCF.numberOfCells] = kFine[posFSWB];
+ offCF.x[intCF.numberOfCells] = xOff;
+ offCF.y[intCF.numberOfCells] = yOff;
+ offCF.z[intCF.numberOfCells] = zOff;
+ intCF.numberOfCells++;
//////////////////////////////////////////////////////////////////////////
@@ -2790,12 +2790,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
if (needInterface[INTERFACE_W]==false)
{
@@ -2805,12 +2805,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_S]==false)
{
@@ -2820,12 +2820,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if (needInterface[INTERFACE_B]==false)
{
@@ -2835,12 +2835,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_S]==false))
{
@@ -2850,12 +2850,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_W]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -2865,12 +2865,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
if ((needInterface[INTERFACE_S]==false) && (needInterface[INTERFACE_B]==false))
{
@@ -2880,12 +2880,12 @@ void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
posC=vectorPosition( iC, jC, hC, LxCoarse, LyCoarse);
posFSWB=vectorPosition(iF, jF, hF, LxFine, LyFine);
- intFC.ICellFCC[intFC.kFC] = kCoarse[posC];
- intFC.ICellFCF[intFC.kFC] = kFine[posFSWB];
- offFC.xOffFC[intFC.kFC] = xOff;
- offFC.yOffFC[intFC.kFC] = yOff;
- offFC.zOffFC[intFC.kFC] = zOff;
- intFC.kFC++;
+ intFC.coarseCellIndices[intFC.numberOfCells] = kCoarse[posC];
+ intFC.fineCellIndices[intFC.numberOfCells] = kFine[posFSWB];
+ offFC.x[intFC.numberOfCells] = xOff;
+ offFC.y[intFC.numberOfCells] = yOff;
+ offFC.z[intFC.numberOfCells] = zOff;
+ intFC.numberOfCells++;
}
}
diff --git a/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.h b/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.h
index 3be49570b33d99f9517796b33934dee1e2f31221..17e63824f930161656291bf2d7ecc05e23af9161 100644
--- a/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.h
+++ b/src/gpu/VirtualFluids_GPU/FindInterface/FindInterface.h
@@ -5,11 +5,11 @@
#include "lbm/constants/D3Q27.h"
-void interpolation(InterpolationCellCF &intCF, InterpolationCellFC &intFC,
+void interpolation(InterpolationCells &intCF, InterpolationCells &intFC,
unsigned int LxCoarse, unsigned int LyCoarse, unsigned int LzCoarse,
unsigned int LxFine, unsigned int LyFine, unsigned int LzFine,
unsigned int dNx, unsigned int dNy, unsigned int dNz,
unsigned int *kCoarse, unsigned int *kFine, bool* needInterface,
- OffsetCF &offCF, OffsetFC &offFC);
+ InterpolationCellNeighbor &offCF, InterpolationCellNeighbor &offFC);
#endif
diff --git a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
index 9fd2a6b2f5c5c10a36856852db47f989ace714ce..e9d40ddf71f2e72d68f01fe333df16cf1c7b49d9 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
+++ b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
@@ -1106,116 +1106,131 @@ void CudaMemoryManager::cudaFreeMedianOut(int lev)
//Interface CF
void CudaMemoryManager::cudaAllocInterfaceCF(int lev)
{
+ uint mem_size_kCF = sizeof(uint) * parameter->getParH(lev)->coarseToFine.numberOfCells;
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intCF.ICellCFC), parameter->getParH(lev)->mem_size_kCF ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intCF.ICellCFF), parameter->getParH(lev)->mem_size_kCF ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coarseToFine.coarseCellIndices), mem_size_kCF ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coarseToFine.fineCellIndices), mem_size_kCF ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intCF.ICellCFC), parameter->getParD(lev)->mem_size_kCF ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intCF.ICellCFF), parameter->getParD(lev)->mem_size_kCF ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coarseToFine.coarseCellIndices), mem_size_kCF ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coarseToFine.fineCellIndices), mem_size_kCF ));
//////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)parameter->getParH(lev)->mem_size_kCF;
+ double tmp = 2. * (double)mem_size_kCF;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyInterfaceCF(int lev)
{
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intCF.ICellCFC, parameter->getParH(lev)->intCF.ICellCFC, parameter->getParH(lev)->mem_size_kCF, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intCF.ICellCFF, parameter->getParH(lev)->intCF.ICellCFF, parameter->getParH(lev)->mem_size_kCF, cudaMemcpyHostToDevice));
+ uint mem_size_kCF = sizeof(uint) * parameter->getParH(lev)->coarseToFine.numberOfCells;
+
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->coarseToFine.coarseCellIndices, parameter->getParH(lev)->coarseToFine.coarseCellIndices, mem_size_kCF, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->coarseToFine.fineCellIndices, parameter->getParH(lev)->coarseToFine.fineCellIndices, mem_size_kCF, cudaMemcpyHostToDevice));
}
void CudaMemoryManager::cudaFreeInterfaceCF(int lev)
{
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intCF.ICellCFC));
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intCF.ICellCFF));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coarseToFine.coarseCellIndices));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coarseToFine.fineCellIndices));
}
//Interface FC
void CudaMemoryManager::cudaAllocInterfaceFC(int lev)
{
+ uint mem_size_kFC = sizeof(uint) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
+
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intFC.ICellFCF), parameter->getParH(lev)->mem_size_kFC ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intFC.ICellFCC), parameter->getParH(lev)->mem_size_kFC ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->fineToCoarse.fineCellIndices), mem_size_kFC ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->fineToCoarse.coarseCellIndices), mem_size_kFC ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intFC.ICellFCF), parameter->getParD(lev)->mem_size_kFC ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intFC.ICellFCC), parameter->getParD(lev)->mem_size_kFC ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->fineToCoarse.fineCellIndices), mem_size_kFC ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->fineToCoarse.coarseCellIndices), mem_size_kFC ));
//////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)parameter->getParH(lev)->mem_size_kFC;
+ double tmp = 2. * (double)mem_size_kFC;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyInterfaceFC(int lev)
{
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intFC.ICellFCF, parameter->getParH(lev)->intFC.ICellFCF, parameter->getParH(lev)->mem_size_kFC, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intFC.ICellFCC, parameter->getParH(lev)->intFC.ICellFCC, parameter->getParH(lev)->mem_size_kFC, cudaMemcpyHostToDevice));
+ uint mem_size_kFC = sizeof(uint) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
+
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->fineToCoarse.fineCellIndices, parameter->getParH(lev)->fineToCoarse.fineCellIndices, mem_size_kFC, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->fineToCoarse.coarseCellIndices, parameter->getParH(lev)->fineToCoarse.coarseCellIndices, mem_size_kFC, cudaMemcpyHostToDevice));
}
void CudaMemoryManager::cudaCheckInterfaceFCBulk(int lev)
{
// only use for testing!
- size_t memsize = sizeof(uint) * parameter->getParH(lev)->intFCBulk.kFC;
- checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->intFCBulk.ICellFCC, parameter->getParH(lev)->intFCBulk.ICellFCC, memsize, cudaMemcpyDeviceToDevice));
- for (uint i = 0; i < parameter->getParH(lev)->intFCBulk.kFC; i++)
- printf("%d %d\n", i, parameter->getParH(lev)->intFCBulk.ICellFCC[i]);
+ size_t memsize = sizeof(uint) * parameter->getParH(lev)->fineToCoarseBulk.numberOfCells;
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->fineToCoarseBulk.coarseCellIndices, parameter->getParH(lev)->fineToCoarseBulk.coarseCellIndices, memsize, cudaMemcpyDeviceToDevice));
+ for (uint i = 0; i < parameter->getParH(lev)->fineToCoarseBulk.numberOfCells; i++)
+ printf("%d %d\n", i, parameter->getParH(lev)->fineToCoarseBulk.coarseCellIndices[i]);
}
void CudaMemoryManager::cudaFreeInterfaceFC(int lev)
{
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intFC.ICellFCF));
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intFC.ICellFCC));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->fineToCoarse.fineCellIndices));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->fineToCoarse.coarseCellIndices));
}
//Interface Offset CF
void CudaMemoryManager::cudaAllocInterfaceOffCF(int lev)
{
+ uint mem_size_kCF_off = sizeof(real) * parameter->getParH(lev)->coarseToFine.numberOfCells;
+
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offCF.xOffCF), parameter->getParH(lev)->mem_size_kCF_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offCF.yOffCF), parameter->getParH(lev)->mem_size_kCF_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offCF.zOffCF), parameter->getParH(lev)->mem_size_kCF_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborCoarseToFine.x), mem_size_kCF_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborCoarseToFine.y), mem_size_kCF_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborCoarseToFine.z), mem_size_kCF_off ));
getLastCudaError("Allocate host memory");
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offCF.xOffCF), parameter->getParD(lev)->mem_size_kCF_off ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offCF.yOffCF), parameter->getParD(lev)->mem_size_kCF_off ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offCF.zOffCF), parameter->getParD(lev)->mem_size_kCF_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborCoarseToFine.x), mem_size_kCF_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborCoarseToFine.y), mem_size_kCF_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborCoarseToFine.z), mem_size_kCF_off ));
getLastCudaError("Allocate device memory");
//////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (double)parameter->getParH(lev)->mem_size_kCF_off;
+ double tmp = 3. * (double)mem_size_kCF_off;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyInterfaceOffCF(int lev)
{
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offCF.xOffCF, parameter->getParH(lev)->offCF.xOffCF, parameter->getParH(lev)->mem_size_kCF_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offCF.yOffCF, parameter->getParH(lev)->offCF.yOffCF, parameter->getParH(lev)->mem_size_kCF_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offCF.zOffCF, parameter->getParH(lev)->offCF.zOffCF, parameter->getParH(lev)->mem_size_kCF_off, cudaMemcpyHostToDevice));
+ uint mem_size_kCF_off = sizeof(real) * parameter->getParH(lev)->coarseToFine.numberOfCells;
+
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborCoarseToFine.x, parameter->getParH(lev)->neighborCoarseToFine.x, mem_size_kCF_off, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborCoarseToFine.y, parameter->getParH(lev)->neighborCoarseToFine.y, mem_size_kCF_off, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborCoarseToFine.z, parameter->getParH(lev)->neighborCoarseToFine.z, mem_size_kCF_off, cudaMemcpyHostToDevice));
getLastCudaError("Copy host memory to device");
}
void CudaMemoryManager::cudaFreeInterfaceOffCF(int lev)
{
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offCF.xOffCF));
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offCF.yOffCF));
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offCF.zOffCF));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborCoarseToFine.x));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborCoarseToFine.y));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborCoarseToFine.z));
}
//Interface Offset FC
void CudaMemoryManager::cudaAllocInterfaceOffFC(int lev)
{
+ uint mem_size_kFC_off = sizeof(real) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
+
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offFC.xOffFC), parameter->getParH(lev)->mem_size_kFC_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offFC.yOffFC), parameter->getParH(lev)->mem_size_kFC_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offFC.zOffFC), parameter->getParH(lev)->mem_size_kFC_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborFineToCoarse.x), mem_size_kFC_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborFineToCoarse.y), mem_size_kFC_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborFineToCoarse.z), mem_size_kFC_off ));
getLastCudaError("Allocate host memory");
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offFC.xOffFC), parameter->getParD(lev)->mem_size_kFC_off ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offFC.yOffFC), parameter->getParD(lev)->mem_size_kFC_off ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offFC.zOffFC), parameter->getParD(lev)->mem_size_kFC_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborFineToCoarse.x), mem_size_kFC_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborFineToCoarse.y), mem_size_kFC_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborFineToCoarse.z), mem_size_kFC_off ));
getLastCudaError("Allocate device memory");
//////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (double)parameter->getParH(lev)->mem_size_kFC_off;
+ double tmp = 3. * (double)mem_size_kFC_off;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyInterfaceOffFC(int lev)
{
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offFC.xOffFC, parameter->getParH(lev)->offFC.xOffFC, parameter->getParH(lev)->mem_size_kFC_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offFC.yOffFC, parameter->getParH(lev)->offFC.yOffFC, parameter->getParH(lev)->mem_size_kFC_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offFC.zOffFC, parameter->getParH(lev)->offFC.zOffFC, parameter->getParH(lev)->mem_size_kFC_off, cudaMemcpyHostToDevice));
+ uint mem_size_kFC_off = sizeof(real) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
+
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborFineToCoarse.x, parameter->getParH(lev)->neighborFineToCoarse.x, mem_size_kFC_off, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborFineToCoarse.y, parameter->getParH(lev)->neighborFineToCoarse.y, mem_size_kFC_off, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborFineToCoarse.z, parameter->getParH(lev)->neighborFineToCoarse.z, mem_size_kFC_off, cudaMemcpyHostToDevice));
getLastCudaError("Copy host memory to device");
}
void CudaMemoryManager::cudaFreeInterfaceOffFC(int lev)
{
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offFC.xOffFC));
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offFC.yOffFC));
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offFC.zOffFC));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborFineToCoarse.x));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborFineToCoarse.y));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborFineToCoarse.z));
}
//Inlet
@@ -2519,24 +2534,24 @@ void CudaMemoryManager::cudaFreePorousMedia(PorousMedia* pm, int lev)
void CudaMemoryManager::cudaAllocConcentration(int lev)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->Conc), parameter->getParH(lev)->memSizeRealLBnodes));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->concentration), parameter->getParH(lev)->memSizeRealLBnodes));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->Conc), parameter->getParD(lev)->memSizeRealLBnodes));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->concentration), parameter->getParD(lev)->memSizeRealLBnodes));
//////////////////////////////////////////////////////////////////////////
double tmp = (double)parameter->getParH(lev)->memSizeRealLBnodes;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyConcentrationDeviceToHost(int lev)
{
- checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->Conc, parameter->getParD(lev)->Conc, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->concentration, parameter->getParD(lev)->concentration, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
}
void CudaMemoryManager::cudaCopyConcentrationHostToDevice(int lev)
{
- checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->Conc, parameter->getParH(lev)->Conc, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->concentration, parameter->getParH(lev)->concentration, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyHostToDevice));
}
void CudaMemoryManager::cudaFreeConcentration(int lev)
{
- checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->Conc));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->concentration));
}
//////////////////////////////////////////////////////////////////////////
void CudaMemoryManager::cudaAllocTempFs(int lev)
@@ -2548,7 +2563,7 @@ void CudaMemoryManager::cudaAllocTempFs(int lev)
}
else if (parameter->getDiffMod() == 27)
{
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->distributionsAD27.f[0]), parameter->getDiffMod()*parameter->getParH(lev)->memSizeRealLBnodes));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->distributionsAD.f[0]), parameter->getDiffMod()*parameter->getParH(lev)->memSizeRealLBnodes));
}
//////////////////////////////////////////////////////////////////////////
double tmp = (double)(parameter->getDiffMod() * parameter->getParH(lev)->memSizeRealLBnodes);
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h b/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h
index 4a5b7816c1b6591e4193639bcdf71242e77688c0..47ca867e5340595d41b2a2694c7c7e477f794184 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h
+++ b/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h
@@ -1353,7 +1353,7 @@ void ScaleCFEff27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleFCEff27(real* DC,
real* DF,
@@ -1377,7 +1377,7 @@ void ScaleFCEff27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleCFLast27(real* DC,
real* DF,
@@ -1401,7 +1401,7 @@ void ScaleCFLast27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleFCLast27(real* DC,
real* DF,
@@ -1425,7 +1425,7 @@ void ScaleFCLast27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleCFpress27(real* DC,
real* DF,
@@ -1449,7 +1449,7 @@ void ScaleCFpress27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleFCpress27( real* DC,
real* DF,
@@ -1473,7 +1473,7 @@ void ScaleFCpress27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleCF_Fix_27(real* DC,
real* DF,
@@ -1497,7 +1497,7 @@ void ScaleCF_Fix_27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleCF_Fix_comp_27( real* DC,
real* DF,
@@ -1521,7 +1521,7 @@ void ScaleCF_Fix_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleCF_0817_comp_27( real* DC,
real* DF,
@@ -1545,7 +1545,7 @@ void ScaleCF_0817_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st* stream);
void ScaleCF_comp_D3Q27F3_2018( real* DC,
@@ -1571,7 +1571,7 @@ void ScaleCF_comp_D3Q27F3_2018( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleCF_comp_D3Q27F3(real* DC,
real* DF,
@@ -1596,7 +1596,7 @@ void ScaleCF_comp_D3Q27F3(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream);
void ScaleCF_staggered_time_comp_27( real* DC,
@@ -1621,11 +1621,11 @@ void ScaleCF_staggered_time_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
-void ScaleCF_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellCF * icellCF, OffCF &offsetCF, CUstream_st *stream);
+void ScaleCF_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * interpolationCellsCoarseToFine, ICellNeigh &neighborCoarseToFine, CUstream_st *stream);
-template<bool hasTurbulentViscosity> void ScaleCF_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellCF * icellCF, OffCF &offsetCF, CUstream_st *stream);
+template<bool hasTurbulentViscosity> void ScaleCF_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * interpolationCellsCoarseToFine, ICellNeigh &neighborCoarseToFine, CUstream_st *stream);
void ScaleCF_RhoSq_3rdMom_comp_27( real* DC,
real* DF,
@@ -1649,7 +1649,7 @@ void ScaleCF_RhoSq_3rdMom_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream);
void ScaleCF_AA2016_comp_27( real* DC,
@@ -1674,7 +1674,7 @@ void ScaleCF_AA2016_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream);
void ScaleCF_NSPress_27(real* DC,
@@ -1699,7 +1699,7 @@ void ScaleCF_NSPress_27(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleFC_Fix_27( real* DC,
real* DF,
@@ -1723,7 +1723,7 @@ void ScaleFC_Fix_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleFC_Fix_comp_27( real* DC,
real* DF,
@@ -1747,7 +1747,7 @@ void ScaleFC_Fix_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleFC_0817_comp_27( real* DC,
real* DF,
@@ -1771,7 +1771,7 @@ void ScaleFC_0817_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream);
void ScaleFC_comp_D3Q27F3_2018(real* DC,
@@ -1797,7 +1797,7 @@ void ScaleFC_comp_D3Q27F3_2018(real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleFC_comp_D3Q27F3( real* DC,
real* DF,
@@ -1822,7 +1822,7 @@ void ScaleFC_comp_D3Q27F3( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream);
void ScaleFC_staggered_time_comp_27( real* DC,
@@ -1847,11 +1847,11 @@ void ScaleFC_staggered_time_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
-void ScaleFC_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellFC * icellFC, OffFC& offsetFC, CUstream_st *stream);
+void ScaleFC_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * interpolationCellsFineToCoarse, ICellNeigh& neighborFineToCoarse, CUstream_st *stream);
-template<bool hasTurbulentViscosity> void ScaleFC_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellFC * icellFC, OffFC& offsetFC, CUstream_st *stream);
+template<bool hasTurbulentViscosity> void ScaleFC_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * icellFC, ICellNeigh& neighborFineToCoarse, CUstream_st *stream);
void ScaleFC_RhoSq_3rdMom_comp_27( real* DC,
real* DF,
@@ -1875,7 +1875,7 @@ void ScaleFC_RhoSq_3rdMom_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream);
void ScaleFC_AA2016_comp_27( real* DC,
@@ -1900,7 +1900,7 @@ void ScaleFC_AA2016_comp_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream);
void ScaleFC_NSPress_27( real* DC,
@@ -1925,7 +1925,7 @@ void ScaleFC_NSPress_27( real* DC,
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleCFThS7( real* DC,
real* DF,
@@ -1986,7 +1986,7 @@ void ScaleCFThSMG7( real* DC,
real nu,
real diffusivity_fine,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleFCThSMG7(real* DC,
real* DF,
@@ -2007,7 +2007,7 @@ void ScaleFCThSMG7(real* DC,
real nu,
real diffusivity_coarse,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void ScaleCFThS27( real* DC,
real* DF,
@@ -2028,7 +2028,7 @@ void ScaleCFThS27( real* DC,
real nu,
real diffusivity_fine,
unsigned int numberOfThreads,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
void ScaleFCThS27( real* DC,
real* DF,
@@ -2049,7 +2049,7 @@ void ScaleFCThS27( real* DC,
real nu,
real diffusivity_coarse,
unsigned int numberOfThreads,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
void DragLiftPostD27(real* DD,
int* k_Q,
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh b/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh
index 0c3c7fcefc2bbb7bc87d7d95863c8c74f14735a3..399bbe35d58d2d3f055325aa8e3ee87bb2bcb63a 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh
+++ b/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh
@@ -1648,7 +1648,7 @@ __global__ void scaleCFEff27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCFLast27( real* DC,
real* DF,
@@ -1671,7 +1671,7 @@ __global__ void scaleCFLast27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCFpress27(real* DC,
real* DF,
@@ -1694,7 +1694,7 @@ __global__ void scaleCFpress27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_Fix_27(real* DC,
real* DF,
@@ -1717,7 +1717,7 @@ __global__ void scaleCF_Fix_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_Fix_comp_27( real* DC,
real* DF,
@@ -1740,7 +1740,7 @@ __global__ void scaleCF_Fix_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_0817_comp_27( real* DC,
real* DF,
@@ -1763,7 +1763,7 @@ __global__ void scaleCF_0817_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_comp_D3Q27F3_2018( real* DC,
real* DF,
@@ -1787,7 +1787,7 @@ __global__ void scaleCF_comp_D3Q27F3_2018( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_comp_D3Q27F3( real* DC,
real* DF,
@@ -1811,7 +1811,7 @@ __global__ void scaleCF_comp_D3Q27F3( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_staggered_time_comp_27(real* DC,
@@ -1835,7 +1835,7 @@ __global__ void scaleCF_staggered_time_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_RhoSq_comp_27( real* DC,
real* DF,
@@ -1858,7 +1858,7 @@ __global__ void scaleCF_RhoSq_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
template<bool hasTurbulentViscosity> __global__ void scaleCF_compressible(
real* distributionsCoarse,
@@ -1879,7 +1879,7 @@ template<bool hasTurbulentViscosity> __global__ void scaleCF_compressible(
real omegaFine,
real* turbulentViscosityCoarse,
real* turbulentViscosityFine,
- OffCF offsetCF);
+ ICellNeigh offsetCF);
__global__ void scaleCF_RhoSq_3rdMom_comp_27(real* DC,
real* DF,
@@ -1902,7 +1902,7 @@ __global__ void scaleCF_RhoSq_3rdMom_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_AA2016_comp_27(real* DC,
real* DF,
@@ -1925,7 +1925,7 @@ __global__ void scaleCF_AA2016_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCF_NSPress_27(real* DC,
real* DF,
@@ -1948,7 +1948,7 @@ __global__ void scaleCF_NSPress_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCFThSMG7( real* DC,
real* DF,
@@ -1968,7 +1968,7 @@ __global__ void scaleCFThSMG7( real* DC,
unsigned int kCF,
real nu,
real diffusivity_fine,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
__global__ void scaleCFThS7(real* DC,
real* DF,
@@ -2007,7 +2007,7 @@ __global__ void scaleCFThS27(real* DC,
unsigned int kCF,
real nu,
real diffusivity_fine,
- OffCF offCF);
+ ICellNeigh neighborCoarseToFine);
//fine to coarse
__global__ void scaleFC27(real* DC,
@@ -2053,7 +2053,7 @@ __global__ void scaleFCEff27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFCLast27( real* DC,
real* DF,
@@ -2076,7 +2076,7 @@ __global__ void scaleFCLast27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFCpress27( real* DC,
real* DF,
@@ -2099,7 +2099,7 @@ __global__ void scaleFCpress27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_Fix_27( real* DC,
real* DF,
@@ -2122,7 +2122,7 @@ __global__ void scaleFC_Fix_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_Fix_comp_27( real* DC,
real* DF,
@@ -2145,7 +2145,7 @@ __global__ void scaleFC_Fix_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_0817_comp_27( real* DC,
real* DF,
@@ -2168,7 +2168,7 @@ __global__ void scaleFC_0817_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_comp_D3Q27F3_2018( real* DC,
real* DF,
@@ -2192,7 +2192,7 @@ __global__ void scaleFC_comp_D3Q27F3_2018( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_comp_D3Q27F3( real* DC,
real* DF,
@@ -2216,7 +2216,7 @@ __global__ void scaleFC_comp_D3Q27F3( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_staggered_time_comp_27(real* DC,
@@ -2240,7 +2240,7 @@ __global__ void scaleFC_staggered_time_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_RhoSq_comp_27( real* DC,
real* DF,
@@ -2263,7 +2263,7 @@ __global__ void scaleFC_RhoSq_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
template<bool hasTurbulentViscosity> __global__ void scaleFC_compressible(
real *distributionsCoarse,
@@ -2284,7 +2284,7 @@ template<bool hasTurbulentViscosity> __global__ void scaleFC_compressible(
real omegaFine,
real* turbulentViscosityCoarse,
real* turbulentViscosityFine,
- OffFC offsetFC);
+ ICellNeigh offsetFC);
__global__ void scaleFC_RhoSq_3rdMom_comp_27(real* DC,
real* DF,
@@ -2307,7 +2307,7 @@ __global__ void scaleFC_RhoSq_3rdMom_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_AA2016_comp_27(real* DC,
real* DF,
@@ -2330,7 +2330,7 @@ __global__ void scaleFC_AA2016_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFC_NSPress_27(real* DC,
real* DF,
@@ -2353,7 +2353,7 @@ __global__ void scaleFC_NSPress_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFCThSMG7( real* DC,
real* DF,
@@ -2373,7 +2373,7 @@ __global__ void scaleFCThSMG7( real* DC,
unsigned int kFC,
real nu,
real diffusivity_coarse,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void scaleFCThS7(real* DC,
real* DF,
@@ -2412,7 +2412,7 @@ __global__ void scaleFCThS27( real* DC,
unsigned int kFC,
real nu,
real diffusivity_coarse,
- OffFC offFC);
+ ICellNeigh neighborFineToCoarse);
__global__ void DragLiftPost27( real* DD,
int* k_Q,
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF27.cu b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF27.cu
index 641d6519669b1522430fe88990c00d0630d00e9b..d720a87c9b9a123739c60439a2b5ef1490eef6f7 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF27.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF27.cu
@@ -35,7 +35,7 @@ __global__ void scaleCF_0817_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real
*fP00dest, *fM00dest, *f0P0dest, *f0M0dest, *f00Pdest, *f00Mdest, *fPP0dest, *fMM0dest, *fPM0dest,
@@ -188,9 +188,9 @@ __global__ void scaleCF_0817_comp_27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -4104,7 +4104,7 @@ __global__ void scaleCF_AA2016_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -4270,9 +4270,9 @@ __global__ void scaleCF_AA2016_comp_27(real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -10987,7 +10987,7 @@ __global__ void scaleCF_RhoSq_3rdMom_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -11153,9 +11153,9 @@ __global__ void scaleCF_RhoSq_3rdMom_comp_27(real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -17862,7 +17862,7 @@ __global__ void scaleCF_RhoSq_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -18008,9 +18008,9 @@ __global__ void scaleCF_RhoSq_comp_27(real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -22146,7 +22146,7 @@ __global__ void scaleCF_staggered_time_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -22292,9 +22292,9 @@ __global__ void scaleCF_staggered_time_comp_27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -26382,7 +26382,7 @@ __global__ void scaleCF_Fix_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -26531,9 +26531,9 @@ __global__ void scaleCF_Fix_comp_27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -31149,7 +31149,7 @@ __global__ void scaleCF_NSPress_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -31294,9 +31294,9 @@ __global__ void scaleCF_NSPress_27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -35093,7 +35093,7 @@ __global__ void scaleCF_Fix_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -35239,9 +35239,9 @@ __global__ void scaleCF_Fix_27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -39351,7 +39351,7 @@ __global__ void scaleCFpress27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -39496,9 +39496,9 @@ __global__ void scaleCFpress27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -41025,7 +41025,7 @@ __global__ void scaleCFLast27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -41170,9 +41170,9 @@ __global__ void scaleCFLast27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -43257,7 +43257,7 @@ __global__ void scaleCFThSMG7( real* DC,
unsigned int kCF,
real nu,
real diffusivity_fine,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, /**fzeroF,*/ *ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -43425,9 +43425,9 @@ __global__ void scaleCFThSMG7( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- real xoff = offCF.xOffCF[k];
- real yoff = offCF.yOffCF[k];
- real zoff = offCF.zOffCF[k];
+ real xoff = offCF.x[k];
+ real yoff = offCF.y[k];
+ real zoff = offCF.z[k];
real xoff_sq = xoff * xoff;
real yoff_sq = yoff * yoff;
real zoff_sq = zoff * zoff;
@@ -45607,7 +45607,7 @@ __global__ void scaleCFThS27( real* DC,
unsigned int kCF,
real nu,
real diffusivity_fine,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, /**fzeroF,*/ *ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -45835,9 +45835,9 @@ __global__ void scaleCFThS27( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -47300,7 +47300,7 @@ __global__ void scaleCFEff27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -47445,9 +47445,9 @@ __global__ void scaleCFEff27(real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF_F3_27.cu b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF_F3_27.cu
index 386493280fd71fff93c117483e754a248bb0830d..fba54269c6d8c2bc3092c52833c98c78e87b988b 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF_F3_27.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleCF_F3_27.cu
@@ -36,7 +36,7 @@ __global__ void scaleCF_comp_D3Q27F3_2018(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real
*fP00dest, *fM00dest, *f0P0dest, *f0M0dest, *f00Pdest, *f00Mdest, *fPP0dest, *fMM0dest, *fPM0dest,
@@ -198,9 +198,9 @@ __global__ void scaleCF_comp_D3Q27F3_2018(real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -4383,7 +4383,7 @@ __global__ void scaleCF_comp_D3Q27F3( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffCF offCF)
+ ICellNeigh offCF)
{
real
*fP00dest, *fM00dest, *f0P0dest, *f0M0dest, *f00Pdest, *f00Mdest, *fPP0dest, *fMM0dest, *fPM0dest,
@@ -4545,9 +4545,9 @@ __global__ void scaleCF_comp_D3Q27F3( real* DC,
if(k<kCF)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offCF.xOffCF[k];
- yoff = offCF.yOffCF[k];
- zoff = offCF.zOffCF[k];
+ xoff = offCF.x[k];
+ yoff = offCF.y[k];
+ zoff = offCF.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC27.cu b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC27.cu
index b37ab44d81d15fbbde46c875c860acd7198b8041..48f5041ce12df3e0a219087a2bcda735ea28afd7 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC27.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC27.cu
@@ -35,7 +35,7 @@ __global__ void scaleFC_0817_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real
*fP00source, *fM00source, *f0P0source, *f0M0source, *f00Psource, *f00Msource, *fPP0source, *fMM0source, *fPM0source,
@@ -183,9 +183,9 @@ __global__ void scaleFC_0817_comp_27( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -1231,7 +1231,7 @@ __global__ void scaleFC_AA2016_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -1393,9 +1393,9 @@ __global__ void scaleFC_AA2016_comp_27(real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -5420,7 +5420,7 @@ __global__ void scaleFC_RhoSq_3rdMom_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -5582,9 +5582,9 @@ __global__ void scaleFC_RhoSq_3rdMom_comp_27(real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -9608,7 +9608,7 @@ __device__ void scaleFC_RhoSq_comp_27_Calculation(
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC,
+ ICellNeigh offFC,
const unsigned k)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF,
@@ -9741,9 +9741,9 @@ __device__ void scaleFC_RhoSq_comp_27_Calculation(
if (k < kFC) {
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -11094,7 +11094,7 @@ __global__ void scaleFC_RhoSq_comp_27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
////////////////////////////////////////////////////////////////////////////////
const unsigned ix = threadIdx.x; // Globaler x-Index
@@ -11187,7 +11187,7 @@ __global__ void scaleFC_staggered_time_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -11329,9 +11329,9 @@ __global__ void scaleFC_staggered_time_comp_27( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -12487,7 +12487,7 @@ __global__ void scaleFC_Fix_comp_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -12631,9 +12631,9 @@ __global__ void scaleFC_Fix_comp_27( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -14347,7 +14347,7 @@ __global__ void scaleFC_NSPress_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -14488,9 +14488,9 @@ __global__ void scaleFC_NSPress_27( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -15553,7 +15553,7 @@ __global__ void scaleFC_Fix_27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -15695,9 +15695,9 @@ __global__ void scaleFC_Fix_27( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -16913,7 +16913,7 @@ __global__ void scaleFCpress27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -17057,9 +17057,9 @@ __global__ void scaleFCpress27(real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -17838,7 +17838,7 @@ __global__ void scaleFCLast27( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -17982,9 +17982,9 @@ __global__ void scaleFCLast27( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -19231,7 +19231,7 @@ __global__ void scaleFCThSMG7( real* DC,
unsigned int kFC,
real nu,
real diffusivity_coarse,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, //*fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -19392,9 +19392,9 @@ __global__ void scaleFCThSMG7( real* DC,
if(k<kFC){
//////////////////////////////////////////////////////////////////////////
- real xoff = offFC.xOffFC[k];
- real yoff = offFC.yOffFC[k];
- real zoff = offFC.zOffFC[k];
+ real xoff = offFC.x[k];
+ real yoff = offFC.y[k];
+ real zoff = offFC.z[k];
real xoff_sq = xoff * xoff;
real yoff_sq = yoff * yoff;
real zoff_sq = zoff * zoff;
@@ -20889,7 +20889,7 @@ __global__ void scaleFCThS27( real* DC,
unsigned int kFC,
real nu,
real diffusivity_coarse,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, //*fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -21110,9 +21110,9 @@ __global__ void scaleFCThS27( real* DC,
if(k<kFC){
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -22012,7 +22012,7 @@ __global__ void scaleFCEff27(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real *feF, *fwF, *fnF, *fsF, *ftF, *fbF, *fneF, *fswF, *fseF, *fnwF, *fteF, *fbwF, *fbeF, *ftwF, *ftnF, *fbsF, *fbnF, *ftsF, *fzeroF,
*ftneF, *ftswF, *ftseF, *ftnwF, *fbneF, *fbswF, *fbseF, *fbnwF;
@@ -22156,9 +22156,9 @@ __global__ void scaleFCEff27(real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC_F3_27.cu b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC_F3_27.cu
index 3b108ad4ae43bd63698f3516a207630214695797..c83da28dfe1781342ea747cfc4b7bc342cbe1dec 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC_F3_27.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/ScaleFC_F3_27.cu
@@ -36,7 +36,7 @@ __global__ void scaleFC_comp_D3Q27F3_2018(real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real
*fP00source, *fM00source, *f0P0source, *f0M0source, *f00Psource, *f00Msource, *fPP0source, *fMM0source, *fPM0source,
@@ -205,9 +205,9 @@ __global__ void scaleFC_comp_D3Q27F3_2018(real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
@@ -1283,7 +1283,7 @@ __global__ void scaleFC_comp_D3Q27F3( real* DC,
unsigned int nyC,
unsigned int nxF,
unsigned int nyF,
- OffFC offFC)
+ ICellNeigh offFC)
{
real
*fP00source, *fM00source, *f0P0source, *f0M0source, *f00Psource, *f00Msource, *fPP0source, *fMM0source, *fPM0source,
@@ -1452,9 +1452,9 @@ __global__ void scaleFC_comp_D3Q27F3( real* DC,
if(k<kFC)
{
//////////////////////////////////////////////////////////////////////////
- xoff = offFC.xOffFC[k];
- yoff = offFC.yOffFC[k];
- zoff = offFC.zOffFC[k];
+ xoff = offFC.x[k];
+ yoff = offFC.y[k];
+ zoff = offFC.z[k];
xoff_sq = xoff * xoff;
yoff_sq = yoff * yoff;
zoff_sq = zoff * zoff;
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleCF_compressible.cu b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleCF_compressible.cu
index 84529ef2694b57448291957f7792360088bd954f..726e31888658d78562913cd2b386481cd69abbc6 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleCF_compressible.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleCF_compressible.cu
@@ -237,7 +237,7 @@ template<bool hasTurbulentViscosity> __global__ void scaleCF_compressible(
real omegaFine,
real* turbulentViscosityCoarse,
real* turbulentViscosityFine,
- OffCF offsetCF)
+ ICellNeigh neighborCoarseToFine)
{
////////////////////////////////////////////////////////////////////////////////
//! - Get the node index coordinates from threadId_100, blockId_100, blockDim and gridDim.
@@ -758,9 +758,9 @@ template<bool hasTurbulentViscosity> __global__ void scaleCF_compressible(
////////////////////////////////////////////////////////////////////////////////
//! - Set the relative position of the offset cell {-1, 0, 1}
//!
- real xoff = offsetCF.xOffCF[nodeIndex];
- real yoff = offsetCF.yOffCF[nodeIndex];
- real zoff = offsetCF.zOffCF[nodeIndex];
+ real xoff = neighborCoarseToFine.x[nodeIndex];
+ real yoff = neighborCoarseToFine.y[nodeIndex];
+ real zoff = neighborCoarseToFine.z[nodeIndex];
real xoff_sq = xoff * xoff;
real yoff_sq = yoff * yoff;
@@ -1487,6 +1487,6 @@ template<bool hasTurbulentViscosity> __global__ void scaleCF_compressible(
(distFine.f[DIR_MMM])[k_MMM] = f_MMM;
}
-template __global__ void scaleCF_compressible<true>( real* distributionsCoarse, real* distributionsFine, unsigned int* neighborXcoarse, unsigned int* neighborYcoarse, unsigned int* neighborZcoarse, unsigned int* neighborXfine, unsigned int* neighborYfine, unsigned int* neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int* indicesCoarseMMM, unsigned int* indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, OffCF offsetCF);
+template __global__ void scaleCF_compressible<true>( real* distributionsCoarse, real* distributionsFine, unsigned int* neighborXcoarse, unsigned int* neighborYcoarse, unsigned int* neighborZcoarse, unsigned int* neighborXfine, unsigned int* neighborYfine, unsigned int* neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int* indicesCoarseMMM, unsigned int* indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, ICellNeigh offsetCF);
-template __global__ void scaleCF_compressible<false>( real* distributionsCoarse, real* distributionsFine, unsigned int* neighborXcoarse, unsigned int* neighborYcoarse, unsigned int* neighborZcoarse, unsigned int* neighborXfine, unsigned int* neighborYfine, unsigned int* neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int* indicesCoarseMMM, unsigned int* indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, OffCF offsetCF);
\ No newline at end of file
+template __global__ void scaleCF_compressible<false>( real* distributionsCoarse, real* distributionsFine, unsigned int* neighborXcoarse, unsigned int* neighborYcoarse, unsigned int* neighborZcoarse, unsigned int* neighborXfine, unsigned int* neighborYfine, unsigned int* neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int* indicesCoarseMMM, unsigned int* indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, ICellNeigh offsetCF);
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleFC_compressible.cu b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleFC_compressible.cu
index c89a524c1dd63f426254c395d1e4881a7e96ce7a..4ed8273589001b9d4c87e4774310424274631e2d 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleFC_compressible.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/GridScaling/scaleFC_compressible.cu
@@ -65,7 +65,7 @@ template<bool hasTurbulentViscosity> __global__ void scaleFC_compressible(
real omegaFine,
real* turbulentViscosityCoarse,
real* turbulentViscosityFine,
- OffFC offsetFC)
+ ICellNeigh neighborFineToCoarse)
{
////////////////////////////////////////////////////////////////////////////////
//! - Get the node index coordinates from threadIdx, blockIdx, blockDim and gridDim.
@@ -424,9 +424,9 @@ template<bool hasTurbulentViscosity> __global__ void scaleFC_compressible(
////////////////////////////////////////////////////////////////////////////////
//! - Set the relative position of the offset cell {-1, 0, 1}
//!
- real xoff = offsetFC.xOffFC[nodeIndex];
- real yoff = offsetFC.yOffFC[nodeIndex];
- real zoff = offsetFC.zOffFC[nodeIndex];
+ real xoff = neighborFineToCoarse.x[nodeIndex];
+ real yoff = neighborFineToCoarse.y[nodeIndex];
+ real zoff = neighborFineToCoarse.z[nodeIndex];
real xoff_sq = xoff * xoff;
real yoff_sq = yoff * yoff;
@@ -708,6 +708,6 @@ template<bool hasTurbulentViscosity> __global__ void scaleFC_compressible(
////////////////////////////////////////////////////////////////////////////////////
}
-template __global__ void scaleFC_compressible<true>( real *distributionsCoarse, real *distributionsFine, unsigned int *neighborXcoarse, unsigned int *neighborYcoarse, unsigned int *neighborZcoarse, unsigned int *neighborXfine, unsigned int *neighborYfine, unsigned int *neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int *indicesCoarse000, unsigned int *indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, OffFC offsetFC);
+template __global__ void scaleFC_compressible<true>( real *distributionsCoarse, real *distributionsFine, unsigned int *neighborXcoarse, unsigned int *neighborYcoarse, unsigned int *neighborZcoarse, unsigned int *neighborXfine, unsigned int *neighborYfine, unsigned int *neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int *indicesCoarse000, unsigned int *indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, ICellNeigh neighborFineToCoarse);
-template __global__ void scaleFC_compressible<false>( real *distributionsCoarse, real *distributionsFine, unsigned int *neighborXcoarse, unsigned int *neighborYcoarse, unsigned int *neighborZcoarse, unsigned int *neighborXfine, unsigned int *neighborYfine, unsigned int *neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int *indicesCoarse000, unsigned int *indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, OffFC offsetFC);
\ No newline at end of file
+template __global__ void scaleFC_compressible<false>( real *distributionsCoarse, real *distributionsFine, unsigned int *neighborXcoarse, unsigned int *neighborYcoarse, unsigned int *neighborZcoarse, unsigned int *neighborXfine, unsigned int *neighborYfine, unsigned int *neighborZfine, unsigned long long numberOfLBnodesCoarse, unsigned long long numberOfLBnodesFine, bool isEvenTimestep, unsigned int *indicesCoarse000, unsigned int *indicesFineMMM, unsigned int numberOfInterfaceNodes, real omegaCoarse, real omegaFine, real* turbulentViscosityCoarse, real* turbulentViscosityFine, ICellNeigh neighborFineToCoarse);
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu b/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
index 9abac27969e74dc90ecdcc707f4fcb2234010d07..c0372741061735b58579a85fbeff7351d1408b07 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
@@ -3563,7 +3563,7 @@ void ScaleCFEff27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3589,7 +3589,7 @@ void ScaleCFEff27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCFEff27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3616,7 +3616,7 @@ void ScaleCFLast27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3642,7 +3642,7 @@ void ScaleCFLast27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCFLast27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3669,7 +3669,7 @@ void ScaleCFpress27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3695,7 +3695,7 @@ void ScaleCFpress27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCFpress27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3722,7 +3722,7 @@ void ScaleCF_Fix_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3748,7 +3748,7 @@ void ScaleCF_Fix_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_Fix_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3775,7 +3775,7 @@ void ScaleCF_Fix_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3801,7 +3801,7 @@ void ScaleCF_Fix_comp_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_Fix_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3828,7 +3828,7 @@ void ScaleCF_0817_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3855,7 +3855,7 @@ void ScaleCF_0817_comp_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_0817_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3883,7 +3883,7 @@ void ScaleCF_comp_D3Q27F3_2018(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3910,7 +3910,7 @@ void ScaleCF_comp_D3Q27F3_2018(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_comp_D3Q27F3_2018 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3938,7 +3938,7 @@ void ScaleCF_comp_D3Q27F3(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -3966,7 +3966,7 @@ void ScaleCF_comp_D3Q27F3(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_comp_D3Q27F3 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -3993,7 +3993,7 @@ void ScaleCF_staggered_time_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -4019,13 +4019,13 @@ void ScaleCF_staggered_time_comp_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_staggered_time_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
-void ScaleCF_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellCF * icellCF, OffCF& offsetCF, CUstream_st *stream)
+void ScaleCF_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * coarseToFine, ICellNeigh& neighborCoarseToFine, CUstream_st *stream)
{
- dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, icellCF->kCF);
+ dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, coarseToFine->numberOfCells);
dim3 threads(parameterDeviceC->numberofthreads, 1, 1 );
scaleCF_RhoSq_comp_27<<<grid, threads, 0, stream>>>(
@@ -4040,23 +4040,23 @@ void ScaleCF_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulat
parameterDeviceC->numberOfNodes,
parameterDeviceF->numberOfNodes,
parameterDeviceC->isEvenTimestep,
- icellCF->ICellCFC,
- icellCF->ICellCFF,
- icellCF->kCF,
+ coarseToFine->coarseCellIndices,
+ coarseToFine->fineCellIndices,
+ coarseToFine->numberOfCells,
parameterDeviceC->omega,
parameterDeviceF->omega,
- parameterDeviceC->vis,
+ parameterDeviceC->viscosity,
parameterDeviceC->nx,
parameterDeviceC->ny,
parameterDeviceF->nx,
parameterDeviceF->ny,
- offsetCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_RhoSq_27 execution failed");
}
-template<bool hasTurbulentViscosity> void ScaleCF_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellCF * icellCF, OffCF& offsetCF, CUstream_st *stream)
+template<bool hasTurbulentViscosity> void ScaleCF_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * coarseToFine, ICellNeigh& neighborCoarseToFine, CUstream_st *stream)
{
- dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, icellCF->kCF);
+ dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, coarseToFine->numberOfCells);
dim3 threads(parameterDeviceC->numberofthreads, 1, 1 );
scaleCF_compressible<hasTurbulentViscosity><<<grid, threads, 0, stream>>>(
@@ -4071,19 +4071,19 @@ template<bool hasTurbulentViscosity> void ScaleCF_compressible(LBMSimulationPara
parameterDeviceC->numberOfNodes,
parameterDeviceF->numberOfNodes,
parameterDeviceC->isEvenTimestep,
- icellCF->ICellCFC,
- icellCF->ICellCFF,
- icellCF->kCF,
+ coarseToFine->coarseCellIndices,
+ coarseToFine->fineCellIndices,
+ coarseToFine->numberOfCells,
parameterDeviceC->omega,
parameterDeviceF->omega,
parameterDeviceC->turbViscosity,
parameterDeviceF->turbViscosity,
- offsetCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_compressible execution failed");
}
-template void ScaleCF_compressible<true>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellCF * icellCF, OffCF& offsetCF, CUstream_st *stream);
-template void ScaleCF_compressible<false>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellCF * icellCF, OffCF& offsetCF, CUstream_st *stream);
+template void ScaleCF_compressible<true>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * coarseToFine, ICellNeigh& neighborCoarseToFine, CUstream_st *stream);
+template void ScaleCF_compressible<false>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * coarseToFine, ICellNeigh& neighborCoarseToFine, CUstream_st *stream);
//////////////////////////////////////////////////////////////////////////
void ScaleCF_RhoSq_3rdMom_comp_27(
@@ -4109,7 +4109,7 @@ void ScaleCF_RhoSq_3rdMom_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -4136,7 +4136,7 @@ void ScaleCF_RhoSq_3rdMom_comp_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_RhoSq_3rdMom_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4163,7 +4163,7 @@ void ScaleCF_AA2016_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF,
+ ICellNeigh neighborCoarseToFine,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -4190,7 +4190,7 @@ void ScaleCF_AA2016_comp_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_AA2016_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4217,7 +4217,7 @@ void ScaleCF_NSPress_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -4243,7 +4243,7 @@ void ScaleCF_NSPress_27(
nyC,
nxF,
nyF,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCF_NSPress_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4267,7 +4267,7 @@ void ScaleCFThSMG7(
real nu,
real diffusivity_fine,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -4290,7 +4290,7 @@ void ScaleCFThSMG7(
kCF,
nu,
diffusivity_fine,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCFThSMG7 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4359,7 +4359,7 @@ void ScaleCFThS27(
real nu,
real diffusivity_fine,
unsigned int numberOfThreads,
- OffCF offCF)
+ ICellNeigh neighborCoarseToFine)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kCF);
@@ -4382,7 +4382,7 @@ void ScaleCFThS27(
kCF,
nu,
diffusivity_fine,
- offCF);
+ neighborCoarseToFine);
getLastCudaError("scaleCFThS27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4460,7 +4460,7 @@ void ScaleFCEff27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4486,7 +4486,7 @@ void ScaleFCEff27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFCEff27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4513,7 +4513,7 @@ void ScaleFCLast27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4539,7 +4539,7 @@ void ScaleFCLast27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("Kernel execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4566,7 +4566,7 @@ void ScaleFCpress27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4592,7 +4592,7 @@ void ScaleFCpress27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFCpress27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4619,7 +4619,7 @@ void ScaleFC_Fix_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4645,7 +4645,7 @@ void ScaleFC_Fix_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_Fix_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4672,7 +4672,7 @@ void ScaleFC_Fix_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4698,7 +4698,7 @@ void ScaleFC_Fix_comp_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_Fix_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4725,7 +4725,7 @@ void ScaleFC_0817_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4752,7 +4752,7 @@ void ScaleFC_0817_comp_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_0817_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4780,7 +4780,7 @@ void ScaleFC_comp_D3Q27F3_2018(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4807,7 +4807,7 @@ void ScaleFC_comp_D3Q27F3_2018(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_comp_D3Q27F3_2018 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4835,7 +4835,7 @@ void ScaleFC_comp_D3Q27F3(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4863,7 +4863,7 @@ void ScaleFC_comp_D3Q27F3(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_comp_D3Q27F3 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -4890,7 +4890,7 @@ void ScaleFC_staggered_time_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -4916,13 +4916,13 @@ void ScaleFC_staggered_time_comp_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_staggered_time_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
-void ScaleFC_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellFC * icellFC, OffFC &offsetFC, CUstream_st *stream)
+void ScaleFC_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * fineToCoarse, ICellNeigh &neighborFineToCoarse, CUstream_st *stream)
{
- dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, icellFC->kFC);
+ dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, fineToCoarse->numberOfCells);
dim3 threads(parameterDeviceC->numberofthreads, 1, 1 );
scaleFC_RhoSq_comp_27<<<grid, threads, 0, stream>>>(
@@ -4937,23 +4937,23 @@ void ScaleFC_RhoSq_comp_27(LBMSimulationParameter * parameterDeviceC, LBMSimulat
parameterDeviceC->numberOfNodes,
parameterDeviceF->numberOfNodes,
parameterDeviceC->isEvenTimestep,
- icellFC->ICellFCC,
- icellFC->ICellFCF,
- icellFC->kFC,
+ fineToCoarse->coarseCellIndices,
+ fineToCoarse->fineCellIndices,
+ fineToCoarse->numberOfCells,
parameterDeviceC->omega,
parameterDeviceF->omega,
- parameterDeviceC->vis,
+ parameterDeviceC->viscosity,
parameterDeviceC->nx,
parameterDeviceC->ny,
parameterDeviceF->nx,
parameterDeviceF->ny,
- offsetFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_RhoSq_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
-template<bool hasTurbulentViscosity> void ScaleFC_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellFC * icellFC, OffFC &offsetFC, CUstream_st *stream)
+template<bool hasTurbulentViscosity> void ScaleFC_compressible(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * fineToCoarse, ICellNeigh &neighborFineToCoarse, CUstream_st *stream)
{
- dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, icellFC->kFC);
+ dim3 grid = vf::cuda::getCudaGrid(parameterDeviceC->numberofthreads, fineToCoarse->numberOfCells);
dim3 threads(parameterDeviceC->numberofthreads, 1, 1 );
scaleFC_compressible<hasTurbulentViscosity><<<grid, threads, 0, stream>>>(
@@ -4968,19 +4968,19 @@ template<bool hasTurbulentViscosity> void ScaleFC_compressible(LBMSimulationPara
parameterDeviceC->numberOfNodes,
parameterDeviceF->numberOfNodes,
parameterDeviceC->isEvenTimestep,
- icellFC->ICellFCC,
- icellFC->ICellFCF,
- icellFC->kFC,
+ fineToCoarse->coarseCellIndices,
+ fineToCoarse->fineCellIndices,
+ fineToCoarse->numberOfCells,
parameterDeviceC->omega,
parameterDeviceF->omega,
parameterDeviceC->turbViscosity,
parameterDeviceF->turbViscosity,
- offsetFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_compressible execution failed");
}
-template void ScaleFC_compressible<true>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellFC * icellFC, OffFC &offsetFC, CUstream_st *stream);
-template void ScaleFC_compressible<false>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICellFC * icellFC, OffFC &offsetFC, CUstream_st *stream);
+template void ScaleFC_compressible<true>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * fineToCoarse, ICellNeigh &neighborFineToCoarse, CUstream_st *stream);
+template void ScaleFC_compressible<false>(LBMSimulationParameter * parameterDeviceC, LBMSimulationParameter* parameterDeviceF, ICells * fineToCoarse, ICellNeigh &neighborFineToCoarse, CUstream_st *stream);
//////////////////////////////////////////////////////////////////////////
void ScaleFC_RhoSq_3rdMom_comp_27(
@@ -5006,7 +5006,7 @@ void ScaleFC_RhoSq_3rdMom_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -5033,7 +5033,7 @@ void ScaleFC_RhoSq_3rdMom_comp_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_RhoSq_3rdMom_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -5060,7 +5060,7 @@ void ScaleFC_AA2016_comp_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC,
+ ICellNeigh neighborFineToCoarse,
CUstream_st *stream)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -5087,7 +5087,7 @@ void ScaleFC_AA2016_comp_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_AA2016_comp_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -5114,7 +5114,7 @@ void ScaleFC_NSPress_27(
unsigned int nxF,
unsigned int nyF,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -5140,7 +5140,7 @@ void ScaleFC_NSPress_27(
nyC,
nxF,
nyF,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFC_NSPress_27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -5164,7 +5164,7 @@ void ScaleFCThSMG7(
real nu,
real diffusivity_coarse,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -5187,7 +5187,7 @@ void ScaleFCThSMG7(
kFC,
nu,
diffusivity_coarse,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFCThSMG7 execution failed");
}
//////////////////////////////////////////////////////////////////////////
@@ -5256,7 +5256,7 @@ void ScaleFCThS27(
real nu,
real diffusivity_coarse,
unsigned int numberOfThreads,
- OffFC offFC)
+ ICellNeigh neighborFineToCoarse)
{
vf::cuda::CudaGrid grid = vf::cuda::CudaGrid(numberOfThreads, kFC);
@@ -5279,7 +5279,7 @@ void ScaleFCThS27(
kFC,
nu,
diffusivity_coarse,
- offFC);
+ neighborFineToCoarse);
getLastCudaError("scaleFCThS27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/VirtualFluids_GPU/Init/InitLattice.cpp b/src/gpu/VirtualFluids_GPU/Init/InitLattice.cpp
index 508e4498c36d352761c3ecaf24abaa52a5f84bbe..ba4a5cae5259ff43a1d85e6ee97dd125e3da912f 100644
--- a/src/gpu/VirtualFluids_GPU/Init/InitLattice.cpp
+++ b/src/gpu/VirtualFluids_GPU/Init/InitLattice.cpp
@@ -82,7 +82,7 @@ void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor, SPtr<Cud
cudaMemoryManager->cudaAllocConcentration(lev);
for (size_t index = 0; index < para->getParH(lev)->numberOfNodes; index++) {
- para->getParH(lev)->Conc[index] = para->getTemperatureInit();
+ para->getParH(lev)->concentration[index] = para->getTemperatureInit();
}
initTemperatur(para.get(), cudaMemoryManager.get(), lev);
}
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Compressible/Mod27/ADComp27/ADComp27.cu b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Compressible/Mod27/ADComp27/ADComp27.cu
index dd30516ac4229908a418d932177c1b63d8f5d685..4d4467acb20232ecb364451f61265b71f1692517 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Compressible/Mod27/ADComp27/ADComp27.cu
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Compressible/Mod27/ADComp27/ADComp27.cu
@@ -20,7 +20,7 @@ void ADComp27::run()
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->numberOfNodes,
para->getParD(level)->isEvenTimestep);
getLastCudaError("LB_KERNEL_AD_COMP_27 execution failed");
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Incompressible/Mod27/ADIncomp27/ADIncomp27.cu b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Incompressible/Mod27/ADIncomp27/ADIncomp27.cu
index 150245a312509d50b77cf86fec18fdb063dbcc2c..3c10e7a6996a9a26668a18390ddee4e2cbbec853 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Incompressible/Mod27/ADIncomp27/ADIncomp27.cu
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/AdvectionDiffusion/Incompressible/Mod27/ADIncomp27/ADIncomp27.cu
@@ -20,7 +20,7 @@ void ADIncomp27::run()
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->numberOfNodes,
para->getParD(level)->isEvenTimestep);
getLastCudaError("LB_Kernel_AD_Incomp_27 execution failed");
diff --git a/src/gpu/VirtualFluids_GPU/KernelManager/ADKernelManager.cpp b/src/gpu/VirtualFluids_GPU/KernelManager/ADKernelManager.cpp
index 5a36daecd5a82fc8a052bf51fedc1cb35b94a960..34a0c589919058d4edd1969812c16e75941d28b4 100644
--- a/src/gpu/VirtualFluids_GPU/KernelManager/ADKernelManager.cpp
+++ b/src/gpu/VirtualFluids_GPU/KernelManager/ADKernelManager.cpp
@@ -56,7 +56,7 @@ void ADKernelManager::initAD(const int level) const
para->getParD(level)->velocityY,
para->getParD(level)->velocityZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
//////////////////////////////////////////////////////////////////////////
para->getParD(level)->isEvenTimestep = false;
@@ -72,7 +72,7 @@ void ADKernelManager::initAD(const int level) const
para->getParD(level)->velocityY,
para->getParD(level)->velocityZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
//////////////////////////////////////////////////////////////////////////
CalcConcentration27(
@@ -83,7 +83,7 @@ void ADKernelManager::initAD(const int level) const
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
}
@@ -173,7 +173,7 @@ void ADKernelManager::runADcollisionKernel(const int level)const
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->numberOfNodes,
para->getParD(level)->forcing,
para->getParD(level)->isEvenTimestep);
@@ -188,7 +188,7 @@ void ADKernelManager::runADslipBCKernel(const int level) const{
para->getParD(level)->slipBC.normalY,
para->getParD(level)->slipBC.normalZ,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->slipBC.k,
para->getParD(level)->slipBC.q27[0],
para->getParD(level)->slipBC.numberOfBCnodes,
@@ -265,7 +265,7 @@ void ADKernelManager::runADpressureBCKernel(const int level) const{
QADPressDev27(
para->getParD(level)->numberofthreads,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->TempPress.temp,
para->getParD(level)->TempPress.velo,
para->getParD(level)->diffusivity,
@@ -346,7 +346,7 @@ void ADKernelManager::runADgeometryBCKernel(const int level) const
QADBBDev27(
para->getParD(level)->numberofthreads,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->Temp.temp,
para->getParD(level)->diffusivity,
para->getParD(level)->Temp.k,
@@ -428,7 +428,7 @@ void ADKernelManager::runADveloBCKernel(const int level) const{
QADVelDev27(
para->getParD(level)->numberofthreads,
para->getParD(level)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->TempVel.tempPulse,
para->getParD(level)->TempVel.velo,
para->getParD(level)->diffusivity,
@@ -498,7 +498,7 @@ void ADKernelManager::printAD(const int level, SPtr<CudaMemoryManager> cudaMemor
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
cudaMemoryManager->cudaCopyConcentrationDeviceToHost(level);
diff --git a/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.cpp b/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.cpp
index 0841d6931bba32440b47d02c9f83864a80f724be..229922b1ec1654e7ca664f9d19a7b7c6e264fd83 100644
--- a/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.cpp
+++ b/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.cpp
@@ -47,8 +47,8 @@ GridScalingKernelManager::GridScalingKernelManager(SPtr<Parameter> parameter, Gr
if(!gridScalingFactory){
throw std::runtime_error("There is more than one level, but no scalingFactory was provided.");
}
- checkScalingFunction(gridScalingFactory->getGridScalingFC(parameter->getUseTurbulentViscosity()), this->para->getParD(0)->intFC, "scalingFineToCoarse");
- checkScalingFunction(gridScalingFactory->getGridScalingCF(parameter->getUseTurbulentViscosity()), this->para->getParD(0)->intCF, "scalingCoarseToFine");
+ checkScalingFunction(gridScalingFactory->getGridScalingFC(parameter->getUseTurbulentViscosity()), this->para->getParD(0)->fineToCoarse, "scalingFineToCoarse");
+ checkScalingFunction(gridScalingFactory->getGridScalingCF(parameter->getUseTurbulentViscosity()), this->para->getParD(0)->coarseToFine, "scalingCoarseToFine");
this->scalingFineToCoarse = gridScalingFactory->getGridScalingFC(parameter->getUseTurbulentViscosity());
this->scalingCoarseToFine = gridScalingFactory->getGridScalingCF(parameter->getUseTurbulentViscosity());
}
@@ -59,11 +59,11 @@ GridScalingKernelManager::GridScalingKernelManager(SPtr<Parameter> parameter, Gr
VF_LOG_TRACE("Function for scalingCoarseToFine is nullptr");
}
-void GridScalingKernelManager::runFineToCoarseKernelLB(const int level, InterpolationCellFC *icellFC, OffFC &offFC, CudaStreamIndex streamIndex) const
+void GridScalingKernelManager::runFineToCoarseKernelLB(const int level, InterpolationCells *fineToCoarse, ICellNeigh &neighborFineToCoarse, CudaStreamIndex streamIndex) const
{
cudaStream_t stream = para->getStreamManager()->getStream(streamIndex);
- this->scalingFineToCoarse(para->getParD(level).get(), para->getParD(level+1).get(), icellFC, offFC, stream);
+ this->scalingFineToCoarse(para->getParD(level).get(), para->getParD(level+1).get(), fineToCoarse, neighborFineToCoarse, stream);
// ScaleFC_comp_D3Q27F3(
// para->getParD(level)->distributions.f[0],
@@ -294,21 +294,21 @@ void GridScalingKernelManager::runFineToCoarseKernelAD(const int level) const
para->getParD(level)->numberOfNodes,
para->getParD(level+1)->numberOfNodes,
para->getParD(level)->isEvenTimestep,
- para->getParD(level)->intFC.ICellFCC,
- para->getParD(level)->intFC.ICellFCF,
- para->getParD(level)->K_FC,
- para->getParD(level)->vis,
+ para->getParD(level)->fineToCoarse.coarseCellIndices,
+ para->getParD(level)->fineToCoarse.fineCellIndices,
+ para->getParD(level)->fineToCoarse.numberOfCells,
+ para->getParD(level)->viscosity,
para->getParD(level)->diffusivity,
para->getParD(level)->numberofthreads,
- para->getParD(level)->offFC);
+ para->getParD(level)->neighborFineToCoarse);
}
else if (para->getDiffMod() == 27)
{
ScaleFCThS27(
para->getParD(level)->distributions.f[0],
para->getParD(level+1)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
- para->getParD(level+1)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
+ para->getParD(level+1)->distributionsAD.f[0],
para->getParD(level)->neighborX,
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
@@ -318,20 +318,20 @@ void GridScalingKernelManager::runFineToCoarseKernelAD(const int level) const
para->getParD(level)->numberOfNodes,
para->getParD(level+1)->numberOfNodes,
para->getParD(level)->isEvenTimestep,
- para->getParD(level)->intFC.ICellFCC,
- para->getParD(level)->intFC.ICellFCF,
- para->getParD(level)->K_FC,
- para->getParD(level)->vis,
+ para->getParD(level)->fineToCoarse.coarseCellIndices,
+ para->getParD(level)->fineToCoarse.fineCellIndices,
+ para->getParD(level)->fineToCoarse.numberOfCells,
+ para->getParD(level)->viscosity,
para->getParD(level)->diffusivity,
para->getParD(level)->numberofthreads,
- para->getParD(level)->offFC);
+ para->getParD(level)->neighborFineToCoarse);
}
}
-void GridScalingKernelManager::runCoarseToFineKernelLB(const int level, InterpolationCellCF* icellCF, OffCF &offCF, CudaStreamIndex streamIndex) const
+void GridScalingKernelManager::runCoarseToFineKernelLB(const int level, InterpolationCells* coarseToFine, ICellNeigh &neighborFineToCoarse, CudaStreamIndex streamIndex) const
{
cudaStream_t stream = para->getStreamManager()->getStream(streamIndex);
- this->scalingCoarseToFine(para->getParD(level).get(), para->getParD(level+1).get(), icellCF, offCF, stream);
+ this->scalingCoarseToFine(para->getParD(level).get(), para->getParD(level+1).get(), coarseToFine, neighborFineToCoarse, stream);
// ScaleCF_comp_D3Q27F3(
// para->getParD(level)->distributions.f[0],
@@ -563,21 +563,21 @@ void GridScalingKernelManager::runCoarseToFineKernelAD(const int level) const
para->getParD(level)->numberOfNodes,
para->getParD(level+1)->numberOfNodes,
para->getParD(level)->isEvenTimestep,
- para->getParD(level)->intCF.ICellCFC,
- para->getParD(level)->intCF.ICellCFF,
- para->getParD(level)->K_CF,
- para->getParD(level)->vis,
+ para->getParD(level)->coarseToFine.coarseCellIndices,
+ para->getParD(level)->coarseToFine.fineCellIndices,
+ para->getParD(level)->coarseToFine.numberOfCells,
+ para->getParD(level)->viscosity,
para->getParD(level+1)->diffusivity,
para->getParD(level)->numberofthreads,
- para->getParD(level)->offCF);
+ para->getParD(level)->neighborCoarseToFine);
}
else if (para->getDiffMod() == 27)
{
ScaleCFThS27(
para->getParD(level)->distributions.f[0],
para->getParD(level+1)->distributions.f[0],
- para->getParD(level)->distributionsAD27.f[0],
- para->getParD(level+1)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
+ para->getParD(level+1)->distributionsAD.f[0],
para->getParD(level)->neighborX,
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
@@ -587,12 +587,12 @@ void GridScalingKernelManager::runCoarseToFineKernelAD(const int level) const
para->getParD(level)->numberOfNodes,
para->getParD(level+1)->numberOfNodes,
para->getParD(level)->isEvenTimestep,
- para->getParD(level)->intCF.ICellCFC,
- para->getParD(level)->intCF.ICellCFF,
- para->getParD(level)->K_CF,
- para->getParD(level)->vis,
+ para->getParD(level)->coarseToFine.coarseCellIndices,
+ para->getParD(level)->coarseToFine.fineCellIndices,
+ para->getParD(level)->coarseToFine.numberOfCells,
+ para->getParD(level)->viscosity,
para->getParD(level+1)->diffusivity,
para->getParD(level)->numberofthreads,
- para->getParD(level)->offCF);
+ para->getParD(level)->neighborCoarseToFine);
}
}
diff --git a/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.h b/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.h
index 3c78ee7f9db254556e8ec6dbbafaf51cd995f10b..ef1e175ed149e6a89016c76249ce31aa1f1828f9 100644
--- a/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.h
+++ b/src/gpu/VirtualFluids_GPU/KernelManager/GridScalingKernelManager.h
@@ -48,10 +48,8 @@ enum class CudaStreamIndex;
struct LBMSimulationParameter;
struct CUstream_st;
-using gridScalingFC =
- std::function<void(LBMSimulationParameter *, LBMSimulationParameter *, ICellFC *, OffFC &, CUstream_st *stream)>;
-using gridScalingCF =
- std::function<void(LBMSimulationParameter *, LBMSimulationParameter *, ICellCF *, OffCF &, CUstream_st *stream)>;
+using gridScaling =
+ std::function<void(LBMSimulationParameter *, LBMSimulationParameter *, ICells *, ICellNeigh &, CUstream_st *stream)>;
//! \class GridScalingKernelManager
//! \brief manage the cuda kernel calls
@@ -64,13 +62,13 @@ public:
GridScalingKernelManager(SPtr<Parameter> parameter, GridScalingFactory *gridScalingFactory);
//! \brief calls the device function of the fine to coarse grid interpolation kernelH
- void runFineToCoarseKernelLB(const int level, InterpolationCellFC *icellFC, OffFC &offFC, CudaStreamIndex streamIndex) const;
+ void runFineToCoarseKernelLB(const int level, InterpolationCells *fineToCoarse, ICellNeigh &neighborFineToCoarse, CudaStreamIndex streamIndex) const;
//! \brief calls the device function of the fine to coarse grid interpolation kernel (advection diffusion)
void runFineToCoarseKernelAD(const int level) const;
//! \brief calls the device function of the coarse to fine grid interpolation kernel
- void runCoarseToFineKernelLB(const int level, InterpolationCellCF *icellCF, OffCF &offCF, CudaStreamIndex streamIndex) const;
+ void runCoarseToFineKernelLB(const int level, InterpolationCells *coarseToFine, ICellNeigh &neighborCoarseToFine, CudaStreamIndex streamIndex) const;
//! \brief calls the device function of the coarse to fine grid interpolation kernel (advection diffusion)
void runCoarseToFineKernelAD(const int level) const;
@@ -78,35 +76,21 @@ public:
private:
//! \brief check if grid scaling was set
//! \throws std::runtime_error if interpolation nodes were assigned, but no scaling function was set in the grid
- //! scaling factory \param scalingFunctionFC: a kernel function for the grid scaling \param scalingStruct: a struct
+ //! scaling factory \param scalingFunction: a kernel function for the grid scaling \param scalingStruct: a struct
//! containing the grid nodes which are part of the interpolation \param scalingName: the name of the checked
//! scaling function
- void checkScalingFunction(const gridScalingFC &scalingFunctionFC, const InterpolationCellFC &scalingStruct,
+ void checkScalingFunction(const gridScaling &scalingFunction, const InterpolationCells &scalingStruct,
const std::string &scalingName)
{
- if (!scalingFunctionFC && scalingStruct.kFC > 0)
+ if (!scalingFunction && scalingStruct.numberOfCells > 0)
throw std::runtime_error("The scaling function " + scalingName + " was not set!");
- if (scalingFunctionFC && scalingStruct.kFC == 0)
- VF_LOG_WARNING("The scaling function {} was set, although there is no refinement", scalingName);
- }
-
- //! \brief check if grid scaling was set
- //! \throws std::runtime_error if interpolation nodes were assigned, but no scaling function was set in the grid
- //! scaling factory \param scalingFunctionCF: a kernel function for the grid scaling \param scalingStruct: a struct
- //! containing the grid nodes which are part of the interpolation \param scalingName: the name of the checked
- //! scaling function
- void checkScalingFunction(const gridScalingCF &scalingFunctionCF, const InterpolationCellCF &scalingStruct,
- const std::string &scalingName)
- {
- if (!scalingFunctionCF && scalingStruct.kCF > 0)
- throw std::runtime_error("The scaling function " + scalingName + " was not set!");
- if (scalingFunctionCF && scalingStruct.kCF == 0)
+ if (scalingFunction && scalingStruct.numberOfCells == 0)
VF_LOG_WARNING("The scaling function {} was set, although there is no refinement", scalingName);
}
SPtr<Parameter> para;
- gridScalingFC scalingFineToCoarse = nullptr;
- gridScalingCF scalingCoarseToFine = nullptr;
+ gridScaling scalingFineToCoarse = nullptr;
+ gridScaling scalingCoarseToFine = nullptr;
};
#endif
diff --git a/src/gpu/VirtualFluids_GPU/LBM/LB.h b/src/gpu/VirtualFluids_GPU/LBM/LB.h
index cfdbbbae040a13f94e97d40d702b93d5a1e19c86..d01c2c80cdb252be72f442505133a1382c816b30 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/LB.h
+++ b/src/gpu/VirtualFluids_GPU/LBM/LB.h
@@ -164,30 +164,19 @@ struct InitCondition
};
//Interface Cells
-typedef struct ICellCF{
- uint* ICellCFF;
- uint* ICellCFC;
- uint kCF;
-} InterpolationCellCF;
-
-typedef struct ICellFC{
- uint* ICellFCF;
- uint* ICellFCC;
- uint kFC;
-} InterpolationCellFC;
-
-//Offset of the interface cells at the wall
-typedef struct OffCF{
- real* xOffCF;
- real* yOffCF;
- real* zOffCF;
-} OffsetCF;
-
-typedef struct OffFC{
- real* xOffFC;
- real* yOffFC;
- real* zOffFC;
-} OffsetFC;
+// example of old names (pre 2023) ICellCFC: interpolation from Coarse (C) to Fine (F), indices of the Coarse cells (C)
+typedef struct ICells{
+ uint* fineCellIndices;
+ uint* coarseCellIndices;
+ uint numberOfCells;
+} InterpolationCells;
+
+//! \brief stores location of neighboring cell (necessary for refinement into the wall)
+typedef struct ICellNeigh{
+ real* x;
+ real* y;
+ real* z;
+} InterpolationCellNeighbor;
// Distribution functions g 6
typedef struct Distri6 {
diff --git a/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp b/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp
index 84ab84ff93fa7706bcc27d7e61a18f580f3c8dbe..a9c71e9550a31cc2572d1e231026a726eaa45345 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp
+++ b/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp
@@ -648,7 +648,7 @@ void Simulation::run()
para->getParD(0)->neighborZ,
para->getParD(0)->numberOfNodes,
para->getParD(0)->numberofthreads,
- para->getParD(0)->distributionsAD27.f[0],
+ para->getParD(0)->distributionsAD.f[0],
para->getParD(0)->isEvenTimestep);
getLastCudaError("PlaneConcThS27 execution failed");
PlaneConcThS27( para->getParD(0)->ConcPlaneOut1,
@@ -660,7 +660,7 @@ void Simulation::run()
para->getParD(0)->neighborZ,
para->getParD(0)->numberOfNodes,
para->getParD(0)->numberofthreads,
- para->getParD(0)->distributionsAD27.f[0],
+ para->getParD(0)->distributionsAD.f[0],
para->getParD(0)->isEvenTimestep);
getLastCudaError("PlaneConcThS27 execution failed");
PlaneConcThS27( para->getParD(0)->ConcPlaneOut2,
@@ -672,7 +672,7 @@ void Simulation::run()
para->getParD(0)->neighborZ,
para->getParD(0)->numberOfNodes,
para->getParD(0)->numberofthreads,
- para->getParD(0)->distributionsAD27.f[0],
+ para->getParD(0)->distributionsAD.f[0],
para->getParD(0)->isEvenTimestep);
getLastCudaError("PlaneConcThS27 execution failed");
//////////////////////////////////////////////////////////////////////////////////
@@ -837,7 +837,7 @@ void Simulation::run()
{
if (para->getDiffMod() == 7)
{
- CalcMacThS7( para->getParD(lev)->Conc,
+ CalcMacThS7( para->getParD(lev)->concentration,
para->getParD(lev)->typeOfGridNode,
para->getParD(lev)->neighborX,
para->getParD(lev)->neighborY,
@@ -852,13 +852,13 @@ void Simulation::run()
{
CalcConcentration27(
para->getParD(lev)->numberofthreads,
- para->getParD(lev)->Conc,
+ para->getParD(lev)->concentration,
para->getParD(lev)->typeOfGridNode,
para->getParD(lev)->neighborX,
para->getParD(lev)->neighborY,
para->getParD(lev)->neighborZ,
para->getParD(lev)->numberOfNodes,
- para->getParD(lev)->distributionsAD27.f[0],
+ para->getParD(lev)->distributionsAD.f[0],
para->getParD(lev)->isEvenTimestep);
}
@@ -1214,7 +1214,7 @@ Simulation::~Simulation()
for (int lev = para->getCoarse(); lev < para->getFine(); lev++)
{
checkCudaErrors(cudaFreeHost(para->getParH(lev)->Conc_Full));
- checkCudaErrors(cudaFreeHost(para->getParH(lev)->Conc));
+ checkCudaErrors(cudaFreeHost(para->getParH(lev)->concentration));
checkCudaErrors(cudaFreeHost(para->getParH(lev)->Temp.temp));
checkCudaErrors(cudaFreeHost(para->getParH(lev)->Temp.k));
checkCudaErrors(cudaFreeHost(para->getParH(lev)->TempVel.temp));
diff --git a/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp b/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp
index edf705421530bdbc9c2c9fd8c44eca6d3c5ab923..7169a82de21c3a6a479386a25670f7c0c75447f2 100644
--- a/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp
+++ b/src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp
@@ -379,7 +379,7 @@ void FileWriter::writeUnstrucuredGridLTConc(std::shared_ptr<Parameter> para, int
nodedata[3][dn1] = (double)para->getParH(level)->velocityY[pos] * (double)para->getVelocityRatio();
nodedata[4][dn1] = (double)para->getParH(level)->velocityZ[pos] * (double)para->getVelocityRatio();
nodedata[5][dn1] = (double)para->getParH(level)->typeOfGridNode[pos];
- nodedata[6][dn1] = (double)para->getParH(level)->Conc[pos];
+ nodedata[6][dn1] = (double)para->getParH(level)->concentration[pos];
//////////////////////////////////////////////////////////////////////////
number2 = para->getParH(level)->neighborX[number1];
number3 = para->getParH(level)->neighborY[number2];
diff --git a/src/gpu/VirtualFluids_GPU/Output/InterfaceDebugWriter.hpp b/src/gpu/VirtualFluids_GPU/Output/InterfaceDebugWriter.hpp
index 4d5895b323efa1b94a5780a59c882fd5ce1be7eb..1989f93159c4b00b340f2b8dd184f6e6c215f679 100644
--- a/src/gpu/VirtualFluids_GPU/Output/InterfaceDebugWriter.hpp
+++ b/src/gpu/VirtualFluids_GPU/Output/InterfaceDebugWriter.hpp
@@ -46,8 +46,7 @@ void writeInterfaceLinesDebugCF(Parameter *para)
{
for (int level = 0; level < para->getMaxLevel(); level++) {
const std::string fileName = para->getFName() + "_" + StringUtil::toString<int>(level) + "_OffDebugCF.vtk";
- writeGridInterfaceLines(para, level, para->getParH(level)->intCF.ICellCFC, para->getParH(level)->intCF.ICellCFF,
- para->getParH(level)->K_CF, fileName);
+ writeGridInterfaceLines(para, level, para->getParH(level)->coarseToFine.coarseCellIndices, para->getParH(level)->coarseToFine.fineCellIndices, para->getParH(level)->coarseToFine.numberOfCells, fileName);
}
}
@@ -55,8 +54,7 @@ void writeInterfaceLinesDebugFC(Parameter *para)
{
for (int level = 0; level < para->getMaxLevel(); level++) {
const std::string fileName = para->getFName() + "_" + StringUtil::toString<int>(level) + "_OffDebugFC.vtk";
- writeGridInterfaceLines(para, level, para->getParH(level)->intFC.ICellFCC, para->getParH(level)->intFC.ICellFCF,
- para->getParH(level)->K_FC, fileName);
+ writeGridInterfaceLines(para, level, para->getParH(level)->fineToCoarse.coarseCellIndices, para->getParH(level)->fineToCoarse.fineCellIndices, para->getParH(level)->fineToCoarse.numberOfCells, fileName);
}
}
@@ -90,7 +88,7 @@ void writeInterfaceLinesDebugCFCneighbor(Parameter *para)
{
for (int level = 0; level < para->getMaxLevel(); level++) {
std::string filename = para->getFName() + "_" + StringUtil::toString<int>(level) + "_CFCneighbor.vtk";
- writeGridInterfaceLinesNeighbors(para, level, para->getParH(level)->intCF.ICellCFC, para->getParH(level)->K_CF,
+ writeGridInterfaceLinesNeighbors(para, level, para->getParH(level)->coarseToFine.coarseCellIndices, para->getParH(level)->coarseToFine.numberOfCells,
filename);
}
}
@@ -100,8 +98,7 @@ void writeInterfaceLinesDebugCFFneighbor(Parameter *para)
{
for (int level = 0; level < para->getMaxLevel(); level++) {
std::string filename = para->getFName() + "_" + StringUtil::toString<int>(level) + "_CFFneighbor.vtk";
- writeGridInterfaceLinesNeighbors(para, level + 1, para->getParH(level)->intCF.ICellCFF,
- para->getParH(level)->K_CF, filename);
+ writeGridInterfaceLinesNeighbors(para, level + 1, para->getParH(level)->coarseToFine.fineCellIndices, para->getParH(level)->coarseToFine.numberOfCells, filename);
}
}
@@ -110,7 +107,7 @@ void writeInterfaceLinesDebugFCCneighbor(Parameter *para)
{
for (int level = 0; level < para->getMaxLevel(); level++) {
std::string filename = para->getFName() + "_" + StringUtil::toString<int>(level) + "_FCCneighbor.vtk";
- writeGridInterfaceLinesNeighbors(para, level, para->getParH(level)->intFC.ICellFCC, para->getParH(level)->K_FC,
+ writeGridInterfaceLinesNeighbors(para, level, para->getParH(level)->fineToCoarse.coarseCellIndices, para->getParH(level)->fineToCoarse.numberOfCells,
filename);
}
}
@@ -120,8 +117,7 @@ void writeInterfaceLinesDebugFCFneighbor(Parameter *para)
{
for (int level = 0; level < para->getMaxLevel(); level++) {
std::string filename = para->getFName() + "_" + StringUtil::toString<int>(level) + "_FCFneighbor.vtk";
- writeGridInterfaceLinesNeighbors(para, level + 1, para->getParH(level)->intFC.ICellFCF,
- para->getParH(level)->K_FC, filename);
+ writeGridInterfaceLinesNeighbors(para, level + 1, para->getParH(level)->fineToCoarse.fineCellIndices, para->getParH(level)->fineToCoarse.numberOfCells, filename);
}
}
@@ -134,17 +130,17 @@ void writeInterfaceLinesDebugOff(Parameter *para)
for (int level = 0; level < para->getMaxLevel(); level++) // evtl. Maxlevel + 1
{
- nodeNumberVec += (int)para->getParH(level)->K_CF;
+ nodeNumberVec += (int)para->getParH(level)->coarseToFine.numberOfCells;
}
nodesVec.resize(nodeNumberVec * 8);
int nodeCount = 0;
for (int level = 0; level < para->getMaxLevel(); level++) {
- for (unsigned int u = 0; u < para->getParH(level)->K_CF; u++) {
- double xoff = para->getParH(level)->offCF.xOffCF[u];
- double yoff = para->getParH(level)->offCF.yOffCF[u];
- double zoff = para->getParH(level)->offCF.zOffCF[u];
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++) {
+ double xoff = para->getParH(level)->neighborCoarseToFine.x[u];
+ double yoff = para->getParH(level)->neighborCoarseToFine.y[u];
+ double zoff = para->getParH(level)->neighborCoarseToFine.z[u];
- int posFine = para->getParH(level)->intCF.ICellCFF[u];
+ int posFine = para->getParH(level)->coarseToFine.fineCellIndices[u];
double x1Fine = para->getParH(level + 1)->coordinateX[posFine];
double x2Fine = para->getParH(level + 1)->coordinateY[posFine];
@@ -175,13 +171,13 @@ void writeInterfacePointsDebugCFC(Parameter *para)
for (int level = 0; level < para->getMaxLevel(); level++) // evtl. Maxlevel + 1
{
- nodeNumberVec += (int)para->getParH(level)->K_CF;
+ nodeNumberVec += (int)para->getParH(level)->coarseToFine.numberOfCells;
}
nodesVec2.resize(nodeNumberVec * 8);
int nodeCount2 = 0;
for (int level = 0; level < para->getMaxLevel(); level++) {
- for (unsigned int u = 0; u < para->getParH(level)->K_CF; u++) {
- int pos = para->getParH(level)->intCF.ICellCFC[u];
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++) {
+ int pos = para->getParH(level)->coarseToFine.coarseCellIndices[u];
double x1 = para->getParH(level)->coordinateX[pos];
double x2 = para->getParH(level)->coordinateY[pos];
@@ -467,13 +463,13 @@ void writeInterfaceCellsDebugCFC(Parameter *para)
int nodeNumberVec = 0;
for (int level = 0; level < para->getMaxLevel(); level++) // evtl. Maxlevel + 1
{
- nodeNumberVec += (int)para->getParH(level)->K_CF;
+ nodeNumberVec += (int)para->getParH(level)->coarseToFine.numberOfCells;
}
nodesVec.resize(nodeNumberVec * 8);
int nodeCount = 0;
for (int level = 0; level < para->getMaxLevel(); level++) {
- for (unsigned int u = 0; u < para->getParH(level)->K_CF; u++) {
- int pos = para->getParH(level)->intCF.ICellCFC[u];
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++) {
+ int pos = para->getParH(level)->coarseToFine.coarseCellIndices[u];
double x1 = para->getParH(level)->coordinateX[pos];
double x2 = para->getParH(level)->coordinateY[pos];
@@ -508,13 +504,13 @@ void writeInterfaceCellsDebugCFF(Parameter *para)
int nodeNumberVec = 0;
for (int level = 0; level < para->getMaxLevel(); level++) // evtl. Maxlevel + 1
{
- nodeNumberVec += (int)para->getParH(level)->K_CF;
+ nodeNumberVec += (int)para->getParH(level)->coarseToFine.numberOfCells;
}
nodesVec.resize(nodeNumberVec * 8);
int nodeCount = 0;
for (int level = 0; level < para->getMaxLevel(); level++) {
- for (unsigned int u = 0; u < para->getParH(level)->K_CF; u++) {
- int pos = para->getParH(level)->intCF.ICellCFF[u];
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++) {
+ int pos = para->getParH(level)->coarseToFine.fineCellIndices[u];
double x1 = para->getParH(level + 1)->coordinateX[pos];
double x2 = para->getParH(level + 1)->coordinateY[pos];
@@ -620,7 +616,7 @@ void writeInterfaceFCC_Send(Parameter *para)
std::vector<std::vector<double>> nodedata;
for (int level = 0; level < para->getMaxLevel(); level++) {
- nodeNumberVec += (int)para->getParH(level)->intFC.kFC;
+ nodeNumberVec += (int)para->getParH(level)->fineToCoarse.numberOfCells;
}
nodesVec.resize(nodeNumberVec);
@@ -628,8 +624,8 @@ void writeInterfaceFCC_Send(Parameter *para)
int nodeCount = 0;
for (int level = 0; level < para->getMaxLevel(); level++) {
- for (unsigned int u = 0; u < para->getParH(level)->intFC.kFC; u++) {
- int pos = para->getParH(level)->intFC.ICellFCC[u];
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++) {
+ int pos = para->getParH(level)->fineToCoarse.coarseCellIndices[u];
nodedata[0][nodeCount] = pos;
// coordinate section
@@ -639,7 +635,7 @@ void writeInterfaceFCC_Send(Parameter *para)
nodesVec[nodeCount] = (makeUbTuple((float)(x1), (float)(x2), (float)(x3)));
// nodedata section
- nodedata[1][nodeCount] = u < para->getParH(level)->intFCBorder.kFC;
+ nodedata[1][nodeCount] = u < para->getParH(level)->fineToCoarseBorder.numberOfCells;
int sendDir = 0.0;
int sendDirectionInCommAfterFtoC = 0.0;
int sendIndex = 0.0;
@@ -674,7 +670,7 @@ void writeInterfaceCFC_Recv(Parameter *para)
std::vector<std::vector<double>> nodedata;
for (int level = 0; level < para->getMaxLevel(); level++) {
- nodeNumberVec += (int)para->getParH(level)->intCF.kCF;
+ nodeNumberVec += (int)para->getParH(level)->coarseToFine.numberOfCells;
}
nodesVec.resize(nodeNumberVec);
@@ -682,8 +678,8 @@ void writeInterfaceCFC_Recv(Parameter *para)
int nodeCount = 0;
for (int level = 0; level < para->getMaxLevel(); level++) {
- for (unsigned int u = 0; u < para->getParH(level)->intCF.kCF; u++) {
- int pos = para->getParH(level)->intCF.ICellCFC[u];
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++) {
+ int pos = para->getParH(level)->coarseToFine.coarseCellIndices[u];
nodedata[0][nodeCount] = pos;
// coordinate section
@@ -693,7 +689,7 @@ void writeInterfaceCFC_Recv(Parameter *para)
nodesVec[nodeCount] = (makeUbTuple((float)(x1), (float)(x2), (float)(x3)));
// nodedata section
- nodedata[1][nodeCount] = u < para->getParH(level)->intCFBorder.kCF;
+ nodedata[1][nodeCount] = u < para->getParH(level)->coarseToFineBorder.numberOfCells;
int recvDir = 0.0;
int recvDirectionInCommAfterFtoC = 0.0;
int recvIndex = 0.0;
@@ -799,12 +795,12 @@ void writeSendNodesStream(Parameter *para)
}
}
- // check if node is in iCellFCC
+ // check if node is in a coarse cell for the interpolation from fine to coarse
nodedata[4].resize(nodedata[0].size());
for (int i = 0; i < (int)nodedata[0].size(); i++) {
pos = nodedata[0][i];
- for (unsigned int u = 0; u < para->getParH(level)->intFC.kFC; u++) {
- if (para->getParH(level)->intFC.ICellFCC[u] == (uint)pos) {
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++) {
+ if (para->getParH(level)->fineToCoarse.coarseCellIndices[u] == (uint)pos) {
nodedata[4][i] = 1.0;
break;
}
@@ -895,7 +891,7 @@ void writeRecvNodesStream(Parameter *para)
}
}
- // Recv are nodes ghost nodes and therefore they can't be iCellCFCs
+ // Recv are nodes ghost nodes and therefore they can't be coarse cells for the interpolation from coarse to fine
std::string filenameVec = para->getFName() + "_writeRecvNodesStreams_PID_" +
std::to_string(vf::gpu::Communicator::getInstance().getPID()) + "_" +
diff --git a/src/gpu/VirtualFluids_GPU/Output/OffsetWriter.hpp b/src/gpu/VirtualFluids_GPU/Output/OffsetWriter.hpp
index 7aa660fa33d8ad31a19053e3511241de3ee07c07..fb04951db68ae509dddc7d2fe52250489b54bde2 100644
--- a/src/gpu/VirtualFluids_GPU/Output/OffsetWriter.hpp
+++ b/src/gpu/VirtualFluids_GPU/Output/OffsetWriter.hpp
@@ -21,13 +21,13 @@ public:
{
for (int level = 0; level < para->getMaxLevel(); level++)
{
- out.writeInteger(para->getParH(level)->K_CF);
+ out.writeInteger(para->getParH(level)->coarseToFine.numberOfCells);
out.writeLine();
- for(unsigned int u=0; u<para->getParH(level)->K_CF; u++)
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++)
{
- out.writeDouble(para->getParH(level)->offCF.xOffCF[u]);
- out.writeDouble(para->getParH(level)->offCF.yOffCF[u]);
- out.writeDouble(para->getParH(level)->offCF.zOffCF[u]);
+ out.writeDouble(para->getParH(level)->neighborCoarseToFine.x[u]);
+ out.writeDouble(para->getParH(level)->neighborCoarseToFine.y[u]);
+ out.writeDouble(para->getParH(level)->neighborCoarseToFine.z[u]);
}
out.writeLine();
} //end levelloop
@@ -36,13 +36,13 @@ public:
{
for (int level = 0; level < para->getMaxLevel(); level++)
{
- out.writeInteger(para->getParH(level)->K_FC);
+ out.writeInteger(para->getParH(level)->fineToCoarse.numberOfCells);
out.writeLine();
- for(unsigned int u=0; u<para->getParH(level)->K_FC; u++)
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++)
{
- out.writeDouble(para->getParH(level)->offFC.xOffFC[u]);
- out.writeDouble(para->getParH(level)->offFC.yOffFC[u]);
- out.writeDouble(para->getParH(level)->offFC.zOffFC[u]);
+ out.writeDouble(para->getParH(level)->neighborFineToCoarse.x[u]);
+ out.writeDouble(para->getParH(level)->neighborFineToCoarse.y[u]);
+ out.writeDouble(para->getParH(level)->neighborFineToCoarse.z[u]);
}
out.writeLine();
} //end levelloop
diff --git a/src/gpu/VirtualFluids_GPU/Output/PosVecIntWriter.hpp b/src/gpu/VirtualFluids_GPU/Output/PosVecIntWriter.hpp
index a9207ed231e8d9667e57636a5a5fdd6b5aeab94f..d7eab31d639d23d2356263aa8b152d69b3c042b8 100644
--- a/src/gpu/VirtualFluids_GPU/Output/PosVecIntWriter.hpp
+++ b/src/gpu/VirtualFluids_GPU/Output/PosVecIntWriter.hpp
@@ -38,11 +38,11 @@ public:
{
for (int level = 0; level < para->getMaxLevel(); level++)
{
- out.writeInteger(para->getParH(level)->K_CF);
+ out.writeInteger(para->getParH(level)->coarseToFine.numberOfCells);
out.writeLine();
- for(unsigned int u=0; u<para->getParH(level)->K_CF; u++)
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++)
{
- out.writeInteger(para->getParH(level)->intCF.ICellCFC[u]);
+ out.writeInteger(para->getParH(level)->coarseToFine.coarseCellIndices[u]);
}
out.writeLine();
} //end levelloop
@@ -51,11 +51,11 @@ public:
{
for (int level = 0; level < para->getMaxLevel(); level++)
{
- out.writeInteger(para->getParH(level)->K_CF);
+ out.writeInteger(para->getParH(level)->coarseToFine.numberOfCells);
out.writeLine();
- for(unsigned int u=0; u<para->getParH(level)->K_CF; u++)
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++)
{
- out.writeInteger(para->getParH(level)->intCF.ICellCFF[u]);
+ out.writeInteger(para->getParH(level)->coarseToFine.fineCellIndices[u]);
}
out.writeLine();
} //end levelloop
@@ -64,11 +64,11 @@ public:
{
for (int level = 0; level < para->getMaxLevel(); level++)
{
- out.writeInteger(para->getParH(level)->K_FC);
+ out.writeInteger(para->getParH(level)->fineToCoarse.numberOfCells);
out.writeLine();
- for(unsigned int u=0; u<para->getParH(level)->K_FC; u++)
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++)
{
- out.writeInteger(para->getParH(level)->intFC.ICellFCC[u]);
+ out.writeInteger(para->getParH(level)->fineToCoarse.coarseCellIndices[u]);
}
out.writeLine();
} //end levelloop
@@ -77,11 +77,11 @@ public:
{
for (int level = 0; level < para->getMaxLevel(); level++)
{
- out.writeInteger(para->getParH(level)->K_FC);
+ out.writeInteger(para->getParH(level)->fineToCoarse.numberOfCells);
out.writeLine();
- for(unsigned int u=0; u<para->getParH(level)->K_FC; u++)
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++)
{
- out.writeInteger(para->getParH(level)->intFC.ICellFCF[u]);
+ out.writeInteger(para->getParH(level)->fineToCoarse.fineCellIndices[u]);
}
out.writeLine();
} //end levelloop
diff --git a/src/gpu/VirtualFluids_GPU/Output/UnstructuredGridWriter.hpp b/src/gpu/VirtualFluids_GPU/Output/UnstructuredGridWriter.hpp
index f26b4e5795466a72aa1894de37bdb066b9ab9d04..cafe70205455ae8592c1efe86e4ba9de8e1ba170 100644
--- a/src/gpu/VirtualFluids_GPU/Output/UnstructuredGridWriter.hpp
+++ b/src/gpu/VirtualFluids_GPU/Output/UnstructuredGridWriter.hpp
@@ -814,7 +814,7 @@ namespace UnstructuredGridWriter
nodedata[3][dn1] = (double)para->getParH(level)->velocityY[pos] * (double)para->getVelocityRatio();
nodedata[4][dn1] = (double)para->getParH(level)->velocityZ[pos] * (double)para->getVelocityRatio();
nodedata[5][dn1] = (double)para->getParH(level)->typeOfGridNode[pos];
- nodedata[6][dn1] = (double)para->getParH(level)->Conc[pos];
+ nodedata[6][dn1] = (double)para->getParH(level)->concentration[pos];
//////////////////////////////////////////////////////////////////////////
number2 = para->getParH(level)->neighborX[number1];
number3 = para->getParH(level)->neighborY[number2];
diff --git a/src/gpu/VirtualFluids_GPU/Output/interfaceWriter.hpp b/src/gpu/VirtualFluids_GPU/Output/interfaceWriter.hpp
index f140b15a6b7595a959139da2a35ed58f01b2a307..bf35411b93fd1f126cfdde1f3739f1baa33a4d83 100644
--- a/src/gpu/VirtualFluids_GPU/Output/interfaceWriter.hpp
+++ b/src/gpu/VirtualFluids_GPU/Output/interfaceWriter.hpp
@@ -32,11 +32,11 @@ public:
{
if ((Type == "_InterfaceCFC") || (Type == "_InterfaceCFF"))
{
- nodeNumberVec += para->getParH(level)->K_CF;
+ nodeNumberVec += para->getParH(level)->coarseToFine.numberOfCells;
}
else if (Type == "_InterfaceFCF")
{
- nodeNumberVec += para->getParH(level)->K_FC;
+ nodeNumberVec += para->getParH(level)->fineToCoarse.numberOfCells;
}
}
nodesVec.resize(nodeNumberVec*8);
@@ -55,9 +55,9 @@ public:
//std::vector<unsigned int>& posVec = posIndexVec[level];
if (Type == "_InterfaceCFC")
{
- for(unsigned int u=0;u<para->getParH(level)->K_CF;u++)
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++)
{
- int pos = para->getParH(level)->intCF.ICellCFC[u];
+ int pos = para->getParH(level)->coarseToFine.coarseCellIndices[u];
int ix1 = pos % nx1lev;
int wertDurchNx1 = pos / nx1lev;
int ix2 = wertDurchNx1 % nx2lev;
@@ -82,9 +82,9 @@ public:
}
else if (Type == "_InterfaceCFF")
{
- for(unsigned int u=0;u<para->getParH(level)->K_CF;u++)
+ for (unsigned int u = 0; u < para->getParH(level)->coarseToFine.numberOfCells; u++)
{
- int pos = para->getParH(level)->intCF.ICellCFF[u];
+ int pos = para->getParH(level)->coarseToFine.fineCellIndices[u];
int ix1 = pos % nx1lev;
int wertDurchNx1 = pos / nx1lev;
int ix2 = wertDurchNx1 % nx2lev;
@@ -109,9 +109,9 @@ public:
}
else if (Type == "_InterfaceFCF")
{
- for(unsigned int u=0;u<para->getParH(level)->K_FC;u++)
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++)
{
- int pos = para->getParH(level)->intFC.ICellFCF[u];
+ int pos = para->getParH(level)->fineToCoarse.fineCellIndices[u];
int ix1 = pos % nx1lev;
int wertDurchNx1 = pos / nx1lev;
int ix2 = wertDurchNx1 % nx2lev;
@@ -146,7 +146,7 @@ public:
int nodeNumberVec = 0;
for (int level = 0; level < para->getMaxLevel(); level++)
{
- nodeNumberVec += para->getParH(level)->K_FC;
+ nodeNumberVec += para->getParH(level)->fineToCoarse.numberOfCells;
}
nodesVec.resize(nodeNumberVec*8);
int nodeCount = 0;
@@ -163,9 +163,9 @@ public:
double achtelNodeDelta = 0.125*nodeDeltaLevel;
//int count = 0;
//std::vector<unsigned int>& posVec = posIndexVec[level];
- for(unsigned int u=0;u<para->getParH(level)->K_FC;u++)
+ for (unsigned int u = 0; u < para->getParH(level)->fineToCoarse.numberOfCells; u++)
{
- int pos = para->getParH(level)->intFC.ICellFCC[u];//posVec[u];
+ int pos = para->getParH(level)->fineToCoarse.coarseCellIndices[u];//posVec[u];
int ix1 = pos % nx1lev;
int wertDurchNx1 = pos / nx1lev;
int ix2 = wertDurchNx1 % nx2lev;
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
index e593d16d6ed1f69ca65a22606a157e7ea9e6b111..9a7f92a96e51cb1fb9c2138721ba5e3143b84ebe 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
@@ -493,9 +493,9 @@ void Parameter::initLBMSimulationParameter()
parH[i]->gridNX = getGridX().at(i);
parH[i]->gridNY = getGridY().at(i);
parH[i]->gridNZ = getGridZ().at(i);
- parH[i]->vis = ic.vis * pow(2.f, i);
- parH[i]->diffusivity = ic.Diffusivity * pow(2.f, i);
- parH[i]->omega = 1.0f / (3.0f * parH[i]->vis + 0.5f); // omega :-) not s9 = -1.0f/(3.0f*parH[i]->vis+0.5f);//
+ parH[i]->viscosity = ic.vis * pow((real)2.0, i);
+ parH[i]->diffusivity = ic.Diffusivity * pow((real)2.0, i);
+ parH[i]->omega = (real)1.0 / (real(3.0) * parH[i]->viscosity + real(0.5)); // omega :-) not s9 = -1.0f/(3.0f*parH[i]->vis+0.5f);//
parH[i]->nx = parH[i]->gridNX + 2 * STARTOFFX;
parH[i]->ny = parH[i]->gridNY + 2 * STARTOFFY;
parH[i]->nz = parH[i]->gridNZ + 2 * STARTOFFZ;
@@ -510,10 +510,10 @@ void Parameter::initLBMSimulationParameter()
parH[i]->isEvenTimestep = true;
parH[i]->startz = parH[i]->gridNZ * ic.myProcessId;
parH[i]->endz = parH[i]->gridNZ * ic.myProcessId + parH[i]->gridNZ;
- parH[i]->Lx = (real)((1.f * parH[i]->gridNX - 1.f) / (pow(2.f, i)));
- parH[i]->Ly = (real)((1.f * parH[i]->gridNY - 1.f) / (pow(2.f, i)));
- parH[i]->Lz = (real)((1.f * parH[i]->gridNZ - 1.f) / (pow(2.f, i)));
- parH[i]->dx = (real)(1.f / (pow(2.f, i)));
+ parH[i]->Lx = ((real)1.0 * parH[i]->gridNX - (real)1.0) / (pow((real)2.0, i));
+ parH[i]->Ly = ((real)1.0 * parH[i]->gridNY - (real)1.0) / (pow((real)2.0, i));
+ parH[i]->Lz = ((real)1.0 * parH[i]->gridNZ - (real)1.0) / (pow((real)2.0, i));
+ parH[i]->dx = (real)1.0 / pow((real)2.0, i);
parH[i]->XdistKn = getDistX().at(i);
parH[i]->YdistKn = getDistY().at(i);
parH[i]->ZdistKn = getDistZ().at(i);
@@ -521,12 +521,12 @@ void Parameter::initLBMSimulationParameter()
parH[i]->distX = (real)getDistX().at(i);
parH[i]->distY = (real)getDistY().at(i);
parH[i]->distZ = (real)getDistZ().at(i);
- parH[i]->mTtoWx = (real)1.0f;
- parH[i]->mTtoWy = (real)1.0f;
- parH[i]->mTtoWz = (real)1.0f;
- parH[i]->cTtoWx = (real)0.0f;
- parH[i]->cTtoWy = (real)0.0f;
- parH[i]->cTtoWz = (real)0.0f;
+ parH[i]->mTtoWx = (real)1.0;
+ parH[i]->mTtoWy = (real)1.0;
+ parH[i]->mTtoWz = (real)1.0;
+ parH[i]->cTtoWx = (real)0.0;
+ parH[i]->cTtoWy = (real)0.0;
+ parH[i]->cTtoWz = (real)0.0;
////MGs Trafo///////////////////////////////////////////////////////////////
// parH[i]->cStartx = (real)parH[i]->XdistKn;
// parH[i]->cStarty = (real)parH[i]->XdistKn;
@@ -534,9 +534,9 @@ void Parameter::initLBMSimulationParameter()
////////////////////////////////////////////////////////////////////////////
} else {
// Geller
- parH[i]->distX = ((real)getDistX().at(i) + 0.25f) * parH[i - 1]->dx;
- parH[i]->distY = ((real)getDistY().at(i) + 0.25f) * parH[i - 1]->dx;
- parH[i]->distZ = ((real)getDistZ().at(i) + 0.25f) * parH[i - 1]->dx;
+ parH[i]->distX = ((real)getDistX().at(i) + (real)0.25) * parH[i - 1]->dx;
+ parH[i]->distY = ((real)getDistY().at(i) + (real)0.25) * parH[i - 1]->dx;
+ parH[i]->distZ = ((real)getDistZ().at(i) + (real)0.25) * parH[i - 1]->dx;
// parH[i]->distX = ((real)getDistX().at(i) + 0.25f) * parH[i-1]->dx + parH[i-1]->distX;
// parH[i]->distY = ((real)getDistY().at(i) + 0.25f) * parH[i-1]->dx + parH[i-1]->distY;
// parH[i]->distZ = ((real)getDistZ().at(i) + 0.25f) * parH[i-1]->dx + parH[i-1]->distZ;
@@ -561,7 +561,7 @@ void Parameter::initLBMSimulationParameter()
parD[i]->gridNX = parH[i]->gridNX;
parD[i]->gridNY = parH[i]->gridNY;
parD[i]->gridNZ = parH[i]->gridNZ;
- parD[i]->vis = parH[i]->vis;
+ parD[i]->viscosity = parH[i]->viscosity;
parD[i]->diffusivity = parH[i]->diffusivity;
parD[i]->omega = parH[i]->omega;
parD[i]->nx = parH[i]->nx;
@@ -598,7 +598,7 @@ void Parameter::checkParameterValidityCumulantK17() const
if (this->mainKernel != "CumulantK17")
return;
- const real viscosity = this->parH[maxlevel]->vis;
+ const real viscosity = this->parH[maxlevel]->viscosity;
const real viscosityLimit = 1.0 / 42.0;
if (viscosity > viscosityLimit) {
VF_LOG_WARNING("The viscosity (in LB units) at level {} is {:1.3g}. It is recommended to keep it smaller than {:1.3g} "
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
index fa45b1742f20e32258195c78b630ce95175af938..cfd13d62be45135d40f69e1f9c6b6d69303b6c9c 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
@@ -85,11 +85,90 @@ struct LBMSimulationParameter {
real *velocityX, *velocityY, *velocityZ, *rho, *pressure;
//! \brief stores the value for omega
real omega;
+ //! \brief stores the value for viscosity
+ real viscosity;
//////////////////////////////////////////////////////////////////////////
//! \brief stores the number of nodes (based on indirect addressing scheme)
unsigned long long numberOfNodes;
//! \brief stores the size of the memory consumption for real/int values of the arrays (e.g. coordinates, velocity)
unsigned long long memSizeRealLBnodes, memSizeLonglongLBnodes;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the slip boundary condition data
+ QforBoundaryConditions slipBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the no slip boundary condition data
+ QforBoundaryConditions noSlipBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the velocity boundary condition data
+ QforBoundaryConditions velocityBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the geometry boundary condition data
+ QforBoundaryConditions geometryBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the pressure boundary condition data
+ QforBoundaryConditions pressureBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the outflow boundary condition data
+ QforBoundaryConditions outflowBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the stress boundary condition data
+ QforBoundaryConditions stressBC;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the precursor boundary condition data
+ QforPrecursorBoundaryConditions precursorBC;
+
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief sets a uniform forcing on each fluid node in all three spatial dimensions
+ real *forcing;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores parameters for a wall model
+ WallModelParameters wallModel;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief allows reading values for a boundary condition from a file
+ std::vector<SPtr<TransientBCInputFileReader>> transientBCInputFileReader;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief can be used for pressure correction at outflow boundary condition
+ real outflowPressureCorrectionFactor;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief store the values of body forces for all 3 dimensions
+ real *forceX_SP, *forceY_SP, *forceZ_SP;
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // Advection Diffusion
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the diffusivity
+ real diffusivity;
+ //! \brief stores the value for omega (for the diffusivity)
+ real omegaDiffusivity;
+ //! \brief stores a field of concentration values
+ real *concentration;
+ //! \brief store all distribution functions for the D3Q27 advection diffusion field
+ Distributions27 distributionsAD;
+ //////////////////////////////////////////////////////////////////////////
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // Grid Refinement
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores the base-node-indices of coarse and fine refinement cells
+ InterpolationCells coarseToFine;
+ InterpolationCells fineToCoarse;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief distinguish between bulk and border interpolation cells (necessary for communication hiding)
+ InterpolationCells fineToCoarseBorder;
+ InterpolationCells fineToCoarseBulk;
+ InterpolationCells coarseToFineBorder;
+ InterpolationCells coarseToFineBulk;
+ //////////////////////////////////////////////////////////////////////////
+ //! \brief stores location of neighboring cell (necessary for refinement into the wall)
+ InterpolationCellNeighbor neighborCoarseToFine;
+ InterpolationCellNeighbor neighborCoarseToFineBulk;
+ InterpolationCellNeighbor neighborFineToCoarse;
+ InterpolationCellNeighbor neighborFineToCoarseBulk;
+ //////////////////////////////////////////////////////////////////////////
+
+
@@ -97,7 +176,30 @@ struct LBMSimulationParameter {
//////////////////////////////////////////////////////////////////////////
- // DEPRECATED
+ // potential additional logic
+ //////////////////////////////////////////////////////////////////////////
+
+ // distributions F3////////
+ Distributions6 g6;
+
+ unsigned int size_Array_SP; //?? Deprecated
+
+ // BC NoSlip
+ TempforBoundaryConditions Temp;
+ // BC Velocity
+ TempVelforBoundaryConditions TempVel;
+ // BC Pressure
+ TempPressforBoundaryConditions TempPress;
+
+
+
+
+
+
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // DEPRECATED - planed to be taken out for next open source release
//////////////////////////////////////////////////////////////////////////
// distributions///////////
@@ -116,50 +218,36 @@ struct LBMSimulationParameter {
//unsigned int mem_size_int;
//unsigned int mem_size_real;
- //////////////////////////////////////////////////////////////////////////
+ QforBoundaryConditions QpressX0, QpressX1, QpressY0, QpressY1, QpressZ0, QpressZ1; // DEPRECATED BCs that are not used any more
+ QforBoundaryConditions QInlet, QOutlet, QPeriodic; // DEPRECATED BCs that are not used any more
+ unsigned int kInletQread, kOutletQread; // DEPRECATED
+ QforBoundaryConditions propellerBC; // DEPRECATED
+ QforBoundaryConditions geometryBCnormalX, geometryBCnormalY, geometryBCnormalZ; // DEPRECATED
+ QforBoundaryConditions inflowBCnormalX, inflowBCnormalY, inflowBCnormalZ; // DEPRECATED
+ QforBoundaryConditions outflowBCnormalX, outflowBCnormalY, outflowBCnormalZ; // DEPRECATED
+ unsigned int numberOfNoSlipBCnodesRead, numberOfVeloBCnodesRead, numberOfOutflowBCnodesRead, // DEPRECATED
+ numberOfSlipBCnodesRead, numberOfStressBCnodesRead, numberOfPressureBCnodesRead, numberOfPrecursorBCnodesRead; // DEPRECATED
+ //! \brief stores a full matrix field of concentration values
+ real *Conc_Full;
-
- //////////////////////////////////////////////////////////////////////////
- // additional logic
//////////////////////////////////////////////////////////////////////////
+ // \brief velocities to fit the force
+ real *VxForce, *VyForce, *VzForce;
- // distributions F3////////
- Distributions6 g6;
-
- unsigned int size_Array_SP;
-
-
- // memsizeSP/////////////////
-
-
-
- //////////////////////////////////////////////////////////////////////////
-
-
- // advection diffusion //////////////////
+ //! \brief stores indices for the concentration field
+ int *concIndex;
+ // real *concentration;
+ unsigned int numberOfPointsConc;
//! \brief store all distribution functions for the D3Q7 advection diffusion field
Distributions7 distributionsAD7;
- //! \brief store all distribution functions for the D3Q27 advection diffusion field
- Distributions27 distributionsAD27;
- //! \brief stores a field of concentration values
- real *Conc, *Conc_Full;
- //! \brief stores the diffusivity
- real diffusivity;
- //! \brief stores the value for omega (for the diffusivity)
- real omegaDiffusivity;
- // BC NoSlip
- TempforBoundaryConditions Temp;
- // BC Velocity
- TempVelforBoundaryConditions TempVel;
- // BC Pressure
- TempPressforBoundaryConditions TempPress;
// Plane Conc
real *ConcPlaneIn, *ConcPlaneOut1, *ConcPlaneOut2;
std::vector<double> PlaneConcVectorIn, PlaneConcVectorOut1, PlaneConcVectorOut2;
+
// trafo///////////////////
real mTtoWx, mTtoWy, mTtoWz;
real cTtoWx, cTtoWy, cTtoWz;
@@ -168,36 +256,19 @@ struct LBMSimulationParameter {
real cStartx, cStarty, cStartz;
real cFx, cFy, cFz;
-
- // body forces////////////
- real *forceX_SP, *forceY_SP, *forceZ_SP;
+ // interface////////////////
+ bool need_interface[6];
+ unsigned int XdistKn, YdistKn, ZdistKn;
// vel parab///////////////
real *vParab;
- // turbulent viscosity ///
- real *turbViscosity;
- real *gSij, *gSDij, *gDxvx, *gDyvx, *gDzvx, *gDxvy, *gDyvy, *gDzvy, *gDxvz, *gDyvz, *gDzvz; // DebugInformation
-
- // turbulence intensity //
- real *vx_mean, *vy_mean, *vz_mean; // means
- real *vxx, *vyy, *vzz, *vxy, *vxz, *vyz; // fluctuations
- std::vector<real> turbulenceIntensity;
-
// macroscopic values//////
// real *vx, *vy, *vz, *rho; // DEPRECATED: macroscopic values for full matrix
- //! \brief stores the value for viscosity (on level 0)
- real vis;
// derivations for iso test
real *dxxUx, *dyyUy, *dzzUz;
- // median-macro-values/////
- real *vx_SP_Med, *vy_SP_Med, *vz_SP_Med, *rho_SP_Med, *press_SP_Med;
- real *vx_SP_Med_Out, *vy_SP_Med_Out, *vz_SP_Med_Out, *rho_SP_Med_Out, *press_SP_Med_Out;
- // Advection-Diffusion
- real *Conc_Med, *Conc_Med_Out;
-
// grid////////////////////
unsigned int nx, ny, nz;
unsigned int gridNX, gridNY, gridNZ;
@@ -218,63 +289,51 @@ struct LBMSimulationParameter {
unsigned int sizePlanePressOUT, startPOUT;
bool isSetPress;
+ // deltaPhi
+ real deltaPhi;
+
+ // particles
+ PathLineParticles plp;
+
+
+ //////////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+
+
+ //////////////////////////////////////////////////////////////////////////
+
+
+
+ // turbulent viscosity ///
+ real *turbViscosity;
+ real *gSij, *gSDij, *gDxvx, *gDyvx, *gDzvx, *gDxvy, *gDyvy, *gDzvy, *gDxvz, *gDyvz, *gDzvz; // DebugInformation
+
+ // turbulence intensity //
+ real *vx_mean, *vy_mean, *vz_mean; // means
+ real *vxx, *vyy, *vzz, *vxy, *vxz, *vyz; // fluctuations
+ std::vector<real> turbulenceIntensity;
+
+
+ // median-macro-values/////
+ real *vx_SP_Med, *vy_SP_Med, *vz_SP_Med, *rho_SP_Med, *press_SP_Med;
+ real *vx_SP_Med_Out, *vy_SP_Med_Out, *vz_SP_Med_Out, *rho_SP_Med_Out, *press_SP_Med_Out;
+ // Advection-Diffusion
+ real *Conc_Med, *Conc_Med_Out;
+
// print///////////////////
unsigned int startz, endz;
real Lx, Ly, Lz, dx;
real distX, distY, distZ;
- // interface////////////////
- bool need_interface[6];
- unsigned int XdistKn, YdistKn, ZdistKn;
- InterpolationCellCF intCF;
- InterpolationCellFC intFC;
- unsigned int K_CF;
- unsigned int K_FC;
- unsigned int mem_size_kCF;
- unsigned int mem_size_kFC;
-
- InterpolationCellFC intFCBorder;
- InterpolationCellFC intFCBulk;
- InterpolationCellCF intCFBorder;
- InterpolationCellCF intCFBulk;
-
- // offset//////////////////
- OffsetCF offCF;
- OffsetCF offCFBulk;
- OffsetFC offFC;
- OffsetFC offFCBulk;
- unsigned int mem_size_kCF_off;
- unsigned int mem_size_kFC_off;
-
- //! \brief stores the boundary condition data
- QforBoundaryConditions noSlipBC, velocityBC, outflowBC, slipBC, stressBC, pressureBC;
- //! \brief number of lattice nodes for the boundary conditions
- unsigned int numberOfNoSlipBCnodesRead, numberOfVeloBCnodesRead, numberOfOutflowBCnodesRead, numberOfSlipBCnodesRead, numberOfStressBCnodesRead, numberOfPressureBCnodesRead, numberOfPrecursorBCnodesRead;
-
- QforBoundaryConditions QpressX0, QpressX1, QpressY0, QpressY1, QpressZ0, QpressZ1; // DEPRECATED
- QforBoundaryConditions propellerBC;
- QforBoundaryConditions geometryBC;
- QforPrecursorBoundaryConditions precursorBC;
- QforBoundaryConditions geometryBCnormalX, geometryBCnormalY, geometryBCnormalZ;
- QforBoundaryConditions inflowBCnormalX, inflowBCnormalY, inflowBCnormalZ;
- QforBoundaryConditions outflowBCnormalX, outflowBCnormalY, outflowBCnormalZ;
- QforBoundaryConditions QInlet, QOutlet, QPeriodic; // DEPRECATED
- unsigned int kInletQread, kOutletQread; // DEPRECATED
-
- WallModelParameters wallModel;
- std::vector<SPtr<TransientBCInputFileReader>> transientBCInputFileReader;
- real outflowPressureCorrectionFactor;
-
// testRoundoffError
Distributions27 kDistTestRE;
- //////////////////////////////////////////////////////////////////////////
- // velocities to fit the force
- real *VxForce, *VyForce, *VzForce;
- //////////////////////////////////////////////////////////////////////////
- //! \brief sets the forcing uniform on every fluid node in all three space dimensions
- real *forcing;
// Measure Points/////////
std::vector<MeasurePoints> MP;
@@ -324,24 +383,12 @@ struct LBMSimulationParameter {
unsigned int numberOfPointsCpBottom2;
std::vector<std::vector<double>> cpBottom2;
- // Concentration////////
- int *concIndex;
- real *concentration;
- unsigned int numberOfPointsConc;
-
// street X and Y velocity fractions///////
real *streetFractionXvelocity;
real *streetFractionYvelocity;
int *naschVelocity;
uint numberOfStreetNodes;
- // deltaPhi
- real deltaPhi;
-
- ////////////////////////////////////////////////////////////////////////////
- // particles
- PathLineParticles plp;
- ////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
// 1D domain decomposition
diff --git a/src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarm.cu b/src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarm.cu
index 9447a8636e801c132df9cef2feced4b5ab4e68de..a721df4fd1a25f24a96cd1e8fee9d0783525fb38 100644
--- a/src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarm.cu
+++ b/src/gpu/VirtualFluids_GPU/PreCollisionInteractor/ActuatorFarm.cu
@@ -62,7 +62,7 @@ __host__ __device__ __inline__ void calcTurbineBladeAndBladeNode(uint node, uint
uint x_off = turbine*numberOfBladeNodes*numberOfBlades;
blade = (node - x_off)/numberOfBlades;
uint y_off = numberOfBladeNodes*blade+x_off;
- bladeNode = (node - y_off)/numberOfBladeNodes;
+ bladeNode = (node - y_off);
}
__host__ __device__ __forceinline__ real distSqrd(real distX, real distY, real distZ)
diff --git a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD27/InitCompAD27.cu b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD27/InitCompAD27.cu
index 60dbb2228e6d01fdabf7a6e1bfca786e2104d5b0..1e70fc642a3fd7f6fca4ed90b9ff4ebc1bb437db 100644
--- a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD27/InitCompAD27.cu
+++ b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD27/InitCompAD27.cu
@@ -18,12 +18,12 @@ void InitCompAD27::init(int level)
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->typeOfGridNode,
- para->getParD(level)->Conc,
+ para->getParD(level)->concentration,
para->getParD(level)->velocityX,
para->getParD(level)->velocityY,
para->getParD(level)->velocityZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
getLastCudaError("LB_Init_Comp_AD_27 execution failed");
}
diff --git a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD7/InitCompAD7.cu b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD7/InitCompAD7.cu
index 8097ee13d9064c4104ead8cd8eb5ba529d8972fc..f8fc6af00d93cc5a51da4a69d67b69b616f97140 100644
--- a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD7/InitCompAD7.cu
+++ b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitCompAD7/InitCompAD7.cu
@@ -18,7 +18,7 @@ void InitCompAD7::init(int level)
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->typeOfGridNode,
- para->getParD(level)->Conc,
+ para->getParD(level)->concentration,
para->getParD(level)->velocityX,
para->getParD(level)->velocityY,
para->getParD(level)->velocityZ,
diff --git a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD27/InitIncompAD27.cu b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD27/InitIncompAD27.cu
index ea700010960b11a1facdda18c35f220f43eb6a66..6a9b4cb31b1032f6921bddbe60d3cd570ef46b6d 100644
--- a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD27/InitIncompAD27.cu
+++ b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD27/InitIncompAD27.cu
@@ -18,12 +18,12 @@ void InitIncompAD27::init(int level)
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->typeOfGridNode,
- para->getParD(level)->Conc,
+ para->getParD(level)->concentration,
para->getParD(level)->velocityX,
para->getParD(level)->velocityY,
para->getParD(level)->velocityZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
getLastCudaError("LB_Init_Incomp_AD_27 execution failed");
}
diff --git a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD7/InitIncompAD7.cu b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD7/InitIncompAD7.cu
index d7c08e6932cacf2fb5a946010c1855212f1631fc..b7c7d46a9ea8e3133b8240e27959b6b4d2ed0cf5 100644
--- a/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD7/InitIncompAD7.cu
+++ b/src/gpu/VirtualFluids_GPU/PreProcessor/PreProcessorStrategy/InitIncompAD7/InitIncompAD7.cu
@@ -18,12 +18,12 @@ void InitIncompAD7::init(int level)
para->getParD(level)->neighborY,
para->getParD(level)->neighborZ,
para->getParD(level)->typeOfGridNode,
- para->getParD(level)->Conc,
+ para->getParD(level)->concentration,
para->getParD(level)->velocityX,
para->getParD(level)->velocityY,
para->getParD(level)->velocityZ,
para->getParD(level)->numberOfNodes,
- para->getParD(level)->distributionsAD27.f[0],
+ para->getParD(level)->distributionsAD.f[0],
para->getParD(level)->isEvenTimestep);
getLastCudaError("LB_Init_Incomp_AD_7 execution failed");
}
diff --git a/src/gpu/VirtualFluids_GPU/Temperature/FindTemperature.cpp b/src/gpu/VirtualFluids_GPU/Temperature/FindTemperature.cpp
index 7b42b22cbf66b248bb1ae6681207eef1da22fa97..a4f6a01f83bd914e6ba7123a10387a463d90e84d 100644
--- a/src/gpu/VirtualFluids_GPU/Temperature/FindTemperature.cpp
+++ b/src/gpu/VirtualFluids_GPU/Temperature/FindTemperature.cpp
@@ -37,7 +37,7 @@ void initTemperatur(Parameter* para, CudaMemoryManager* cudaMemoryManager, int l
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- CalcMacThS7(para->getParD(lev)->Conc,
+ CalcMacThS7(para->getParD(lev)->concentration,
para->getParD(lev)->typeOfGridNode,
para->getParD(lev)->neighborX,
para->getParD(lev)->neighborY,
@@ -68,13 +68,13 @@ void initTemperatur(Parameter* para, CudaMemoryManager* cudaMemoryManager, int l
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CalcConcentration27(
para->getParD(lev)->numberofthreads,
- para->getParD(lev)->Conc,
+ para->getParD(lev)->concentration,
para->getParD(lev)->typeOfGridNode,
para->getParD(lev)->neighborX,
para->getParD(lev)->neighborY,
para->getParD(lev)->neighborZ,
para->getParD(lev)->numberOfNodes,
- para->getParD(lev)->distributionsAD27.f[0],
+ para->getParD(lev)->distributionsAD.f[0],
para->getParD(lev)->isEvenTimestep);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}