Skip to content
Snippets Groups Projects
Commit c952bf6f authored by LEGOLAS\lenz's avatar LEGOLAS\lenz
Browse files

implements alternative SutherlandsLaw

parent b80f9d07
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 181 additions and 168 deletions
CMakeLists.txt
+ 14
− 13
View file @ c952bf6f
......@@ -77,8 +77,8 @@ ENDIF(MSVC)
### OPTIONS ###
#############################################################
option(BUILD_SHARED_LIBS "Build shared libraries" ON )
option(VF.BUILD_VF_GPU "Build VirtualFluids GPU" ON )
option(VF.BUILD_VF_GKS "Build VirtualFluids GKS" OFF)
option(VF.BUILD_VF_GPU "Build VirtualFluids GPU" OFF)
option(VF.BUILD_VF_GKS "Build VirtualFluids GKS" ON )
option(VF.BUILD_VF_TRAFFIC "Build VirtualFluids Traffic" OFF)
option(VF.BUILD_JSONCPP "Builds json cpp " OFF)
option(VF.BUILD_NUMERIC_TESTS "Build numeric tests" OFF)
......@@ -166,33 +166,34 @@ IF (VF.BUILD_VF_GKS)
#add_subdirectory(targets/apps/GKS/LiFuXu)
#add_subdirectory(targets/apps/GKS/TaylorGreen3D)
add_subdirectory(targets/apps/GKS/DrivenCavity3D)
#add_subdirectory(targets/apps/GKS/DrivenCavity3D)
#add_subdirectory(targets/apps/GKS/ThermalCavity)
add_subdirectory(targets/apps/GKS/ThermalCavityMultiGPU)
#add_subdirectory(targets/apps/GKS/ThermalCavityMultiGPU)
#add_subdirectory(targets/apps/GKS/DrivenCavityMultiGPU)
add_subdirectory(targets/apps/GKS/RayleighBenardMultiGPU)
add_subdirectory(targets/apps/GKS/SalinasVazquez)
#add_subdirectory(targets/apps/GKS/SalinasVazquez)
#add_subdirectory(targets/apps/GKS/BoundaryJet)
#add_subdirectory(targets/apps/GKS/PropaneFlame)
add_subdirectory(targets/apps/GKS/ConfinedCombustion)
#add_subdirectory(targets/apps/GKS/ConfinedCombustion)
#add_subdirectory(targets/apps/GKS/MethaneFlame)
#add_subdirectory(targets/apps/GKS/Room)
#add_subdirectory(targets/apps/GKS/RoomMultiGPU)
#add_subdirectory(targets/apps/GKS/RoomFire)
add_subdirectory(targets/apps/GKS/RoomFireExtended)
add_subdirectory(targets/apps/GKS/ConcreteHeatFluxBCTest)
#add_subdirectory(targets/apps/GKS/RoomFireExtended)
#add_subdirectory(targets/apps/GKS/ConcreteHeatFluxBCTest)
#add_subdirectory(targets/apps/GKS/PoolFire)
add_subdirectory(targets/apps/GKS/Flame7cm)
add_subdirectory(targets/apps/GKS/SandiaFlame_1m)
#add_subdirectory(targets/apps/GKS/Flame7cm)
#add_subdirectory(targets/apps/GKS/SandiaFlame_1m)
#add_subdirectory(targets/apps/GKS/Candle)
add_subdirectory(targets/apps/GKS/MultiGPU)
add_subdirectory(targets/apps/GKS/MultiGPU_nD)
add_subdirectory(targets/apps/GKS/SingleGPU)
#add_subdirectory(targets/apps/GKS/MultiGPU)
#add_subdirectory(targets/apps/GKS/MultiGPU_nD)
#add_subdirectory(targets/apps/GKS/SingleGPU)
ELSE()
MESSAGE( STATUS "exclude Virtual Fluids GKS." )
ENDIF()
......
src/GksGpu/Analyzer/HeatFluxAnalyzer.cu
+ 1
− 7
View file @ c952bf6f
......@@ -106,13 +106,7 @@ __host__ __device__ void heatFluxFunction(DataBaseStruct& dataBase, GksGpu::Boun
real r = parameters.lambdaRef / lambda;
real mu;
if ( parameters.viscosityModel == ViscosityModel::constant ){
mu = parameters.mu;
}
else if ( parameters.viscosityModel == ViscosityModel::sutherlandsLaw ){
mu = sutherlandsLaw( parameters, r );
}
real mu = getViscosity(parameters, r);
heatFlux[ startIndex + index ] = c1o4 * (parameters.K + c5o1) * ( mu / parameters.Pr ) / parameters.dx * ( c1o1 / domainPrim.lambda - c1o1 / ghostPrim.lambda );
}
......
src/GksGpu/Analyzer/KineticEnergyAnalyzer.cu
+ 2
− 0
View file @ c952bf6f
......@@ -52,6 +52,8 @@ bool KineticEnergyAnalyzer::run(uint iter)
this->kineticEnergyTimeSeries.push_back( EKin );
//*logging::out << logging::Logger::INFO_HIGH << "EKin = " << EKin << "\n";
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
......
src/GksGpu/BoundaryConditions/InflowComplete.cu
+ 92
− 92
View file @ c952bf6f
......@@ -202,98 +202,98 @@ __host__ __device__ inline void boundaryConditionFunction(const DataBaseStruct&
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if( false )
{
PrimitiveVariables domainCellPrim;
{
ConservedVariables domainCellData;
readCellData(domainCellIdx, dataBase, domainCellData);
domainCellPrim = toPrimitiveVariables(domainCellData, parameters.K);
}
PrimitiveVariables facePrim = boundaryCondition.prim;
//////////////////////////////////////////////////////////////////////////
real ax[LENGTH_CELL_DATA];
real ay[LENGTH_CELL_DATA];
real az[LENGTH_CELL_DATA];
real at[LENGTH_CELL_DATA];
#pragma unroll
for( uint i = 0; i < LENGTH_CELL_DATA; i++ )
{
ax[i] = c0o1;
ay[i] = c0o1;
az[i] = c0o1;
at[i] = c0o1;
}
{
ConservedVariables gradN, gradT1, gradT2;
transformGlobalToLocal( gradN , 'z' );
transformGlobalToLocal( gradT1, 'z' );
transformGlobalToLocal( gradT2, 'z' );
transformGlobalToLocal( facePrim, 'z' );
computeExpansionCoefficients(facePrim, gradN , parameters.K, ax);
computeExpansionCoefficients(facePrim, gradT1, parameters.K, ay);
computeExpansionCoefficients(facePrim, gradT2, parameters.K, az);
}
//////////////////////////////////////////////////////////////////////////
{
ConservedVariables flux;
{
real momentU [ NUMBER_OF_MOMENTS ];
real momentV [ NUMBER_OF_MOMENTS ];
real momentW [ NUMBER_OF_MOMENTS ];
real momentXi[ NUMBER_OF_MOMENTS ];
computeMoments( facePrim, parameters.K, momentU, momentV, momentW, momentXi );
Vec3 force = parameters.force;
transformGlobalToLocal(force, 'z');
{
ConservedVariables timeGrad;
computeTimeDerivative( facePrim,
momentU,
momentV,
momentW,
momentXi,
ax, ay, az,
force,
timeGrad );
computeExpansionCoefficients( facePrim, timeGrad, parameters.K, at );
}
{
real timeCoefficients[4];
computeTimeCoefficients( facePrim, parameters, timeCoefficients );
real heatFlux;
assembleFlux( facePrim,
momentU, momentV, momentW, momentXi,
ax, ay, az, at,
timeCoefficients,
parameters,
force,
flux,
heatFlux );
transformLocalToGlobal( flux, 'z' );
}
}
applyFluxToPosCell(dataBase, domainCellIdx, flux, 'z', parameters);
applyFluxToNegCell(dataBase, ghostCellIdx , flux, 'z', parameters);
}
}
//if( false )
//{
// PrimitiveVariables domainCellPrim;
// {
// ConservedVariables domainCellData;
// readCellData(domainCellIdx, dataBase, domainCellData);
// domainCellPrim = toPrimitiveVariables(domainCellData, parameters.K);
// }
// PrimitiveVariables facePrim = boundaryCondition.prim;
// //////////////////////////////////////////////////////////////////////////
// real ax[LENGTH_CELL_DATA];
// real ay[LENGTH_CELL_DATA];
// real az[LENGTH_CELL_DATA];
// real at[LENGTH_CELL_DATA];
//#pragma unroll
// for( uint i = 0; i < LENGTH_CELL_DATA; i++ )
// {
// ax[i] = c0o1;
// ay[i] = c0o1;
// az[i] = c0o1;
// at[i] = c0o1;
// }
//
// {
// ConservedVariables gradN, gradT1, gradT2;
// transformGlobalToLocal( gradN , 'z' );
// transformGlobalToLocal( gradT1, 'z' );
// transformGlobalToLocal( gradT2, 'z' );
// transformGlobalToLocal( facePrim, 'z' );
// computeExpansionCoefficients(facePrim, gradN , parameters.K, ax);
// computeExpansionCoefficients(facePrim, gradT1, parameters.K, ay);
// computeExpansionCoefficients(facePrim, gradT2, parameters.K, az);
// }
// //////////////////////////////////////////////////////////////////////////
// {
// ConservedVariables flux;
// {
// real momentU [ NUMBER_OF_MOMENTS ];
// real momentV [ NUMBER_OF_MOMENTS ];
// real momentW [ NUMBER_OF_MOMENTS ];
// real momentXi[ NUMBER_OF_MOMENTS ];
// computeMoments( facePrim, parameters.K, momentU, momentV, momentW, momentXi );
// Vec3 force = parameters.force;
// transformGlobalToLocal(force, 'z');
// {
// ConservedVariables timeGrad;
// computeTimeDerivative( facePrim,
// momentU,
// momentV,
// momentW,
// momentXi,
// ax, ay, az,
// force,
// timeGrad );
// computeExpansionCoefficients( facePrim, timeGrad, parameters.K, at );
// }
// {
// real timeCoefficients[4];
// computeTimeCoefficients( facePrim, parameters, timeCoefficients );
// real heatFlux;
// assembleFlux( facePrim,
// momentU, momentV, momentW, momentXi,
// ax, ay, az, at,
// timeCoefficients,
// parameters,
// force,
// flux,
// heatFlux );
// transformLocalToGlobal( flux, 'z' );
// }
// }
// applyFluxToPosCell(dataBase, domainCellIdx, flux, 'z', parameters);
// applyFluxToNegCell(dataBase, ghostCellIdx , flux, 'z', parameters);
// }
//}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
......
src/GksGpu/FluxComputation/AssembleFlux.cuh
+ 4
− 16
View file @ c952bf6f
......@@ -205,19 +205,13 @@ __host__ __device__ inline void computeTimeDerivative( const PrimitiveVariables&
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
__host__ __device__ inline void computeTimeCoefficients(const PrimitiveVariables & facePrim, const Parameters& parameters, real timeCoefficients[4])
__host__ __device__ inline void computeTimeCoefficients(const PrimitiveVariables & facePrim, Parameters& parameters, real timeCoefficients[4])
{
real r = parameters.lambdaRef / facePrim.lambda;
//if( r < zero ) printf( "ERROR: %f/%f\n", parameters.lambdaRef, facePrim.lambda );
real mu;
if ( parameters.viscosityModel == ViscosityModel::constant ){
mu = parameters.mu;
}
else if ( parameters.viscosityModel == ViscosityModel::sutherlandsLaw ){
mu = sutherlandsLaw( parameters, r );
}
real mu = getViscosity(parameters, r);
real tau = c2o1 * facePrim.lambda * mu / facePrim.rho;
......@@ -230,17 +224,11 @@ __host__ __device__ inline void computeTimeCoefficients(const PrimitiveVariables
timeCoefficients[3] = tau ;
}
__host__ __device__ inline void getTau(const PrimitiveVariables & facePrim, const Parameters& parameters, real& tau)
__host__ __device__ inline void getTau(const PrimitiveVariables & facePrim, Parameters& parameters, real& tau)
{
real r = parameters.lambdaRef / facePrim.lambda;
real mu;
if ( parameters.viscosityModel == ViscosityModel::constant ){
mu = parameters.mu;
}
else if ( parameters.viscosityModel == ViscosityModel::sutherlandsLaw ){
mu = sutherlandsLaw( parameters, r );
}
real mu = getViscosity(parameters, r); mu = sutherlandsLaw2( parameters, r );
tau = c2o1 * facePrim.lambda * mu / facePrim.rho;
}
......
src/GksGpu/FluxComputation/SutherlandsLaw.cuh
+ 24
− 1
View file @ c952bf6f
......@@ -15,7 +15,7 @@
namespace GksGpu {
inline __host__ __device__ real sutherlandsLaw(const Parameters & parameters, const real r)
inline __host__ __device__ real sutherlandsLaw(Parameters & parameters, const real r)
{
real S = real( 110.5 );
......@@ -26,6 +26,29 @@ inline __host__ __device__ real sutherlandsLaw(const Parameters & parameters, co
return parameters.mu * sqrt( r * r * r ) * ( C + c1o1 ) / ( r + C );
}
inline __host__ __device__ real sutherlandsLaw2(Parameters & parameters, const real r)
{
real Smu = real( 0.648 );
real Sk = real( 0.368 );
parameters.Pr *= ( ( Smu + c1o1 ) / ( Sk + c1o1 ) ) * ( ( r + Sk ) / ( r + Smu ) );
return parameters.mu * sqrt( r * r * r ) * ( Smu + c1o1 ) / ( r + Smu );
}
inline __host__ __device__ real getViscosity(Parameters & parameters, const real r)
{
if ( parameters.viscosityModel == ViscosityModel::sutherlandsLaw ){
return sutherlandsLaw( parameters, r );
}
else if ( parameters.viscosityModel == ViscosityModel::sutherlandsLaw2 ){
return sutherlandsLaw2( parameters, r );
}
return parameters.mu;
}
} // namespace GksGpu
#endif
src/GksGpu/Parameters/Parameters.h
+ 2
− 1
View file @ c952bf6f
......@@ -10,7 +10,8 @@ namespace GksGpu {
enum class VF_PUBLIC ViscosityModel{
constant,
sutherlandsLaw
sutherlandsLaw,
sutherlandsLaw2
};
struct VF_PUBLIC Parameters
......
targets/apps/GKS/RayleighBenardMultiGPU/RayleighBenardMultiGPU.cpp
+ 42
− 38
View file @ c952bf6f
......@@ -99,8 +99,8 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
real dx = L / real(nx);
//real Ra = 1.0e7;
real Ra = 1.0e2;
real Ra = 3.0e6;
//real Ra = 1.0e2;
real Ba = 0.1;
real eps = 0.8;
......@@ -119,7 +119,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
real cs = sqrt( ( ( K + 4.0 ) / ( K + 2.0 ) ) / ( 2.0 * lambda ) );
real U = sqrt( Ra ) * mu / ( rho * L );
real CFL = 0.05;
real CFL = 0.5;
real dt = CFL * ( dx / ( ( U + cs ) * ( c1o1 + ( c2o1 * mu ) / ( U * dx * rho ) ) ) );
......@@ -129,7 +129,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
//////////////////////////////////////////////////////////////////////////
Parameters parameters;
GksGpu::Parameters parameters;
parameters.K = K;
parameters.Pr = Pr;
......@@ -144,8 +144,8 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
parameters.lambdaRef = lambda;
//parameters.viscosityModel = ViscosityModel::sutherlandsLaw;
parameters.viscosityModel = ViscosityModel::constant;
parameters.viscosityModel = GksGpu::ViscosityModel::sutherlandsLaw2;
//parameters.viscosityModel = ViscosityModel::constant;
parameters.forcingSchemeIdx = 0;
......@@ -237,7 +237,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
if( sideLengthZ == 1 || rankZ == 1 ) firstRefLevel.add( new Cuboid (-100.0, -100.0, 0.5*L - refL[1],
100.0, 100.0, 100.0 ) );
//gridBuilder->addGrid( &firstRefLevel, 2);
gridBuilder->addGrid( &firstRefLevel, 2);
//////////////////////////////////////////////////////////////////////////
......@@ -346,7 +346,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
auto dataBase = std::make_shared<DataBase>( "GPU" );
auto dataBase = std::make_shared<GksGpu::DataBase>( "GPU" );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
......@@ -397,18 +397,18 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
dataBase->setCommunicators( meshAdapter );
CudaUtility::printCudaMemoryUsage();
GksGpu::CudaUtility::printCudaMemoryUsage();
if( restartIter == INVALID_INDEX )
{
Initializer::interpret(dataBase, [&](Vec3 cellCenter) -> ConservedVariables {
GksGpu::Initializer::interpret(dataBase, [&](Vec3 cellCenter) -> GksGpu::ConservedVariables {
//real Th = 1.0 / lambdaHot;
//real Tc = 1.0 / lambdaCold;
//real T = Th - (Th - Tc)*((cellCenter.x + 0.5 * L) / L);
//real lambdaLocal = 1.0 / T;
return toConservedVariables(PrimitiveVariables(rho, 0.0, 0.0, 0.0, lambda), parameters.K);
return GksGpu::toConservedVariables(GksGpu::PrimitiveVariables(rho, 0.0, 0.0, 0.0, lambda), parameters.K);
});
if (rank == 0) writeVtkXMLParallelSummaryFile(dataBase, parameters, path + simulationName + "_0", mpiWorldSize);
......@@ -417,7 +417,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
}
else
{
Restart::readRestart( dataBase, path + simulationName + "_" + std::to_string( restartIter ) + "_rank_" + std::to_string(rank), startIter );
GksGpu::Restart::readRestart( dataBase, path + simulationName + "_" + std::to_string( restartIter ) + "_rank_" + std::to_string(rank), startIter );
if (rank == 0) writeVtkXMLParallelSummaryFile( dataBase, parameters, path + simulationName + "_" + std::to_string( restartIter ) + "_restart", mpiWorldSize );
......@@ -428,7 +428,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
dataBase->copyDataHostToDevice();
Initializer::initializeDataUpdate(dataBase);
GksGpu::Initializer::initializeDataUpdate(dataBase);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
......@@ -436,12 +436,12 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CupsAnalyzer cupsAnalyzer( dataBase, true, 300.0 );
GksGpu::CupsAnalyzer cupsAnalyzer( dataBase, true, 300.0 );
ConvergenceAnalyzer convergenceAnalyzer( dataBase );
GksGpu::ConvergenceAnalyzer convergenceAnalyzer( dataBase );
//auto turbulenceAnalyzer = std::make_shared<TurbulenceAnalyzer>( dataBase, 0 );
auto turbulenceAnalyzer = std::make_shared<TurbulenceAnalyzer>( dataBase, 50000 );
auto turbulenceAnalyzer = std::make_shared<GksGpu::TurbulenceAnalyzer>( dataBase, 50000 );
turbulenceAnalyzer->collect_UU = true;
turbulenceAnalyzer->collect_VV = true;
......@@ -470,8 +470,8 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
// if( subDomainBox->isInside( 0.485, y, 0.3*H ) ) pointTimeSeriesCollector->addAnalyzer( dataBase, meshAdapter, Vec3( 0.485, y, 0.3*H ), 'W', 10000 );
//}
HeatFluxAnalyzer heatFluxAnalyzerPZ(dataBase, bcPZ, 100, 100, lambdaHot, lambdaCold, L);
HeatFluxAnalyzer heatFluxAnalyzerMZ(dataBase, bcMZ, 100, 100, lambdaHot, lambdaCold, L);
GksGpu::HeatFluxAnalyzer heatFluxAnalyzerPZ(dataBase, bcPZ, 100, 10000, lambdaHot, lambdaCold, L);
GksGpu::HeatFluxAnalyzer heatFluxAnalyzerMZ(dataBase, bcMZ, 100, 10000, lambdaHot, lambdaCold, L);
//HeatFluxAnalyzer heatFluxAnalyzer(dataBase, bcPZ);
//////////////////////////////////////////////////////////////////////////
......@@ -480,16 +480,7 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
for( uint iter = startIter + 1; iter <= 100000000; iter++ )
{
TimeStepping::nestedTimeStep(dataBase, parameters, 0);
if( iter % 10000 == 0 )
{
dataBase->copyDataDeviceToHost();
if( rank == 0 ) writeVtkXMLParallelSummaryFile( dataBase, parameters, path + simulationName + "_" + std::to_string( iter ), mpiWorldSize );
writeVtkXML( dataBase, parameters, 0, path + simulationName + "_" + std::to_string( iter ) + "_rank_" + std::to_string(rank) );
}
GksGpu::TimeStepping::nestedTimeStep(dataBase, parameters, 0);
cupsAnalyzer.run( iter, parameters.dt );
......@@ -500,21 +491,33 @@ void simulation( std::string path, std::string simulationName, bool fine, uint r
if(rankZ == 1) heatFluxAnalyzerPZ.run( iter, parameters );
if(rankZ == 0) heatFluxAnalyzerMZ.run( iter, parameters );
if( iter % 10000 == 0 )
//if( iter % 25 == 0 )
{
dataBase->copyDataDeviceToHost();
if( rank == 0 ) writeVtkXMLParallelSummaryFile( dataBase, parameters, path + simulationName + "_" + std::to_string( iter ), mpiWorldSize );
writeVtkXML( dataBase, parameters, 0, path + simulationName + "_" + std::to_string( iter ) + "_rank_" + std::to_string(rank) );
if(rankZ == 1) heatFluxAnalyzerPZ.writeToFile( path + simulationName + "_Nu_top_" + std::to_string( iter ) + "_rank_" + std::to_string(rank) );
if(rankZ == 0) heatFluxAnalyzerMZ.writeToFile( path + simulationName + "_Nu_bot_" + std::to_string( iter ) + "_rank_" + std::to_string(rank) );
}
//pointTimeSeriesCollector->run(iter, parameters);
if( iter > 50000 && iter % 10000 == 0 )
//if(iter % 1000 == 0)
{
turbulenceAnalyzer->download();
if( rank == 0 ) writeTurbulenceVtkXMLParallelSummaryFile( dataBase, turbulenceAnalyzer, parameters, path + simulationName + "_Turbulence_" + std::to_string( iter ), mpiWorldSize );
writeTurbulenceVtkXML( dataBase, turbulenceAnalyzer, 0, path + simulationName + "_Turbulence_" + std::to_string( iter ) + "_rank_" + std::to_string(rank) );
}
if( iter > 50000 && iter % 10000 == 0 )
if( iter % 10000 == 0 )
{
Restart::writeRestart( dataBase, path + simulationName + "_" + std::to_string( iter ) + "_rank_" + std::to_string(rank), iter );
GksGpu::Restart::writeRestart( dataBase, path + simulationName + "_" + std::to_string( iter ) + "_rank_" + std::to_string(rank), iter );
turbulenceAnalyzer->writeRestartFile( path + simulationName + "_Turbulence_" + std::to_string( iter ) + "_rank_" + std::to_string(rank) );
}
......@@ -549,14 +552,15 @@ int main( int argc, char* argv[])
int mpiWorldSize = 1;
MPI_Comm_size(MPI_COMM_WORLD, &mpiWorldSize);
#else
int rank = MpiUtility::getMpiRankBeforeInit();
int mpiWorldSize = MpiUtility::getMpiWorldSizeBeforeInit();
int rank = GksGpu::MpiUtility::getMpiRankBeforeInit();
int mpiWorldSize = GksGpu::MpiUtility::getMpiWorldSizeBeforeInit();
#endif
//////////////////////////////////////////////////////////////////////////
#ifdef _WIN32
std::string path( "F:/Work/Computations/out/RayleighBenardMultiGPU/" );
std::string path( "F:/Work/Computations/out/RayleighBenardMultiGPU/test/" );
//std::string path( "F:/Work/Computations/out/RayleighBenardMultiGPU/" );
#else
std::string path( "out/" );
#endif
......@@ -579,7 +583,7 @@ int main( int argc, char* argv[])
//////////////////////////////////////////////////////////////////////////
// Important: for Cuda-Aware MPI the device must be set before MPI_Init()
int deviceCount = CudaUtility::getCudaDeviceCount();
int deviceCount = GksGpu::CudaUtility::getCudaDeviceCount();
if(deviceCount == 0)
{
......@@ -588,7 +592,7 @@ int main( int argc, char* argv[])
*logging::out << logging::Logger::WARNING << msg.str(); msg.str("");
}
CudaUtility::setCudaDevice( rank % deviceCount );
GksGpu::CudaUtility::setCudaDevice( rank % deviceCount );
//////////////////////////////////////////////////////////////////////////
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment