From 296626d7b25dd3971a4805a16f9b62eee3390846 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Sch=C3=B6nherr?= <schoen@irmb.tu-bs.de>
Date: Tue, 5 Mar 2019 22:56:04 +0100
Subject: [PATCH] add some classes to get flexible config files
---
src/Core/Input/ConfigData/ConfigData.h | 167 +++
src/Core/Input/ConfigData/ConfigDataImp.cpp | 1271 +++++++++++++++++
src/Core/Input/ConfigData/ConfigDataImp.h | 405 ++++++
src/Core/Input/ConfigData/package.include | 0
.../ConfigFileReader/ConfigFileReader.cpp | 265 ++++
.../Input/ConfigFileReader/ConfigFileReader.h | 21 +
.../Input/ConfigFileReader/package.include | 0
src/VirtualFluids_GPU/Parameter/Parameter.cpp | 502 ++++++-
src/VirtualFluids_GPU/Parameter/Parameter.h | 9 +-
targets/apps/LBM/Basel/main.cpp | 253 +---
targets/apps/LBM/TGV_3D/TGV_3D.cpp | 263 +---
targets/apps/LBM/lbmTest/main.cpp | 2 +-
targets/apps/LBM/metisTest/main.cpp | 2 +-
13 files changed, 2676 insertions(+), 484 deletions(-)
create mode 100644 src/Core/Input/ConfigData/ConfigData.h
create mode 100644 src/Core/Input/ConfigData/ConfigDataImp.cpp
create mode 100644 src/Core/Input/ConfigData/ConfigDataImp.h
create mode 100644 src/Core/Input/ConfigData/package.include
create mode 100644 src/Core/Input/ConfigFileReader/ConfigFileReader.cpp
create mode 100644 src/Core/Input/ConfigFileReader/ConfigFileReader.h
create mode 100644 src/Core/Input/ConfigFileReader/package.include
diff --git a/src/Core/Input/ConfigData/ConfigData.h b/src/Core/Input/ConfigData/ConfigData.h
new file mode 100644
index 000000000..36351cf75
--- /dev/null
+++ b/src/Core/Input/ConfigData/ConfigData.h
@@ -0,0 +1,167 @@
+#ifndef CONFIGDATA_H
+#define CONFIGDATA_H
+
+#include "../../DataTypes.h"
+
+#include <memory>
+#include <vector>
+
+class ConfigData
+{
+public:
+ virtual real getViscosity() = 0;
+ virtual uint getNumberOfDevices() = 0;
+ virtual std::vector<uint> getDevices() = 0;
+ virtual std::string getOutputPath() = 0;
+ virtual std::string getPrefix() = 0;
+ virtual std::string getGridPath() = 0;
+ virtual bool getPrintOutputFiles() = 0;
+ virtual bool getGeometryValues() = 0;
+ virtual bool getCalc2ndOrderMoments() = 0;
+ virtual bool getCalc3rdOrderMoments() = 0;
+ virtual bool getCalcHighOrderMoments() = 0;
+ virtual bool getReadGeo() = 0;
+ virtual bool getCalcMedian() = 0;
+ virtual bool getConcFile() = 0;
+ virtual bool getUseMeasurePoints() = 0;
+ virtual bool getUseWale() = 0;
+ virtual bool getSimulatePorousMedia() = 0;
+ virtual uint getD3Qxx() = 0;
+ virtual uint getTEnd() = 0;
+ virtual uint getTOut() = 0;
+ virtual uint getTStartOut() = 0;
+ virtual uint getTimeCalcMedStart() = 0;
+ virtual uint getTimeCalcMedEnd() = 0;
+ virtual uint getPressInID() = 0;
+ virtual uint getPressOutID() = 0;
+ virtual uint getPressInZ() = 0;
+ virtual uint getPressOutZ() = 0;
+ virtual bool getDiffOn() = 0;
+ virtual uint getDiffMod() = 0;
+ virtual real getDiffusivity() = 0;
+ virtual real getTemperatureInit() = 0;
+ virtual real getTemperatureBC() = 0;
+ virtual real getVelocity() = 0;
+ virtual real getViscosityRatio() = 0;
+ virtual real getVelocityRatio() = 0;
+ virtual real getDensityRatio() = 0;
+ virtual real getPressRatio() = 0;
+ virtual real getRealX() = 0;
+ virtual real getRealY() = 0;
+ virtual real getFactorPressBC() = 0;
+ virtual std::string getGeometryFileC() = 0;
+ virtual std::string getGeometryFileM() = 0;
+ virtual std::string getGeometryFileF() = 0;
+ virtual uint getClockCycleForMP() = 0;
+ virtual uint getTimestepForMP() = 0;
+ virtual real getForcingX() = 0;
+ virtual real getForcingY() = 0;
+ virtual real getForcingZ() = 0;
+ virtual bool getCalcParticles() = 0;
+ virtual int getParticleBasicLevel() = 0;
+ virtual int getParticleInitLevel() = 0;
+ virtual int getNumberOfParticles() = 0;
+ virtual real getStartXHotWall() = 0;
+ virtual real getEndXHotWall() = 0;
+ virtual std::vector<std::string> getPossNeighborFilesX() = 0;
+ virtual std::vector<std::string> getPossNeighborFilesY() = 0;
+ virtual std::vector<std::string> getPossNeighborFilesZ() = 0;
+ //virtual std::vector<std::string> getPossNeighborFilesX() = 0;
+ //virtual std::vector<std::string> getPossNeighborFilesY() = 0;
+ //virtual std::vector<std::string> getPossNeighborFilesZ() = 0;
+ virtual int getTimeDoCheckPoint() = 0;
+ virtual int getTimeDoRestart() = 0;
+ virtual bool getDoCheckPoint() = 0;
+ virtual bool getDoRestart() = 0;
+ virtual uint getMaxLevel() = 0;
+ virtual std::vector<int> getGridX() = 0;
+ virtual std::vector<int> getGridY() = 0;
+ virtual std::vector<int> getGridZ() = 0;
+ virtual std::vector<int> getDistX() = 0;
+ virtual std::vector<int> getDistY() = 0;
+ virtual std::vector<int> getDistZ() = 0;
+ virtual std::vector<bool> getNeedInterface() = 0;
+ virtual std::string getMainKernel() = 0;
+ virtual bool getMultiKernelOn() = 0;
+ virtual std::vector<int> getMultiKernelLevel() = 0;
+ virtual std::vector<std::string>getMultiKernelName() = 0;
+
+ virtual bool isViscosityInConfigFile() = 0;
+ virtual bool isNumberOfDevicesInConfigFile() = 0;
+ virtual bool isDevicesInConfigFile() = 0;
+ virtual bool isOutputPathInConfigFile() = 0;
+ virtual bool isPrefixInConfigFile() = 0;
+ virtual bool isGridPathInConfigFile() = 0;
+ virtual bool isPrintOutputFilesInConfigFile() = 0;
+ virtual bool isGeometryValuesInConfigFile() = 0;
+ virtual bool isCalc2ndOrderMomentsInConfigFile() = 0;
+ virtual bool isCalc3rdOrderMomentsInConfigFile() = 0;
+ virtual bool isCalcHighOrderMomentsInConfigFile() = 0;
+ virtual bool isReadGeoInConfigFile() = 0;
+ virtual bool isCalcMedianInConfigFile() = 0;
+ virtual bool isConcFileInConfigFile() = 0;
+ virtual bool isUseMeasurePointsInConfigFile() = 0;
+ virtual bool isUseWaleInConfigFile() = 0;
+ virtual bool isSimulatePorousMediaInConfigFile() = 0;
+ virtual bool isD3QxxInConfigFile() = 0;
+ virtual bool isTEndInConfigFile() = 0;
+ virtual bool isTOutInConfigFile() = 0;
+ virtual bool isTStartOutInConfigFile() = 0;
+ virtual bool isTimeCalcMedStartInConfigFile() = 0;
+ virtual bool isTimeCalcMedEndInConfigFile() = 0;
+ virtual bool isPressInIDInConfigFile() = 0;
+ virtual bool isPressOutIDInConfigFile() = 0;
+ virtual bool isPressInZInConfigFile() = 0;
+ virtual bool isPressOutZInConfigFile() = 0;
+ virtual bool isDiffOnInConfigFile() = 0;
+ virtual bool isDiffModInConfigFile() = 0;
+ virtual bool isDiffusivityInConfigFile() = 0;
+ virtual bool isTemperatureInitInConfigFile() = 0;
+ virtual bool isTemperatureBCInConfigFile() = 0;
+ //virtual bool isViscosityInConfigFile() = 0;
+ virtual bool isVelocityInConfigFile() = 0;
+ virtual bool isViscosityRatioInConfigFile() = 0;
+ virtual bool isVelocityRatioInConfigFile() = 0;
+ virtual bool isDensityRatioInConfigFile() = 0;
+ virtual bool isPressRatioInConfigFile() = 0;
+ virtual bool isRealXInConfigFile() = 0;
+ virtual bool isRealYInConfigFile() = 0;
+ virtual bool isFactorPressBCInConfigFile() = 0;
+ virtual bool isGeometryFileCInConfigFile() = 0;
+ virtual bool isGeometryFileMInConfigFile() = 0;
+ virtual bool isGeometryFileFInConfigFile() = 0;
+ virtual bool isClockCycleForMPInConfigFile() = 0;
+ virtual bool isTimestepForMPInConfigFile() = 0;
+ virtual bool isForcingXInConfigFile() = 0;
+ virtual bool isForcingYInConfigFile() = 0;
+ virtual bool isForcingZInConfigFile() = 0;
+ virtual bool isCalcParticlesInConfigFile() = 0;
+ virtual bool isParticleBasicLevelInConfigFile() = 0;
+ virtual bool isParticleInitLevelInConfigFile() = 0;
+ virtual bool isNumberOfParticlesInConfigFile() = 0;
+ virtual bool isNeighborWSBInConfigFile() = 0;
+ virtual bool isStartXHotWallInConfigFile() = 0;
+ virtual bool isEndXHotWallInConfigFile() = 0;
+ virtual bool isPossNeighborFilesXInConfigFile() = 0;
+ virtual bool isPossNeighborFilesYInConfigFile() = 0;
+ virtual bool isPossNeighborFilesZInConfigFile() = 0;
+ virtual bool isTimeDoCheckPointInConfigFile() = 0;
+ virtual bool isTimeDoRestartInConfigFile() = 0;
+ virtual bool isDoCheckPointInConfigFile() = 0;
+ virtual bool isDoRestartInConfigFile() = 0;
+ virtual bool isMaxLevelInConfigFile() = 0;
+ virtual bool isGridXInConfigFile() = 0;
+ virtual bool isGridYInConfigFile() = 0;
+ virtual bool isGridZInConfigFile() = 0;
+ virtual bool isDistXInConfigFile() = 0;
+ virtual bool isDistYInConfigFile() = 0;
+ virtual bool isDistZInConfigFile() = 0;
+ virtual bool isNeedInterfaceInConfigFile() = 0;
+ virtual bool isMainKernelInConfigFile() = 0;
+ virtual bool isMultiKernelOnInConfigFile() = 0;
+ virtual bool isMultiKernelLevelInConfigFile() = 0;
+ virtual bool isMultiKernelNameInConfigFile() = 0;
+
+
+};
+#endif
diff --git a/src/Core/Input/ConfigData/ConfigDataImp.cpp b/src/Core/Input/ConfigData/ConfigDataImp.cpp
new file mode 100644
index 000000000..644230ebc
--- /dev/null
+++ b/src/Core/Input/ConfigData/ConfigDataImp.cpp
@@ -0,0 +1,1271 @@
+#include "ConfigDataImp.h"
+
+
+std::shared_ptr<ConfigDataImp> ConfigDataImp::getNewInstance()
+{
+ return std::shared_ptr<ConfigDataImp>(new ConfigDataImp());
+}
+
+ConfigDataImp::ConfigDataImp()
+{
+ this->isViscosity=false;
+ this->isNumberOfDevices=false;
+ this->isDevices=false;
+ this->isOutputPath=false;
+ this->isPrefix=false;
+ this->isGridPath=false;
+ this->isPrintOutputFiles=false;
+ this->isGeometryValues=false;
+ this->isCalc2ndOrderMoments=false;
+ this->isCalc3rdOrderMoments=false;
+ this->isCalcHighOrderMoments=false;
+ this->isReadGeo=false;
+ this->isCalcMedian=false;
+ this->isConcFile=false;
+ this->isUseMeasurePoints=false;
+ this->isUseWale=false;
+ this->isSimulatePorousMedia=false;
+ this->isD3Qxx=false;
+ this->isTEnd=false;
+ this->isTOut=false;
+ this->isTStartOut=false;
+ this->isTimeCalcMedStart=false;
+ this->isTimeCalcMedEnd=false;
+ this->isPressInID=false;
+ this->isPressOutID=false;
+ this->isPressInZ=false;
+ this->isPressOutZ=false;
+ this->isDiffOn=false;
+ this->isDiffMod=false;
+ this->isDiffusivity=false;
+ this->isTemperatureInit=false;
+ this->isTemperatureBC=false;
+ this->isVelocity=false;
+ this->isViscosityRatio=false;
+ this->isVelocityRatio=false;
+ this->isDensityRatio=false;
+ this->isPressRatio=false;
+ this->isRealX=false;
+ this->isRealY=false;
+ this->isFactorPressBC=false;
+ this->isGeometryFileC=false;
+ this->isGeometryFileM=false;
+ this->isGeometryFileF=false;
+ this->isClockCycleForMP=false;
+ this->isTimestepForMP=false;
+ this->isForcingX=false;
+ this->isForcingY=false;
+ this->isForcingZ=false;
+ this->isCalcParticles=false;
+ this->isParticleBasicLevel=false;
+ this->isParticleInitLevel=false;
+ this->isNumberOfParticles=false;
+ this->isNeighborWSB=false;
+ this->isStartXHotWall=false;
+ this->isEndXHotWall=false;
+ this->isPossNeighborFilesX=false;
+ this->isPossNeighborFilesY=false;
+ this->isPossNeighborFilesZ=false;
+ this->isTimeDoCheckPoint=false;
+ this->isTimeDoRestart=false;
+ this->isDoCheckPoint=false;
+ this->isDoRestart=false;
+ this->isMaxLevel=false;
+ this->isGridX=false;
+ this->isGridY=false;
+ this->isGridZ=false;
+ this->isDistX=false;
+ this->isDistY=false;
+ this->isDistZ=false;
+ this->isNeedInterface=false;
+ this->isMainKernel=false;
+ this->isMultiKernelOn=false;
+ this->isMultiKernelLevel=false;
+ this->isMultiKernelName=false;
+
+}
+
+ConfigDataImp::~ConfigDataImp(void)
+{
+}
+
+real ConfigDataImp::getViscosity()
+{
+ return this->viscosity;
+}
+
+uint ConfigDataImp::getNumberOfDevices()
+{
+ return this->numberOfDevices;
+}
+
+std::vector<uint> ConfigDataImp::getDevices()
+{
+ return this->devices;
+}
+
+std::string ConfigDataImp::getOutputPath()
+{
+ return this->outputPath;
+}
+
+std::string ConfigDataImp::getPrefix()
+{
+ return this->prefix;
+}
+
+std::string ConfigDataImp::getGridPath()
+{
+ return this->gridPath;
+}
+
+bool ConfigDataImp::getPrintOutputFiles()
+{
+ return this->printOutputFiles;
+}
+
+bool ConfigDataImp::getGeometryValues()
+{
+ return this->geometryValues;
+}
+
+bool ConfigDataImp::getCalc2ndOrderMoments()
+{
+ return this->calc2ndOrderMoments;
+}
+
+bool ConfigDataImp::getCalc3rdOrderMoments()
+{
+ return this->calc3rdOrderMoments;
+}
+
+bool ConfigDataImp::getCalcHighOrderMoments()
+{
+ return this->calcHighOrderMoments;
+}
+
+bool ConfigDataImp::getReadGeo()
+{
+ return this->readGeo;
+}
+
+bool ConfigDataImp::getCalcMedian()
+{
+ return this->calcMedian;
+}
+
+bool ConfigDataImp::getConcFile()
+{
+ return this->concFile;
+}
+
+bool ConfigDataImp::getUseMeasurePoints()
+{
+ return this->useMeasurePoints;
+}
+
+bool ConfigDataImp::getUseWale()
+{
+ return this->useWale;
+}
+
+bool ConfigDataImp::getSimulatePorousMedia()
+{
+ return this->simulatePorousMedia;
+}
+
+uint ConfigDataImp::getD3Qxx()
+{
+ return this->d3Qxx;
+}
+
+uint ConfigDataImp::getTEnd()
+{
+ return this->tEnd;
+}
+
+uint ConfigDataImp::getTOut()
+{
+ return this->tOut;
+}
+
+uint ConfigDataImp::getTStartOut()
+{
+ return this->tStartOut;
+}
+
+uint ConfigDataImp::getTimeCalcMedStart()
+{
+ return this->timeCalcMedStart;
+}
+
+uint ConfigDataImp::getTimeCalcMedEnd()
+{
+ return this->timeCalcMedEnd;
+}
+
+uint ConfigDataImp::getPressInID()
+{
+ return this->pressInID;
+}
+
+uint ConfigDataImp::getPressOutID()
+{
+ return this->pressOutID;
+}
+
+uint ConfigDataImp::getPressInZ()
+{
+ return this->pressInZ;
+}
+
+uint ConfigDataImp::getPressOutZ()
+{
+ return this->pressOutZ;
+}
+
+bool ConfigDataImp::getDiffOn()
+{
+ return this->diffOn;
+}
+
+uint ConfigDataImp::getDiffMod()
+{
+ return this->diffMod;
+}
+
+real ConfigDataImp::getDiffusivity()
+{
+ return this->diffusivity;
+}
+
+real ConfigDataImp::getTemperatureInit()
+{
+ return this->temperatureInit;
+}
+
+real ConfigDataImp::getTemperatureBC()
+{
+ return this->temperatureBC;
+}
+
+real ConfigDataImp::getVelocity()
+{
+ return this->velocity;
+}
+
+real ConfigDataImp::getViscosityRatio()
+{
+ return this->viscosityRatio;
+}
+
+real ConfigDataImp::getVelocityRatio()
+{
+ return this->velocityRatio;
+}
+
+real ConfigDataImp::getDensityRatio()
+{
+ return this->densityRatio;
+}
+
+real ConfigDataImp::getPressRatio()
+{
+ return this->pressRatio;
+}
+
+real ConfigDataImp::getRealX()
+{
+ return this->realX;
+}
+
+real ConfigDataImp::getRealY()
+{
+ return this->realY;
+}
+
+real ConfigDataImp::getFactorPressBC()
+{
+ return this->factorPressBC;
+}
+
+std::string ConfigDataImp::getGeometryFileC()
+{
+ return this->geometryFileC;
+}
+
+std::string ConfigDataImp::getGeometryFileM()
+{
+ return this->geometryFileM;
+}
+
+std::string ConfigDataImp::getGeometryFileF()
+{
+ return this->geometryFileF;
+}
+
+uint ConfigDataImp::getClockCycleForMP()
+{
+ return this->clockCycleForMP;
+}
+
+uint ConfigDataImp::getTimestepForMP()
+{
+ return this->timestepForMP;
+}
+
+real ConfigDataImp::getForcingX()
+{
+ return this->forcingX;
+}
+
+real ConfigDataImp::getForcingY()
+{
+ return this->forcingY;
+}
+
+real ConfigDataImp::getForcingZ()
+{
+ return this->forcingZ;
+}
+
+bool ConfigDataImp::getCalcParticles()
+{
+ return this->calcParticles;
+}
+
+int ConfigDataImp::getParticleBasicLevel()
+{
+ return this->particleBasicLevel;
+}
+
+int ConfigDataImp::getParticleInitLevel()
+{
+ return this->particleInitLevel;
+}
+
+int ConfigDataImp::getNumberOfParticles()
+{
+ return this->numberOfParticles;
+}
+
+real ConfigDataImp::getStartXHotWall()
+{
+ return this->startXHotWall;
+}
+
+real ConfigDataImp::getEndXHotWall()
+{
+ return this->endXHotWall;
+}
+
+std::vector<std::string> ConfigDataImp::getPossNeighborFilesX()
+{
+ return this->possNeighborFilesX;
+}
+
+std::vector<std::string> ConfigDataImp::getPossNeighborFilesY()
+{
+ return this->possNeighborFilesY;
+}
+
+std::vector<std::string> ConfigDataImp::getPossNeighborFilesZ()
+{
+ return this->possNeighborFilesZ;
+}
+
+int ConfigDataImp::getTimeDoCheckPoint()
+{
+ return this->timeDoCheckPoint;
+}
+
+int ConfigDataImp::getTimeDoRestart()
+{
+ return this->timeDoRestart;
+}
+
+bool ConfigDataImp::getDoCheckPoint()
+{
+ return this->doCheckPoint;
+}
+
+bool ConfigDataImp::getDoRestart()
+{
+ return this->doRestart;
+}
+
+uint ConfigDataImp::getMaxLevel()
+{
+ return this->maxLevel;
+}
+
+std::vector<int> ConfigDataImp::getGridX()
+{
+ return this->gridX;
+}
+
+std::vector<int> ConfigDataImp::getGridY()
+{
+ return this->gridY;
+}
+
+std::vector<int> ConfigDataImp::getGridZ()
+{
+ return this->gridZ;
+}
+
+std::vector<int> ConfigDataImp::getDistX()
+{
+ return this->distX;
+}
+
+std::vector<int> ConfigDataImp::getDistY()
+{
+ return this->distY;
+}
+
+std::vector<int> ConfigDataImp::getDistZ()
+{
+ return this->distZ;
+}
+
+std::vector<bool> ConfigDataImp::getNeedInterface()
+{
+ return this->needInterface;
+}
+
+std::string ConfigDataImp::getMainKernel()
+{
+ return this->mainKernel;
+}
+
+bool ConfigDataImp::getMultiKernelOn()
+{
+ return this->multiKernelOn;
+}
+
+std::vector<int> ConfigDataImp::getMultiKernelLevel()
+{
+ return this->multiKernelLevel;
+}
+
+std::vector<std::string> ConfigDataImp::getMultiKernelName()
+{
+ return this->multiKernelName;
+}
+
+void ConfigDataImp::setViscosity(real viscosity)
+{
+ this->viscosity = viscosity;
+ this->isViscosity = true;
+}
+
+void ConfigDataImp::setNumberOfDevices(uint numberOfDevices)
+{
+ this->numberOfDevices = numberOfDevices;
+ this->isNumberOfDevices = true;
+}
+
+void ConfigDataImp::setDevices(std::vector<uint> devices)
+{
+ this->devices = devices;
+ this->isDevices = true;
+}
+
+void ConfigDataImp::setOutputPath(std::string outputPath)
+{
+ this->outputPath = outputPath;
+ this->isOutputPath = true;
+}
+
+void ConfigDataImp::setPrefix(std::string prefix)
+{
+ this->prefix = prefix;
+ this->isPrefix = true;
+}
+
+void ConfigDataImp::setGridPath(std::string gridPath)
+{
+ this->gridPath = gridPath;
+ this->isGridPath = true;
+}
+
+void ConfigDataImp::setPrintOutputFiles(bool printOutputFiles)
+{
+ this->printOutputFiles = printOutputFiles;
+ this->isPrintOutputFiles = true;
+}
+
+void ConfigDataImp::setGeometryValues(bool geometryValues)
+{
+ this->geometryValues = geometryValues;
+ this->isGeometryValues = true;
+}
+
+void ConfigDataImp::setCalc2ndOrderMoments(bool calc2ndOrderMoments)
+{
+ this->calc2ndOrderMoments = calc2ndOrderMoments;
+ this->isCalc2ndOrderMoments = true;
+}
+
+void ConfigDataImp::setCalc3rdOrderMoments(bool calc3rdOrderMoments)
+{
+ this->calc3rdOrderMoments = calc3rdOrderMoments;
+ this->isCalc3rdOrderMoments = true;
+}
+
+void ConfigDataImp::setCalcHighOrderMoments(bool calcHighOrderMoments)
+{
+ this->calcHighOrderMoments = calcHighOrderMoments;
+ this->isCalcHighOrderMoments = true;
+}
+
+void ConfigDataImp::setReadGeo(bool readGeo)
+{
+ this->readGeo = readGeo;
+ this->isReadGeo = true;
+}
+
+void ConfigDataImp::setCalcMedian(bool calcMedian)
+{
+ this->calcMedian = calcMedian;
+ this->isCalcMedian = true;
+}
+
+void ConfigDataImp::setConcFile(bool concFile)
+{
+ this->concFile = concFile;
+ this->isConcFile = true;
+}
+
+void ConfigDataImp::setUseMeasurePoints(bool useMeasurePoints)
+{
+ this->useMeasurePoints = useMeasurePoints;
+ this->isUseMeasurePoints = true;
+}
+
+void ConfigDataImp::setUseWale(bool useWale)
+{
+ this->useWale = useWale;
+ this->isUseWale = true;
+}
+
+void ConfigDataImp::setSimulatePorousMedia(bool simulatePorousMedia)
+{
+ this->simulatePorousMedia = simulatePorousMedia;
+ this->isSimulatePorousMedia = true;
+}
+
+void ConfigDataImp::setD3Qxx(uint d3Qxx)
+{
+ this->d3Qxx = d3Qxx;
+ this->isD3Qxx = true;
+}
+
+void ConfigDataImp::setTEnd(uint tEnd)
+{
+ this->tEnd = tEnd;
+ this->isTEnd = true;
+}
+
+void ConfigDataImp::setTOut(uint tOut)
+{
+ this->tOut = tOut;
+ this->isTOut = true;
+}
+
+void ConfigDataImp::setTStartOut(uint tStartOut)
+{
+ this->tStartOut = tStartOut;
+ this->isTStartOut = true;
+}
+
+void ConfigDataImp::setTimeCalcMedStart(uint timeCalcMedStart)
+{
+ this->timeCalcMedStart = timeCalcMedStart;
+ this->isTimeCalcMedStart = true;
+}
+
+void ConfigDataImp::setTimeCalcMedEnd(uint timeCalcMedEnd)
+{
+ this->timeCalcMedEnd = timeCalcMedEnd;
+ this->isTimeCalcMedEnd = true;
+}
+
+void ConfigDataImp::setPressInID(uint pressInID)
+{
+ this->pressInID = pressInID;
+ this->isPressInID = true;
+}
+
+void ConfigDataImp::setPressOutID(uint pressOutID)
+{
+ this->pressOutID = pressOutID;
+ this->isPressOutID = true;
+}
+
+void ConfigDataImp::setPressInZ(uint pressInZ)
+{
+ this->pressInZ = pressInZ;
+ this->isPressInZ = true;
+}
+
+void ConfigDataImp::setPressOutZ(uint pressOutZ)
+{
+ this->pressOutZ = pressOutZ;
+ this->isPressOutZ = true;
+}
+
+void ConfigDataImp::setDiffOn(bool diffOn)
+{
+ this->diffOn = diffOn;
+ this->isDiffOn = true;
+}
+
+void ConfigDataImp::setDiffMod(uint diffMod)
+{
+ this->diffMod = diffMod;
+ this->isDiffMod = true;
+}
+
+void ConfigDataImp::setDiffusivity(real diffusivity)
+{
+ this->diffusivity = diffusivity;
+ this->isDiffusivity = true;
+}
+
+void ConfigDataImp::setTemperatureInit(real temperatureInit)
+{
+ this->temperatureInit = temperatureInit;
+ this->isTemperatureInit = true;
+}
+
+void ConfigDataImp::setTemperatureBC(real temperatureBC)
+{
+ this->temperatureBC = temperatureBC;
+ this->isTemperatureBC = true;
+}
+
+//void ConfigDataImp::setViscosity(real viscosity)
+//{
+// this->viscosity = viscosity;
+// this->isViscosity = true;
+//}
+
+void ConfigDataImp::setVelocity(real velocity)
+{
+ this->velocity = velocity;
+ this->isVelocity = true;
+}
+
+void ConfigDataImp::setViscosityRatio(real viscosityRatio)
+{
+ this->viscosityRatio = viscosityRatio;
+ this->isViscosityRatio = true;
+}
+
+void ConfigDataImp::setVelocityRatio(real velocityRatio)
+{
+ this->velocityRatio = velocityRatio;
+ this->isVelocityRatio = true;
+}
+
+void ConfigDataImp::setDensityRatio(real densityRatio)
+{
+ this->densityRatio = densityRatio;
+ this->isDensityRatio = true;
+}
+
+void ConfigDataImp::setPressRatio(real pressRatio)
+{
+ this->pressRatio = pressRatio;
+ this->isPressRatio = true;
+}
+
+void ConfigDataImp::setRealX(real realX)
+{
+ this->realX = realX;
+ this->isRealX = true;
+}
+
+void ConfigDataImp::setRealY(real realY)
+{
+ this->realY = realY;
+ this->isRealY = true;
+}
+
+void ConfigDataImp::setFactorPressBC(real factorPressBC)
+{
+ this->factorPressBC = factorPressBC;
+ this->isFactorPressBC = true;
+}
+
+void ConfigDataImp::setGeometryFileC(std::string geometryFileC)
+{
+ this->geometryFileC = geometryFileC;
+ this->isGeometryFileC = true;
+}
+
+void ConfigDataImp::setGeometryFileM(std::string geometryFileM)
+{
+ this->geometryFileM = geometryFileM;
+ this->isGeometryFileM = true;
+}
+
+void ConfigDataImp::setGeometryFileF(std::string geometryFileF)
+{
+ this->geometryFileF = geometryFileF;
+ this->isGeometryFileF = true;
+}
+
+void ConfigDataImp::setClockCycleForMP(uint clockCycleForMP)
+{
+ this->clockCycleForMP = clockCycleForMP;
+ this->isClockCycleForMP = true;
+}
+
+void ConfigDataImp::setTimestepForMP(uint timestepForMP)
+{
+ this->timestepForMP = timestepForMP;
+ this->isTimestepForMP = true;
+}
+
+void ConfigDataImp::setForcingX(real forcingX)
+{
+ this->forcingX = forcingX;
+ this->isForcingX = true;
+}
+
+void ConfigDataImp::setForcingY(real forcingY)
+{
+ this->forcingY = forcingY;
+ this->isForcingY = true;
+}
+
+void ConfigDataImp::setForcingZ(real forcingZ)
+{
+ this->forcingZ = forcingZ;
+ this->isForcingZ = true;
+}
+
+void ConfigDataImp::setCalcParticles(bool calcParticles)
+{
+ this->calcParticles = calcParticles;
+ this->isCalcParticles = true;
+}
+
+void ConfigDataImp::setParticleBasicLevel(int particleBasicLevel)
+{
+ this->particleBasicLevel = particleBasicLevel;
+ this->isParticleBasicLevel = true;
+}
+
+void ConfigDataImp::setParticleInitLevel(int particleInitLevel)
+{
+ this->particleInitLevel = particleInitLevel;
+ this->isParticleInitLevel = true;
+}
+
+void ConfigDataImp::setNumberOfParticles(int numberOfParticles)
+{
+ this->numberOfParticles = numberOfParticles;
+ this->isNumberOfParticles = true;
+}
+
+void ConfigDataImp::setStartXHotWall(real startXHotWall)
+{
+ this->startXHotWall = startXHotWall;
+ this->isStartXHotWall = true;
+}
+
+void ConfigDataImp::setEndXHotWall(real endXHotWall)
+{
+ this->endXHotWall = endXHotWall;
+ this->isEndXHotWall = true;
+}
+
+void ConfigDataImp::setPossNeighborFilesX(std::vector<std::string> possNeighborFilesX)
+{
+ this->possNeighborFilesX = possNeighborFilesX;
+ this->isPossNeighborFilesX = true;
+}
+
+void ConfigDataImp::setPossNeighborFilesY(std::vector<std::string> possNeighborFilesY)
+{
+ this->possNeighborFilesY = possNeighborFilesY;
+ this->isPossNeighborFilesY = true;
+}
+
+void ConfigDataImp::setPossNeighborFilesZ(std::vector<std::string> possNeighborFilesZ)
+{
+ this->possNeighborFilesZ = possNeighborFilesZ;
+ this->isPossNeighborFilesZ = true;
+}
+
+void ConfigDataImp::setTimeDoCheckPoint(int timeDoCheckPoint)
+{
+ this->timeDoCheckPoint = timeDoCheckPoint;
+ this->isTimeDoCheckPoint = true;
+}
+
+void ConfigDataImp::setTimeDoRestart(int timeDoRestart)
+{
+ this->timeDoRestart = timeDoRestart;
+ this->isTimeDoRestart = true;
+}
+
+void ConfigDataImp::setDoCheckPoint(bool doCheckPoint)
+{
+ this->doCheckPoint = doCheckPoint;
+ this->isDoCheckPoint = true;
+}
+
+void ConfigDataImp::setDoRestart(bool doRestart)
+{
+ this->doRestart = doRestart;
+ this->isDoRestart = true;
+}
+
+void ConfigDataImp::setMaxLevel(uint maxLevel)
+{
+ this->maxLevel = maxLevel;
+ this->isMaxLevel = true;
+}
+
+void ConfigDataImp::setGridX(std::vector<int> gridX)
+{
+ this->gridX = gridX;
+ this->isGridX = true;
+}
+
+void ConfigDataImp::setGridY(std::vector<int> gridY)
+{
+ this->gridY = gridY;
+ this->isGridY = true;
+}
+
+void ConfigDataImp::setGridZ(std::vector<int> gridZ)
+{
+ this->gridZ = gridZ;
+ this->isGridZ = true;
+}
+
+void ConfigDataImp::setDistX(std::vector<int> distX)
+{
+ this->distX = distX;
+ this->isDistX = true;
+}
+
+void ConfigDataImp::setDistY(std::vector<int> distY)
+{
+ this->distY = distY;
+ this->isDistY = true;
+}
+
+void ConfigDataImp::setDistZ(std::vector<int> distZ)
+{
+ this->distZ = distZ;
+ this->isDistZ = true;
+}
+
+void ConfigDataImp::setNeedInterface(std::vector<bool> needInterface)
+{
+ this->needInterface = needInterface;
+ this->isNeedInterface = true;
+}
+
+void ConfigDataImp::setMainKernel(std::string mainKernel)
+{
+ this->mainKernel = mainKernel;
+ this->isMainKernel = true;
+}
+
+void ConfigDataImp::setMultiKernelOn(bool multiKernelOn)
+{
+ this->multiKernelOn = multiKernelOn;
+ this->isMultiKernelOn = true;
+}
+
+void ConfigDataImp::setMultiKernelLevel(std::vector<int> multiKernelLevel)
+{
+ this->multiKernelLevel = multiKernelLevel;
+ this->isMultiKernelLevel = true;
+}
+
+void ConfigDataImp::setMultiKernelName(std::vector<std::string> multiKernelName)
+{
+ this->multiKernelName = multiKernelName;
+ this->isMultiKernelName = true;
+}
+
+bool ConfigDataImp::isCalc2ndOrderMomentsInConfigFile()
+{
+ return this->isCalc2ndOrderMoments;
+}
+
+bool ConfigDataImp::isCalc3rdOrderMomentsInConfigFile()
+{
+ return this->isCalc2ndOrderMoments;
+}
+
+bool ConfigDataImp::isCalcHighOrderMomentsInConfigFile()
+{
+ return this->isCalcHighOrderMoments;
+}
+
+bool ConfigDataImp::isReadGeoInConfigFile()
+{
+ return this->isReadGeo;
+}
+
+bool ConfigDataImp::isCalcMedianInConfigFile()
+{
+ return this->isCalcMedian;
+}
+
+bool ConfigDataImp::isConcFileInConfigFile()
+{
+ return this->isConcFile;
+}
+
+bool ConfigDataImp::isUseMeasurePointsInConfigFile()
+{
+ return this->isUseMeasurePoints;
+}
+
+bool ConfigDataImp::isUseWaleInConfigFile()
+{
+ return this->isUseWale;
+}
+
+bool ConfigDataImp::isSimulatePorousMediaInConfigFile()
+{
+ return this->isSimulatePorousMedia;
+}
+
+bool ConfigDataImp::isD3QxxInConfigFile()
+{
+ return this->isD3Qxx;
+}
+
+bool ConfigDataImp::isTEndInConfigFile()
+{
+ return this->isTEnd;
+}
+
+bool ConfigDataImp::isTOutInConfigFile()
+{
+ return this->isTOut;
+}
+
+bool ConfigDataImp::isTStartOutInConfigFile()
+{
+ return this->isTStartOut;
+}
+
+bool ConfigDataImp::isTimeCalcMedStartInConfigFile()
+{
+ return this->isTimeCalcMedStart;
+}
+
+bool ConfigDataImp::isTimeCalcMedEndInConfigFile()
+{
+ return this->isTimeCalcMedEnd;
+}
+
+bool ConfigDataImp::isPressInIDInConfigFile()
+{
+ return this->isPressInID;
+}
+
+bool ConfigDataImp::isPressOutIDInConfigFile()
+{
+ return this->isPressOutID;
+}
+
+bool ConfigDataImp::isPressInZInConfigFile()
+{
+ return this->isPressInZ;
+}
+
+bool ConfigDataImp::isPressOutZInConfigFile()
+{
+ return this->isPressOutZ;
+}
+
+bool ConfigDataImp::isDiffOnInConfigFile()
+{
+ return this->isDiffOn;
+}
+
+bool ConfigDataImp::isDiffModInConfigFile()
+{
+ return this->isDiffMod;
+}
+
+bool ConfigDataImp::isDiffusivityInConfigFile()
+{
+ return this->isDiffusivity;
+}
+
+bool ConfigDataImp::isTemperatureInitInConfigFile()
+{
+ return this->isTemperatureInit;
+}
+
+bool ConfigDataImp::isTemperatureBCInConfigFile()
+{
+ return this->isTemperatureBC;
+}
+
+bool ConfigDataImp::isViscosityInConfigFile()
+{
+ return this->isViscosity;
+}
+
+bool ConfigDataImp::isNumberOfDevicesInConfigFile()
+{
+ return this->isNumberOfDevices;
+}
+
+bool ConfigDataImp::isDevicesInConfigFile()
+{
+ return this->isDevices;
+}
+
+bool ConfigDataImp::isOutputPathInConfigFile()
+{
+ return this->isOutputPath;
+}
+
+bool ConfigDataImp::isPrefixInConfigFile()
+{
+ return this->isPrefix;
+}
+
+bool ConfigDataImp::isGridPathInConfigFile()
+{
+ return this->isGridPath;
+}
+
+bool ConfigDataImp::isPrintOutputFilesInConfigFile()
+{
+ return this->isPrintOutputFiles;
+}
+
+bool ConfigDataImp::isGeometryValuesInConfigFile()
+{
+ return this->isGeometryValues;
+}
+
+bool ConfigDataImp::isVelocityInConfigFile()
+{
+ return this->isVelocity;
+}
+
+bool ConfigDataImp::isViscosityRatioInConfigFile()
+{
+ return this->isViscosityRatio;
+}
+
+bool ConfigDataImp::isVelocityRatioInConfigFile()
+{
+ return this->isVelocityRatio;
+}
+
+bool ConfigDataImp::isDensityRatioInConfigFile()
+{
+ return this->isDensityRatio;
+}
+
+bool ConfigDataImp::isPressRatioInConfigFile()
+{
+ return this->isPressRatio;
+}
+
+bool ConfigDataImp::isRealXInConfigFile()
+{
+ return this->isRealX;
+}
+
+bool ConfigDataImp::isRealYInConfigFile()
+{
+ return this->isRealY;
+}
+
+bool ConfigDataImp::isFactorPressBCInConfigFile()
+{
+ return this->isFactorPressBC;
+}
+
+bool ConfigDataImp::isGeometryFileCInConfigFile()
+{
+ return this->isGeometryFileC;
+}
+
+bool ConfigDataImp::isGeometryFileMInConfigFile()
+{
+ return this->isGeometryFileM;
+}
+
+bool ConfigDataImp::isGeometryFileFInConfigFile()
+{
+ return this->isGeometryFileF;
+}
+
+bool ConfigDataImp::isClockCycleForMPInConfigFile()
+{
+ return this->isClockCycleForMP;
+}
+
+bool ConfigDataImp::isTimestepForMPInConfigFile()
+{
+ return this->isTimestepForMP;
+}
+
+bool ConfigDataImp::isForcingXInConfigFile()
+{
+ return this->isForcingX;
+}
+
+bool ConfigDataImp::isForcingYInConfigFile()
+{
+ return this->isForcingY;
+}
+
+bool ConfigDataImp::isForcingZInConfigFile()
+{
+ return this->isForcingZ;
+}
+
+bool ConfigDataImp::isCalcParticlesInConfigFile()
+{
+ return this->isCalcParticles;
+}
+
+bool ConfigDataImp::isParticleBasicLevelInConfigFile()
+{
+ return this->isParticleBasicLevel;
+}
+
+bool ConfigDataImp::isParticleInitLevelInConfigFile()
+{
+ return this->isParticleInitLevel;
+}
+
+bool ConfigDataImp::isNumberOfParticlesInConfigFile()
+{
+ return this->isNumberOfParticles;
+}
+
+bool ConfigDataImp::isNeighborWSBInConfigFile()
+{
+ return this->isNeighborWSB;
+}
+
+bool ConfigDataImp::isStartXHotWallInConfigFile()
+{
+ return this->isStartXHotWall;
+}
+
+bool ConfigDataImp::isEndXHotWallInConfigFile()
+{
+ return this->isEndXHotWall;
+}
+
+bool ConfigDataImp::isPossNeighborFilesXInConfigFile()
+{
+ return this->isPossNeighborFilesX;
+}
+
+bool ConfigDataImp::isPossNeighborFilesYInConfigFile()
+{
+ return this->isPossNeighborFilesY;
+}
+
+bool ConfigDataImp::isPossNeighborFilesZInConfigFile()
+{
+ return this->isPossNeighborFilesZ;
+}
+
+bool ConfigDataImp::isTimeDoCheckPointInConfigFile()
+{
+ return this->isTimeDoCheckPoint;
+}
+
+bool ConfigDataImp::isTimeDoRestartInConfigFile()
+{
+ return this->isTimeDoCheckPoint;
+}
+
+bool ConfigDataImp::isDoCheckPointInConfigFile()
+{
+ return this->isDoCheckPoint;
+}
+
+bool ConfigDataImp::isDoRestartInConfigFile()
+{
+ return this->isDoRestart;
+}
+
+bool ConfigDataImp::isMaxLevelInConfigFile()
+{
+ return this->isMaxLevel;
+}
+
+bool ConfigDataImp::isGridXInConfigFile()
+{
+ return this->isGridX;
+}
+
+bool ConfigDataImp::isGridYInConfigFile()
+{
+ return this->isGridY;
+}
+
+bool ConfigDataImp::isGridZInConfigFile()
+{
+ return this->isGridZ;
+}
+
+bool ConfigDataImp::isDistXInConfigFile()
+{
+ return this->isDistX;
+}
+
+bool ConfigDataImp::isDistYInConfigFile()
+{
+ return this->isDistY;
+}
+
+bool ConfigDataImp::isDistZInConfigFile()
+{
+ return this->isDistZ;
+}
+
+bool ConfigDataImp::isNeedInterfaceInConfigFile()
+{
+ return this->isNeedInterface;
+}
+
+bool ConfigDataImp::isMainKernelInConfigFile()
+{
+ return this->isMainKernel;
+}
+
+bool ConfigDataImp::isMultiKernelOnInConfigFile()
+{
+ return this->isMultiKernelOn;
+}
+
+bool ConfigDataImp::isMultiKernelLevelInConfigFile()
+{
+ return this->isMultiKernelLevel;
+}
+
+bool ConfigDataImp::isMultiKernelNameInConfigFile()
+{
+ return this->isMultiKernelName;
+}
+
+
diff --git a/src/Core/Input/ConfigData/ConfigDataImp.h b/src/Core/Input/ConfigData/ConfigDataImp.h
new file mode 100644
index 000000000..2628e1869
--- /dev/null
+++ b/src/Core/Input/ConfigData/ConfigDataImp.h
@@ -0,0 +1,405 @@
+#ifndef CONFIGDATAIMP_H
+#define CONFIGDATAIMP_H
+
+#include "ConfigData.h"
+
+#include <memory>
+#include <string>
+
+class ConfigDataImp : public ConfigData
+{
+public:
+ static std::shared_ptr<ConfigDataImp> getNewInstance();
+ virtual ~ConfigDataImp(void);
+
+ real getViscosity();
+ uint getNumberOfDevices();
+ std::vector<uint> getDevices();
+ std::string getOutputPath();
+ std::string getPrefix();
+ std::string getGridPath();
+ bool getPrintOutputFiles();
+ bool getGeometryValues();
+ bool getCalc2ndOrderMoments();
+ bool getCalc3rdOrderMoments();
+ bool getCalcHighOrderMoments();
+ bool getReadGeo();
+ bool getCalcMedian();
+ bool getConcFile();
+ bool getUseMeasurePoints();
+ bool getUseWale();
+ bool getSimulatePorousMedia();
+ uint getD3Qxx();
+ uint getTEnd();
+ uint getTOut();
+ uint getTStartOut();
+ uint getTimeCalcMedStart();
+ uint getTimeCalcMedEnd();
+ uint getPressInID();
+ uint getPressOutID();
+ uint getPressInZ();
+ uint getPressOutZ();
+ bool getDiffOn();
+ uint getDiffMod();
+ real getDiffusivity();
+ real getTemperatureInit();
+ real getTemperatureBC();
+ real getVelocity();
+ real getViscosityRatio();
+ real getVelocityRatio();
+ real getDensityRatio();
+ real getPressRatio();
+ real getRealX();
+ real getRealY();
+ real getFactorPressBC();
+ std::string getGeometryFileC();
+ std::string getGeometryFileM();
+ std::string getGeometryFileF();
+ uint getClockCycleForMP();
+ uint getTimestepForMP();
+ real getForcingX();
+ real getForcingY();
+ real getForcingZ();
+ bool getCalcParticles();
+ int getParticleBasicLevel();
+ int getParticleInitLevel();
+ int getNumberOfParticles();
+ real getStartXHotWall();
+ real getEndXHotWall();
+ std::vector<std::string> getPossNeighborFilesX();
+ std::vector<std::string> getPossNeighborFilesY();
+ std::vector<std::string> getPossNeighborFilesZ();
+ //std::vector<std::string> getPossNeighborFilesX();
+ //std::vector<std::string> getPossNeighborFilesY();
+ //std::vector<std::string> getPossNeighborFilesZ();
+ int getTimeDoCheckPoint();
+ int getTimeDoRestart();
+ bool getDoCheckPoint();
+ bool getDoRestart();
+ uint getMaxLevel();
+ std::vector<int> getGridX();
+ std::vector<int> getGridY();
+ std::vector<int> getGridZ();
+ std::vector<int> getDistX();
+ std::vector<int> getDistY();
+ std::vector<int> getDistZ();
+ std::vector<bool> getNeedInterface();
+ std::string getMainKernel();
+ bool getMultiKernelOn();
+ std::vector<int> getMultiKernelLevel();
+ std::vector<std::string> getMultiKernelName();
+
+ void setViscosity(real viscosity);
+ void setNumberOfDevices(uint numberOfDevices);
+ void setDevices(std::vector<uint> devices);
+ void setOutputPath(std::string outputPath);
+ void setPrefix(std::string prefix);
+ void setGridPath(std::string gridPath);
+ void setPrintOutputFiles(bool printOutputFiles);
+ void setGeometryValues(bool geometryValues);
+ void setCalc2ndOrderMoments(bool calc2ndOrderMoments);
+ void setCalc3rdOrderMoments(bool calc3rdOrderMoments);
+ void setCalcHighOrderMoments(bool calcHighOrderMoment);
+ void setReadGeo(bool readGeo);
+ void setCalcMedian(bool calcMedian);
+ void setConcFile(bool concFile);
+ void setUseMeasurePoints(bool useMeasurePoints);
+ void setUseWale(bool useWale);
+ void setSimulatePorousMedia(bool simulatePorousMedia);
+ void setD3Qxx(uint d3Qxx);
+ void setTEnd(uint tEnd);
+ void setTOut(uint tOut);
+ void setTStartOut(uint tStartOut);
+ void setTimeCalcMedStart(uint timeCalcMedStart);
+ void setTimeCalcMedEnd(uint timeCalcMedEnd);
+ void setPressInID(uint pressInID);
+ void setPressOutID(uint pressOutID);
+ void setPressInZ(uint pressInZ);
+ void setPressOutZ(uint pressOutZ);
+ void setDiffOn(bool diffOn);
+ void setDiffMod(uint diffMod);
+ void setDiffusivity(real diffusivity);
+ void setTemperatureInit(real temperatureInit);
+ void setTemperatureBC(real temperatureBC);
+ //void setViscosity(real viscosity);
+ void setVelocity(real velocity);
+ void setViscosityRatio(real viscosityRatio);
+ void setVelocityRatio(real velocityRatio);
+ void setDensityRatio(real fensityRatio);
+ void setPressRatio(real pressRatio);
+ void setRealX(real realX);
+ void setRealY(real realY);
+ void setFactorPressBC(real factorPressBC);
+ void setGeometryFileC(std::string geometryFileC);
+ void setGeometryFileM(std::string geometryFileM);
+ void setGeometryFileF(std::string geometryFileF);
+ void setClockCycleForMP(uint clockCycleForMP);
+ void setTimestepForMP(uint timestepForMP);
+ void setForcingX(real forcingX);
+ void setForcingY(real forcingY);
+ void setForcingZ(real forcingZ);
+ void setCalcParticles(bool calcParticles);
+ void setParticleBasicLevel(int particleBasicLevel);
+ void setParticleInitLevel(int particleInitLevel);
+ void setNumberOfParticles(int numberOfParticles);
+ void setStartXHotWall(real startXHotWall);
+ void setEndXHotWall(real endXHotWall);
+ void setPossNeighborFilesX(std::vector<std::string> possNeighborFilesX);
+ void setPossNeighborFilesY(std::vector<std::string> possNeighborFilesY);
+ void setPossNeighborFilesZ(std::vector<std::string> possNeighborFilesZ);
+ //void setPossNeighborFilesX(std::vector<std::string> possNeighborFilesX);
+ //void setPossNeighborFilesY(std::vector<std::string> possNeighborFilesY);
+ //void setPossNeighborFilesZ(std::vector<std::string> possNeighborFilesZ);
+ void setTimeDoCheckPoint(int timeDoCheckPoint);
+ void setTimeDoRestart(int timeDoRestart);
+ void setDoCheckPoint(bool doCheckPoint);
+ void setDoRestart(bool doRestart);
+ void setMaxLevel(uint maxLevel);
+ void setGridX(std::vector<int> gridX);
+ void setGridY(std::vector<int> gridY);
+ void setGridZ(std::vector<int> gridZ);
+ void setDistX(std::vector<int> distX);
+ void setDistY(std::vector<int> distY);
+ void setDistZ(std::vector<int> distZ);
+ void setNeedInterface(std::vector<bool> needInterface);
+ void setMainKernel(std::string mainKernel);
+ void setMultiKernelOn(bool multiKernelOn);
+ void setMultiKernelLevel(std::vector<int> multiKernelLevel);
+ void setMultiKernelName(std::vector<std::string> multiKernelName);
+
+ bool isViscosityInConfigFile();
+ bool isNumberOfDevicesInConfigFile();
+ bool isDevicesInConfigFile();
+ bool isOutputPathInConfigFile();
+ bool isPrefixInConfigFile();
+ bool isGridPathInConfigFile();
+ bool isPrintOutputFilesInConfigFile();
+ bool isGeometryValuesInConfigFile();
+ bool isCalc2ndOrderMomentsInConfigFile();
+ bool isCalc3rdOrderMomentsInConfigFile();
+ bool isCalcHighOrderMomentsInConfigFile();
+ bool isReadGeoInConfigFile();
+ bool isCalcMedianInConfigFile();
+ bool isConcFileInConfigFile();
+ bool isUseMeasurePointsInConfigFile();
+ bool isUseWaleInConfigFile();
+ bool isSimulatePorousMediaInConfigFile();
+ bool isD3QxxInConfigFile();
+ bool isTEndInConfigFile();
+ bool isTOutInConfigFile();
+ bool isTStartOutInConfigFile();
+ bool isTimeCalcMedStartInConfigFile();
+ bool isTimeCalcMedEndInConfigFile();
+ bool isPressInIDInConfigFile();
+ bool isPressOutIDInConfigFile();
+ bool isPressInZInConfigFile();
+ bool isPressOutZInConfigFile();
+ bool isDiffOnInConfigFile();
+ bool isDiffModInConfigFile();
+ bool isDiffusivityInConfigFile();
+ bool isTemperatureInitInConfigFile();
+ bool isTemperatureBCInConfigFile();
+ //bool isViscosityInConfigFile();
+ bool isVelocityInConfigFile();
+ bool isViscosityRatioInConfigFile();
+ bool isVelocityRatioInConfigFile();
+ bool isDensityRatioInConfigFile();
+ bool isPressRatioInConfigFile();
+ bool isRealXInConfigFile();
+ bool isRealYInConfigFile();
+ bool isFactorPressBCInConfigFile();
+ bool isGeometryFileCInConfigFile();
+ bool isGeometryFileMInConfigFile();
+ bool isGeometryFileFInConfigFile();
+ bool isClockCycleForMPInConfigFile();
+ bool isTimestepForMPInConfigFile();
+ bool isForcingXInConfigFile();
+ bool isForcingYInConfigFile();
+ bool isForcingZInConfigFile();
+ bool isCalcParticlesInConfigFile();
+ bool isParticleBasicLevelInConfigFile();
+ bool isParticleInitLevelInConfigFile();
+ bool isNumberOfParticlesInConfigFile();
+ bool isNeighborWSBInConfigFile();
+ bool isStartXHotWallInConfigFile();
+ bool isEndXHotWallInConfigFile();
+ bool isPossNeighborFilesXInConfigFile();
+ bool isPossNeighborFilesYInConfigFile();
+ bool isPossNeighborFilesZInConfigFile();
+ bool isTimeDoCheckPointInConfigFile();
+ bool isTimeDoRestartInConfigFile();
+ bool isDoCheckPointInConfigFile();
+ bool isDoRestartInConfigFile();
+ bool isMaxLevelInConfigFile();
+ bool isGridXInConfigFile();
+ bool isGridYInConfigFile();
+ bool isGridZInConfigFile();
+ bool isDistXInConfigFile();
+ bool isDistYInConfigFile();
+ bool isDistZInConfigFile();
+ bool isNeedInterfaceInConfigFile();
+ bool isMainKernelInConfigFile();
+ bool isMultiKernelOnInConfigFile();
+ bool isMultiKernelLevelInConfigFile();
+ bool isMultiKernelNameInConfigFile();
+
+
+private:
+ ConfigDataImp();
+
+ real viscosity;
+ uint numberOfDevices;
+ std::vector<uint> devices;
+ std::string outputPath;
+ std::string prefix;
+ std::string gridPath;
+ bool printOutputFiles;
+ bool geometryValues;
+ bool calc2ndOrderMoments;
+ bool calc3rdOrderMoments;
+ bool calcHighOrderMoments;
+ bool readGeo;
+ bool calcMedian;
+ bool concFile;
+ bool useMeasurePoints;
+ bool useWale;
+ bool simulatePorousMedia;
+ uint d3Qxx;
+ uint tEnd;
+ uint tOut;
+ uint tStartOut;
+ uint timeCalcMedStart;
+ uint timeCalcMedEnd;
+ uint pressInID;
+ uint pressOutID;
+ uint pressInZ;
+ uint pressOutZ;
+ bool diffOn;
+ uint diffMod;
+ real diffusivity;
+ real temperatureInit;
+ real temperatureBC;
+ //real viscosity;
+ real velocity;
+ real viscosityRatio;
+ real velocityRatio;
+ real densityRatio;
+ real pressRatio;
+ real realX;
+ real realY;
+ real factorPressBC;
+ std::string geometryFileC;
+ std::string geometryFileM;
+ std::string geometryFileF;
+ uint clockCycleForMP;
+ uint timestepForMP;
+ real forcingX;
+ real forcingY;
+ real forcingZ;
+ bool calcParticles;
+ int particleBasicLevel;
+ int particleInitLevel;
+ int numberOfParticles;
+ real startXHotWall;
+ real endXHotWall;
+ std::vector<std::string> possNeighborFilesX;
+ std::vector<std::string> possNeighborFilesY;
+ std::vector<std::string> possNeighborFilesZ;
+ //std::vector<std::string> possNeighborFilesX;
+ //std::vector<std::string> possNeighborFilesY;
+ //std::vector<std::string> possNeighborFilesZ;
+ int timeDoCheckPoint;
+ int timeDoRestart;
+ bool doCheckPoint;
+ bool doRestart;
+ int maxLevel;
+ std::vector<int> gridX;
+ std::vector<int> gridY;
+ std::vector<int> gridZ;
+ std::vector<int> distX;
+ std::vector<int> distY;
+ std::vector<int> distZ;
+ std::vector<bool> needInterface;
+ std::string mainKernel;
+ bool multiKernelOn;
+ std::vector<int> multiKernelLevel;
+ std::vector<std::string> multiKernelName;
+
+ bool isViscosity;
+ bool isNumberOfDevices;
+ bool isDevices;
+ bool isOutputPath;
+ bool isPrefix;
+ bool isGridPath;
+ bool isPrintOutputFiles;
+ bool isGeometryValues;
+ bool isCalc2ndOrderMoments;
+ bool isCalc3rdOrderMoments;
+ bool isCalcHighOrderMoments;
+ bool isReadGeo;
+ bool isCalcMedian;
+ bool isConcFile;
+ bool isUseMeasurePoints;
+ bool isUseWale;
+ bool isSimulatePorousMedia;
+ bool isD3Qxx;
+ bool isTEnd;
+ bool isTOut;
+ bool isTStartOut;
+ bool isTimeCalcMedStart;
+ bool isTimeCalcMedEnd;
+ bool isPressInID;
+ bool isPressOutID;
+ bool isPressInZ;
+ bool isPressOutZ;
+ bool isDiffOn;
+ bool isDiffMod;
+ bool isDiffusivity;
+ bool isTemperatureInit;
+ bool isTemperatureBC;
+ //bool isViscosity;
+ bool isVelocity;
+ bool isViscosityRatio;
+ bool isVelocityRatio;
+ bool isDensityRatio;
+ bool isPressRatio;
+ bool isRealX;
+ bool isRealY;
+ bool isFactorPressBC;
+ bool isGeometryFileC;
+ bool isGeometryFileM;
+ bool isGeometryFileF;
+ bool isClockCycleForMP;
+ bool isTimestepForMP;
+ bool isForcingX;
+ bool isForcingY;
+ bool isForcingZ;
+ bool isCalcParticles;
+ bool isParticleBasicLevel;
+ bool isParticleInitLevel;
+ bool isNumberOfParticles;
+ bool isNeighborWSB;
+ bool isStartXHotWall;
+ bool isEndXHotWall;
+ bool isPossNeighborFilesX;
+ bool isPossNeighborFilesY;
+ bool isPossNeighborFilesZ;
+ bool isTimeDoCheckPoint;
+ bool isTimeDoRestart;
+ bool isDoCheckPoint;
+ bool isDoRestart;
+ bool isMaxLevel;
+ bool isGridX;
+ bool isGridY;
+ bool isGridZ;
+ bool isDistX;
+ bool isDistY;
+ bool isDistZ;
+ bool isNeedInterface;
+ bool isMainKernel;
+ bool isMultiKernelOn;
+ bool isMultiKernelLevel;
+ bool isMultiKernelName;
+
+};
+#endif
diff --git a/src/Core/Input/ConfigData/package.include b/src/Core/Input/ConfigData/package.include
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/Core/Input/ConfigFileReader/ConfigFileReader.cpp b/src/Core/Input/ConfigFileReader/ConfigFileReader.cpp
new file mode 100644
index 000000000..483856e5c
--- /dev/null
+++ b/src/Core/Input/ConfigFileReader/ConfigFileReader.cpp
@@ -0,0 +1,265 @@
+#include "ConfigFileReader.h"
+#include "../ConfigData/ConfigDataImp.h"
+#include "../Input.h"
+#include "../../StringUtilities/StringUtil.h"
+
+#include <iostream>
+#include <fstream>
+
+
+VF_PUBLIC std::shared_ptr<ConfigFileReader> ConfigFileReader::getNewInstance()
+{
+ return std::shared_ptr<ConfigFileReader>(new ConfigFileReader());
+}
+
+ConfigFileReader::ConfigFileReader()
+{
+
+}
+
+VF_PUBLIC ConfigFileReader::~ConfigFileReader()
+{
+
+}
+
+VF_PUBLIC std::shared_ptr<ConfigData> ConfigFileReader::readConfigFile(const std::string &filePath) const
+{
+ std::shared_ptr<ConfigDataImp> data = ConfigDataImp::getNewInstance();
+ std::ifstream stream;
+ stream.open(filePath.c_str(), std::ios::in);
+ if (stream.fail())
+ throw std::runtime_error("can not open config file!");
+ std::unique_ptr<input::Input> input = input::Input::makeInput(stream, "config");
+
+ if (input->getValue("NumberOfDevices") != "")
+ data->setNumberOfDevices(StringUtil::toInt(input->getValue("NumberOfDevices")));
+
+ if (input->getValue("Devices") != "")
+ data->setDevices(StringUtil::toUintVector(input->getValue("Devices")));
+
+ if (input->getValue("Path") != "")
+ data->setOutputPath(input->getValue("Path"));
+
+ if (input->getValue("Prefix") != "")
+ data->setPrefix(input->getValue("Prefix"));
+
+ if (input->getValue("GridPath") != "")
+ data->setGridPath(input->getValue("GridPath"));
+ else
+ {
+ std::cout << "GridPath has to be defined!" << std::endl;
+ exit(1);
+ }
+
+
+ if (input->getValue("WriteGrid") != "")
+ data->setPrintOutputFiles(StringUtil::toBool(input->getValue("WriteGrid")));
+
+ if (input->getValue("GeometryValues") != "")
+ data->setGeometryValues(StringUtil::toBool(input->getValue("GeometryValues")));
+
+ if (input->getValue("calc2ndOrderMoments") != "")
+ data->setCalc2ndOrderMoments(StringUtil::toBool(input->getValue("calc2ndOrderMoments")));
+
+ if (input->getValue("calc3rdOrderMoments") != "")
+ data->setCalc3rdOrderMoments(StringUtil::toBool(input->getValue("calc3rdOrderMoments")));
+
+ if (input->getValue("calcHigherOrderMoments") != "")
+ data->setCalcHighOrderMoments(StringUtil::toBool(input->getValue("calcHigherOrderMoments")));
+
+ if (input->getValue("ReadGeometry") != "")
+ data->setReadGeo(StringUtil::toBool(input->getValue("ReadGeometry")));
+
+ if (input->getValue("calcMedian") != "")
+ data->setCalcMedian(StringUtil::toBool(input->getValue("calcMedian")));
+
+ if (input->getValue("UseConcFile") != "")
+ data->setConcFile(StringUtil::toBool(input->getValue("UseConcFile")));
+
+ if (input->getValue("UseMeasurePoints") != "")
+ data->setUseMeasurePoints(StringUtil::toBool(input->getValue("UseMeasurePoints")));
+
+ if (input->getValue("UseWale") != "")
+ data->setUseWale(StringUtil::toBool(input->getValue("UseWale")));
+
+ if (input->getValue("SimulatePorousMedia") != "")
+ data->setSimulatePorousMedia(StringUtil::toBool(input->getValue("SimulatePorousMedia")));
+
+ if (input->getValue("D3Qxx") != "")
+ data->setD3Qxx(StringUtil::toInt(input->getValue("D3Qxx")));
+
+ if (input->getValue("TimeEnd") != "")
+ data->setTEnd(StringUtil::toInt(input->getValue("TimeEnd")));
+
+ if (input->getValue("TimeOut") != "")
+ data->setTOut(StringUtil::toInt(input->getValue("TimeOut")));
+
+ if (input->getValue("TimeStartOut") != "")
+ data->setTStartOut(StringUtil::toInt(input->getValue("TimeStartOut")));
+
+ if (input->getValue("TimeStartCalcMedian") != "")
+ data->setTimeCalcMedStart(StringUtil::toInt(input->getValue("TimeStartCalcMedian")));
+
+ if (input->getValue("TimeEndCalcMedian") != "")
+ data->setTimeCalcMedEnd(StringUtil::toInt(input->getValue("TimeEndCalcMedian")));
+
+ if (input->getValue("PressInID") != "")
+ data->setPressInID(StringUtil::toInt(input->getValue("PressInID")));
+
+ if (input->getValue("PressOutID") != "")
+ data->setPressOutID(StringUtil::toInt(input->getValue("PressOutID")));
+
+ if (input->getValue("PressInZ") != "")
+ data->setPressInZ(StringUtil::toInt(input->getValue("PressInZ")));
+
+ if (input->getValue("PressOutZ") != "")
+ data->setPressOutZ(StringUtil::toInt(input->getValue("PressOutZ")));
+ //////////////////////////////////////////////////////////////////////////
+ if (input->getValue("DiffOn") != "")
+ data->setDiffOn(StringUtil::toBool(input->getValue("DiffOn")));
+
+ if (input->getValue("DiffMod") != "")
+ data->setDiffMod(StringUtil::toInt(input->getValue("DiffMod")));
+
+ if (input->getValue("Diffusivity") != "")
+ data->setDiffusivity(StringUtil::toFloat(input->getValue("Diffusivity")));
+
+ if (input->getValue("Temp") != "")
+ data->setTemperatureInit(StringUtil::toFloat(input->getValue("Temp")));
+
+ if (input->getValue("TempBC") != "")
+ data->setTemperatureBC(StringUtil::toFloat(input->getValue("TempBC")));
+ //////////////////////////////////////////////////////////////////////////
+ if (input->getValue("Viscosity_LB") != "")
+ data->setViscosity(StringUtil::toFloat(input->getValue("Viscosity_LB")));
+
+ if (input->getValue("Velocity_LB") != "")
+ data->setVelocity(StringUtil::toFloat(input->getValue("Velocity_LB")));
+
+ if (input->getValue("Viscosity_Ratio_World_to_LB") != "")
+ data->setViscosityRatio(StringUtil::toFloat(input->getValue("Viscosity_Ratio_World_to_LB")));
+
+ if (input->getValue("Velocity_Ratio_World_to_LB") != "")
+ data->setVelocityRatio(StringUtil::toFloat(input->getValue("Velocity_Ratio_World_to_LB")));
+
+ if (input->getValue("Density_Ratio_World_to_LB") != "")
+ data->setDensityRatio(StringUtil::toFloat(input->getValue("Density_Ratio_World_to_LB")));
+
+ if (input->getValue("Delta_Press") != "")
+ data->setPressRatio(StringUtil::toFloat(input->getValue("Delta_Press")));
+
+ if (input->getValue("SliceRealX") != "")
+ data->setRealX(StringUtil::toFloat(input->getValue("SliceRealX")));
+
+ if (input->getValue("SliceRealY") != "")
+ data->setRealY(StringUtil::toFloat(input->getValue("SliceRealY")));
+
+ if (input->getValue("FactorPressBC") != "")
+ data->setFactorPressBC(StringUtil::toFloat(input->getValue("FactorPressBC")));
+
+ if (input->getValue("GeometryC") != "")
+ data->setGeometryFileC(input->getValue("GeometryC"));
+
+ if (input->getValue("GeometryM") != "")
+ data->setGeometryFileM(input->getValue("GeometryM"));
+
+ if (input->getValue("GeometryF") != "")
+ data->setGeometryFileF(input->getValue("GeometryF"));
+ //////////////////////////////////////////////////////////////////////////
+ if (input->getValue("measureClockCycle") != "")
+ data->setClockCycleForMP(StringUtil::toFloat(input->getValue("measureClockCycle")));
+
+ if (input->getValue("measureTimestep") != "")
+ data->setTimestepForMP(StringUtil::toInt(input->getValue("measureTimestep")));
+ //////////////////////////////////////////////////////////////////////////
+ //Forcing
+ if (input->getValue("ForcingX") != "")
+ data->setForcingX(StringUtil::toFloat(input->getValue("ForcingX")));
+ if (input->getValue("ForcingY") != "")
+ data->setForcingY(StringUtil::toFloat(input->getValue("ForcingY")));
+ if (input->getValue("ForcingZ") != "")
+ data->setForcingZ(StringUtil::toFloat(input->getValue("ForcingZ")));
+ //////////////////////////////////////////////////////////////////////////
+ //Particles
+ if (input->getValue("calcParticles") != "")
+ data->setCalcParticles(StringUtil::toBool(input->getValue("calcParticles")));
+
+ if (input->getValue("baseLevel") != "")
+ data->setParticleBasicLevel(StringUtil::toInt(input->getValue("baseLevel")));
+
+ if (input->getValue("initLevel") != "")
+ data->setParticleInitLevel(StringUtil::toInt(input->getValue("initLevel")));
+
+ if (input->getValue("numberOfParticles") != "")
+ data->setNumberOfParticles(StringUtil::toInt(input->getValue("numberOfParticles")));
+
+ if (input->getValue("startXHotWall") != "")
+ data->setStartXHotWall(StringUtil::toDouble(input->getValue("startXHotWall")));
+
+ if (input->getValue("endXHotWall") != "")
+ data->setEndXHotWall(StringUtil::toDouble(input->getValue("endXHotWall")));
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //Restart
+ if (input->getValue("TimeDoCheckPoint") != "")
+ data->setTimeDoCheckPoint(StringUtil::toInt(input->getValue("TimeDoCheckPoint")));
+
+ if (input->getValue("TimeDoRestart") != "")
+ data->setTimeDoRestart(StringUtil::toInt(input->getValue("TimeDoRestart")));
+
+ if (input->getValue("DoCheckPoint") != "")
+ data->setDoCheckPoint(StringUtil::toBool(input->getValue("DoCheckPoint")));
+
+ if (input->getValue("DoRestart") != "")
+ data->setDoRestart(StringUtil::toBool(input->getValue("DoRestart")));
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if (input->getValue("NOGL") != "")
+ data->setMaxLevel(StringUtil::toInt(input->getValue("NOGL")));
+
+ if (input->getValue("GridX") != "")
+ data->setGridX(StringUtil::toIntVector(input->getValue("GridX")));
+
+ if (input->getValue("GridY") != "")
+ data->setGridY(StringUtil::toIntVector(input->getValue("GridY")));
+
+ if (input->getValue("GridZ") != "")
+ data->setGridZ(StringUtil::toIntVector(input->getValue("GridZ")));
+
+ if (input->getValue("DistX") != "")
+ data->setDistX(StringUtil::toIntVector(input->getValue("DistX")));
+
+ if (input->getValue("DistY") != "")
+ data->setDistY(StringUtil::toIntVector(input->getValue("DistY")));
+
+ if (input->getValue("DistZ") != "")
+ data->setDistZ(StringUtil::toIntVector(input->getValue("DistZ")));
+
+ if (input->getValue("NeedInterface") != "")
+ data->setNeedInterface(StringUtil::toBoolVector(input->getValue("NeedInterface")));
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Kernel
+ if (input->getValue("MainKernelName") != "")
+ data->setMainKernel(input->getValue("MainKernelName"));
+
+ if (input->getValue("MultiKernelOn") != "")
+ data->setMultiKernelOn(StringUtil::toBool(input->getValue("MultiKernelOn")));
+
+ if (input->getValue("MultiKernelLevel") != "")
+ data->setMultiKernelLevel(StringUtil::toIntVector(input->getValue("MultiKernelLevel")));
+
+ if (input->getValue("MultiKernelName") != "")
+ data->setMultiKernelName(StringUtil::toStringVector(input->getValue("MultiKernelName")));
+
+ if (StringUtil::toStringVector(input->getValue("MultiKernelName")).size() != StringUtil::toIntVector(input->getValue("MultiKernelLevel")).size())
+ {
+ std::cout << "MultiKernelName and MultiKernelLevel has to be of same size!" << std::endl;
+ exit(1);
+ }
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ return data;
+
+}
+
+
+
+
diff --git a/src/Core/Input/ConfigFileReader/ConfigFileReader.h b/src/Core/Input/ConfigFileReader/ConfigFileReader.h
new file mode 100644
index 000000000..42bb1b29b
--- /dev/null
+++ b/src/Core/Input/ConfigFileReader/ConfigFileReader.h
@@ -0,0 +1,21 @@
+#ifndef CONFIGFILEREADER_H
+#define CONFIGFILEREADER_H
+
+#include "../Input.h"
+
+#include <memory>
+
+class ConfigData;
+
+class ConfigFileReader
+{
+public:
+ VF_PUBLIC static std::shared_ptr<ConfigFileReader> getNewInstance();
+ VF_PUBLIC virtual ~ConfigFileReader(void);
+
+ VF_PUBLIC std::shared_ptr<ConfigData> readConfigFile(const std::string &filePath) const;
+
+private:
+ ConfigFileReader();
+};
+#endif
diff --git a/src/Core/Input/ConfigFileReader/package.include b/src/Core/Input/ConfigFileReader/package.include
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/VirtualFluids_GPU/Parameter/Parameter.cpp b/src/VirtualFluids_GPU/Parameter/Parameter.cpp
index 88ab57701..6826c5369 100644
--- a/src/VirtualFluids_GPU/Parameter/Parameter.cpp
+++ b/src/VirtualFluids_GPU/Parameter/Parameter.cpp
@@ -7,19 +7,509 @@
#include <stdlib.h>
#include <math.h>
+
+#include "Core/Input/ConfigData/ConfigData.h"
+#include "Core/StringUtilities/StringUtil.h"
+#include "VirtualFluids_GPU/Communication/Communicator.h"
//#ifdef WIN32
// #include <Winsock2.h>
//#endif
//lib for windows Ws2_32.lib
+
SPtr<Parameter> Parameter::make()
{
return SPtr<Parameter>(new Parameter());
}
+SPtr<Parameter> Parameter::make(SPtr<ConfigData> configData, Communicator* comm)
+{
+ return SPtr<Parameter>(new Parameter(configData, comm));
+}
+
Parameter::Parameter()
{
}
+Parameter::Parameter(SPtr<ConfigData> configData, Communicator* comm)
+{
+ //////////////////////////////////////////////////////////////////////////
+ this->setNumprocs(comm->getNummberOfProcess());
+ this->setMyID(comm->getPID());
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isNumberOfDevicesInConfigFile())
+ this->setMaxDev(configData->getNumberOfDevices());
+ else
+ this->setMaxDev((int)1);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isDevicesInConfigFile())
+ this->setDevices(configData->getDevices());
+ else
+ this->setDevices(std::vector<uint>{(uint)0});
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isOutputPathInConfigFile())
+ this->setOutputPath(configData->getOutputPath());
+ else
+ this->setOutputPath("C:/Output/");
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPrefixInConfigFile())
+ this->setOutputPrefix(configData->getPrefix());
+ else
+ this->setOutputPrefix("MyFile");
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPrintOutputFilesInConfigFile())
+ this->setPrintFiles(configData->getPrintOutputFiles());
+ else
+ this->setPrintFiles(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isGeometryValuesInConfigFile())
+ this->setGeometryValues(configData->getGeometryValues());
+ else
+ this->setGeometryValues(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isCalc2ndOrderMomentsInConfigFile())
+ this->setCalc2ndOrderMoments(configData->getCalc2ndOrderMoments());
+ else
+ this->setCalc2ndOrderMoments(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isCalc3rdOrderMomentsInConfigFile())
+ this->setCalc3rdOrderMoments(configData->getCalc3rdOrderMoments());
+ else
+ this->setCalc3rdOrderMoments(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isCalcHighOrderMomentsInConfigFile())
+ this->setCalcHighOrderMoments(configData->getCalcHighOrderMoments());
+ else
+ this->setCalcHighOrderMoments(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isCalcMedianInConfigFile())
+ this->setCalcMedian(configData->getCalcMedian());
+ else
+ this->setCalcMedian(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isConcFileInConfigFile())
+ this->setConcFile(configData->getConcFile());
+ else
+ this->setConcFile(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isUseMeasurePointsInConfigFile())
+ this->setUseMeasurePoints(configData->getUseMeasurePoints());
+ else
+ this->setUseMeasurePoints(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isUseWaleInConfigFile())
+ this->setUseWale(configData->getUseWale());
+ else
+ this->setUseWale(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isSimulatePorousMediaInConfigFile())
+ this->setSimulatePorousMedia(configData->getSimulatePorousMedia());
+ else
+ this->setSimulatePorousMedia(false);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isD3QxxInConfigFile())
+ this->setD3Qxx(configData->getD3Qxx());
+ else
+ this->setD3Qxx((int)27);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isTEndInConfigFile())
+ this->setTEnd(configData->getTEnd());
+ else
+ this->setTEnd((uint)10);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isTOutInConfigFile())
+ this->setTOut(configData->getTOut());
+ else
+ this->setTOut((uint)1);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isTStartOutInConfigFile())
+ this->setTStartOut(configData->getTStartOut());
+ else
+ this->setTStartOut((uint)0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isTimeCalcMedStartInConfigFile())
+ this->setTimeCalcMedStart(configData->getTimeCalcMedStart());
+ else
+ this->setTimeCalcMedStart((int)0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isTimeCalcMedEndInConfigFile())
+ this->setTimeCalcMedEnd(configData->getTimeCalcMedEnd());
+ else
+ this->setTimeCalcMedEnd((int)10);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPressInIDInConfigFile())
+ this->setPressInID(configData->getPressInID());
+ else
+ this->setPressInID((uint)0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPressOutIDInConfigFile())
+ this->setPressOutID(configData->getPressOutID());
+ else
+ this->setPressOutID((uint)0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPressInZInConfigFile())
+ this->setPressInZ(configData->getPressInZ());
+ else
+ this->setPressInZ((uint)1);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPressOutZInConfigFile())
+ this->setPressOutZ(configData->getPressOutZ());
+ else
+ this->setPressOutZ((uint)2);
+ //////////////////////////////////////////////////////////////////////////
+ //second component
+ if (configData->isDiffOnInConfigFile())
+ this->setDiffOn(configData->getDiffOn());
+ else
+ this->setDiffOn(false);
+
+ if (configData->isDiffModInConfigFile())
+ this->setDiffMod(configData->getDiffMod());
+ else
+ this->setDiffMod((int)27);
+
+ if (configData->isDiffusivityInConfigFile())
+ this->setDiffusivity(configData->getDiffusivity());
+ else
+ this->setDiffusivity((real)0.001);
+
+ if (configData->isTemperatureInitInConfigFile())
+ this->setTemperatureInit(configData->getTemperatureInit());
+ else
+ this->setTemperatureInit((real)0.0);
+
+ if (configData->isTemperatureBCInConfigFile())
+ this->setTemperatureBC(configData->getTemperatureBC());
+ else
+ this->setTemperatureBC((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isViscosityInConfigFile())
+ this->setViscosity(configData->getViscosity());
+ else
+ this->setViscosity((real)0.001);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isVelocityInConfigFile())
+ this->setVelocity(configData->getVelocity());
+ else
+ this->setVelocity((real)0.01);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isViscosityRatioInConfigFile())
+ this->setViscosityRatio(configData->getViscosityRatio());
+ else
+ this->setViscosityRatio((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isVelocityRatioInConfigFile())
+ this->setVelocityRatio(configData->getVelocityRatio());
+ else
+ this->setVelocityRatio((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isDensityRatioInConfigFile())
+ this->setDensityRatio(configData->getDensityRatio());
+ else
+ this->setDensityRatio((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isPressRatioInConfigFile())
+ this->setPressRatio(configData->getPressRatio());
+ else
+ this->setPressRatio((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isRealXInConfigFile())
+ this->setRealX(configData->getRealX());
+ else
+ this->setRealX((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isRealYInConfigFile())
+ this->setRealY(configData->getRealY());
+ else
+ this->setRealY((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isFactorPressBCInConfigFile())
+ this->setFactorPressBC(configData->getFactorPressBC());
+ else
+ this->setFactorPressBC((real)1.0);
+ //////////////////////////////////////////////////////////////////////////
+ //read Geometry (STL)
+ if (configData->isReadGeoInConfigFile())
+ this->setReadGeo(configData->getReadGeo());
+ else
+ this->setReadGeo(false);
+
+ if (configData->isGeometryFileCInConfigFile())
+ this->setGeometryFileC(configData->getGeometryFileC());
+ else if (this->getReadGeo())
+ {
+ std::cout << "GeometryFileC has to be defined!" << std::endl;
+ exit(1);
+ }
+ else
+ this->setGeometryFileC("");
+
+ if (configData->isGeometryFileMInConfigFile())
+ this->setGeometryFileM(configData->getGeometryFileM());
+ else if (this->getReadGeo())
+ {
+ std::cout << "GeometryFileM has to be defined!" << std::endl;
+ exit(1);
+ }
+ else
+ this->setGeometryFileM("");
+
+ if (configData->isGeometryFileFInConfigFile())
+ this->setGeometryFileF(configData->getGeometryFileF());
+ else if (this->getReadGeo())
+ {
+ std::cout << "GeometryFileF has to be defined!" << std::endl;
+ exit(1);
+ }
+ else
+ this->setGeometryFileF("");
+ //////////////////////////////////////////////////////////////////////////
+ if (configData->isClockCycleForMPInConfigFile())
+ this->setclockCycleForMP(configData->getClockCycleForMP());
+ else
+ this->setclockCycleForMP((real)1.0);
+
+ if (configData->isTimestepForMPInConfigFile())
+ this->settimestepForMP(configData->getTimestepForMP());
+ else
+ this->settimestepForMP((uint)10);
+ //////////////////////////////////////////////////////////////////////////
+ std::string gridPath = "";
+ if (configData->isGridPathInConfigFile())
+ gridPath = configData->getGridPath();
+ else
+ {
+ std::cout << "GridPath has to be defined!" << std::endl;
+ exit(1);
+ }
+
+ if (this->getNumprocs() == 1)
+ gridPath += "/";
+ else
+ gridPath += "/" + StringUtil::toString(this->getMyID()) + "/";
+ //////////////////////////////////////////////////////////////////////////
+ this->setFName(this->getOutputPath() + "/" + this->getOutputPrefix());
+ //////////////////////////////////////////////////////////////////////////
+ this->setgeoVec( gridPath + "geoVec.dat");
+ this->setcoordX( gridPath + "coordX.dat");
+ this->setcoordY( gridPath + "coordY.dat");
+ this->setcoordZ( gridPath + "coordZ.dat");
+ this->setneighborX( gridPath + "neighborX.dat");
+ this->setneighborY( gridPath + "neighborY.dat");
+ this->setneighborZ( gridPath + "neighborZ.dat");
+ this->setneighborWSB( gridPath + "neighborWSB.dat");
+ this->setscaleCFC( gridPath + "scaleCFC.dat");
+ this->setscaleCFF( gridPath + "scaleCFF.dat");
+ this->setscaleFCC( gridPath + "scaleFCC.dat");
+ this->setscaleFCF( gridPath + "scaleFCF.dat");
+ this->setscaleOffsetCF( gridPath + "offsetVecCF.dat");
+ this->setscaleOffsetFC( gridPath + "offsetVecFC.dat");
+ this->setgeomBoundaryBcQs( gridPath + "geomBoundaryQs.dat");
+ this->setgeomBoundaryBcValues( gridPath + "geomBoundaryValues.dat");
+ this->setinletBcQs( gridPath + "inletBoundaryQs.dat");
+ this->setinletBcValues( gridPath + "inletBoundaryValues.dat");
+ this->setoutletBcQs( gridPath + "outletBoundaryQs.dat");
+ this->setoutletBcValues( gridPath + "outletBoundaryValues.dat");
+ this->settopBcQs( gridPath + "topBoundaryQs.dat");
+ this->settopBcValues( gridPath + "topBoundaryValues.dat");
+ this->setbottomBcQs( gridPath + "bottomBoundaryQs.dat");
+ this->setbottomBcValues( gridPath + "bottomBoundaryValues.dat");
+ this->setfrontBcQs( gridPath + "frontBoundaryQs.dat");
+ this->setfrontBcValues( gridPath + "frontBoundaryValues.dat");
+ this->setbackBcQs( gridPath + "backBoundaryQs.dat");
+ this->setbackBcValues( gridPath + "backBoundaryValues.dat");
+ this->setnumberNodes( gridPath + "numberNodes.dat");
+ this->setLBMvsSI( gridPath + "LBMvsSI.dat");
+ this->setmeasurePoints( gridPath + "measurePoints.dat");
+ this->setpropellerValues( gridPath + "propellerValues.dat");
+ this->setcpTop( gridPath + "cpTop.dat");
+ this->setcpBottom( gridPath + "cpBottom.dat");
+ this->setcpBottom2( gridPath + "cpBottom2.dat");
+ this->setConcentration( gridPath + "conc.dat");
+ //////////////////////////////////////////////////////////////////////////
+ //Normals - Geometry
+ this->setgeomBoundaryNormalX(gridPath + "geomBoundaryNormalX.dat");
+ this->setgeomBoundaryNormalY(gridPath + "geomBoundaryNormalY.dat");
+ this->setgeomBoundaryNormalZ(gridPath + "geomBoundaryNormalZ.dat");
+ //Normals - Inlet
+ this->setInflowBoundaryNormalX(gridPath + "inletBoundaryNormalX.dat");
+ this->setInflowBoundaryNormalY(gridPath + "inletBoundaryNormalY.dat");
+ this->setInflowBoundaryNormalZ(gridPath + "inletBoundaryNormalZ.dat");
+ //Normals - Outlet
+ this->setOutflowBoundaryNormalX(gridPath + "outletBoundaryNormalX.dat");
+ this->setOutflowBoundaryNormalY(gridPath + "outletBoundaryNormalY.dat");
+ this->setOutflowBoundaryNormalZ(gridPath + "outletBoundaryNormalZ.dat");
+ //////////////////////////////////////////////////////////////////////////
+ //Forcing
+ real forcingX = 0.0;
+ real forcingY = 0.0;
+ real forcingZ = 0.0;
+
+ if (configData->isForcingXInConfigFile())
+ forcingX = configData->getForcingX();
+ if (configData->isForcingYInConfigFile())
+ forcingY = configData->getForcingY();
+ if (configData->isForcingZInConfigFile())
+ forcingZ = configData->getForcingZ();
+
+ this->setForcing(forcingX, forcingY, forcingZ);
+ //////////////////////////////////////////////////////////////////////////
+ //Particles
+ if (configData->isCalcParticlesInConfigFile())
+ this->setCalcParticles(configData->getCalcParticles());
+ else
+ this->setCalcParticles(false);
+
+ if (configData->isParticleBasicLevelInConfigFile())
+ this->setParticleBasicLevel(configData->getParticleBasicLevel());
+ else
+ this->setParticleBasicLevel((int)0);
+
+ if (configData->isParticleInitLevelInConfigFile())
+ this->setParticleInitLevel(configData->getParticleInitLevel());
+ else
+ this->setParticleInitLevel((int)0);
+
+ if (configData->isNumberOfParticlesInConfigFile())
+ this->setNumberOfParticles(configData->getNumberOfParticles());
+ else
+ this->setNumberOfParticles((int)0);
+
+ if (configData->isStartXHotWallInConfigFile())
+ this->setStartXHotWall(configData->getStartXHotWall());
+ else
+ this->setStartXHotWall((real)0);
+
+ if (configData->isEndXHotWallInConfigFile())
+ this->setEndXHotWall(configData->getEndXHotWall());
+ else
+ this->setEndXHotWall((real)0);
+ //////////////////////////////////////////////////////////////////////////
+ //for Multi GPU
+ if (this->getNumprocs() > 1)
+ {
+ //////////////////////////////////////////////////////////////////////////
+ //3D domain decomposition
+ std::vector<std::string> sendProcNeighborsX, sendProcNeighborsY, sendProcNeighborsZ;
+ std::vector<std::string> recvProcNeighborsX, recvProcNeighborsY, recvProcNeighborsZ;
+ for (int i = 0; i < this->getNumprocs(); i++)
+ {
+ sendProcNeighborsX.push_back(gridPath + StringUtil::toString(i) + "Xs.dat");
+ sendProcNeighborsY.push_back(gridPath + StringUtil::toString(i) + "Ys.dat");
+ sendProcNeighborsZ.push_back(gridPath + StringUtil::toString(i) + "Zs.dat");
+ recvProcNeighborsX.push_back(gridPath + StringUtil::toString(i) + "Xr.dat");
+ recvProcNeighborsY.push_back(gridPath + StringUtil::toString(i) + "Yr.dat");
+ recvProcNeighborsZ.push_back(gridPath + StringUtil::toString(i) + "Zr.dat");
+ }
+ this->setPossNeighborFilesX(sendProcNeighborsX, "send");
+ this->setPossNeighborFilesY(sendProcNeighborsY, "send");
+ this->setPossNeighborFilesZ(sendProcNeighborsZ, "send");
+ this->setPossNeighborFilesX(recvProcNeighborsX, "recv");
+ this->setPossNeighborFilesY(recvProcNeighborsY, "recv");
+ this->setPossNeighborFilesZ(recvProcNeighborsZ, "recv");
+ }
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //Restart
+ if (configData->isTimeDoCheckPointInConfigFile())
+ this->setTimeDoCheckPoint(configData->getTimeDoCheckPoint());
+ else
+ this->setTimeDoCheckPoint((uint)0);
+
+ if (configData->isTimeDoRestartInConfigFile())
+ this->setTimeDoRestart(configData->getTimeDoRestart());
+ else
+ this->setTimeDoRestart((uint)0);
+
+ if (configData->isDoCheckPointInConfigFile())
+ this->setDoCheckPoint(configData->getDoCheckPoint());
+ else
+ this->setDoCheckPoint(false);
+
+ if (configData->isDoRestartInConfigFile())
+ this->setDoRestart(configData->getDoRestart());
+ else
+ this->setDoRestart(false);
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if (configData->isMaxLevelInConfigFile())
+ this->setMaxLevel(configData->getMaxLevel());
+ else
+ this->setMaxLevel((int)1);
+
+ if (configData->isGridXInConfigFile())
+ this->setGridX(configData->getGridX());
+ else
+ this->setGridX(std::vector<int>(this->getMaxLevel()+1, 32));
+
+ if (configData->isGridYInConfigFile())
+ this->setGridY(configData->getGridY());
+ else
+ this->setGridY(std::vector<int>(this->getMaxLevel()+1, 32));
+
+ if (configData->isGridZInConfigFile())
+ this->setGridZ(configData->getGridZ());
+ else
+ this->setGridZ(std::vector<int>(this->getMaxLevel()+1, 32));
+
+ if (configData->isDistXInConfigFile())
+ this->setDistX(configData->getDistX());
+ else
+ this->setDistX(std::vector<int>(this->getMaxLevel()+1, 32));
+
+ if (configData->isDistYInConfigFile())
+ this->setDistY(configData->getDistY());
+ else
+ this->setDistY(std::vector<int>(this->getMaxLevel()+1, 32));
+
+ if (configData->isDistZInConfigFile())
+ this->setDistZ(configData->getDistZ());
+ else
+ this->setDistZ(std::vector<int>(this->getMaxLevel()+1, 32));
+
+ if (configData->isNeedInterfaceInConfigFile())
+ this->setNeedInterface(configData->getNeedInterface());
+ else
+ this->setNeedInterface(std::vector<bool>(6, true));
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Kernel
+ if (configData->isMainKernelInConfigFile())
+ this->setMainKernel(configData->getMainKernel());
+ else
+ this->setMainKernel("CumulantOneCompSP27");
+
+ if (configData->isMultiKernelOnInConfigFile())
+ this->setMultiKernelOn(configData->getMultiKernelOn());
+ else
+ this->setMultiKernelOn(false);
+
+ if (configData->isMultiKernelLevelInConfigFile())
+ this->setMultiKernelLevel(configData->getMultiKernelLevel());
+ else if (this->getMultiKernelOn())
+ {
+ std::vector<int> tmp;
+ for (int i = 0; i < this->getMaxLevel()+1; i++)
+ {
+ tmp.push_back(i);
+ }
+ this->setMultiKernelLevel(tmp);
+ }
+ else
+ this->setMultiKernelLevel(std::vector<int>(0));
+
+ if (configData->isMultiKernelNameInConfigFile())
+ this->setMultiKernelName(configData->getMultiKernelName());
+ else if (this->getMultiKernelOn())
+ {
+ std::vector<std::string> tmp;
+ for (int i = 0; i < this->getMaxLevel()+1; i++)
+ {
+ tmp.push_back("CumulantOneCompSP27");
+ }
+ this->setMultiKernelName(tmp);
+ }
+ else
+ this->setMultiKernelName(std::vector<std::string>(0));
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+}
Parameter::~Parameter()
{
}
@@ -59,10 +549,10 @@ void Parameter::initParameter()
parH[i]->sizePlaneXY = parH[i]->nx * parH[i]->ny;
parH[i]->sizePlaneYZ = parH[i]->ny * parH[i]->nz;
parH[i]->sizePlaneXZ = parH[i]->nx * parH[i]->nz;
- parH[i]->mem_size_real = sizeof(real ) * parH[i]->size_Mat;
+ parH[i]->mem_size_real = sizeof(real ) * parH[i]->size_Mat;
parH[i]->mem_size_int = sizeof(unsigned int) * parH[i]->size_Mat;
parH[i]->mem_size_bool = sizeof(bool ) * parH[i]->size_Mat;
- parH[i]->mem_size_real_yz = sizeof(real ) * parH[i]->ny * parH[i]->nz;
+ parH[i]->mem_size_real_yz = sizeof(real ) * parH[i]->ny * parH[i]->nz;
parH[i]->evenOrOdd = true;
parH[i]->startz = parH[i]->gridNZ * ic.myid;
parH[i]->endz = parH[i]->gridNZ * ic.myid + parH[i]->gridNZ;
@@ -137,10 +627,10 @@ void Parameter::initParameter()
parD[i]->sizePlaneXY = parH[i]->sizePlaneXY;
parD[i]->sizePlaneYZ = parH[i]->sizePlaneYZ;
parD[i]->sizePlaneXZ = parH[i]->sizePlaneXZ;
- parD[i]->mem_size_real = sizeof(real ) * parD[i]->size_Mat;
+ parD[i]->mem_size_real = sizeof(real ) * parD[i]->size_Mat;
parD[i]->mem_size_int = sizeof(unsigned int) * parD[i]->size_Mat;
parD[i]->mem_size_bool = sizeof(bool ) * parD[i]->size_Mat;
- parD[i]->mem_size_real_yz = sizeof(real ) * parD[i]->ny * parD[i]->nz;
+ parD[i]->mem_size_real_yz = sizeof(real ) * parD[i]->ny * parD[i]->nz;
parD[i]->evenOrOdd = parH[i]->evenOrOdd;
parD[i]->startz = parH[i]->startz;
parD[i]->endz = parH[i]->endz;
@@ -2891,7 +3381,7 @@ void Parameter::setNumprocs(int numprocs)
{
ic.numprocs = numprocs;
}
-void Parameter::setDevices(std::vector<int> devices)
+void Parameter::setDevices(std::vector<uint> devices)
{
ic.devices = devices;
}
@@ -3840,7 +4330,7 @@ int Parameter::getNumprocs()
{
return ic.numprocs;
}
-std::vector<int> Parameter::getDevices()
+std::vector<uint> Parameter::getDevices()
{
return ic.devices;
}
diff --git a/src/VirtualFluids_GPU/Parameter/Parameter.h b/src/VirtualFluids_GPU/Parameter/Parameter.h
index 0d993f700..d99494434 100644
--- a/src/VirtualFluids_GPU/Parameter/Parameter.h
+++ b/src/VirtualFluids_GPU/Parameter/Parameter.h
@@ -17,6 +17,9 @@
#include "Core/PointerDefinitions.h"
#include "VirtualFluidsDefinitions.h"
+class ConfigData;
+class Communicator;
+
//struct
struct ParameterStruct{
bool evenOrOdd;
@@ -275,6 +278,7 @@ public:
//Parameter();
////////////////////////////////////////////////////////////////////////////
static SPtr<Parameter> make();
+ static SPtr<Parameter> make(SPtr<ConfigData> configData, Communicator* comm);
static Parameter* getInstanz();
@@ -670,7 +674,7 @@ public:
void setUseWale(bool useWale);
void setSimulatePorousMedia(bool simulatePorousMedia);
void setclockCycleForMP(real clockCycleForMP);
- void setDevices(std::vector<int> devices);
+ void setDevices(std::vector<uint> devices);
void setGridX(std::vector<int> GridX);
void setGridY(std::vector<int> GridY);
void setGridZ(std::vector<int> GridZ);
@@ -863,7 +867,7 @@ public:
real getRe();
real getFactorPressBC();
real getclockCycleForMP();
- std::vector<int> getDevices();
+ std::vector<uint> getDevices();
std::vector<int> getGridX();
std::vector<int> getGridY();
std::vector<int> getGridZ();
@@ -995,6 +999,7 @@ private:
//LogWriter output;
Parameter();
+ Parameter(SPtr<ConfigData> configData, Communicator* comm);
Parameter(const Parameter&);
void initInterfaceParameter(int level);
real TrafoXtoWorld(int CoordX, int level);
diff --git a/targets/apps/LBM/Basel/main.cpp b/targets/apps/LBM/Basel/main.cpp
index ef6711f45..43aab9e01 100644
--- a/targets/apps/LBM/Basel/main.cpp
+++ b/targets/apps/LBM/Basel/main.cpp
@@ -19,6 +19,7 @@
#include "Core/LbmOrGks.h"
#include "Core/Input/Input.h"
#include "Core/StringUtilities/StringUtil.h"
+#include "Core/Input/ConfigFileReader/ConfigFileReader.h"
#include "VirtualFluids_GPU/LBM/Simulation.h"
#include "VirtualFluids_GPU/Communication/Communicator.h"
@@ -54,222 +55,6 @@
#include "utilities/communication.h"
#include "utilities/transformator/TransformatorImp.h"
-std::string getGridPath(std::shared_ptr<Parameter> para, std::string Gridpath)
-{
- if (para->getNumprocs() == 1)
- return Gridpath + "/";
-
- return Gridpath + "/" + StringUtil::toString(para->getMyID()) + "/";
-}
-
-void setParameters(std::shared_ptr<Parameter> para, std::unique_ptr<input::Input> &input)
-{
- Communicator* comm = Communicator::getInstanz();
-
- para->setMaxDev(StringUtil::toInt(input->getValue("NumberOfDevices")));
- para->setNumprocs(comm->getNummberOfProcess());
- para->setDevices(StringUtil::toIntVector(input->getValue("Devices")));
- para->setMyID(comm->getPID());
-
- std::string _path = input->getValue("Path");
- std::string _prefix = input->getValue("Prefix");
- std::string _gridpath = input->getValue("GridPath");
- std::string gridPath = getGridPath(para, _gridpath);
- para->setOutputPath(_path);
- para->setOutputPrefix(_prefix);
- para->setFName(_path + "/" + _prefix);
- para->setPrintFiles(false);
- para->setPrintFiles(StringUtil::toBool(input->getValue("WriteGrid")));
- para->setGeometryValues(StringUtil::toBool(input->getValue("GeometryValues")));
- para->setCalc2ndOrderMoments(StringUtil::toBool(input->getValue("calc2ndOrderMoments")));
- para->setCalc3rdOrderMoments(StringUtil::toBool(input->getValue("calc3rdOrderMoments")));
- para->setCalcHighOrderMoments(StringUtil::toBool(input->getValue("calcHigherOrderMoments")));
- para->setReadGeo(StringUtil::toBool(input->getValue("ReadGeometry")));
- para->setCalcMedian(StringUtil::toBool(input->getValue("calcMedian")));
- para->setConcFile(StringUtil::toBool(input->getValue("UseConcFile")));
- para->setUseMeasurePoints(StringUtil::toBool(input->getValue("UseMeasurePoints")));
- para->setUseWale(StringUtil::toBool(input->getValue("UseWale")));
- para->setSimulatePorousMedia(StringUtil::toBool(input->getValue("SimulatePorousMedia")));
- para->setD3Qxx(StringUtil::toInt(input->getValue("D3Qxx")));
- para->setTEnd(StringUtil::toInt(input->getValue("TimeEnd")));
- para->setTOut(StringUtil::toInt(input->getValue("TimeOut")));
- para->setTStartOut(StringUtil::toInt(input->getValue("TimeStartOut")));
- para->setTimeCalcMedStart(StringUtil::toInt(input->getValue("TimeStartCalcMedian")));
- para->setTimeCalcMedEnd(StringUtil::toInt(input->getValue("TimeEndCalcMedian")));
- para->setPressInID(StringUtil::toInt(input->getValue("PressInID")));
- para->setPressOutID(StringUtil::toInt(input->getValue("PressOutID")));
- para->setPressInZ(StringUtil::toInt(input->getValue("PressInZ")));
- para->setPressOutZ(StringUtil::toInt(input->getValue("PressOutZ")));
- //////////////////////////////////////////////////////////////////////////
- para->setCompOn(StringUtil::toBool(input->getValue("CompOn")));
- para->setDiffOn(StringUtil::toBool(input->getValue("DiffOn")));
- para->setDiffMod(StringUtil::toInt(input->getValue("DiffMod")));
- para->setDiffusivity(StringUtil::toFloat(input->getValue("Diffusivity")));
- para->setTemperatureInit(StringUtil::toFloat(input->getValue("Temp")));
- para->setTemperatureBC(StringUtil::toFloat(input->getValue("TempBC")));
- //////////////////////////////////////////////////////////////////////////
- para->setViscosity(StringUtil::toFloat(input->getValue("Viscosity_LB")));
- para->setVelocity(StringUtil::toFloat(input->getValue("Velocity_LB")));
- para->setViscosityRatio(StringUtil::toFloat(input->getValue("Viscosity_Ratio_World_to_LB")));
- para->setVelocityRatio(StringUtil::toFloat(input->getValue("Velocity_Ratio_World_to_LB")));
- para->setDensityRatio(StringUtil::toFloat(input->getValue("Density_Ratio_World_to_LB")));
- para->setPressRatio(StringUtil::toFloat(input->getValue("Delta_Press")));
- para->setRealX(StringUtil::toFloat(input->getValue("SliceRealX")));
- para->setRealY(StringUtil::toFloat(input->getValue("SliceRealY")));
- para->setFactorPressBC(StringUtil::toFloat(input->getValue("dfpbc")));
- para->setGeometryFileC(input->getValue("GeometryC"));
- para->setGeometryFileM(input->getValue("GeometryM"));
- para->setGeometryFileF(input->getValue("GeometryF"));
- //////////////////////////////////////////////////////////////////////////
- para->setgeoVec(gridPath + input->getValue("geoVec"));
- para->setcoordX(gridPath + input->getValue("coordX"));
- para->setcoordY(gridPath + input->getValue("coordY"));
- para->setcoordZ(gridPath + input->getValue("coordZ"));
- para->setneighborX(gridPath + input->getValue("neighborX"));
- para->setneighborY(gridPath + input->getValue("neighborY"));
- para->setneighborZ(gridPath + input->getValue("neighborZ"));
- para->setscaleCFC(gridPath + input->getValue("scaleCFC"));
- para->setscaleCFF(gridPath + input->getValue("scaleCFF"));
- para->setscaleFCC(gridPath + input->getValue("scaleFCC"));
- para->setscaleFCF(gridPath + input->getValue("scaleFCF"));
- para->setscaleOffsetCF(gridPath + input->getValue("scaleOffsetCF"));
- para->setscaleOffsetFC(gridPath + input->getValue("scaleOffsetFC"));
- para->setgeomBoundaryBcQs(gridPath + input->getValue("geomBoundaryBcQs"));
- para->setgeomBoundaryBcValues(gridPath + input->getValue("geomBoundaryBcValues"));
- para->setinletBcQs(gridPath + input->getValue("inletBcQs"));
- para->setinletBcValues(gridPath + input->getValue("inletBcValues"));
- para->setoutletBcQs(gridPath + input->getValue("outletBcQs"));
- para->setoutletBcValues(gridPath + input->getValue("outletBcValues"));
- para->settopBcQs(gridPath + input->getValue("topBcQs"));
- para->settopBcValues(gridPath + input->getValue("topBcValues"));
- para->setbottomBcQs(gridPath + input->getValue("bottomBcQs"));
- para->setbottomBcValues(gridPath + input->getValue("bottomBcValues"));
- para->setfrontBcQs(gridPath + input->getValue("frontBcQs"));
- para->setfrontBcValues(gridPath + input->getValue("frontBcValues"));
- para->setbackBcQs(gridPath + input->getValue("backBcQs"));
- para->setbackBcValues(gridPath + input->getValue("backBcValues"));
- para->setnumberNodes(gridPath + input->getValue("numberNodes"));
- para->setLBMvsSI(gridPath + input->getValue("LBMvsSI"));
- //////////////////////////////gridPath + ////////////////////////////////////////////
- para->setmeasurePoints(gridPath + input->getValue("measurePoints"));
- para->setpropellerValues(gridPath + input->getValue("propellerValues"));
- para->setclockCycleForMP(StringUtil::toFloat(input->getValue("measureClockCycle")));
- para->settimestepForMP(StringUtil::toInt(input->getValue("measureTimestep")));
- para->setcpTop(gridPath + input->getValue("cpTop"));
- para->setcpBottom(gridPath + input->getValue("cpBottom"));
- para->setcpBottom2(gridPath + input->getValue("cpBottom2"));
- para->setConcentration(gridPath + input->getValue("Concentration"));
- //////////////////////////////////////////////////////////////////////////
- //Normals - Geometry
- para->setgeomBoundaryNormalX(gridPath + input->getValue("geomBoundaryNormalX"));
- para->setgeomBoundaryNormalY(gridPath + input->getValue("geomBoundaryNormalY"));
- para->setgeomBoundaryNormalZ(gridPath + input->getValue("geomBoundaryNormalZ"));
- //Normals - Inlet
- para->setInflowBoundaryNormalX(gridPath + input->getValue("inletBoundaryNormalX"));
- para->setInflowBoundaryNormalY(gridPath + input->getValue("inletBoundaryNormalY"));
- para->setInflowBoundaryNormalZ(gridPath + input->getValue("inletBoundaryNormalZ"));
- //Normals - Outlet
- para->setOutflowBoundaryNormalX(gridPath + input->getValue("outletBoundaryNormalX"));
- para->setOutflowBoundaryNormalY(gridPath + input->getValue("outletBoundaryNormalY"));
- para->setOutflowBoundaryNormalZ(gridPath + input->getValue("outletBoundaryNormalZ"));
- //////////////////////////////////////////////////////////////////////////
- //Forcing
- para->setForcing(StringUtil::toFloat(input->getValue("ForcingX")), StringUtil::toFloat(input->getValue("ForcingY")), StringUtil::toFloat(input->getValue("ForcingZ")));
- //////////////////////////////////////////////////////////////////////////
- //Particles
- para->setCalcParticles(StringUtil::toBool(input->getValue("calcParticles")));
- para->setParticleBasicLevel(StringUtil::toInt(input->getValue("baseLevel")));
- para->setParticleInitLevel(StringUtil::toInt(input->getValue("initLevel")));
- para->setNumberOfParticles(StringUtil::toInt(input->getValue("numberOfParticles")));
- para->setneighborWSB(gridPath + input->getValue("neighborWSB"));
- para->setStartXHotWall(StringUtil::toDouble(input->getValue("startXHotWall")));
- para->setEndXHotWall(StringUtil::toDouble(input->getValue("endXHotWall")));
- //////////////////////////////////////////////////////////////////////////
- //for Multi GPU
- if (para->getNumprocs() > 1)
- {
- ////////////////////////////////////////////////////////////////////////////
- ////1D domain decomposition
- //std::vector<std::string> sendProcNeighbors;
- //std::vector<std::string> recvProcNeighbors;
- //for (int i = 0; i<para->getNumprocs();i++)
- //{
- // sendProcNeighbors.push_back(gridPath + StringUtil::toString(i) + "s.dat");
- // recvProcNeighbors.push_back(gridPath + StringUtil::toString(i) + "r.dat");
- //}
- //para->setPossNeighborFiles(sendProcNeighbors, "send");
- //para->setPossNeighborFiles(recvProcNeighbors, "recv");
- //////////////////////////////////////////////////////////////////////////
- //3D domain decomposition
- std::vector<std::string> sendProcNeighborsX, sendProcNeighborsY, sendProcNeighborsZ;
- std::vector<std::string> recvProcNeighborsX, recvProcNeighborsY, recvProcNeighborsZ;
- for (int i = 0; i < para->getNumprocs(); i++)
- {
- sendProcNeighborsX.push_back(gridPath + StringUtil::toString(i) + "Xs.dat");
- sendProcNeighborsY.push_back(gridPath + StringUtil::toString(i) + "Ys.dat");
- sendProcNeighborsZ.push_back(gridPath + StringUtil::toString(i) + "Zs.dat");
- recvProcNeighborsX.push_back(gridPath + StringUtil::toString(i) + "Xr.dat");
- recvProcNeighborsY.push_back(gridPath + StringUtil::toString(i) + "Yr.dat");
- recvProcNeighborsZ.push_back(gridPath + StringUtil::toString(i) + "Zr.dat");
- }
- para->setPossNeighborFilesX(sendProcNeighborsX, "send");
- para->setPossNeighborFilesY(sendProcNeighborsY, "send");
- para->setPossNeighborFilesZ(sendProcNeighborsZ, "send");
- para->setPossNeighborFilesX(recvProcNeighborsX, "recv");
- para->setPossNeighborFilesY(recvProcNeighborsY, "recv");
- para->setPossNeighborFilesZ(recvProcNeighborsZ, "recv");
- }
- //////////////////////////////////////////////////////////////////////////
- //para->setkFull( input->getValue( "kFull" ));
- //para->setgeoFull( input->getValue( "geoFull" ));
- //para->setnoSlipBcPos( input->getValue( "noSlipBcPos" ));
- //para->setnoSlipBcQs( input->getValue( "noSlipBcQs" ));
- //para->setnoSlipBcValues( input->getValue( "noSlipBcValues" ));
- //para->setnoSlipBcValue( input->getValue( "noSlipBcValue" ));
- //para->setslipBcPos( input->getValue( "slipBcPos" ));
- //para->setslipBcQs( input->getValue( "slipBcQs" ));
- //para->setslipBcValue( input->getValue( "slipBcValue" ));
- //para->setpressBcPos( input->getValue( "pressBcPos" ));
- //para->setpressBcQs( input->getValue( "pressBcQs" ));
- //para->setpressBcValues( input->getValue( "pressBcValues" ));
- //para->setpressBcValue( input->getValue( "pressBcValue" ));
- //para->setvelBcQs( input->getValue( "velBcQs" ));
- //para->setvelBcValues( input->getValue( "velBcValues" ));
- //para->setpropellerCylinder( input->getValue( "propellerCylinder" ));
- //para->setpropellerQs( input->getValue( "propellerQs" ));
- //para->setwallBcQs( input->getValue( "wallBcQs" ));
- //para->setwallBcValues( input->getValue( "wallBcValues" ));
- //para->setperiodicBcQs( input->getValue( "periodicBcQs" ));
- //para->setperiodicBcValues( input->getValue( "periodicBcValues" ));
- //cout << "Try this: " << para->getgeomBoundaryBcValues() << endl;
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //Restart
- para->setTimeDoCheckPoint(StringUtil::toInt(input->getValue("TimeDoCheckPoint")));
- para->setTimeDoRestart(StringUtil::toInt(input->getValue("TimeDoRestart")));
- para->setDoCheckPoint(StringUtil::toBool(input->getValue("DoCheckPoint")));
- para->setDoRestart(StringUtil::toBool(input->getValue("DoRestart")));
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->setMaxLevel(StringUtil::toInt(input->getValue("NOGL")));
- para->setGridX(StringUtil::toIntVector(input->getValue("GridX")));
- para->setGridY(StringUtil::toIntVector(input->getValue("GridY")));
- para->setGridZ(StringUtil::toIntVector(input->getValue("GridZ")));
- para->setDistX(StringUtil::toIntVector(input->getValue("DistX")));
- para->setDistY(StringUtil::toIntVector(input->getValue("DistY")));
- para->setDistZ(StringUtil::toIntVector(input->getValue("DistZ")));
-
- para->setNeedInterface(std::vector<bool>{true, true, true, true, true, true});
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- // Kernel
- para->setMainKernel(input->getValue("MainKernelName"));
- para->setMultiKernelOn(StringUtil::toBool(input->getValue("multiKernelOn")));
- para->setMultiKernelLevel(StringUtil::toIntVector(input->getValue("multiKernelLevel")));
- para->setMultiKernelName(StringUtil::toStringVector(input->getValue("multiKernelName")));
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-}
-
-
void multipleLevel(const std::string& configPath)
{
@@ -291,8 +76,12 @@ void multipleLevel(const std::string& configPath)
//gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::POINT_UNDER_TRIANGLE);
auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
-
- SPtr<Parameter> para = Parameter::make();
+
+ SPtr<ConfigFileReader> configReader = ConfigFileReader::getNewInstance();
+ SPtr<ConfigData> configData = configReader->readConfigFile(configPath);
+ Communicator* comm = Communicator::getInstanz();
+
+ SPtr<Parameter> para = Parameter::make(configData, comm);
SPtr<GridProvider> gridGenerator;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -306,7 +95,7 @@ void multipleLevel(const std::string& configPath)
real dx = 1.2;
real vx = 0.05;
- TriangularMesh* BaselSTL = TriangularMesh::make("M:/Basel2019/stl/BaselUrbanProfile_066_deg_bridge_All_CLOSED.stl");
+ TriangularMesh* BaselSTL = TriangularMesh::make("E:/temp/Basel2019/stl/BaselUrbanProfile_066_deg_bridge_All_CLOSED.stl");
gridBuilder->addCoarseGrid(-256.0, -256.0, - 8.0,
256.0, 256.0, 160.0, dx);
@@ -326,23 +115,23 @@ void multipleLevel(const std::string& configPath)
//////////////////////////////////////////////////////////////////////////
- gridBuilder->writeGridsToVtk("M:/Basel2019/grids/BaselUni/Basel_Grid");
+ gridBuilder->writeGridsToVtk("E:/temp/Basel2019/grids/BaselUni/Basel_Grid");
- SimulationFileWriter::write("M:/Basel2019/grids/BaselUni/", gridBuilder, FILEFORMAT::BINARY);
+ SimulationFileWriter::write("E:/temp/Basel2019/grids/BaselUni/", gridBuilder, FILEFORMAT::BINARY);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StreetPointFinder finder;
- finder.readStreets("C:/Users/schoen/Desktop/git/MS2/git/targets/apps/LBM/streetTest/resources/ExampleStreets.txt");
+ finder.readStreets("C:/Users/schoen/Desktop/git/MS/git/targets/apps/LBM/streetTest/resources/ExampleStreets.txt");
- finder.writeVTK("F:/Work/Computations/NagelSchreckenberg/ExampleStreets.vtk");
+ finder.writeVTK("E:/temp/Basel2019/results/ExampleStreets.vtk");
finder.findIndicesLB(gridBuilder->getGrid(0));
- finder.writeConnectionVTK("M:/Basel2019/grids/BaselUni/Basel_Grid/ExampleStreetsConnection.vtk", gridBuilder->getGrid(0));
+ finder.writeConnectionVTK("E:/temp/Basel2019/grids/BaselUni/Basel_Grid/ExampleStreetsConnection.vtk", gridBuilder->getGrid(0));
- finder.writeSimulationFile("M:/Basel2019/grids/BaselUni/", 1.0, gridBuilder->getNumberOfLevels(), 0);
+ finder.writeSimulationFile("E:/temp/Basel2019/grids/BaselUni/", 1.0, gridBuilder->getNumberOfLevels(), 0);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -366,14 +155,12 @@ void multipleLevel(const std::string& configPath)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- std::ifstream stream;
- stream.open(configPath.c_str(), std::ios::in);
- if (stream.fail())
- throw std::runtime_error("can not open config file!");
-
- UPtr<input::Input> input = input::Input::makeInput(stream, "config");
+ //std::ifstream stream;
+ //stream.open(configPath.c_str(), std::ios::in);
+ //if (stream.fail())
+ // throw std::runtime_error("can not open config file!");
- setParameters(para, input);
+ //UPtr<input::Input> input = input::Input::makeInput(stream, "config");
Simulation sim;
SPtr<FileWriter> fileWriter = SPtr<FileWriter>(new FileWriter());
@@ -411,7 +198,7 @@ int main( int argc, char* argv[])
{
try
{
- multipleLevel("C:/Users/schoen/Desktop/bin/ReleaseBasel/configBasel.txt");
+ multipleLevel("E:/temp/Basel2019/config/configBasel.txt");
//multipleLevel("F:/Work/Computations/gridGenerator/inp/configTest.txt");
}
catch (const std::exception& e)
diff --git a/targets/apps/LBM/TGV_3D/TGV_3D.cpp b/targets/apps/LBM/TGV_3D/TGV_3D.cpp
index 4f5386486..7d28afa55 100644
--- a/targets/apps/LBM/TGV_3D/TGV_3D.cpp
+++ b/targets/apps/LBM/TGV_3D/TGV_3D.cpp
@@ -20,6 +20,7 @@
#include "Core/LbmOrGks.h"
#include "Core/Input/Input.h"
#include "Core/StringUtilities/StringUtil.h"
+#include "Core/Input/ConfigFileReader/ConfigFileReader.h"
#include "VirtualFluids_GPU/LBM/Simulation.h"
#include "VirtualFluids_GPU/Communication/Communicator.h"
@@ -53,215 +54,7 @@
#include "utilities/communication.h"
#include "utilities/transformator/TransformatorImp.h"
-std::string getGridPath(std::shared_ptr<Parameter> para, std::string Gridpath)
-{
- if (para->getNumprocs() == 1)
- return Gridpath + "/";
-
- return Gridpath + "/" + StringUtil::toString(para->getMyID()) + "/";
-}
-
-void setParameters(std::shared_ptr<Parameter> para, std::unique_ptr<input::Input> &input)
-{
- Communicator* comm = Communicator::getInstanz();
-
- para->setMaxDev(StringUtil::toInt(input->getValue("NumberOfDevices")));
- para->setNumprocs(comm->getNummberOfProcess());
- para->setDevices(StringUtil::toIntVector(input->getValue("Devices")));
- para->setMyID(comm->getPID());
-
- std::string _path = input->getValue("Path");
- std::string _prefix = input->getValue("Prefix");
- std::string _gridpath = input->getValue("GridPath");
- std::string gridPath = getGridPath(para, _gridpath);
- para->setOutputPath(_path);
- para->setOutputPrefix(_prefix);
- para->setFName(_path + "/" + _prefix);
- para->setPrintFiles(false);
- para->setPrintFiles(StringUtil::toBool(input->getValue("WriteGrid")));
- para->setGeometryValues(StringUtil::toBool(input->getValue("GeometryValues")));
- para->setCalc2ndOrderMoments(StringUtil::toBool(input->getValue("calc2ndOrderMoments")));
- para->setCalc3rdOrderMoments(StringUtil::toBool(input->getValue("calc3rdOrderMoments")));
- para->setCalcHighOrderMoments(StringUtil::toBool(input->getValue("calcHigherOrderMoments")));
- para->setReadGeo(StringUtil::toBool(input->getValue("ReadGeometry")));
- para->setCalcMedian(StringUtil::toBool(input->getValue("calcMedian")));
- para->setConcFile(StringUtil::toBool(input->getValue("UseConcFile")));
- para->setUseMeasurePoints(StringUtil::toBool(input->getValue("UseMeasurePoints")));
- para->setUseWale(StringUtil::toBool(input->getValue("UseWale")));
- para->setSimulatePorousMedia(StringUtil::toBool(input->getValue("SimulatePorousMedia")));
- para->setD3Qxx(StringUtil::toInt(input->getValue("D3Qxx")));
- para->setTEnd(StringUtil::toInt(input->getValue("TimeEnd")));
- para->setTOut(StringUtil::toInt(input->getValue("TimeOut")));
- para->setTStartOut(StringUtil::toInt(input->getValue("TimeStartOut")));
- para->setTimeCalcMedStart(StringUtil::toInt(input->getValue("TimeStartCalcMedian")));
- para->setTimeCalcMedEnd(StringUtil::toInt(input->getValue("TimeEndCalcMedian")));
- para->setPressInID(StringUtil::toInt(input->getValue("PressInID")));
- para->setPressOutID(StringUtil::toInt(input->getValue("PressOutID")));
- para->setPressInZ(StringUtil::toInt(input->getValue("PressInZ")));
- para->setPressOutZ(StringUtil::toInt(input->getValue("PressOutZ")));
- //////////////////////////////////////////////////////////////////////////
- para->setDiffOn(StringUtil::toBool(input->getValue("DiffOn")));
- para->setDiffMod(StringUtil::toInt(input->getValue("DiffMod")));
- para->setDiffusivity(StringUtil::toFloat(input->getValue("Diffusivity")));
- para->setTemperatureInit(StringUtil::toFloat(input->getValue("Temp")));
- para->setTemperatureBC(StringUtil::toFloat(input->getValue("TempBC")));
- //////////////////////////////////////////////////////////////////////////
- para->setViscosity(StringUtil::toFloat(input->getValue("Viscosity_LB")));
- para->setVelocity(StringUtil::toFloat(input->getValue("Velocity_LB")));
- para->setViscosityRatio(StringUtil::toFloat(input->getValue("Viscosity_Ratio_World_to_LB")));
- para->setVelocityRatio(StringUtil::toFloat(input->getValue("Velocity_Ratio_World_to_LB")));
- para->setDensityRatio(StringUtil::toFloat(input->getValue("Density_Ratio_World_to_LB")));
- para->setPressRatio(StringUtil::toFloat(input->getValue("Delta_Press")));
- para->setRealX(StringUtil::toFloat(input->getValue("SliceRealX")));
- para->setRealY(StringUtil::toFloat(input->getValue("SliceRealY")));
- para->setFactorPressBC(StringUtil::toFloat(input->getValue("dfpbc")));
- para->setGeometryFileC(input->getValue("GeometryC"));
- para->setGeometryFileM(input->getValue("GeometryM"));
- para->setGeometryFileF(input->getValue("GeometryF"));
- //////////////////////////////////////////////////////////////////////////
- para->setgeoVec(gridPath + input->getValue("geoVec"));
- para->setcoordX(gridPath + input->getValue("coordX"));
- para->setcoordY(gridPath + input->getValue("coordY"));
- para->setcoordZ(gridPath + input->getValue("coordZ"));
- para->setneighborX(gridPath + input->getValue("neighborX"));
- para->setneighborY(gridPath + input->getValue("neighborY"));
- para->setneighborZ(gridPath + input->getValue("neighborZ"));
- para->setscaleCFC(gridPath + input->getValue("scaleCFC"));
- para->setscaleCFF(gridPath + input->getValue("scaleCFF"));
- para->setscaleFCC(gridPath + input->getValue("scaleFCC"));
- para->setscaleFCF(gridPath + input->getValue("scaleFCF"));
- para->setscaleOffsetCF(gridPath + input->getValue("scaleOffsetCF"));
- para->setscaleOffsetFC(gridPath + input->getValue("scaleOffsetFC"));
- para->setgeomBoundaryBcQs(gridPath + input->getValue("geomBoundaryBcQs"));
- para->setgeomBoundaryBcValues(gridPath + input->getValue("geomBoundaryBcValues"));
- para->setinletBcQs(gridPath + input->getValue("inletBcQs"));
- para->setinletBcValues(gridPath + input->getValue("inletBcValues"));
- para->setoutletBcQs(gridPath + input->getValue("outletBcQs"));
- para->setoutletBcValues(gridPath + input->getValue("outletBcValues"));
- para->settopBcQs(gridPath + input->getValue("topBcQs"));
- para->settopBcValues(gridPath + input->getValue("topBcValues"));
- para->setbottomBcQs(gridPath + input->getValue("bottomBcQs"));
- para->setbottomBcValues(gridPath + input->getValue("bottomBcValues"));
- para->setfrontBcQs(gridPath + input->getValue("frontBcQs"));
- para->setfrontBcValues(gridPath + input->getValue("frontBcValues"));
- para->setbackBcQs(gridPath + input->getValue("backBcQs"));
- para->setbackBcValues(gridPath + input->getValue("backBcValues"));
- para->setnumberNodes(gridPath + input->getValue("numberNodes"));
- para->setLBMvsSI(gridPath + input->getValue("LBMvsSI"));
- //////////////////////////////gridPath + ////////////////////////////////////////////
- para->setmeasurePoints(gridPath + input->getValue("measurePoints"));
- para->setpropellerValues(gridPath + input->getValue("propellerValues"));
- para->setclockCycleForMP(StringUtil::toFloat(input->getValue("measureClockCycle")));
- para->settimestepForMP(StringUtil::toInt(input->getValue("measureTimestep")));
- para->setcpTop(gridPath + input->getValue("cpTop"));
- para->setcpBottom(gridPath + input->getValue("cpBottom"));
- para->setcpBottom2(gridPath + input->getValue("cpBottom2"));
- para->setConcentration(gridPath + input->getValue("Concentration"));
- //////////////////////////////////////////////////////////////////////////
- //Normals - Geometry
- para->setgeomBoundaryNormalX(gridPath + input->getValue("geomBoundaryNormalX"));
- para->setgeomBoundaryNormalY(gridPath + input->getValue("geomBoundaryNormalY"));
- para->setgeomBoundaryNormalZ(gridPath + input->getValue("geomBoundaryNormalZ"));
- //Normals - Inlet
- para->setInflowBoundaryNormalX(gridPath + input->getValue("inletBoundaryNormalX"));
- para->setInflowBoundaryNormalY(gridPath + input->getValue("inletBoundaryNormalY"));
- para->setInflowBoundaryNormalZ(gridPath + input->getValue("inletBoundaryNormalZ"));
- //Normals - Outlet
- para->setOutflowBoundaryNormalX(gridPath + input->getValue("outletBoundaryNormalX"));
- para->setOutflowBoundaryNormalY(gridPath + input->getValue("outletBoundaryNormalY"));
- para->setOutflowBoundaryNormalZ(gridPath + input->getValue("outletBoundaryNormalZ"));
- //////////////////////////////////////////////////////////////////////////
- //Forcing
- para->setForcing(StringUtil::toFloat(input->getValue("ForcingX")), StringUtil::toFloat(input->getValue("ForcingY")), StringUtil::toFloat(input->getValue("ForcingZ")));
- //////////////////////////////////////////////////////////////////////////
- //Particles
- para->setCalcParticles(StringUtil::toBool(input->getValue("calcParticles")));
- para->setParticleBasicLevel(StringUtil::toInt(input->getValue("baseLevel")));
- para->setParticleInitLevel(StringUtil::toInt(input->getValue("initLevel")));
- para->setNumberOfParticles(StringUtil::toInt(input->getValue("numberOfParticles")));
- para->setneighborWSB(gridPath + input->getValue("neighborWSB"));
- para->setStartXHotWall(StringUtil::toDouble(input->getValue("startXHotWall")));
- para->setEndXHotWall(StringUtil::toDouble(input->getValue("endXHotWall")));
- //////////////////////////////////////////////////////////////////////////
- //for Multi GPU
- if (para->getNumprocs() > 1)
- {
- ////////////////////////////////////////////////////////////////////////////
- ////1D domain decomposition
- //std::vector<std::string> sendProcNeighbors;
- //std::vector<std::string> recvProcNeighbors;
- //for (int i = 0; i<para->getNumprocs();i++)
- //{
- // sendProcNeighbors.push_back(gridPath + StringUtil::toString(i) + "s.dat");
- // recvProcNeighbors.push_back(gridPath + StringUtil::toString(i) + "r.dat");
- //}
- //para->setPossNeighborFiles(sendProcNeighbors, "send");
- //para->setPossNeighborFiles(recvProcNeighbors, "recv");
- //////////////////////////////////////////////////////////////////////////
- //3D domain decomposition
- std::vector<std::string> sendProcNeighborsX, sendProcNeighborsY, sendProcNeighborsZ;
- std::vector<std::string> recvProcNeighborsX, recvProcNeighborsY, recvProcNeighborsZ;
- for (int i = 0; i < para->getNumprocs(); i++)
- {
- sendProcNeighborsX.push_back(gridPath + StringUtil::toString(i) + "Xs.dat");
- sendProcNeighborsY.push_back(gridPath + StringUtil::toString(i) + "Ys.dat");
- sendProcNeighborsZ.push_back(gridPath + StringUtil::toString(i) + "Zs.dat");
- recvProcNeighborsX.push_back(gridPath + StringUtil::toString(i) + "Xr.dat");
- recvProcNeighborsY.push_back(gridPath + StringUtil::toString(i) + "Yr.dat");
- recvProcNeighborsZ.push_back(gridPath + StringUtil::toString(i) + "Zr.dat");
- }
- para->setPossNeighborFilesX(sendProcNeighborsX, "send");
- para->setPossNeighborFilesY(sendProcNeighborsY, "send");
- para->setPossNeighborFilesZ(sendProcNeighborsZ, "send");
- para->setPossNeighborFilesX(recvProcNeighborsX, "recv");
- para->setPossNeighborFilesY(recvProcNeighborsY, "recv");
- para->setPossNeighborFilesZ(recvProcNeighborsZ, "recv");
- }
- //////////////////////////////////////////////////////////////////////////
- //para->setkFull( input->getValue( "kFull" ));
- //para->setgeoFull( input->getValue( "geoFull" ));
- //para->setnoSlipBcPos( input->getValue( "noSlipBcPos" ));
- //para->setnoSlipBcQs( input->getValue( "noSlipBcQs" ));
- //para->setnoSlipBcValues( input->getValue( "noSlipBcValues" ));
- //para->setnoSlipBcValue( input->getValue( "noSlipBcValue" ));
- //para->setslipBcPos( input->getValue( "slipBcPos" ));
- //para->setslipBcQs( input->getValue( "slipBcQs" ));
- //para->setslipBcValue( input->getValue( "slipBcValue" ));
- //para->setpressBcPos( input->getValue( "pressBcPos" ));
- //para->setpressBcQs( input->getValue( "pressBcQs" ));
- //para->setpressBcValues( input->getValue( "pressBcValues" ));
- //para->setpressBcValue( input->getValue( "pressBcValue" ));
- //para->setvelBcQs( input->getValue( "velBcQs" ));
- //para->setvelBcValues( input->getValue( "velBcValues" ));
- //para->setpropellerCylinder( input->getValue( "propellerCylinder" ));
- //para->setpropellerQs( input->getValue( "propellerQs" ));
- //para->setwallBcQs( input->getValue( "wallBcQs" ));
- //para->setwallBcValues( input->getValue( "wallBcValues" ));
- //para->setperiodicBcQs( input->getValue( "periodicBcQs" ));
- //para->setperiodicBcValues( input->getValue( "periodicBcValues" ));
- //cout << "Try this: " << para->getgeomBoundaryBcValues() << endl;
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //Restart
- para->setTimeDoCheckPoint(StringUtil::toInt(input->getValue("TimeDoCheckPoint")));
- para->setTimeDoRestart(StringUtil::toInt(input->getValue("TimeDoRestart")));
- para->setDoCheckPoint(StringUtil::toBool(input->getValue("DoCheckPoint")));
- para->setDoRestart(StringUtil::toBool(input->getValue("DoRestart")));
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->setMaxLevel(StringUtil::toInt(input->getValue("NOGL")));
- para->setGridX(StringUtil::toIntVector(input->getValue("GridX")));
- para->setGridY(StringUtil::toIntVector(input->getValue("GridY")));
- para->setGridZ(StringUtil::toIntVector(input->getValue("GridZ")));
- para->setDistX(StringUtil::toIntVector(input->getValue("DistX")));
- para->setDistY(StringUtil::toIntVector(input->getValue("DistY")));
- para->setDistZ(StringUtil::toIntVector(input->getValue("DistZ")));
-
- para->setNeedInterface(std::vector<bool>{true, true, true, true, true, true});
-}
-
-
-
-void multipleLevel(const std::string& configPath, uint nx, int gpuIndex)
+void multipleLevel(const std::string& configPath, uint nx, uint gpuIndex)
{
//std::ofstream logFile( "F:/Work/Computations/gridGenerator/grid/gridGeneratorLog.txt" );
//std::ofstream logFile( "grid/gridGeneratorLog.txt" );
@@ -282,7 +75,10 @@ void multipleLevel(const std::string& configPath, uint nx, int gpuIndex)
auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
- SPtr<Parameter> para = Parameter::make();
+ SPtr<ConfigFileReader> configReader = ConfigFileReader::getNewInstance();
+ SPtr<ConfigData> configData = configReader->readConfigFile(configPath);
+ Communicator* comm = Communicator::getInstanz();
+ SPtr<Parameter> para = Parameter::make(configData, comm);
SPtr<GridProvider> gridGenerator;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -323,39 +119,25 @@ void multipleLevel(const std::string& configPath, uint nx, int gpuIndex)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ //std::stringstream _path;
+ // std::stringstream _prefix;
+ // //_path << "F:/Work/Computations/TaylorGreenVortex_3D/TGV_LBM/" << nx << "_Re_1.6e4";
+ // //_path << "F:/Work/Computations/TaylorGreenVortex_3D/TGV_LBM/" << nx << "_neqInit";
+ // _path << "F:/Work/Computations/TaylorGreenVortex_3D/TGV_LBM/Re_1600/AA2016/" << nx << "_FD_O8";
- std::ifstream stream;
- stream.open(configPath.c_str(), std::ios::in);
- if (stream.fail())
- throw std::runtime_error("can not open config file!");
-
- UPtr<input::Input> input = input::Input::makeInput(stream, "config");
-
- setParameters(para, input);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- std::stringstream _path;
- std::stringstream _prefix;
-
- //_path << "F:/Work/Computations/TaylorGreenVortex_3D/TGV_LBM/" << nx << "_Re_1.6e4";
- //_path << "F:/Work/Computations/TaylorGreenVortex_3D/TGV_LBM/" << nx << "_neqInit";
- _path << "F:/Work/Computations/TaylorGreenVortex_3D/TGV_LBM/Re_1600/AA2016/" << nx << "_FD_O8";
-
- //_path << "./results/AA2016/" << nx;
- //_path << "./results/CumOne/" << nx;
- //_path << "./results/F3_2018/" << nx;
+ // //_path << "./results/AA2016/" << nx;
+ // //_path << "./results/CumOne/" << nx;
+ // //_path << "./results/F3_2018/" << nx;
- _prefix << "TGV_3D_" << nx << "_" ;
+ // _prefix << "TGV_3D_" << nx << "_" ;
- para->setOutputPath(_path.str());
- para->setOutputPrefix(_prefix.str());
- para->setFName(_path.str() + "/" + _prefix.str());
+ // para->setOutputPath(_path.str());
+ // para->setOutputPrefix(_prefix.str());
+ // para->setFName(_path.str() + "/" + _prefix.str());
- para->setDevices({gpuIndex});
+ // para->setDevices(std::vector<uint>{gpuIndex});
//////////////////////////////////////////////////////////////////////////
@@ -391,7 +173,7 @@ int main( int argc, char* argv[])
{
//////////////////////////////////////////////////////////////////////////
- uint gpuIndex = 0;
+ uint gpuIndex = 2;
uint nx = 64;
@@ -399,8 +181,7 @@ int main( int argc, char* argv[])
if( argc > 2 ) nx = atoi( argv[2] );
- multipleLevel("F:/Work/Computations/inp/configTGV3D.txt", nx, gpuIndex);
- //multipleLevel("./inp/configTGV3D.txt", nx, gpuIndex);
+ multipleLevel("C:/Users/schoen/Desktop/bin/3D/VirtualFluidsGpuCodes/TGV3D/configTGV3D.txt", nx, gpuIndex);
//////////////////////////////////////////////////////////////////////////
}
diff --git a/targets/apps/LBM/lbmTest/main.cpp b/targets/apps/LBM/lbmTest/main.cpp
index f55e5b908..56c36c395 100644
--- a/targets/apps/LBM/lbmTest/main.cpp
+++ b/targets/apps/LBM/lbmTest/main.cpp
@@ -66,7 +66,7 @@ void setParameters(std::shared_ptr<Parameter> para, std::unique_ptr<input::Input
para->setMaxDev(StringUtil::toInt(input->getValue("NumberOfDevices")));
para->setNumprocs(comm->getNummberOfProcess());
- para->setDevices(StringUtil::toIntVector(input->getValue("Devices")));
+ para->setDevices(StringUtil::toUintVector(input->getValue("Devices")));
para->setMyID(comm->getPID());
std::string _path = input->getValue("Path");
diff --git a/targets/apps/LBM/metisTest/main.cpp b/targets/apps/LBM/metisTest/main.cpp
index 498f1c8ea..fb5116d5d 100644
--- a/targets/apps/LBM/metisTest/main.cpp
+++ b/targets/apps/LBM/metisTest/main.cpp
@@ -65,7 +65,7 @@ void setParameters(std::shared_ptr<Parameter> para, std::unique_ptr<input::Input
para->setMaxDev(StringUtil::toInt(input->getValue("NumberOfDevices")));
para->setNumprocs(comm->getNummberOfProcess());
- para->setDevices(StringUtil::toIntVector(input->getValue("Devices")));
+ para->setDevices(StringUtil::toUintVector(input->getValue("Devices")));
para->setMyID(comm->getPID());
std::string _path = input->getValue("Path");
--
GitLab