VirtualFluids 0.2.0
Parallel CFD LBM Solver
Loading...
Searching...
No Matches
CudaMemoryManager.cpp
Go to the documentation of this file.
1//=======================================================================================
2// ____ ____ __ ______ __________ __ __ __ __
3// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
4// \ \ | | | | | |_) | | | | | | | / \ | |
5// \ \ | | | | | _ / | | | | | | / /\ \ | |
6// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
7// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
8// \ \ | | ________________________________________________________________
9// \ \ | | | ______________________________________________________________|
10// \ \| | | | __ __ __ __ ______ _______
11// \ | | |_____ | | | | | | | | | _ \ / _____)
12// \ | | _____| | | | | | | | | | | \ \ \_______
13// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
14// \ _____| |__| |________| \_______/ |__| |______/ (_______/
15//
16// This file is part of VirtualFluids. VirtualFluids is free software: you can
17// redistribute it and/or modify it under the terms of the GNU General Public
18// License as published by the Free Software Foundation, either version 3 of
19// the License, or (at your option) any later version.
20//
21// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
22// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
23// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24// for more details.
25//
26// SPDX-License-Identifier: GPL-3.0-or-later
27// SPDX-FileCopyrightText: Copyright © VirtualFluids Project contributors, see AUTHORS.md in root folder
28//
33//=======================================================================================
34#include "CudaMemoryManager.h"
35
36#include <cmath>
37#include <cstdio>
38#include <cstdlib>
39
40#include <cuda_runtime.h>
41#include <helper_cuda.h>
42
43#include <basics/constants/NumericConstants.h>
44
45#include "Calculation/Calculation.h"
46#include "Parameter/Parameter.h"
47#include "CudaStreamManager.h"
48#include "PreCollisionInteractor/Actuator/ActuatorFarm.h"
49#include "PreCollisionInteractor/Forest.h"
50#include "PreCollisionInteractor/BuoyancyProvider/BuoyancyProvider.h"
51#include "Samplers/Probe.h"
52#include "Samplers/PlanarAverageProbe.h"
53#include "Samplers/PrecursorWriter.h"
54#include "PreCollisionInteractor/DampingLayer/DampingLayer.h"
55
56namespace vf::gpu {
57
58void CudaMemoryManager::cudaCopyPrint(int lev)
59{
60 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityX , parameter->getParD(lev)->velocityX , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
61 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityY , parameter->getParD(lev)->velocityY , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
62 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityZ , parameter->getParD(lev)->velocityZ , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
63 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->rho , parameter->getParD(lev)->rho , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
64 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->pressure , parameter->getParD(lev)->pressure , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
65
66 if(parameter->getIsBodyForce())
67 {
68 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->forceX_SP , parameter->getParD(lev)->forceX_SP , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
69 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->forceY_SP , parameter->getParD(lev)->forceY_SP , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
70 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->forceZ_SP , parameter->getParD(lev)->forceZ_SP , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
71 }
72
73 if(parameter->getUseTurbulentViscosity())
74 {
75 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->turbulentViscosity , parameter->getParD(lev)->turbulentViscosity , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
76 }
77}
78void CudaMemoryManager::cudaCopyMeanPrint(int lev)
79{
80 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->meanVelocityInXdirection , parameter->getParD(lev)->meanVelocityInXdirection , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
81 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->meanVelocityInYdirection , parameter->getParD(lev)->meanVelocityInYdirection , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
82 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->meanVelocityInZdirection , parameter->getParD(lev)->meanVelocityInZdirection , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
83 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->meanDensity , parameter->getParD(lev)->meanDensity , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
84 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->meanPressure, parameter->getParD(lev)->meanPressure, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
85}
86void CudaMemoryManager::cudaAllocCoord(int lev)
87{
88 //Host
89 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coordinateX ), parameter->getParH(lev)->memSizeRealLBnodes ));
90 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coordinateY ), parameter->getParH(lev)->memSizeRealLBnodes ));
91 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coordinateZ ), parameter->getParH(lev)->memSizeRealLBnodes ));
92 //Device (spinning ship + uppsala)
93 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coordinateX ), parameter->getParH(lev)->memSizeRealLBnodes ));
94 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coordinateY ), parameter->getParH(lev)->memSizeRealLBnodes ));
95 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coordinateZ ), parameter->getParH(lev)->memSizeRealLBnodes ));
97 double tmp = 3. * (double)parameter->getParH(lev)->memSizeRealLBnodes;
98 setMemsizeGPU(tmp, false);
99}
100void CudaMemoryManager::cudaCopyCoord(int lev)
101{
102 //copy host to device
103 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->coordinateX, parameter->getParH(lev)->coordinateX, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
104 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->coordinateY, parameter->getParH(lev)->coordinateY, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
105 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->coordinateZ, parameter->getParH(lev)->coordinateZ, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
106}
107void CudaMemoryManager::cudaFreeCoord(int lev)
108{
109 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coordinateX ));
110 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coordinateY ));
111 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coordinateZ ));
112}
113void CudaMemoryManager::cudaAllocBodyForce(int lev)
114{
115 //Host
116 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->forceX_SP ), parameter->getParH(lev)->memSizeRealLBnodes ));
117 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->forceY_SP ), parameter->getParH(lev)->memSizeRealLBnodes ));
118 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->forceZ_SP ), parameter->getParH(lev)->memSizeRealLBnodes ));
119 //Device
120 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->forceX_SP ), parameter->getParH(lev)->memSizeRealLBnodes ));
121 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->forceY_SP ), parameter->getParH(lev)->memSizeRealLBnodes ));
122 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->forceZ_SP ), parameter->getParH(lev)->memSizeRealLBnodes ));
124 double tmp = 3. * (double)parameter->getParH(lev)->memSizeRealLBnodes;
125 setMemsizeGPU(tmp, false);
126
127}
128void CudaMemoryManager::cudaCopyBodyForce(int lev)
129{
130 //copy host to device
131 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->forceX_SP, parameter->getParH(lev)->forceX_SP, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
132 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->forceY_SP, parameter->getParH(lev)->forceY_SP, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
133 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->forceZ_SP, parameter->getParH(lev)->forceZ_SP, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
134
135}
136void CudaMemoryManager::cudaFreeBodyForce(int lev)
137{
138 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->forceX_SP ));
139 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->forceY_SP ));
140 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->forceZ_SP ));
141
142}
143//print
144void CudaMemoryManager::cudaCopyDataToHost(int lev)
145{
146 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityX , parameter->getParD(lev)->velocityX , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
147 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityY , parameter->getParD(lev)->velocityY , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
148 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityZ , parameter->getParD(lev)->velocityZ , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
149 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->rho , parameter->getParD(lev)->rho , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
150 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->pressure , parameter->getParD(lev)->pressure , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
151}
152//sparse
153void CudaMemoryManager::cudaAllocSP(int lev)
154{
155 //Host
156 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->typeOfGridNode), parameter->getParH(lev)->memSizeLonglongLBnodes));
157 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborX ), parameter->getParH(lev)->memSizeLonglongLBnodes));
158 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborY ), parameter->getParH(lev)->memSizeLonglongLBnodes));
159 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborZ ), parameter->getParH(lev)->memSizeLonglongLBnodes));
160 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->rho ), parameter->getParH(lev)->memSizeRealLBnodes ));
161 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityX ), parameter->getParH(lev)->memSizeRealLBnodes ));
162 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityY ), parameter->getParH(lev)->memSizeRealLBnodes ));
163 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityZ ), parameter->getParH(lev)->memSizeRealLBnodes ));
164 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->pressure ), parameter->getParH(lev)->memSizeRealLBnodes ));
165 //Device
166 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->typeOfGridNode ), parameter->getParD(lev)->memSizeLonglongLBnodes));
167 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborX ), parameter->getParD(lev)->memSizeLonglongLBnodes));
168 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborY ), parameter->getParD(lev)->memSizeLonglongLBnodes));
169 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborZ ), parameter->getParD(lev)->memSizeLonglongLBnodes));
170 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->rho ), parameter->getParD(lev)->memSizeRealLBnodes ));
171 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityX ), parameter->getParD(lev)->memSizeRealLBnodes ));
172 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityY ), parameter->getParD(lev)->memSizeRealLBnodes ));
173 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityZ ), parameter->getParD(lev)->memSizeRealLBnodes ));
174 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->pressure ), parameter->getParD(lev)->memSizeRealLBnodes ));
175 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->distributions.f[0]), (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParD(lev)->memSizeRealLBnodes));
177 double tmp = 4. * (double)parameter->getParH(lev)->memSizeLonglongLBnodes + 5. * (double)parameter->getParH(lev)->memSizeRealLBnodes + (double)parameter->getD3Qxx() * (double)parameter->getParH(lev)->memSizeRealLBnodes;
178 setMemsizeGPU(tmp, false);
179}
180void CudaMemoryManager::cudaCopySP(int lev)
181{
182 //copy host to device
183 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->typeOfGridNode, parameter->getParH(lev)->typeOfGridNode, parameter->getParH(lev)->memSizeLonglongLBnodes , cudaMemcpyHostToDevice));
184 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->neighborX , parameter->getParH(lev)->neighborX , parameter->getParH(lev)->memSizeLonglongLBnodes , cudaMemcpyHostToDevice));
185 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->neighborY , parameter->getParH(lev)->neighborY , parameter->getParH(lev)->memSizeLonglongLBnodes , cudaMemcpyHostToDevice));
186 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->neighborZ , parameter->getParH(lev)->neighborZ , parameter->getParH(lev)->memSizeLonglongLBnodes , cudaMemcpyHostToDevice));
187 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->rho , parameter->getParH(lev)->rho , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
188 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityX , parameter->getParH(lev)->velocityX , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
189 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityY , parameter->getParH(lev)->velocityY , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
190 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityZ , parameter->getParH(lev)->velocityZ , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
191 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->pressure , parameter->getParH(lev)->pressure , parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
192}
193void CudaMemoryManager::cudaFreeSP(int lev)
194{
195 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->typeOfGridNode ));
196 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityX ));
197 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityY ));
198 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityZ ));
199 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->rho ));
200 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->pressure ));
201 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborX ));
202 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborY ));
203 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborZ ));
204}
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226//Velo
227void CudaMemoryManager::cudaAllocVeloBC(int lev)
228{
229 unsigned int mem_size_inflow_Q_k = sizeof(int)*parameter->getParH(lev)->velocityBC.numberOfBCnodes;
230 unsigned int mem_size_inflow_Q_q = sizeof(real)*parameter->getParH(lev)->velocityBC.numberOfBCnodes;
231
232 //Host
233 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.q27[0]), parameter->getD3Qxx()*mem_size_inflow_Q_q ));
234 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.k), mem_size_inflow_Q_k ));
235 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.Vx), mem_size_inflow_Q_q ));
236 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.Vy), mem_size_inflow_Q_q ));
237 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.Vz), mem_size_inflow_Q_q ));
238 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.deltaVz), mem_size_inflow_Q_q ));
239 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityBC.RhoBC), mem_size_inflow_Q_q ));
240
241 //Device
242 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityBC.q27[0]), parameter->getD3Qxx()*mem_size_inflow_Q_q ));
243 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityBC.k), mem_size_inflow_Q_k ));
244 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityBC.Vx), mem_size_inflow_Q_q ));
245 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityBC.Vy), mem_size_inflow_Q_q ));
246 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityBC.Vz), mem_size_inflow_Q_q ));
247 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityBC.deltaVz), mem_size_inflow_Q_q ));
248
250 double tmp = (double)mem_size_inflow_Q_k + 4. * (double)mem_size_inflow_Q_q + (double)parameter->getD3Qxx() * (double)mem_size_inflow_Q_q;
251 setMemsizeGPU(tmp, false);
252}
253void CudaMemoryManager::cudaCopyVeloBC(int lev)
254{
255 unsigned int mem_size_inflow_Q_k = sizeof(int)*parameter->getParH(lev)->velocityBC.numberOfBCnodes;
256 unsigned int mem_size_inflow_Q_q = sizeof(real)*parameter->getParH(lev)->velocityBC.numberOfBCnodes;
257
258 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityBC.q27[0], parameter->getParH(lev)->velocityBC.q27[0], parameter->getD3Qxx()* mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
259 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityBC.k, parameter->getParH(lev)->velocityBC.k, mem_size_inflow_Q_k, cudaMemcpyHostToDevice));
260 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityBC.Vx, parameter->getParH(lev)->velocityBC.Vx, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
261 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityBC.Vy, parameter->getParH(lev)->velocityBC.Vy, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
262 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityBC.Vz, parameter->getParH(lev)->velocityBC.Vz, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
263 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityBC.deltaVz, parameter->getParH(lev)->velocityBC.deltaVz, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
264
265}
266
267void CudaMemoryManager::cudaFreeVeloBC(int lev)
268{
269 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityBC.q27[0] ));
270 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityBC.k ));
271 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityBC.Vx ));
272 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityBC.Vy ));
273 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityBC.Vz ));
274 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityBC.deltaVz));
275}
276//Press
277void CudaMemoryManager::cudaAllocOutflowBC(int lev)
278{
279 unsigned int mem_size_outflow_Q_k = sizeof(int)*parameter->getParH(lev)->outflowBC.numberOfBCnodes;
280 unsigned int mem_size_outflow_Q_q = sizeof(real)*parameter->getParH(lev)->outflowBC.numberOfBCnodes;
281
282 //Host
283 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->outflowBC.q27[0]), parameter->getD3Qxx()*mem_size_outflow_Q_q ));
284 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->outflowBC.k), mem_size_outflow_Q_k ));
285 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->outflowBC.kN), mem_size_outflow_Q_k ));
286 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->outflowBC.RhoBC), mem_size_outflow_Q_q ));
287
288 //Device
289 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->outflowBC.q27[0]), parameter->getD3Qxx()* mem_size_outflow_Q_q ));
290 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->outflowBC.k), mem_size_outflow_Q_k ));
291 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->outflowBC.kN), mem_size_outflow_Q_k ));
292 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->outflowBC.RhoBC), mem_size_outflow_Q_q ));
293
295 double tmp = (double)mem_size_outflow_Q_q + 2. * (double)mem_size_outflow_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_outflow_Q_q;
296 setMemsizeGPU(tmp, false);
297}
298void CudaMemoryManager::cudaCopyOutflowBC(int lev)
299{
300 unsigned int mem_size_outflow_Q_k = sizeof(int)*parameter->getParH(lev)->outflowBC.numberOfBCnodes;
301 unsigned int mem_size_outflow_Q_q = sizeof(real)*parameter->getParH(lev)->outflowBC.numberOfBCnodes;
302
303 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->outflowBC.q27[0], parameter->getParH(lev)->outflowBC.q27[0], parameter->getD3Qxx()* mem_size_outflow_Q_q, cudaMemcpyHostToDevice));
304 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->outflowBC.k, parameter->getParH(lev)->outflowBC.k, mem_size_outflow_Q_k, cudaMemcpyHostToDevice));
305 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->outflowBC.kN, parameter->getParH(lev)->outflowBC.kN, mem_size_outflow_Q_k, cudaMemcpyHostToDevice));
306 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->outflowBC.RhoBC, parameter->getParH(lev)->outflowBC.RhoBC, mem_size_outflow_Q_q, cudaMemcpyHostToDevice));
307}
308void CudaMemoryManager::cudaFreeOutflowBC(int lev)
309{
310 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->outflowBC.q27[0] ));
311 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->outflowBC.k ));
312 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->outflowBC.kN ));
313 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->outflowBC.RhoBC ));
314}
315//No-Slip
316void CudaMemoryManager::cudaAllocNoSlipBC(int lev)
317{
318 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->noSlipBC.numberOfBCnodes;
319 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->noSlipBC.numberOfBCnodes;
320
321 //Host
322 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->noSlipBC.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
323 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->noSlipBC.k), mem_size_Q_k ));
324
325 //Device
326 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->noSlipBC.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
327 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->noSlipBC.k), mem_size_Q_k ));
328
330 double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
331 setMemsizeGPU(tmp, false);
332}
333void CudaMemoryManager::cudaCopyNoSlipBC(int lev)
334{
335 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->noSlipBC.numberOfBCnodes;
336 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->noSlipBC.numberOfBCnodes;
337
338 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->noSlipBC.q27[0], parameter->getParH(lev)->noSlipBC.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
339 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->noSlipBC.k, parameter->getParH(lev)->noSlipBC.k, mem_size_Q_k, cudaMemcpyHostToDevice));
340}
341void CudaMemoryManager::cudaFreeNoSlipBC(int lev)
342{
343 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->noSlipBC.q27[0]));
344 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->noSlipBC.k));
345}
346//Geometrie
347void CudaMemoryManager::cudaAllocGeomBC(int lev)
348{
349 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->geometryBC.numberOfBCnodes;
350 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->geometryBC.numberOfBCnodes;
351
352 //Host
353 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geometryBC.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
354 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geometryBC.k), mem_size_Q_k ));
355
356 //Device
357 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->geometryBC.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
358 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->geometryBC.k), mem_size_Q_k ));
359
361 double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
362 setMemsizeGPU(tmp, false);
363}
364void CudaMemoryManager::cudaCopyGeomBC(int lev)
365{
366 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->geometryBC.numberOfBCnodes;
367 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->geometryBC.numberOfBCnodes;
368
369 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->geometryBC.q27[0], parameter->getParH(lev)->geometryBC.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
370 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->geometryBC.k, parameter->getParH(lev)->geometryBC.k, mem_size_Q_k, cudaMemcpyHostToDevice));
371}
372void CudaMemoryManager::cudaFreeGeomBC(int lev)
373{
374 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->geometryBC.q27[0]));
375 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->geometryBC.k));
376}
377//Press
378void CudaMemoryManager::cudaAllocPress(int lev)
379{
380 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->pressureBC.numberOfBCnodes;
381 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->pressureBC.numberOfBCnodes;
382
383 //Host
384 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->pressureBC.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
385 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->pressureBC.k), mem_size_Q_k ));
386 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->pressureBC.kN), mem_size_Q_k ));
387 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->pressureBC.RhoBC), mem_size_Q_q ));
388
389 //Device
390 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->pressureBC.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
391 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->pressureBC.k), mem_size_Q_k ));
392 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->pressureBC.kN), mem_size_Q_k ));
393 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->pressureBC.RhoBC), mem_size_Q_q ));
394
396 double tmp = 2. * (double)mem_size_Q_k + (double)mem_size_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
397 setMemsizeGPU(tmp, false);
398}
399void CudaMemoryManager::cudaCopyPress(int lev)
400{
401 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->pressureBC.numberOfBCnodes;
402 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->pressureBC.numberOfBCnodes;
403
404 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->pressureBC.q27[0], parameter->getParH(lev)->pressureBC.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
405 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->pressureBC.k, parameter->getParH(lev)->pressureBC.k, mem_size_Q_k, cudaMemcpyHostToDevice));
406 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->pressureBC.kN, parameter->getParH(lev)->pressureBC.kN, mem_size_Q_k, cudaMemcpyHostToDevice));
407 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->pressureBC.RhoBC, parameter->getParH(lev)->pressureBC.RhoBC, mem_size_Q_q, cudaMemcpyHostToDevice));
408}
409void CudaMemoryManager::cudaFreePress(int lev)
410{
411 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->pressureBC.q27[0]));
412 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->pressureBC.k));
413 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->pressureBC.kN));
414 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->pressureBC.RhoBC));
415}
416
439
451
452void CudaMemoryManager::cudaFreeDirectionalBoundaryCondition(int lev)
453{
454 auto& parH = parameter->getParHostAsReference(lev);
455 auto& parD = parameter->getParDeviceAsReference(lev);
456
457 for (size_t i = 0; i < parH.pressureBCDirectional.size(); i++) {
458 checkCudaErrors(cudaFreeHost(parH.pressureBCDirectional[i].q27[0]));
459 checkCudaErrors(cudaFreeHost(parH.pressureBCDirectional[i].k));
460 checkCudaErrors(cudaFreeHost(parH.pressureBCDirectional[i].kN));
461 checkCudaErrors(cudaFreeHost(parH.pressureBCDirectional[i].RhoBC));
462
463 checkCudaErrors(cudaFree(parD.pressureBCDirectional[i].q27[0]));
464 checkCudaErrors(cudaFree(parD.pressureBCDirectional[i].k));
465 checkCudaErrors(cudaFree(parD.pressureBCDirectional[i].kN));
466 checkCudaErrors(cudaFree(parD.pressureBCDirectional[i].RhoBC));
467 }
468}
469
492
504
505// void CudaMemoryManager::cudaFreeDirectionalADBoundaryCondition(QforDirectionalADBoundaryCondition& boundaryConditionHost,
506// QforDirectionalADBoundaryCondition& boundaryConditionDevice)
507void CudaMemoryManager::cudaFreeDirectionalADBoundaryCondition(int lev)
508{
509 auto& parH = parameter->getParHostAsReference(lev);
510 auto& parD = parameter->getParDeviceAsReference(lev);
511
512 for (size_t i = 0; i < parH.concentrationBCDirectional.size(); i++) {
513 checkCudaErrors(cudaFreeHost(parH.concentrationBCDirectional[i].q27[0]));
514 checkCudaErrors(cudaFreeHost(parH.concentrationBCDirectional[i].k));
515 checkCudaErrors(cudaFreeHost(parH.concentrationBCDirectional[i].kN));
516 checkCudaErrors(cudaFreeHost(parH.concentrationBCDirectional[i].concentration));
517
518 checkCudaErrors(cudaFree(parD.concentrationBCDirectional[i].q27[0]));
519 checkCudaErrors(cudaFree(parD.concentrationBCDirectional[i].k));
520 checkCudaErrors(cudaFree(parD.concentrationBCDirectional[i].kN));
521 checkCudaErrors(cudaFree(parD.concentrationBCDirectional[i].concentration));
522 }
523}
524
525//Forcing
526void CudaMemoryManager::cudaAllocForcing()
527{
528 unsigned int mem_size = sizeof(real) * 3;
529 //Host
530 checkCudaErrors( cudaMallocHost((void**) &(parameter->forcingH), mem_size));
531 parameter->forcingH[0] = parameter->getForcesDouble()[0];
532 parameter->forcingH[1] = parameter->getForcesDouble()[1];
533 parameter->forcingH[2] = parameter->getForcesDouble()[2];
534 //Device
535 checkCudaErrors( cudaMalloc((void**) &parameter->forcingD, mem_size));
537 double tmp = (double)mem_size;
538 setMemsizeGPU(tmp, false);
539}
540void CudaMemoryManager::cudaCopyForcingToDevice()
541{
542 unsigned int mem_size = sizeof(real) * 3;
543 checkCudaErrors( cudaMemcpy(parameter->forcingD, parameter->forcingH, mem_size, cudaMemcpyHostToDevice));
544}
545void CudaMemoryManager::cudaCopyForcingToHost()
546{
547 unsigned int mem_size = sizeof(real) * 3;
548 checkCudaErrors( cudaMemcpy(parameter->forcingH, parameter->forcingD, mem_size, cudaMemcpyDeviceToHost));
549}
550void CudaMemoryManager::cudaFreeForcing()
551{
552 checkCudaErrors( cudaFreeHost(parameter->getForcesHost()));
553}
554
555void CudaMemoryManager::cudaAllocLevelForcing(int level)
556{
557 real fx_t{ 1. }, fy_t{ 1. }, fz_t{ 1. };
558 for (int i = 0; i < level; i++) {
559 fx_t *= vf::basics::constant::c2o1;
560 fy_t *= vf::basics::constant::c2o1;
561 fz_t *= vf::basics::constant::c2o1;
562 }
563
564 const unsigned int mem_size = sizeof(real) * 3;
565
566 //Host
567 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(level)->forcing), mem_size));
568 parameter->getParH(level)->forcing[0] = parameter->forcingH[0] / fx_t;
569 parameter->getParH(level)->forcing[1] = parameter->forcingH[1] / fy_t;
570 parameter->getParH(level)->forcing[2] = parameter->forcingH[2] / fz_t;
571
572 //Device
573 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(level)->forcing, mem_size));
575 const double tmp = (double)mem_size;
576 setMemsizeGPU(tmp, false);
577}
578
579void CudaMemoryManager::cudaCopyLevelForcingToDevice(int level)
580{
581 unsigned int mem_size = sizeof(real) * 3;
582 checkCudaErrors( cudaMemcpy(parameter->getParD(level)->forcing, parameter->getParH(level)->forcing, mem_size, cudaMemcpyHostToDevice));
583}
584
585void CudaMemoryManager::cudaFreeLevelForcing(int level)
586{
587 checkCudaErrors( cudaFreeHost(parameter->getParH(level)->forcing));
588 checkCudaErrors( cudaFree(parameter->getParD(level)->forcing));
589}
590
591
592//quadric Limiters
593void CudaMemoryManager::cudaAllocQuadricLimiters()
594{
595 unsigned int mem_size = sizeof(real) * 3;
596 //Host
597 checkCudaErrors( cudaMallocHost((void**) &(parameter->quadricLimitersH), mem_size));
598 parameter->quadricLimitersH[0] = parameter->getQuadricLimitersDouble()[0];
599 parameter->quadricLimitersH[1] = parameter->getQuadricLimitersDouble()[1];
600 parameter->quadricLimitersH[2] = parameter->getQuadricLimitersDouble()[2];
601 //Device
602 checkCudaErrors( cudaMalloc((void**) &parameter->quadricLimitersD, mem_size));
604 double tmp = (double)mem_size;
605 setMemsizeGPU(tmp, false);
606}
607void CudaMemoryManager::cudaCopyQuadricLimitersToDevice()
608{
609 unsigned int mem_size = sizeof(real) * 3;
610 checkCudaErrors( cudaMemcpy(parameter->quadricLimitersD, parameter->quadricLimitersH, mem_size, cudaMemcpyHostToDevice));
611}
612void CudaMemoryManager::cudaFreeQuadricLimiters()
613{
614 checkCudaErrors( cudaFreeHost(parameter->getQuadricLimitersHost()));
615}
616
618//Process Neighbors
619void CudaMemoryManager::cudaAllocProcessNeighbor(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice)
620{
621 // Host
622 checkCudaErrors(cudaMallocHost((void**)&(neighborHost.index), neighborHost.memsizeIndex));
623 checkCudaErrors(cudaMallocHost((void**)&(neighborHost.populations[0]), neighborHost.memsizeFs));
624
625 // Device
626 checkCudaErrors(cudaMalloc((void**)&(neighborDevice.index), neighborDevice.memsizeIndex));
627 checkCudaErrors(cudaMalloc((void**)&(neighborDevice.populations[0]), neighborDevice.memsizeFs));
628
629 double tmp = double(neighborHost.memsizeIndex + neighborHost.memsizeFs);
630 if(parameter->getDiffOn())
631 {
632 checkCudaErrors(cudaMallocHost((void**)&(neighborHost.populationsAD[0]), neighborHost.memsizeFs));
633 checkCudaErrors(cudaMalloc((void**)&(neighborDevice.populationsAD[0]), neighborDevice.memsizeFs));
634 tmp += neighborDevice.memsizeFs;
635 }
636 setMemsizeGPU(tmp, false);
637}
643
656
657void CudaMemoryManager::cudaCopyProcessNeighborFsHtoD(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice) const
658{
659 if (!parameter->getStreamManager()->streamIsRegistered(CudaStreamIndex::SubDomainBorder)) {
660 checkCudaErrors(cudaMemcpy(neighborDevice.populations[0], neighborHost.populations[0], neighborDevice.memsizeFs, cudaMemcpyHostToDevice));
661 if (parameter->getDiffOn())
662 checkCudaErrors(cudaMemcpy(neighborDevice.populationsAD[0], neighborHost.populationsAD[0], neighborDevice.memsizeFs, cudaMemcpyHostToDevice));
663 } else {
664 checkCudaErrors(cudaMemcpyAsync(neighborDevice.populations[0], neighborHost.populations[0], neighborDevice.memsizeFs,cudaMemcpyHostToDevice,parameter->getStreamManager()->getStream(CudaStreamIndex::SubDomainBorder)));
665 if (parameter->getDiffOn()) {
666 checkCudaErrors(cudaMemcpyAsync(neighborDevice.populationsAD[0], neighborHost.populationsAD[0], neighborDevice.memsizeFs,cudaMemcpyHostToDevice,parameter->getStreamManager()->getStream(CudaStreamIndex::SubDomainBorder)));
667 }
668 }
669}
670void CudaMemoryManager::cudaCopyProcessNeighborFsDtoH(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice) const
671{
672 if (!parameter->getStreamManager()->streamIsRegistered(CudaStreamIndex::SubDomainBorder)) {
673 checkCudaErrors(cudaMemcpy(neighborHost.populations[0], neighborDevice.populations[0], neighborDevice.memsizeFs, cudaMemcpyDeviceToHost));
674 if (parameter->getDiffOn())
675 checkCudaErrors(cudaMemcpy(neighborHost.populationsAD[0], neighborDevice.populationsAD[0], neighborDevice.memsizeFs, cudaMemcpyDeviceToHost));
676 } else {
677 checkCudaErrors(cudaMemcpyAsync(neighborHost.populations[0], neighborDevice.populations[0], neighborDevice.memsizeFs,cudaMemcpyDeviceToHost,parameter->getStreamManager()->getStream(CudaStreamIndex::SubDomainBorder)));
678 if (parameter->getDiffOn())
679 checkCudaErrors(cudaMemcpyAsync(neighborHost.populationsAD[0], neighborDevice.populationsAD[0], neighborDevice.memsizeFs,cudaMemcpyDeviceToHost,parameter->getStreamManager()->getStream(CudaStreamIndex::SubDomainBorder)));
680 }
681}
682
683void CudaMemoryManager::cudaAllocNeighborWSB(int lev)
684{
685 //Host
686 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborInverse ), parameter->getParH(lev)->memSizeLonglongLBnodes ));
687 //Device
688 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborInverse ), parameter->getParD(lev)->memSizeLonglongLBnodes ));
690 double tmp = (double)parameter->getParH(lev)->memSizeLonglongLBnodes;
691 setMemsizeGPU(tmp, false);
692}
693void CudaMemoryManager::cudaCopyNeighborWSB(int lev)
694{
695 //copy host to device
696 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->neighborInverse, parameter->getParH(lev)->neighborInverse, parameter->getParH(lev)->memSizeLonglongLBnodes , cudaMemcpyHostToDevice));
697}
698void CudaMemoryManager::cudaFreeNeighborWSB(int lev)
699{
700 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborInverse));
701}
702//turbulent viscosity
703void CudaMemoryManager::cudaAllocTurbulentViscosity(int lev)
704{
705 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->turbulentViscosity), parameter->getParH(lev)->memSizeRealLBnodes));
706 checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->turbulentViscosity), parameter->getParD(lev)->memSizeRealLBnodes));
707
708 double tmp = (double)parameter->getParH(lev)->memSizeRealLBnodes;
709 setMemsizeGPU(tmp, false);
710}
711void CudaMemoryManager::cudaCopyTurbulentViscosityHD(int lev)
712{
713 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->turbulentViscosity, parameter->getParH(lev)->turbulentViscosity, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyHostToDevice));
714}
715void CudaMemoryManager::cudaCopyTurbulentViscosityDH(int lev)
716{
717 checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->turbulentViscosity, parameter->getParD(lev)->turbulentViscosity, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyDeviceToHost));
718}
719void CudaMemoryManager::cudaFreeTurbulentViscosity(int lev)
720{
721 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->turbulentViscosity));
722 checkCudaErrors(cudaFree(parameter->getParD(lev)->turbulentViscosity));
723}
724
725//turbulence intensity
726void CudaMemoryManager::cudaAllocTurbulenceIntensity(int lev, uint size)
727{
728 uint mem_size = sizeof(real) * size;
729 // Host
730 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vxx ), mem_size));
731 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vyy ), mem_size));
732 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vzz ), mem_size));
733 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vxy ), mem_size));
734 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vxz ), mem_size));
735 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vyz ), mem_size));
736 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vx_mean ), mem_size));
737 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vy_mean ), mem_size));
738 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vz_mean ), mem_size));
739 //Device
740 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vxx ), mem_size));
741 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vyy ), mem_size));
742 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vzz ), mem_size));
743 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vxy ), mem_size));
744 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vxz ), mem_size));
745 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vyz ), mem_size));
746 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vx_mean ), mem_size));
747 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vy_mean ), mem_size));
748 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vz_mean ), mem_size));
750 double tmp = 9. * (double)mem_size;
751 setMemsizeGPU(tmp, false);
752}
753void CudaMemoryManager::cudaCopyTurbulenceIntensityHD(int lev, uint size)
754{
755 uint mem_size = sizeof(real) * size;
756 //copy host to device
757 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vxx , parameter->getParH(lev)->vxx , mem_size , cudaMemcpyHostToDevice));
758 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vyy , parameter->getParH(lev)->vyy , mem_size , cudaMemcpyHostToDevice));
759 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vzz , parameter->getParH(lev)->vzz , mem_size , cudaMemcpyHostToDevice));
760 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vxy , parameter->getParH(lev)->vxy , mem_size , cudaMemcpyHostToDevice));
761 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vxz , parameter->getParH(lev)->vxz , mem_size , cudaMemcpyHostToDevice));
762 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vyz , parameter->getParH(lev)->vyz , mem_size , cudaMemcpyHostToDevice));
763 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vx_mean, parameter->getParH(lev)->vx_mean, mem_size , cudaMemcpyHostToDevice));
764 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vy_mean, parameter->getParH(lev)->vy_mean, mem_size , cudaMemcpyHostToDevice));
765 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vz_mean, parameter->getParH(lev)->vz_mean, mem_size , cudaMemcpyHostToDevice));
766}
767void CudaMemoryManager::cudaCopyTurbulenceIntensityDH(int lev, uint size)
768{
769 uint mem_size = sizeof(real) * size;
770 //copy device to host
771 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vxx , parameter->getParD(lev)->vxx , mem_size , cudaMemcpyDeviceToHost));
772 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vyy , parameter->getParD(lev)->vyy , mem_size , cudaMemcpyDeviceToHost));
773 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vzz , parameter->getParD(lev)->vzz , mem_size , cudaMemcpyDeviceToHost));
774 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vxy , parameter->getParD(lev)->vxy , mem_size , cudaMemcpyDeviceToHost));
775 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vxz , parameter->getParD(lev)->vxz , mem_size , cudaMemcpyDeviceToHost));
776 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vyz , parameter->getParD(lev)->vyz , mem_size , cudaMemcpyDeviceToHost));
777 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vx_mean, parameter->getParD(lev)->vx_mean, mem_size , cudaMemcpyDeviceToHost));
778 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vy_mean, parameter->getParD(lev)->vy_mean, mem_size , cudaMemcpyDeviceToHost));
779 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vz_mean, parameter->getParD(lev)->vz_mean, mem_size , cudaMemcpyDeviceToHost));
780}
781void CudaMemoryManager::cudaFreeTurbulenceIntensity(int lev)
782{
783 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vxx ));
784 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vyy ));
785 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vzz ));
786 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vxy ));
787 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vxz ));
788 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vyz ));
789 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vx_mean ));
790 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vy_mean ));
791 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vz_mean ));
792}
793//mean
794void CudaMemoryManager::cudaAllocMeanSP(int lev)
795{
796 //Host
797 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanDensity), parameter->getParH(lev)->memSizeRealLBnodes));
798 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInXdirection), parameter->getParH(lev)->memSizeRealLBnodes));
799 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInYdirection), parameter->getParH(lev)->memSizeRealLBnodes));
800 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInZdirection), parameter->getParH(lev)->memSizeRealLBnodes));
801 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanPressure), parameter->getParH(lev)->memSizeRealLBnodes));
802 //Device
803 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->meanDensity), parameter->getParD(lev)->memSizeRealLBnodes));
804 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->meanVelocityInXdirection), parameter->getParD(lev)->memSizeRealLBnodes));
805 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->meanVelocityInYdirection), parameter->getParD(lev)->memSizeRealLBnodes));
806 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->meanVelocityInZdirection), parameter->getParD(lev)->memSizeRealLBnodes));
807 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->meanPressure), parameter->getParD(lev)->memSizeRealLBnodes));
809 double tmp = 5. * (double)parameter->getParH(lev)->memSizeRealLBnodes;
810 setMemsizeGPU(tmp, false);
811}
812void CudaMemoryManager::cudaCopyMeanSP(int lev)
813{
814 //copy host to device
815 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->meanDensity, parameter->getParH(lev)->meanDensity, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
816 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->meanVelocityInXdirection, parameter->getParH(lev)->meanVelocityInXdirection, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
817 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->meanVelocityInYdirection, parameter->getParH(lev)->meanVelocityInYdirection, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
818 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->meanVelocityInZdirection, parameter->getParH(lev)->meanVelocityInZdirection, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
819 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->meanPressure, parameter->getParH(lev)->meanPressure, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
820}
821void CudaMemoryManager::cudaFreeMeanSP(int lev)
822{
823 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanVelocityInXdirection ));
824 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanVelocityInYdirection ));
825 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanVelocityInZdirection ));
826 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanDensity ));
827 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanPressure));
828}
829void CudaMemoryManager::cudaAllocMeanOut(int lev)
830{
831 //Host
832 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanDensityOut ), parameter->getParH(lev)->memSizeRealLBnodes));
833 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInXdirectionOut ), parameter->getParH(lev)->memSizeRealLBnodes));
834 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInYdirectionOut ), parameter->getParH(lev)->memSizeRealLBnodes));
835 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInZdirectionOut ), parameter->getParH(lev)->memSizeRealLBnodes));
836 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->meanPressureOut ), parameter->getParH(lev)->memSizeRealLBnodes));
837}
838void CudaMemoryManager::cudaFreeMeanOut(int lev)
839{
840 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanVelocityInXdirectionOut ));
841 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanVelocityInYdirectionOut ));
842 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanVelocityInZdirectionOut ));
843 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanDensityOut ));
844 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->meanPressureOut));
845}
846//Interface CF
847void CudaMemoryManager::cudaAllocInterfaceCF(int lev)
848{
849 uint mem_size_kCF = sizeof(uint) * parameter->getParH(lev)->coarseToFine.numberOfCells;
850 //Host
851 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coarseToFine.coarseCellIndices), mem_size_kCF ));
852 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->coarseToFine.fineCellIndices), mem_size_kCF ));
853 //Device
854 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coarseToFine.coarseCellIndices), mem_size_kCF ));
855 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coarseToFine.fineCellIndices), mem_size_kCF ));
857 double tmp = 2. * (double)mem_size_kCF;
858 setMemsizeGPU(tmp, false);
859}
860void CudaMemoryManager::cudaCopyInterfaceCF(int lev)
861{
862 uint mem_size_kCF = sizeof(uint) * parameter->getParH(lev)->coarseToFine.numberOfCells;
863
864 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->coarseToFine.coarseCellIndices, parameter->getParH(lev)->coarseToFine.coarseCellIndices, mem_size_kCF, cudaMemcpyHostToDevice));
865 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->coarseToFine.fineCellIndices, parameter->getParH(lev)->coarseToFine.fineCellIndices, mem_size_kCF, cudaMemcpyHostToDevice));
866}
867void CudaMemoryManager::cudaFreeInterfaceCF(int lev)
868{
869 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coarseToFine.coarseCellIndices));
870 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->coarseToFine.fineCellIndices));
871}
872//Interface FC
873void CudaMemoryManager::cudaAllocInterfaceFC(int lev)
874{
875 uint mem_size_kFC = sizeof(uint) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
876
877 //Host
878 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->fineToCoarse.fineCellIndices), mem_size_kFC ));
879 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->fineToCoarse.coarseCellIndices), mem_size_kFC ));
880 //Device
881 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->fineToCoarse.fineCellIndices), mem_size_kFC ));
882 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->fineToCoarse.coarseCellIndices), mem_size_kFC ));
884 double tmp = 2. * (double)mem_size_kFC;
885 setMemsizeGPU(tmp, false);
886}
887void CudaMemoryManager::cudaCopyInterfaceFC(int lev)
888{
889 uint mem_size_kFC = sizeof(uint) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
890
891 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->fineToCoarse.fineCellIndices, parameter->getParH(lev)->fineToCoarse.fineCellIndices, mem_size_kFC, cudaMemcpyHostToDevice));
892 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->fineToCoarse.coarseCellIndices, parameter->getParH(lev)->fineToCoarse.coarseCellIndices, mem_size_kFC, cudaMemcpyHostToDevice));
893}
894void CudaMemoryManager::cudaCheckInterfaceFCBulk(int lev)
895{
896 // only use for testing!
897 size_t memsize = sizeof(uint) * parameter->getParH(lev)->fineToCoarseBulk.numberOfCells;
898 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->fineToCoarseBulk.coarseCellIndices, parameter->getParH(lev)->fineToCoarseBulk.coarseCellIndices, memsize, cudaMemcpyDeviceToDevice));
899 for (uint i = 0; i < parameter->getParH(lev)->fineToCoarseBulk.numberOfCells; i++)
900 printf("%d %d\n", i, parameter->getParH(lev)->fineToCoarseBulk.coarseCellIndices[i]);
901}
902void CudaMemoryManager::cudaFreeInterfaceFC(int lev)
903{
904 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->fineToCoarse.fineCellIndices));
905 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->fineToCoarse.coarseCellIndices));
906}
907//Interface Offset CF
908void CudaMemoryManager::cudaAllocInterfaceOffCF(int lev)
909{
910 uint mem_size_kCF_off = sizeof(real) * parameter->getParH(lev)->coarseToFine.numberOfCells;
911
912 //Host
913 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborCoarseToFine.x), mem_size_kCF_off ));
914 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborCoarseToFine.y), mem_size_kCF_off ));
915 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborCoarseToFine.z), mem_size_kCF_off ));
916 getLastCudaError("Allocate host memory");
917 //Device
918 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborCoarseToFine.x), mem_size_kCF_off ));
919 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborCoarseToFine.y), mem_size_kCF_off ));
920 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborCoarseToFine.z), mem_size_kCF_off ));
921 getLastCudaError("Allocate device memory");
923 double tmp = 3. * (double)mem_size_kCF_off;
924 setMemsizeGPU(tmp, false);
925}
926void CudaMemoryManager::cudaCopyInterfaceOffCF(int lev)
927{
928 uint mem_size_kCF_off = sizeof(real) * parameter->getParH(lev)->coarseToFine.numberOfCells;
929
930 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborCoarseToFine.x, parameter->getParH(lev)->neighborCoarseToFine.x, mem_size_kCF_off, cudaMemcpyHostToDevice));
931 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborCoarseToFine.y, parameter->getParH(lev)->neighborCoarseToFine.y, mem_size_kCF_off, cudaMemcpyHostToDevice));
932 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborCoarseToFine.z, parameter->getParH(lev)->neighborCoarseToFine.z, mem_size_kCF_off, cudaMemcpyHostToDevice));
933 getLastCudaError("Copy host memory to device");
934}
935void CudaMemoryManager::cudaFreeInterfaceOffCF(int lev)
936{
937 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborCoarseToFine.x));
938 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborCoarseToFine.y));
939 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborCoarseToFine.z));
940}
941//Interface Offset FC
942void CudaMemoryManager::cudaAllocInterfaceOffFC(int lev)
943{
944 uint mem_size_kFC_off = sizeof(real) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
945
946 //Host
947 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborFineToCoarse.x), mem_size_kFC_off ));
948 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborFineToCoarse.y), mem_size_kFC_off ));
949 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborFineToCoarse.z), mem_size_kFC_off ));
950 getLastCudaError("Allocate host memory");
951 //Device
952 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborFineToCoarse.x), mem_size_kFC_off ));
953 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborFineToCoarse.y), mem_size_kFC_off ));
954 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborFineToCoarse.z), mem_size_kFC_off ));
955 getLastCudaError("Allocate device memory");
957 double tmp = 3. * (double)mem_size_kFC_off;
958 setMemsizeGPU(tmp, false);
959}
960void CudaMemoryManager::cudaCopyInterfaceOffFC(int lev)
961{
962 uint mem_size_kFC_off = sizeof(real) * parameter->getParH(lev)->fineToCoarse.numberOfCells;
963
964 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborFineToCoarse.x, parameter->getParH(lev)->neighborFineToCoarse.x, mem_size_kFC_off, cudaMemcpyHostToDevice));
965 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborFineToCoarse.y, parameter->getParH(lev)->neighborFineToCoarse.y, mem_size_kFC_off, cudaMemcpyHostToDevice));
966 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->neighborFineToCoarse.z, parameter->getParH(lev)->neighborFineToCoarse.z, mem_size_kFC_off, cudaMemcpyHostToDevice));
967 getLastCudaError("Copy host memory to device");
968}
969void CudaMemoryManager::cudaFreeInterfaceOffFC(int lev)
970{
971 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborFineToCoarse.x));
972 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborFineToCoarse.y));
973 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborFineToCoarse.z));
974}
975
976
977
978
979//Geometrie inkl. Values
980void CudaMemoryManager::cudaAllocGeomValuesBC(int lev)
981{
982 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->geometryBC.numberOfBCnodes;
983
984 //Host
985 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geometryBC.Vx), mem_size_Q_q ));
986 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geometryBC.Vy), mem_size_Q_q ));
987 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geometryBC.Vz), mem_size_Q_q ));
988
989 //Device
990 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->geometryBC.Vx), mem_size_Q_q ));
991 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->geometryBC.Vy), mem_size_Q_q ));
992 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->geometryBC.Vz), mem_size_Q_q ));
993
995 double tmp = 3. * (double)mem_size_Q_q;
996 setMemsizeGPU(tmp, false);
997}
998void CudaMemoryManager::cudaCopyGeomValuesBC(int lev)
999{
1000 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->geometryBC.numberOfBCnodes;
1001
1002 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->geometryBC.Vx, parameter->getParH(lev)->geometryBC.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
1003 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->geometryBC.Vy, parameter->getParH(lev)->geometryBC.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
1004 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->geometryBC.Vz, parameter->getParH(lev)->geometryBC.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
1005}
1006void CudaMemoryManager::cudaFreeGeomValuesBC(int lev)
1007{
1008 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->geometryBC.Vx));
1009 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->geometryBC.Vy));
1010 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->geometryBC.Vz));
1011}
1012//Slip
1013void CudaMemoryManager::cudaAllocSlipBC(int lev)
1014{
1015 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->slipBC.numberOfBCnodes;
1016 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->slipBC.numberOfBCnodes;
1017 //Host
1018 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->slipBC.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
1019 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->slipBC.k), mem_size_Q_k ));
1020 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->slipBC.normalX), mem_size_Q_q ));
1021 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->slipBC.normalY), mem_size_Q_q ));
1022 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->slipBC.normalZ), mem_size_Q_q ));
1023
1024 //Device
1025 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->slipBC.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
1026 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->slipBC.k), mem_size_Q_k ));
1027 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->slipBC.normalX), mem_size_Q_q ));
1028 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->slipBC.normalY), mem_size_Q_q ));
1029 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->slipBC.normalZ), mem_size_Q_q ));
1030
1032 double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q + 3.0*(double)mem_size_Q_q;;
1033 setMemsizeGPU(tmp, false);
1034}
1035void CudaMemoryManager::cudaCopySlipBC(int lev)
1036{
1037 unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->slipBC.numberOfBCnodes;
1038 unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->slipBC.numberOfBCnodes;
1039
1040 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->slipBC.q27[0], parameter->getParH(lev)->slipBC.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
1041 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->slipBC.k, parameter->getParH(lev)->slipBC.k, mem_size_Q_k, cudaMemcpyHostToDevice));
1042 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->slipBC.normalX, parameter->getParH(lev)->slipBC.normalX, mem_size_Q_q, cudaMemcpyHostToDevice));
1043 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->slipBC.normalY, parameter->getParH(lev)->slipBC.normalY, mem_size_Q_q, cudaMemcpyHostToDevice));
1044 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->slipBC.normalZ, parameter->getParH(lev)->slipBC.normalZ, mem_size_Q_q, cudaMemcpyHostToDevice));
1045}
1046void CudaMemoryManager::cudaFreeSlipBC(int lev)
1047{
1048 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->slipBC.q27[0]));
1049 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->slipBC.k));
1050 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->slipBC.normalX));
1051 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->slipBC.normalY));
1052 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->slipBC.normalZ));
1053}
1054//Stress
1055void CudaMemoryManager::cudaAllocStressBC(int lev)
1056{
1057 auto& parH = parameter->getParHostAsReference(lev);
1058 auto& parD = parameter->getParDeviceAsReference(lev);
1059 const uint memSizeInt = sizeof(int) * parH.stressBC.numberOfBCnodes;
1060 const uint memSizeReal = sizeof(real) * parH.stressBC.numberOfBCnodes;
1061 // Host
1062 checkCudaErrors(cudaMallocHost((void**)&(parH.stressBC.q27[0]), parameter->getD3Qxx() * memSizeReal));
1063 checkCudaErrors(cudaMallocHost((void**)&(parH.stressBC.k), memSizeInt));
1064 checkCudaErrors(cudaMallocHost((void**)&(parH.stressBC.normalX), memSizeReal));
1065 checkCudaErrors(cudaMallocHost((void**)&(parH.stressBC.normalY), memSizeReal));
1066 checkCudaErrors(cudaMallocHost((void**)&(parH.stressBC.normalZ), memSizeReal));
1067
1068 // Device
1069 checkCudaErrors(cudaMalloc((void**)&(parD.stressBC.q27[0]), parameter->getD3Qxx() * memSizeReal));
1070 checkCudaErrors(cudaMalloc((void**)&(parD.stressBC.k), memSizeInt));
1071 checkCudaErrors(cudaMalloc((void**)&(parD.stressBC.normalX), memSizeReal));
1072 checkCudaErrors(cudaMalloc((void**)&(parD.stressBC.normalY), memSizeReal));
1073 checkCudaErrors(cudaMalloc((void**)&(parD.stressBC.normalZ), memSizeReal));
1074
1076 double tmp = memSizeInt + parameter->getD3Qxx() * memSizeReal + 3 * memSizeReal;
1077 setMemsizeGPU(tmp, false);
1078}
1079void CudaMemoryManager::cudaCopyStressBC(int lev)
1080{
1081 auto& parH = parameter->getParHostAsReference(lev);
1082 auto& parD = parameter->getParDeviceAsReference(lev);
1083 const uint memSizeInt = sizeof(int) * parH.stressBC.numberOfBCnodes;
1084 const uint memSizeReal = sizeof(real) * parH.stressBC.numberOfBCnodes;
1085
1086 checkCudaErrors( cudaMemcpy(parD.stressBC.q27[0], parH.stressBC.q27[0], parameter->getD3Qxx()* memSizeReal, cudaMemcpyHostToDevice));
1087 checkCudaErrors( cudaMemcpy(parD.stressBC.k, parH.stressBC.k, memSizeInt, cudaMemcpyHostToDevice));
1088 checkCudaErrors( cudaMemcpy(parD.stressBC.normalX, parH.stressBC.normalX, memSizeReal, cudaMemcpyHostToDevice));
1089 checkCudaErrors( cudaMemcpy(parD.stressBC.normalY, parH.stressBC.normalY, memSizeReal, cudaMemcpyHostToDevice));
1090 checkCudaErrors( cudaMemcpy(parD.stressBC.normalZ, parH.stressBC.normalZ, memSizeReal, cudaMemcpyHostToDevice));
1091
1092}
1093void CudaMemoryManager::cudaFreeStressBC(int lev)
1094{
1095 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->stressBC.q27[0]));
1096 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->stressBC.k));
1097 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->stressBC.normalX));
1098 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->stressBC.normalY));
1099 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->stressBC.normalZ));
1100}
1101
1102void CudaMemoryManager::cudaAllocSurfaceLayerBC(int lev)
1103{
1104 const size_t memSizeInt = sizeof(int)*parameter->getParH(lev)->surfaceLayerBC.numberOfBCnodes;
1105 const size_t memSizeReal = sizeof(real)*parameter->getParH(lev)->surfaceLayerBC.numberOfBCnodes;
1106
1107 //Host
1108 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->surfaceLayerBC.q27[0]), parameter->getD3Qxx()*memSizeReal ));
1109 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->surfaceLayerBC.k), memSizeInt ));
1110 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->surfaceLayerBC.normalX), memSizeReal ));
1111 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->surfaceLayerBC.normalY), memSizeReal ));
1112 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->surfaceLayerBC.normalZ), memSizeReal ));
1113
1114 //Device
1115 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->surfaceLayerBC.q27[0]), parameter->getD3Qxx()* memSizeReal ));
1116 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->surfaceLayerBC.k), memSizeInt ));
1117 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->surfaceLayerBC.normalX), memSizeReal ));
1118 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->surfaceLayerBC.normalY), memSizeReal ));
1119 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->surfaceLayerBC.normalZ), memSizeReal ));
1121 const double tmp = memSizeInt + parameter->getD3Qxx()*memSizeReal + 3 * memSizeReal;
1122 setMemsizeGPU(tmp, false);
1123}
1124
1125void CudaMemoryManager::cudaCopySurfaceLayerBC(int lev)
1126{
1127 const size_t memSizeInt = sizeof(int)*parameter->getParH(lev)->surfaceLayerBC.numberOfBCnodes;
1128 const size_t memSizeReal = sizeof(real)*parameter->getParH(lev)->surfaceLayerBC.numberOfBCnodes;
1129
1130 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->surfaceLayerBC.q27[0], parameter->getParH(lev)->surfaceLayerBC.q27[0], parameter->getD3Qxx()* memSizeReal, cudaMemcpyHostToDevice));
1131 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->surfaceLayerBC.k, parameter->getParH(lev)->surfaceLayerBC.k, memSizeInt, cudaMemcpyHostToDevice));
1132 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->surfaceLayerBC.normalX, parameter->getParH(lev)->surfaceLayerBC.normalX, memSizeReal, cudaMemcpyHostToDevice));
1133 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->surfaceLayerBC.normalY, parameter->getParH(lev)->surfaceLayerBC.normalY, memSizeReal, cudaMemcpyHostToDevice));
1134 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->surfaceLayerBC.normalZ, parameter->getParH(lev)->surfaceLayerBC.normalZ, memSizeReal, cudaMemcpyHostToDevice));
1135}
1136void CudaMemoryManager::cudaFreeSurfaceLayerBC(int lev)
1137{
1138 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->surfaceLayerBC.q27[0]));
1139 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->surfaceLayerBC.k));
1140 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->surfaceLayerBC.normalX));
1141 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->surfaceLayerBC.normalY));
1142 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->surfaceLayerBC.normalZ));
1143
1144 checkCudaErrors( cudaFree(parameter->getParD(lev)->surfaceLayerBC.q27[0]));
1145 checkCudaErrors( cudaFree(parameter->getParD(lev)->surfaceLayerBC.k));
1146 checkCudaErrors( cudaFree(parameter->getParD(lev)->surfaceLayerBC.normalX));
1147 checkCudaErrors( cudaFree(parameter->getParD(lev)->surfaceLayerBC.normalY));
1148 checkCudaErrors( cudaFree(parameter->getParD(lev)->surfaceLayerBC.normalZ));
1149}
1150// Wall model
1151void CudaMemoryManager::cudaAllocWallModel(WallModelParameters& wallModelHost, WallModelParameters& wallModelDevice, uint numberOfNodes)
1152{
1153 const uint memSizeUint = sizeof(uint) * numberOfNodes;
1154 const uint memSizeReal = sizeof(real) * numberOfNodes;
1155
1156 // Host
1157 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.samplingIndices), memSizeUint));
1158 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.samplingDistance), memSizeReal));
1159 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.vonKarmanConstant), memSizeReal));
1160 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.roughnessLength), memSizeReal));
1161 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.velocityMagnitudeNode), memSizeReal));
1162 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.velocityMagnitudeSample), memSizeReal));
1163
1164 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.frictionVelocity), memSizeReal));
1165 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.forceX), memSizeReal));
1166 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.forceY), memSizeReal));
1167 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.forceZ), memSizeReal));
1168
1169
1170 // Device
1171 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.samplingIndices), memSizeUint));
1172 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.samplingDistance), memSizeReal));
1173 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.vonKarmanConstant), memSizeReal));
1174 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.roughnessLength), memSizeReal));
1175 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.velocityMagnitudeNode), memSizeReal));
1176 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.velocityMagnitudeSample), memSizeReal));
1177
1178 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.frictionVelocity), memSizeReal));
1179 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.forceX), memSizeReal));
1180 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.forceY), memSizeReal));
1181 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.forceZ), memSizeReal));
1182
1183
1185 double tmp = memSizeUint + 9 * memSizeReal;
1186 setMemsizeGPU(tmp, false);
1187}
1188void CudaMemoryManager::cudaCopyWallModel(WallModelParameters& wallModelHost, WallModelParameters& wallModelDevice, uint numberOfNodes)
1189{
1190 const uint memSizeUint = sizeof(uint) * numberOfNodes;
1191 const uint memSizeReal = sizeof(real) * numberOfNodes;
1192
1193 checkCudaErrors(cudaMemcpy(wallModelDevice.samplingIndices, wallModelHost.samplingIndices, memSizeUint, cudaMemcpyHostToDevice));
1194 checkCudaErrors(cudaMemcpy(wallModelDevice.samplingDistance, wallModelHost.samplingDistance, memSizeReal, cudaMemcpyHostToDevice));
1195 checkCudaErrors(cudaMemcpy(wallModelDevice.vonKarmanConstant, wallModelHost.vonKarmanConstant, memSizeReal, cudaMemcpyHostToDevice));
1196 checkCudaErrors(cudaMemcpy(wallModelDevice.roughnessLength, wallModelHost.roughnessLength, memSizeReal, cudaMemcpyHostToDevice));
1197}
1198
1224
1225void CudaMemoryManager::cudaAllocTemperatureWallModel(TemperatureWallModelParameters& wallModelHost,
1226 TemperatureWallModelParameters& wallModelDevice, uint numberOfNodes)
1227{
1228 const size_t memSize = sizeof(real) * numberOfNodes;
1229
1230 // Host
1231 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.temperatureNode), memSize));
1232 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.temperatureSample), memSize));
1233 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.surfaceHeatFlux), memSize));
1234 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.surfaceTemperature), memSize));
1235 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.roughnessLength), memSize));
1236 checkCudaErrors(cudaMallocHost((void**)&(wallModelHost.heatingRate), memSize));
1237
1238 // Device
1239 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.temperatureNode), memSize));
1240 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.temperatureSample), memSize));
1241 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.surfaceHeatFlux), memSize));
1242 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.surfaceTemperature), memSize));
1243 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.roughnessLength), memSize));
1244 checkCudaErrors(cudaMalloc((void**)&(wallModelDevice.heatingRate), memSize));
1245
1247 const double tmp = 6 * memSize;
1248 setMemsizeGPU(tmp, false);
1249}
1250
1263
1281
1282//Precursor BC
1283void CudaMemoryManager::cudaAllocPrecursorBC(int lev)
1284{
1285 uint memSizeQInt = parameter->getParH(lev)->precursorBC.numberOfBCnodes*sizeof(int);
1286 uint memSizeQUint = parameter->getParH(lev)->precursorBC.numberOfBCnodes*sizeof(uint);
1287 uint memSizeQReal = parameter->getParH(lev)->precursorBC.numberOfBCnodes*sizeof(real);
1288
1289 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.k, memSizeQInt));
1290 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.q27[0], parameter->getD3Qxx()*memSizeQReal));
1291
1292
1293 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.planeNeighbor0PP, memSizeQUint));
1294 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.planeNeighbor0PM, memSizeQUint));
1295 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.planeNeighbor0MP, memSizeQUint));
1296 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.planeNeighbor0MM, memSizeQUint));
1297
1298 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.weights0PP, memSizeQReal));
1299 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.weights0PM, memSizeQReal));
1300 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.weights0MP, memSizeQReal));
1301 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.weights0MM, memSizeQReal));
1302
1303 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.k, memSizeQInt));
1304 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.q27[0], parameter->getD3Qxx()*memSizeQReal));
1305
1306 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.planeNeighbor0PP, memSizeQUint));
1307 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.planeNeighbor0PM, memSizeQUint));
1308 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.planeNeighbor0MP, memSizeQUint));
1309 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.planeNeighbor0MM, memSizeQUint));
1310
1311 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.weights0PP, memSizeQReal));
1312 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.weights0PM, memSizeQReal));
1313 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.weights0MP, memSizeQReal));
1314 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.weights0MM, memSizeQReal));
1315
1316 real memSize = memSizeQInt+4*memSizeQUint+(4+parameter->getD3Qxx())*memSizeQReal;
1317 setMemsizeGPU(memSize, false);
1318
1319}
1320
1321
1322void CudaMemoryManager::cudaAllocPrecursorData(int lev)
1323{
1324 size_t size = parameter->getParH(lev)->precursorBC.numberOfPrecursorNodes*sizeof(real)*parameter->getParH(lev)->precursorBC.numberOfQuantities;
1325
1326 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.last, size));
1327 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.current, size));
1328 checkCudaErrors( cudaMallocHost((void**) &parameter->getParH(lev)->precursorBC.next, size));
1329
1330 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.last, size));
1331 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.current, size));
1332 checkCudaErrors( cudaMalloc((void**) &parameter->getParD(lev)->precursorBC.next, size));
1333 setMemsizeGPU(3*size, false);
1334}
1335
1336
1337void CudaMemoryManager::cudaCopyPrecursorBC(int lev)
1338{
1339 uint memSizeQInt = parameter->getParH(lev)->precursorBC.numberOfBCnodes*sizeof(int);
1340 uint memSizeQUint = parameter->getParH(lev)->precursorBC.numberOfBCnodes*sizeof(uint);
1341 uint memSizeQReal = parameter->getParH(lev)->precursorBC.numberOfBCnodes*sizeof(real);
1342
1343 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.k, parameter->getParH(lev)->precursorBC.k, memSizeQInt, cudaMemcpyHostToDevice));
1344
1345 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.q27[0], parameter->getParH(lev)->precursorBC.q27[0], memSizeQReal*parameter->getD3Qxx(), cudaMemcpyHostToDevice));
1346
1347 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.planeNeighbor0PP, parameter->getParH(lev)->precursorBC.planeNeighbor0PP, memSizeQUint, cudaMemcpyHostToDevice));
1348 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.planeNeighbor0PM, parameter->getParH(lev)->precursorBC.planeNeighbor0PM, memSizeQUint, cudaMemcpyHostToDevice));
1349 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.planeNeighbor0MP, parameter->getParH(lev)->precursorBC.planeNeighbor0MP, memSizeQUint, cudaMemcpyHostToDevice));
1350 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.planeNeighbor0MM, parameter->getParH(lev)->precursorBC.planeNeighbor0MM, memSizeQUint, cudaMemcpyHostToDevice));
1351
1352 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.weights0PP, parameter->getParH(lev)->precursorBC.weights0PP, memSizeQReal, cudaMemcpyHostToDevice));
1353 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.weights0PM, parameter->getParH(lev)->precursorBC.weights0PM, memSizeQReal, cudaMemcpyHostToDevice));
1354 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.weights0MP, parameter->getParH(lev)->precursorBC.weights0MP, memSizeQReal, cudaMemcpyHostToDevice));
1355 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->precursorBC.weights0MM, parameter->getParH(lev)->precursorBC.weights0MM, memSizeQReal, cudaMemcpyHostToDevice));
1356}
1357void CudaMemoryManager::cudaCopyPrecursorData(int lev)
1358{
1359 auto precurser = &parameter->getParH(lev)->precursorBC;
1360 auto precurserStream = parameter->getStreamManager()->getStream(CudaStreamIndex::Precursor, precurser->streamIndex);
1361 size_t memSize = precurser->numberOfPrecursorNodes*sizeof(real)*precurser->numberOfQuantities;
1362 checkCudaErrors( cudaStreamSynchronize(precurserStream) );
1363 checkCudaErrors( cudaMemcpyAsync(parameter->getParD(lev)->precursorBC.next, precurser->next, memSize, cudaMemcpyHostToDevice, precurserStream) );
1364}
1365
1366
1367void CudaMemoryManager::cudaFreePrecursorBC(int lev)
1368{
1369 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.k));
1370
1371 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.q27[0]));
1372
1373 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.planeNeighbor0PP));
1374 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.planeNeighbor0PM));
1375 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.planeNeighbor0MP));
1376 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.planeNeighbor0MM));
1377
1378 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.weights0PP));
1379 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.weights0PM));
1380 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.weights0MP));
1381 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.weights0MM));
1382
1383 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.k));
1384
1385 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.q27[0]));
1386
1387 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.planeNeighbor0PP));
1388 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.planeNeighbor0PM));
1389 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.planeNeighbor0MP));
1390 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.planeNeighbor0MM));
1391
1392 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.weights0PP));
1393 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.weights0PM));
1394 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.weights0MP));
1395 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.weights0MM));
1396}
1397
1398void CudaMemoryManager::cudaFreePrecursorData(int lev)
1399{
1400 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.last));
1401 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.current));
1402 checkCudaErrors( cudaFreeHost( parameter->getParH(lev)->precursorBC.next));
1403
1404 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.last));
1405 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.current));
1406 checkCudaErrors( cudaFree( parameter->getParD(lev)->precursorBC.next));
1407}
1408void CudaMemoryManager::cudaAllocMeasurePointsIndex(int lev)
1409{
1410 //Host
1411 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->indicesOfMeasurePoints), parameter->getParH(lev)->memSizeIntegerMeasurePoints ));
1412 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityInXdirectionAtMeasurePoints), parameter->getParH(lev)->memSizeRealMeasurePoints ));
1413 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityInYdirectionAtMeasurePoints), parameter->getParH(lev)->memSizeRealMeasurePoints ));
1414 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->velocityInZdirectionAtMeasurePoints), parameter->getParH(lev)->memSizeRealMeasurePoints ));
1415 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->densityAtMeasurePoints), parameter->getParH(lev)->memSizeRealMeasurePoints ));
1416
1417 //Device
1418 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->indicesOfMeasurePoints), parameter->getParD(lev)->memSizeIntegerMeasurePoints ));
1419 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityInXdirectionAtMeasurePoints), parameter->getParD(lev)->memSizeRealMeasurePoints ));
1420 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityInYdirectionAtMeasurePoints), parameter->getParD(lev)->memSizeRealMeasurePoints ));
1421 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->velocityInZdirectionAtMeasurePoints), parameter->getParD(lev)->memSizeRealMeasurePoints ));
1422 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->densityAtMeasurePoints), parameter->getParD(lev)->memSizeRealMeasurePoints ));
1423
1425 double tmp = (double)parameter->getParH(lev)->memSizeIntegerMeasurePoints + 4. * (double)parameter->getParH(lev)->memSizeRealMeasurePoints;
1426 setMemsizeGPU(tmp, false);
1427}
1428void CudaMemoryManager::cudaCopyMeasurePointsIndex(int lev)
1429{
1430 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->indicesOfMeasurePoints, parameter->getParH(lev)->indicesOfMeasurePoints, parameter->getParH(lev)->memSizeIntegerMeasurePoints, cudaMemcpyHostToDevice));
1431 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityInXdirectionAtMeasurePoints, parameter->getParH(lev)->velocityInXdirectionAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyHostToDevice));
1432 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityInYdirectionAtMeasurePoints, parameter->getParH(lev)->velocityInYdirectionAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyHostToDevice));
1433 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->velocityInZdirectionAtMeasurePoints, parameter->getParH(lev)->velocityInZdirectionAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyHostToDevice));
1434 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->densityAtMeasurePoints, parameter->getParH(lev)->densityAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyHostToDevice));
1435}
1436void CudaMemoryManager::cudaCopyMeasurePointsToHost(int lev)
1437{
1438 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->indicesOfMeasurePoints, parameter->getParD(lev)->indicesOfMeasurePoints, parameter->getParH(lev)->memSizeIntegerMeasurePoints, cudaMemcpyDeviceToHost));
1439 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityInXdirectionAtMeasurePoints, parameter->getParD(lev)->velocityInXdirectionAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyDeviceToHost));
1440 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityInYdirectionAtMeasurePoints, parameter->getParD(lev)->velocityInYdirectionAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyDeviceToHost));
1441 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->velocityInZdirectionAtMeasurePoints, parameter->getParD(lev)->velocityInZdirectionAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyDeviceToHost));
1442 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->densityAtMeasurePoints, parameter->getParD(lev)->densityAtMeasurePoints, parameter->getParH(lev)->memSizeRealMeasurePoints, cudaMemcpyDeviceToHost));
1443}
1444void CudaMemoryManager::cudaFreeMeasurePointsIndex(int lev)
1445{
1446 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->indicesOfMeasurePoints));
1447 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityInXdirectionAtMeasurePoints));
1448 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityInYdirectionAtMeasurePoints));
1449 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->velocityInZdirectionAtMeasurePoints));
1450 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->densityAtMeasurePoints));
1451}
1452void CudaMemoryManager::cudaAllocFsForCheckPointAndRestart(int lev) const
1453{
1454 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->distributions.f[0] ), (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParH(lev)->memSizeRealLBnodes));
1455}
1456void CudaMemoryManager::cudaAllocFsForAllLevelsOnHost() const
1457{
1458 for (int level = 0; level <= parameter->getMaxLevel(); level++) {
1459 cudaAllocFsForCheckPointAndRestart(level);
1460 }
1461}
1462void CudaMemoryManager::cudaCopyFsForRestart(int lev) const
1463{
1464 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->distributions.f[0], parameter->getParH(lev)->distributions.f[0], (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyHostToDevice));
1465}
1466void CudaMemoryManager::cudaCopyFsForCheckPoint(int lev) const
1467{
1468 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->distributions.f[0], parameter->getParD(lev)->distributions.f[0], (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
1469}
1470void CudaMemoryManager::cudaCopyFsForAllLevelsToHost() const
1471{
1472 for (int level = 0; level <= parameter->getMaxLevel(); level++)
1473 cudaCopyFsForCheckPoint(level);
1474}
1475void CudaMemoryManager::cudaFreeFsForCheckPointAndRestart(int lev) const
1476{
1477 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->distributions.f[0]));
1478}
1479//DragLift
1480void CudaMemoryManager::cudaAllocDragLift(int lev, int numofelem)
1481{
1482 unsigned int mem_size = sizeof(double)*numofelem;
1483
1484 //Host
1485 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragLiftPreProcessingInXdirection), mem_size ));
1486 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragLiftPreProcessingInYdirection), mem_size ));
1487 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragLiftPreProcessingInZdirection), mem_size ));
1488 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragLiftPostProcessingInXdirection), mem_size ));
1489 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragLiftPostProcessingInYdirection), mem_size ));
1490 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragLiftPostProcessingInZdirection), mem_size ));
1491
1492 //Device
1493 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragLiftPreProcessingInXdirection), mem_size ));
1494 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragLiftPreProcessingInYdirection), mem_size ));
1495 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragLiftPreProcessingInZdirection), mem_size ));
1496 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragLiftPostProcessingInXdirection), mem_size ));
1497 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragLiftPostProcessingInYdirection), mem_size ));
1498 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragLiftPostProcessingInZdirection), mem_size ));
1499
1501 double tmp = 6. * (double)mem_size;
1502 setMemsizeGPU(tmp, false);
1503}
1504void CudaMemoryManager::cudaCopyDragLift(int lev, int numofelem)
1505{
1506 unsigned int mem_size = sizeof(double)*numofelem;
1507
1508 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragLiftPreProcessingInXdirection, parameter->getParD(lev)->DragLiftPreProcessingInXdirection, mem_size, cudaMemcpyDeviceToHost));
1509 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragLiftPreProcessingInYdirection, parameter->getParD(lev)->DragLiftPreProcessingInYdirection, mem_size, cudaMemcpyDeviceToHost));
1510 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragLiftPreProcessingInZdirection, parameter->getParD(lev)->DragLiftPreProcessingInZdirection, mem_size, cudaMemcpyDeviceToHost));
1511 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragLiftPostProcessingInXdirection, parameter->getParD(lev)->DragLiftPostProcessingInXdirection, mem_size, cudaMemcpyDeviceToHost));
1512 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragLiftPostProcessingInYdirection, parameter->getParD(lev)->DragLiftPostProcessingInYdirection, mem_size, cudaMemcpyDeviceToHost));
1513 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragLiftPostProcessingInZdirection, parameter->getParD(lev)->DragLiftPostProcessingInZdirection, mem_size, cudaMemcpyDeviceToHost));
1514}
1515void CudaMemoryManager::cudaFreeDragLift(int lev)
1516{
1517 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragLiftPreProcessingInXdirection));
1518 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragLiftPreProcessingInYdirection));
1519 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragLiftPreProcessingInZdirection));
1520 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragLiftPostProcessingInXdirection));
1521 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragLiftPostProcessingInYdirection));
1522 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragLiftPostProcessingInZdirection));
1523}
1524//2ndMoments
1525void CudaMemoryManager::cudaAlloc2ndMoments(int lev, int numofelem)
1526{
1527 unsigned int mem_size = sizeof(real)*numofelem;
1528
1529 //Host
1530 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxyFromfcNEQ ), mem_size ));
1531 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kyzFromfcNEQ ), mem_size ));
1532 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxzFromfcNEQ ), mem_size ));
1533 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxxMyyFromfcNEQ), mem_size ));
1534 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxxMzzFromfcNEQ), mem_size ));
1535
1536 //Device
1537 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxyFromfcNEQ ), mem_size ));
1538 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kyzFromfcNEQ ), mem_size ));
1539 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxzFromfcNEQ ), mem_size ));
1540 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxxMyyFromfcNEQ), mem_size ));
1541 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxxMzzFromfcNEQ), mem_size ));
1542
1544 double tmp = 5. * (double)mem_size;
1545 setMemsizeGPU(tmp, false);
1546}
1547void CudaMemoryManager::cudaCopy2ndMoments(int lev, int numofelem)
1548{
1549 unsigned int mem_size = sizeof(real)*numofelem;
1550
1551 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxyFromfcNEQ , parameter->getParD(lev)->kxyFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
1552 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kyzFromfcNEQ , parameter->getParD(lev)->kyzFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
1553 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxzFromfcNEQ , parameter->getParD(lev)->kxzFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
1554 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxxMyyFromfcNEQ, parameter->getParD(lev)->kxxMyyFromfcNEQ, mem_size, cudaMemcpyDeviceToHost));
1555 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxxMzzFromfcNEQ, parameter->getParD(lev)->kxxMzzFromfcNEQ, mem_size, cudaMemcpyDeviceToHost));
1556}
1557void CudaMemoryManager::cudaFree2ndMoments(int lev)
1558{
1559 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxyFromfcNEQ ));
1560 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kyzFromfcNEQ ));
1561 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxzFromfcNEQ ));
1562 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxxMyyFromfcNEQ));
1563 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxxMzzFromfcNEQ));
1564}
1565//3rdMoments
1566void CudaMemoryManager::cudaAlloc3rdMoments(int lev, int numofelem)
1567{
1568 unsigned int mem_size = sizeof(real)*numofelem;
1569
1570 //Host
1571 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbbb ), mem_size ));
1572 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMabc ), mem_size ));
1573 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbac ), mem_size ));
1574 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbca ), mem_size ));
1575 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcba ), mem_size ));
1576 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMacb ), mem_size ));
1577 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcab ), mem_size ));
1578
1579 //Device
1580 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbbb ), mem_size ));
1581 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMabc ), mem_size ));
1582 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbac ), mem_size ));
1583 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbca ), mem_size ));
1584 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcba ), mem_size ));
1585 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMacb ), mem_size ));
1586 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcab ), mem_size ));
1587
1589 double tmp = 7. * (double)mem_size;
1590 setMemsizeGPU(tmp, false);
1591}
1592void CudaMemoryManager::cudaCopy3rdMoments(int lev, int numofelem)
1593{
1594 unsigned int mem_size = sizeof(real)*numofelem;
1595
1596 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbbb, parameter->getParD(lev)->CUMbbb, mem_size, cudaMemcpyDeviceToHost));
1597 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMabc, parameter->getParD(lev)->CUMabc, mem_size, cudaMemcpyDeviceToHost));
1598 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbac, parameter->getParD(lev)->CUMbac, mem_size, cudaMemcpyDeviceToHost));
1599 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbca, parameter->getParD(lev)->CUMbca, mem_size, cudaMemcpyDeviceToHost));
1600 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcba, parameter->getParD(lev)->CUMcba, mem_size, cudaMemcpyDeviceToHost));
1601 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMacb, parameter->getParD(lev)->CUMacb, mem_size, cudaMemcpyDeviceToHost));
1602 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcab, parameter->getParD(lev)->CUMcab, mem_size, cudaMemcpyDeviceToHost));
1603}
1604void CudaMemoryManager::cudaFree3rdMoments(int lev)
1605{
1606 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbbb ));
1607 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMabc ));
1608 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbac ));
1609 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbca ));
1610 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcba ));
1611 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMacb ));
1612 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcab ));
1613}
1614//higher order moments
1615void CudaMemoryManager::cudaAllocHigherMoments(int lev, int numofelem)
1616{
1617 unsigned int mem_size = sizeof(real)*numofelem;
1618
1619 //Host
1620 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcbb ), mem_size ));
1621 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbcb ), mem_size ));
1622 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbbc ), mem_size ));
1623 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcca ), mem_size ));
1624 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcac ), mem_size ));
1625 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMacc ), mem_size ));
1626 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbcc ), mem_size ));
1627 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcbc ), mem_size ));
1628 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMccb ), mem_size ));
1629 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMccc ), mem_size ));
1630
1631 //Device
1632 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcbb ), mem_size ));
1633 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbcb ), mem_size ));
1634 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbbc ), mem_size ));
1635 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcca ), mem_size ));
1636 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcac ), mem_size ));
1637 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMacc ), mem_size ));
1638 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbcc ), mem_size ));
1639 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcbc ), mem_size ));
1640 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMccb ), mem_size ));
1641 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMccc ), mem_size ));
1642
1644 double tmp = 10. * (double)mem_size;
1645 setMemsizeGPU(tmp, false);
1646}
1647void CudaMemoryManager::cudaCopyHigherMoments(int lev, int numofelem)
1648{
1649 unsigned int mem_size = sizeof(real)*numofelem;
1650
1651 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcbb, parameter->getParD(lev)->CUMcbb, mem_size, cudaMemcpyDeviceToHost));
1652 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbcb, parameter->getParD(lev)->CUMbcb, mem_size, cudaMemcpyDeviceToHost));
1653 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbbc, parameter->getParD(lev)->CUMbbc, mem_size, cudaMemcpyDeviceToHost));
1654 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcca, parameter->getParD(lev)->CUMcca, mem_size, cudaMemcpyDeviceToHost));
1655 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcac, parameter->getParD(lev)->CUMcac, mem_size, cudaMemcpyDeviceToHost));
1656 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMacc, parameter->getParD(lev)->CUMacc, mem_size, cudaMemcpyDeviceToHost));
1657 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbcc, parameter->getParD(lev)->CUMbcc, mem_size, cudaMemcpyDeviceToHost));
1658 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcbc, parameter->getParD(lev)->CUMcbc, mem_size, cudaMemcpyDeviceToHost));
1659 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMccb, parameter->getParD(lev)->CUMccb, mem_size, cudaMemcpyDeviceToHost));
1660 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMccc, parameter->getParD(lev)->CUMccc, mem_size, cudaMemcpyDeviceToHost));
1661}
1662void CudaMemoryManager::cudaFreeHigherMoments(int lev)
1663{
1664 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcbb ));
1665 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbcb ));
1666 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbbc ));
1667 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcca ));
1668 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcac ));
1669 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMacc ));
1670 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbcc ));
1671 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcbc ));
1672 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMccb ));
1673 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMccc ));
1674}
1675//cp Top
1676void CudaMemoryManager::cudaAllocCpTop(int lev)
1677{
1678 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpTop;
1679 unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpTop;
1680
1681 //Host
1682 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpPressTop), mem_size_double ));
1683 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpTopIndex), mem_size_int ));
1684
1685 //Device
1686 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpPressTop), mem_size_double ));
1687 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpTopIndex), mem_size_int ));
1688
1690 double tmp = (double)mem_size_double + (double)mem_size_int;
1691 setMemsizeGPU(tmp, false);
1692}
1693void CudaMemoryManager::cudaCopyCpTopInit(int lev)
1694{
1695 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpTop;
1696 unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpTop;
1697
1698 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpPressTop, parameter->getParH(lev)->cpPressTop, mem_size_double, cudaMemcpyHostToDevice));
1699 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpTopIndex, parameter->getParH(lev)->cpTopIndex, mem_size_int, cudaMemcpyHostToDevice));
1700}
1701void CudaMemoryManager::cudaCopyCpTop(int lev)
1702{
1703 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpTop;
1704 //unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpTop;
1705
1706 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpPressTop, parameter->getParD(lev)->cpPressTop, mem_size_double, cudaMemcpyDeviceToHost));
1707 //checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpTopIndex, parameter->getParD(lev)->cpTopIndex, mem_size_int, cudaMemcpyDeviceToHost));
1708}
1709void CudaMemoryManager::cudaFreeCpTop(int lev)
1710{
1711 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpPressTop));
1712 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpTopIndex));
1713}
1714//cp Bottom
1715void CudaMemoryManager::cudaAllocCpBottom(int lev)
1716{
1717 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom;
1718 unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom;
1719
1720 //Host
1721 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpPressBottom), mem_size_double ));
1722 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpBottomIndex), mem_size_int ));
1723
1724 //Device
1725 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpPressBottom), mem_size_double ));
1726 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpBottomIndex), mem_size_int ));
1727
1729 double tmp = (double)mem_size_double + (double)mem_size_int;
1730 setMemsizeGPU(tmp, false);
1731}
1732void CudaMemoryManager::cudaCopyCpBottomInit(int lev)
1733{
1734 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom;
1735 unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom;
1736
1737 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpPressBottom, parameter->getParH(lev)->cpPressBottom, mem_size_double, cudaMemcpyHostToDevice));
1738 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpBottomIndex, parameter->getParH(lev)->cpBottomIndex, mem_size_int, cudaMemcpyHostToDevice));
1739}
1740void CudaMemoryManager::cudaCopyCpBottom(int lev)
1741{
1742 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom;
1743 //unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom;
1744
1745 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpPressBottom, parameter->getParD(lev)->cpPressBottom, mem_size_double, cudaMemcpyDeviceToHost));
1746 //checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpBottomIndex, parameter->getParD(lev)->cpBottomIndex, mem_size_int, cudaMemcpyDeviceToHost));
1747}
1748void CudaMemoryManager::cudaFreeCpBottom(int lev)
1749{
1750 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpPressBottom));
1751 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpBottomIndex));
1752}
1753//cp Bottom 2
1754void CudaMemoryManager::cudaAllocCpBottom2(int lev)
1755{
1756 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom2;
1757 unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom2;
1758
1759 //Host
1760 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpPressBottom2), mem_size_double ));
1761 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpBottom2Index), mem_size_int ));
1762
1763 //Device
1764 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpPressBottom2), mem_size_double ));
1765 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpBottom2Index), mem_size_int ));
1766
1768 double tmp = (double)mem_size_double + (double)mem_size_int;
1769 setMemsizeGPU(tmp, false);
1770}
1771void CudaMemoryManager::cudaCopyCpBottom2Init(int lev)
1772{
1773 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom2;
1774 unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom2;
1775
1776 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpPressBottom2, parameter->getParH(lev)->cpPressBottom2, mem_size_double, cudaMemcpyHostToDevice));
1777 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpBottom2Index, parameter->getParH(lev)->cpBottom2Index, mem_size_int, cudaMemcpyHostToDevice));
1778}
1779void CudaMemoryManager::cudaCopyCpBottom2(int lev)
1780{
1781 unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom2;
1782
1783 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpPressBottom2, parameter->getParD(lev)->cpPressBottom2, mem_size_double, cudaMemcpyDeviceToHost));
1784}
1785void CudaMemoryManager::cudaFreeCpBottom2(int lev)
1786{
1787 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpPressBottom2));
1788 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpBottom2Index));
1789}
1791//advection diffusion
1792void CudaMemoryManager::cudaAllocConcentration(int lev)
1793{
1794 //Host
1795 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->concentration), parameter->getParH(lev)->memSizeRealLBnodes));
1796 //Device
1797 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->concentration), parameter->getParD(lev)->memSizeRealLBnodes));
1799 double tmp = (double)parameter->getParH(lev)->memSizeRealLBnodes;
1800 setMemsizeGPU(tmp, false);
1801}
1802void CudaMemoryManager::cudaCopyConcentrationDeviceToHost(int lev)
1803{
1804 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->concentration, parameter->getParD(lev)->concentration, parameter->getParH(lev)->memSizeRealLBnodes , cudaMemcpyDeviceToHost));
1805}
1806void CudaMemoryManager::cudaCopyConcentrationHostToDevice(int lev)
1807{
1808 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->concentration, parameter->getParH(lev)->concentration, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyHostToDevice));
1809}
1810void CudaMemoryManager::cudaFreeConcentration(int lev)
1811{
1812 checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->concentration));
1813}
1815void CudaMemoryManager::cudaAllocConcentrationFs(int lev)
1816{
1817 //Device
1818 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->distributionsAD.f[0]), 27*parameter->getParH(lev)->memSizeRealLBnodes));
1820 double tmp = (double)(27 * parameter->getParH(lev)->memSizeRealLBnodes);
1821 setMemsizeGPU(tmp, false);
1822}
1824void CudaMemoryManager::cudaAllocTurbulentDiffusivity(int lev)
1825{
1826 const uint size = parameter->getParH(lev)->memSizeRealLBnodes;
1827 checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->turbulentDiffusivity), size));
1828 checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->turbulentDiffusivity), size));
1829 setMemsizeGPU((double)size, false);
1830}
1831
1832void CudaMemoryManager::cudaCopyTurbulentDiffusivityHostToDevice(int lev)
1833{
1834 checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->turbulentDiffusivity, parameter->getParH(lev)->turbulentDiffusivity, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyHostToDevice));
1835}
1836
1837void CudaMemoryManager::cudaCopyTurbulentDiffusivityDeviceToHost(int lev)
1838{
1839 checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->turbulentDiffusivity, parameter->getParD(lev)->turbulentDiffusivity, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyDeviceToHost));
1840}
1841
1842void CudaMemoryManager::cudaFreeTurbulentDiffusivity(int lev){
1843 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->turbulentDiffusivity));
1844 checkCudaErrors(cudaFree(parameter->getParD(lev)->turbulentDiffusivity));
1845}
1846
1847void CudaMemoryManager::cudaAllocLocalReferenceTemperature(int lev)
1848{
1849 const size_t size = parameter->getParH(lev)->memSizeRealLBnodes;
1850 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->localReferenceTemperature), size));
1851 checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->localReferenceTemperature), size));
1852}
1853void CudaMemoryManager::cudaCopyLocalReferenceTemperatureDeviceToHost(int lev)
1854{
1855 checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->localReferenceTemperature, parameter->getParD(lev)->localReferenceTemperature, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyDeviceToHost));
1856}
1857void CudaMemoryManager::cudaCopyLocalReferenceTemperatureHostToDevice(int lev)
1858{
1859 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->localReferenceTemperature, parameter->getParH(lev)->localReferenceTemperature, parameter->getParH(lev)->memSizeRealLBnodes, cudaMemcpyHostToDevice));
1860}
1861void CudaMemoryManager::cudaFreeLocalReferenceTemperature(int lev)
1862{
1863 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->localReferenceTemperature));
1864 checkCudaErrors(cudaFree(parameter->getParD(lev)->localReferenceTemperature));
1865}
1867void CudaMemoryManager::cudaAllocConcentrationNoFluxBC(int lev)
1868{
1869 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionNoFluxBC;
1870 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionNoFluxBC;
1871 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
1872 const size_t memSizeReal = sizeof(real) * bcParamsH->numberOfBCnodes;
1873
1874 // Host Memory
1875 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->BCNodeIndices, memSizeInt));
1876 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal));
1877
1878 // Device Memory
1879 checkCudaErrors(cudaMalloc((void**)&bcParamsD->BCNodeIndices, memSizeInt));
1880 checkCudaErrors(cudaMalloc((void**)&bcParamsD->q27[0], parameter->getD3Qxx()*memSizeReal));
1881
1883 double tmp = double(parameter->getD3Qxx()*memSizeReal+memSizeInt);
1884 setMemsizeGPU(tmp, false);
1885}
1886void CudaMemoryManager::cudaCopyConcentrationNoFluxBCHostToDevice(int lev)
1887{
1888 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionNoFluxBC;
1889 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionNoFluxBC;
1890 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
1891 const size_t memSizeReal = sizeof(int) * bcParamsH->numberOfBCnodes;
1892
1893 checkCudaErrors(cudaMemcpy(bcParamsD->BCNodeIndices, bcParamsH->BCNodeIndices, memSizeInt, cudaMemcpyHostToDevice));
1894 checkCudaErrors(cudaMemcpy(bcParamsD->q27[0], bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal, cudaMemcpyHostToDevice));
1895}
1896void CudaMemoryManager::cudaFreeConcentrationNoFluxBC(int lev)
1897{
1898 const auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionNoFluxBC;
1899 const auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionNoFluxBC;
1900 checkCudaErrors(cudaFreeHost(bcParamsH->BCNodeIndices));
1901 checkCudaErrors(cudaFreeHost(bcParamsH->q27[0]));
1902 checkCudaErrors(cudaFree(bcParamsD->BCNodeIndices));
1903 checkCudaErrors(cudaFree(bcParamsD->q27[0]));
1904}
1906void CudaMemoryManager::cudaAllocConcentrationFluxBC(int lev)
1907{
1908 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionFluxBC;
1909 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionFluxBC;
1910 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
1911 const size_t memSizeReal = sizeof(real) * bcParamsH->numberOfBCnodes;
1912
1913 // Host Memory
1914 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->BCNodeIndices, memSizeInt));
1915 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->normalX, memSizeReal));
1916 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->normalY, memSizeReal));
1917 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->normalZ, memSizeReal));
1918 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->gradient, memSizeReal));
1919 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal));
1920
1921 // Device Memory
1922 checkCudaErrors(cudaMalloc((void**)&bcParamsD->BCNodeIndices, memSizeInt));
1923 checkCudaErrors(cudaMalloc((void**)&bcParamsD->normalX, memSizeReal));
1924 checkCudaErrors(cudaMalloc((void**)&bcParamsD->normalY, memSizeReal));
1925 checkCudaErrors(cudaMalloc((void**)&bcParamsD->normalZ, memSizeReal));
1926 checkCudaErrors(cudaMalloc((void**)&bcParamsD->gradient, memSizeReal));
1927 checkCudaErrors(cudaMalloc((void**)&bcParamsD->q27[0], parameter->getD3Qxx()*memSizeReal));
1928
1930 double tmp = double((parameter->getD3Qxx()+4)*memSizeReal+memSizeInt);
1931 setMemsizeGPU(tmp, false);
1932}
1933void CudaMemoryManager::cudaCopyConcentrationFluxBCHostToDevice(int lev)
1934{
1935 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionFluxBC;
1936 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionFluxBC;
1937 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
1938 const size_t memSizeReal = sizeof(int) * bcParamsH->numberOfBCnodes;
1939
1940 checkCudaErrors(cudaMemcpy(bcParamsD->BCNodeIndices, bcParamsH->BCNodeIndices, memSizeInt, cudaMemcpyHostToDevice));
1941 checkCudaErrors(cudaMemcpy(bcParamsD->normalX, bcParamsH->normalX, memSizeReal, cudaMemcpyHostToDevice));
1942 checkCudaErrors(cudaMemcpy(bcParamsD->normalY, bcParamsH->normalY, memSizeReal, cudaMemcpyHostToDevice));
1943 checkCudaErrors(cudaMemcpy(bcParamsD->normalZ, bcParamsH->normalZ, memSizeReal, cudaMemcpyHostToDevice));
1944 checkCudaErrors(cudaMemcpy(bcParamsD->gradient, bcParamsH->gradient, memSizeReal, cudaMemcpyHostToDevice));
1945 checkCudaErrors(cudaMemcpy(bcParamsD->q27[0], bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal, cudaMemcpyHostToDevice));
1946}
1947void CudaMemoryManager::cudaFreeConcentrationFluxBC(int lev)
1948{
1949 const auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionFluxBC;
1950 const auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionFluxBC;
1951 checkCudaErrors(cudaFreeHost(bcParamsH->BCNodeIndices));
1952 checkCudaErrors(cudaFreeHost(bcParamsH->normalX));
1953 checkCudaErrors(cudaFreeHost(bcParamsH->normalY));
1954 checkCudaErrors(cudaFreeHost(bcParamsH->normalZ));
1955 checkCudaErrors(cudaFreeHost(bcParamsH->gradient));
1956 checkCudaErrors(cudaFreeHost(bcParamsH->q27[0]));
1957
1958 checkCudaErrors(cudaFree(bcParamsD->BCNodeIndices));
1959 checkCudaErrors(cudaFree(bcParamsD->normalX));
1960 checkCudaErrors(cudaFree(bcParamsD->normalY));
1961 checkCudaErrors(cudaFree(bcParamsD->normalZ));
1962 checkCudaErrors(cudaFree(bcParamsD->gradient));
1963 checkCudaErrors(cudaFree(bcParamsD->q27[0]));
1964}
1965void CudaMemoryManager::cudaAllocConcentrationDirichletBC(int lev)
1966{
1967 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionDirichletBC;
1968 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionDirichletBC;
1969 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
1970 const size_t memSizeReal = sizeof(real) * bcParamsH->numberOfBCnodes;
1971
1972 // Host Memory
1973 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->concentration, memSizeReal));
1974 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->vx, memSizeReal));
1975 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->vy, memSizeReal));
1976 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->vz, memSizeReal));
1977 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->BCNodeIndices, memSizeInt));
1978 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal));
1979
1980 // Device Memory
1981 checkCudaErrors(cudaMalloc((void**)&bcParamsD->concentration, memSizeReal));
1982 checkCudaErrors(cudaMalloc((void**)&bcParamsD->vx, memSizeReal));
1983 checkCudaErrors(cudaMalloc((void**)&bcParamsD->vy, memSizeReal));
1984 checkCudaErrors(cudaMalloc((void**)&bcParamsD->vz, memSizeReal));
1985 checkCudaErrors(cudaMalloc((void**)&bcParamsD->BCNodeIndices, memSizeInt));
1986 checkCudaErrors(cudaMalloc((void**)&bcParamsD->q27[0], parameter->getD3Qxx()*memSizeReal));
1987
1989 double tmp = double((parameter->getD3Qxx()+4)*memSizeReal + memSizeInt);
1990 setMemsizeGPU(tmp, false);
1991}
1992void CudaMemoryManager::cudaCopyConcentrationDirichletBCHostToDevice(int lev)
1993{
1994 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionDirichletBC;
1995 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionDirichletBC;
1996 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
1997 const size_t memSizeReal = sizeof(real) * bcParamsH->numberOfBCnodes;
1998
1999 checkCudaErrors(cudaMemcpy(bcParamsD->concentration, bcParamsH->concentration, memSizeInt, cudaMemcpyHostToDevice));
2000 checkCudaErrors(cudaMemcpy(bcParamsD->vx, bcParamsH->vx, memSizeInt, cudaMemcpyHostToDevice));
2001 checkCudaErrors(cudaMemcpy(bcParamsD->vy, bcParamsH->vy, memSizeInt, cudaMemcpyHostToDevice));
2002 checkCudaErrors(cudaMemcpy(bcParamsD->vz, bcParamsH->vz, memSizeInt, cudaMemcpyHostToDevice));
2003 checkCudaErrors(cudaMemcpy(bcParamsD->q27[0], bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal, cudaMemcpyHostToDevice));
2004 checkCudaErrors(cudaMemcpy(bcParamsD->BCNodeIndices, bcParamsH->BCNodeIndices, memSizeReal, cudaMemcpyHostToDevice));
2005}
2006void CudaMemoryManager::cudaFreeConcentrationDirichletBC(int lev)
2007{
2008 auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionDirichletBC;
2009 auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionDirichletBC;
2010
2011 checkCudaErrors(cudaFreeHost(bcParamsH->concentration));
2012 checkCudaErrors(cudaFreeHost(bcParamsH->vx));
2013 checkCudaErrors(cudaFreeHost(bcParamsH->vy));
2014 checkCudaErrors(cudaFreeHost(bcParamsH->vz));
2015 checkCudaErrors(cudaFreeHost(bcParamsH->q27[0]));
2016 checkCudaErrors(cudaFreeHost(bcParamsH->BCNodeIndices));
2017
2018 checkCudaErrors(cudaFree(bcParamsD->concentration));
2019 checkCudaErrors(cudaFree(bcParamsD->vx));
2020 checkCudaErrors(cudaFree(bcParamsD->vy));
2021 checkCudaErrors(cudaFree(bcParamsD->vz));
2022 checkCudaErrors(cudaFree(bcParamsD->q27[0]));
2023 checkCudaErrors(cudaFree(bcParamsD->BCNodeIndices));
2024}
2026
2027void CudaMemoryManager::cudaAllocConcentrationNeumannBC(int lev)
2028{
2029 const auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionNeumannBC;
2030 const auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionNeumannBC;
2031 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
2032 const size_t memSizeReal = sizeof(real) * bcParamsH->numberOfBCnodes;
2033
2034 // Host Memory
2035 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->gradient, memSizeReal));
2036 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->vx, memSizeReal));
2037 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->vy, memSizeReal));
2038 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->vz, memSizeReal));
2039 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->BCNodeIndices, memSizeInt));
2040 checkCudaErrors(cudaMallocHost((void**)&bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal));
2041
2042 // Device Memory
2043 checkCudaErrors(cudaMalloc((void**)&bcParamsD->gradient, memSizeReal));
2044 checkCudaErrors(cudaMalloc((void**)&bcParamsD->vx, memSizeReal));
2045 checkCudaErrors(cudaMalloc((void**)&bcParamsD->vy, memSizeReal));
2046 checkCudaErrors(cudaMalloc((void**)&bcParamsD->vz, memSizeReal));
2047 checkCudaErrors(cudaMalloc((void**)&bcParamsD->BCNodeIndices, memSizeInt));
2048 checkCudaErrors(cudaMalloc((void**)&bcParamsD->q27[0], parameter->getD3Qxx()*memSizeReal));
2049
2051 double tmp = double((parameter->getD3Qxx()+4)*memSizeReal + memSizeInt);
2052 setMemsizeGPU(tmp, false);
2053}
2054void CudaMemoryManager::cudaCopyConcentrationNeumannBCHostToDevice(int lev)
2055{
2056 const auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionNeumannBC;
2057 const auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionNeumannBC;
2058 const size_t memSizeInt = sizeof(int) * bcParamsH->numberOfBCnodes;
2059 const size_t memSizeReal = sizeof(real) * bcParamsH->numberOfBCnodes;
2060
2061 checkCudaErrors(cudaMemcpy(bcParamsD->gradient, bcParamsH->gradient, memSizeInt, cudaMemcpyHostToDevice));
2062 checkCudaErrors(cudaMemcpy(bcParamsD->vx, bcParamsH->vx, memSizeInt, cudaMemcpyHostToDevice));
2063 checkCudaErrors(cudaMemcpy(bcParamsD->vy, bcParamsH->vy, memSizeInt, cudaMemcpyHostToDevice));
2064 checkCudaErrors(cudaMemcpy(bcParamsD->vz, bcParamsH->vz, memSizeInt, cudaMemcpyHostToDevice));
2065 checkCudaErrors(cudaMemcpy(bcParamsD->q27[0], bcParamsH->q27[0], parameter->getD3Qxx()*memSizeReal, cudaMemcpyHostToDevice));
2066 checkCudaErrors(cudaMemcpy(bcParamsD->BCNodeIndices, bcParamsH->BCNodeIndices, memSizeReal, cudaMemcpyHostToDevice));
2067}
2068void CudaMemoryManager::cudaFreeConcentrationNeumannBC(int lev)
2069{
2070 const auto* bcParamsH = &parameter->getParH(lev)->AdvectionDiffusionNeumannBC;
2071 const auto* bcParamsD = &parameter->getParD(lev)->AdvectionDiffusionNeumannBC;
2072
2073 checkCudaErrors(cudaFreeHost(bcParamsH->gradient));
2074 checkCudaErrors(cudaFreeHost(bcParamsH->vx));
2075 checkCudaErrors(cudaFreeHost(bcParamsH->vy));
2076 checkCudaErrors(cudaFreeHost(bcParamsH->vz));
2077 checkCudaErrors(cudaFreeHost(bcParamsH->q27[0]));
2078 checkCudaErrors(cudaFreeHost(bcParamsH->BCNodeIndices));
2079
2080 checkCudaErrors(cudaFree(bcParamsD->gradient));
2081 checkCudaErrors(cudaFree(bcParamsD->vx));
2082 checkCudaErrors(cudaFree(bcParamsD->vy));
2083 checkCudaErrors(cudaFree(bcParamsD->vz));
2084 checkCudaErrors(cudaFree(bcParamsD->q27[0]));
2085 checkCudaErrors(cudaFree(bcParamsD->BCNodeIndices));
2086}
2088
2089void CudaMemoryManager::cudaAllocMeanOutAD(int lev)
2090{
2091 //Host
2092 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->meanDensityOut), parameter->getParH(lev)->memSizeRealLBnodes));
2093 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInXdirectionOut), parameter->getParH(lev)->memSizeRealLBnodes));
2094 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInYdirectionOut), parameter->getParH(lev)->memSizeRealLBnodes));
2095 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->meanVelocityInZdirectionOut), parameter->getParH(lev)->memSizeRealLBnodes));
2096 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->meanPressureOut), parameter->getParH(lev)->memSizeRealLBnodes));
2097 checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->meanConcentrationOut), parameter->getParH(lev)->memSizeRealLBnodes));
2098}
2099void CudaMemoryManager::cudaFreeMeanOutAD(int lev)
2100{
2101 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->meanVelocityInXdirectionOut));
2102 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->meanVelocityInYdirectionOut));
2103 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->meanVelocityInZdirectionOut));
2104 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->meanDensityOut));
2105 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->meanPressureOut));
2106 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->meanConcentrationOut));
2107}
2108
2109void CudaMemoryManager::cudaAllocTaggedFluidNodeIndices(CollisionTemplate tag, int lev) {
2110 uint mem_size_tagged_fluid_nodes = sizeof(uint) * parameter->getParH(lev)->numberOfTaggedFluidNodes[tag];
2111 // Host
2112 checkCudaErrors(cudaMallocHost((void **)&(parameter->getParH(lev)->taggedFluidNodeIndices[tag]), mem_size_tagged_fluid_nodes));
2113 // Device
2114 checkCudaErrors(cudaMalloc((void **)&(parameter->getParD(lev)->taggedFluidNodeIndices[tag]), mem_size_tagged_fluid_nodes));
2116 setMemsizeGPU((double)mem_size_tagged_fluid_nodes, false);
2117}
2118
2119void CudaMemoryManager::cudaCopyTaggedFluidNodeIndices(CollisionTemplate tag, int lev) {
2120 uint mem_size_tagged_fluid_nodes = sizeof(uint) * parameter->getParH(lev)->numberOfTaggedFluidNodes[tag];
2121 checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->taggedFluidNodeIndices[tag],
2122 parameter->getParH(lev)->taggedFluidNodeIndices[tag],
2123 mem_size_tagged_fluid_nodes, cudaMemcpyHostToDevice));
2124}
2125
2126void CudaMemoryManager::cudaFreeTaggedFluidNodeIndices(CollisionTemplate tag, int lev) {
2127 checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->taggedFluidNodeIndices[tag]));
2128}
2129
2131// ActuatorFarm
2133void CudaMemoryManager::cudaAllocBladeGeometries(ActuatorFarm* actuatorFarm)
2134{
2135 const uint sizeRealTurbine = sizeof(real)*actuatorFarm->getNumberOfTurbines();
2136 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->turbinePosXH, sizeRealTurbine) );
2137 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->turbinePosYH, sizeRealTurbine) );
2138 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->turbinePosZH, sizeRealTurbine) );
2139
2140 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->turbinePosXD, sizeRealTurbine) );
2141 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->turbinePosYD, sizeRealTurbine) );
2142 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->turbinePosZD, sizeRealTurbine) );
2143 setMemsizeGPU(sizeof(real)*3.f*actuatorFarm->getNumberOfTurbines(), false);
2144
2145}
2172
2173void CudaMemoryManager::cudaAllocCoords(ActuatorFarm* actuatorFarm)
2174{
2175 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2176
2177 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->coordsXH, sizeof(real)*totalPoints) );
2178 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->coordsYH, sizeof(real)*totalPoints) );
2179 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->coordsZH, sizeof(real)*totalPoints) );
2180
2181 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->coordsXDCurrentTimestep, sizeof(real)*totalPoints) );
2182 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->coordsYDCurrentTimestep, sizeof(real)*totalPoints) );
2183 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->coordsZDCurrentTimestep, sizeof(real)*totalPoints) );
2184
2185 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->coordsXDPreviousTimestep, sizeof(real)*totalPoints) );
2186 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->coordsYDPreviousTimestep, sizeof(real)*totalPoints) );
2187 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->coordsZDPreviousTimestep, sizeof(real)*totalPoints) );
2188
2189 setMemsizeGPU(6.*sizeof(real)*totalPoints, false);
2190}
2191
2192void CudaMemoryManager::cudaCopyCoordsHtoD(ActuatorFarm* actuatorFarm)
2193{
2194 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2195 checkCudaErrors( cudaMemcpy(actuatorFarm->coordsXDCurrentTimestep, actuatorFarm->coordsXH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2196 checkCudaErrors( cudaMemcpy(actuatorFarm->coordsYDCurrentTimestep, actuatorFarm->coordsYH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2197 checkCudaErrors( cudaMemcpy(actuatorFarm->coordsZDCurrentTimestep, actuatorFarm->coordsZH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2198}
2199
2200void CudaMemoryManager::cudaCopyCoordsDtoH(ActuatorFarm* actuatorFarm)
2201{
2202 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2203 checkCudaErrors( cudaMemcpy(actuatorFarm->coordsXH, actuatorFarm->coordsXDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2204 checkCudaErrors( cudaMemcpy(actuatorFarm->coordsYH, actuatorFarm->coordsYDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2205 checkCudaErrors( cudaMemcpy(actuatorFarm->coordsZH, actuatorFarm->coordsZDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2206}
2207
2208void CudaMemoryManager::cudaFreeCoords(ActuatorFarm* actuatorFarm)
2209{
2210 checkCudaErrors( cudaFree(actuatorFarm->coordsXDCurrentTimestep) );
2211 checkCudaErrors( cudaFree(actuatorFarm->coordsYDCurrentTimestep) );
2212 checkCudaErrors( cudaFree(actuatorFarm->coordsZDCurrentTimestep) );
2213
2214 checkCudaErrors( cudaFree(actuatorFarm->coordsXDPreviousTimestep) );
2215 checkCudaErrors( cudaFree(actuatorFarm->coordsYDPreviousTimestep) );
2216 checkCudaErrors( cudaFree(actuatorFarm->coordsZDPreviousTimestep) );
2217
2218 checkCudaErrors( cudaFreeHost(actuatorFarm->coordsXH) );
2219 checkCudaErrors( cudaFreeHost(actuatorFarm->coordsYH) );
2220 checkCudaErrors( cudaFreeHost(actuatorFarm->coordsZH) );
2221}
2222
2223void CudaMemoryManager::cudaAllocIndices(ActuatorFarm* actuatorFarm)
2224{
2225 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2226 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->indicesH, sizeof(uint)*totalPoints) );
2227 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->indicesD, sizeof(uint)*totalPoints) );
2228
2229 setMemsizeGPU(sizeof(uint)*totalPoints, false);
2230}
2231
2237
2243
2244void CudaMemoryManager::cudaAllocVelocities(ActuatorFarm* actuatorFarm)
2245{
2246 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2247
2248 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->velocitiesXH, sizeof(real)*totalPoints) );
2249 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->velocitiesYH, sizeof(real)*totalPoints) );
2250 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->velocitiesZH, sizeof(real)*totalPoints) );
2251
2252 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->velocitiesXDCurrentTimestep, sizeof(real)*totalPoints) );
2253 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->velocitiesYDCurrentTimestep, sizeof(real)*totalPoints) );
2254 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->velocitiesZDCurrentTimestep, sizeof(real)*totalPoints) );
2255
2256 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->velocitiesXDPreviousTimestep, sizeof(real)*totalPoints) );
2257 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->velocitiesYDPreviousTimestep, sizeof(real)*totalPoints) );
2258 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->velocitiesZDPreviousTimestep, sizeof(real)*totalPoints) );
2259
2260 setMemsizeGPU(6.*sizeof(real)*totalPoints, false);
2261}
2262
2263void CudaMemoryManager::cudaCopyVelocitiesHtoD(ActuatorFarm* actuatorFarm)
2264{
2265 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2266 checkCudaErrors( cudaMemcpy(actuatorFarm->velocitiesXDCurrentTimestep, actuatorFarm->velocitiesXH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2267 checkCudaErrors( cudaMemcpy(actuatorFarm->velocitiesYDCurrentTimestep, actuatorFarm->velocitiesYH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2268 checkCudaErrors( cudaMemcpy(actuatorFarm->velocitiesZDCurrentTimestep, actuatorFarm->velocitiesZH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2269}
2270
2271void CudaMemoryManager::cudaCopyVelocitiesDtoH(ActuatorFarm* actuatorFarm)
2272{
2273 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2274 checkCudaErrors( cudaMemcpy(actuatorFarm->velocitiesXH, actuatorFarm->velocitiesXDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2275 checkCudaErrors( cudaMemcpy(actuatorFarm->velocitiesYH, actuatorFarm->velocitiesYDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2276 checkCudaErrors( cudaMemcpy(actuatorFarm->velocitiesZH, actuatorFarm->velocitiesZDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2277}
2278
2279void CudaMemoryManager::cudaFreeVelocities(ActuatorFarm* actuatorFarm)
2280{
2281 checkCudaErrors( cudaFree(actuatorFarm->velocitiesXDCurrentTimestep) );
2282 checkCudaErrors( cudaFree(actuatorFarm->velocitiesYDCurrentTimestep) );
2283 checkCudaErrors( cudaFree(actuatorFarm->velocitiesZDCurrentTimestep) );
2284
2285 checkCudaErrors( cudaFree(actuatorFarm->velocitiesXDPreviousTimestep) );
2286 checkCudaErrors( cudaFree(actuatorFarm->velocitiesYDPreviousTimestep) );
2287 checkCudaErrors( cudaFree(actuatorFarm->velocitiesZDPreviousTimestep) );
2288
2289 checkCudaErrors( cudaFreeHost(actuatorFarm->velocitiesXH) );
2290 checkCudaErrors( cudaFreeHost(actuatorFarm->velocitiesYH) );
2291 checkCudaErrors( cudaFreeHost(actuatorFarm->velocitiesZH) );
2292}
2293
2294void CudaMemoryManager::cudaAllocForces(ActuatorFarm* actuatorFarm)
2295{
2296 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2297
2298 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->forcesXH, sizeof(real)*totalPoints) );
2299 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->forcesYH, sizeof(real)*totalPoints) );
2300 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->forcesZH, sizeof(real)*totalPoints) );
2301 if (actuatorFarm->requiresLocalSmearingWidth())
2302 checkCudaErrors( cudaMallocHost((void**) &actuatorFarm->localSmearingWidthH, sizeof(real)*totalPoints) );
2303
2304 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->forcesXDCurrentTimestep, sizeof(real)*totalPoints) );
2305 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->forcesYDCurrentTimestep, sizeof(real)*totalPoints) );
2306 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->forcesZDCurrentTimestep, sizeof(real)*totalPoints) );
2307 if (actuatorFarm->requiresLocalSmearingWidth())
2308 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->localSmearingWidthDCurrentTimestep, sizeof(real)*totalPoints) );
2309
2310 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->forcesXDPreviousTimestep, sizeof(real)*totalPoints) );
2311 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->forcesYDPreviousTimestep, sizeof(real)*totalPoints) );
2312 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->forcesZDPreviousTimestep, sizeof(real)*totalPoints) );
2313 if (actuatorFarm->requiresLocalSmearingWidth())
2314 checkCudaErrors( cudaMalloc((void**) &actuatorFarm->localSmearingWidthDPreviousTimestep, sizeof(real)*totalPoints) );
2315
2316 if (actuatorFarm->requiresLocalSmearingWidth()){
2317 setMemsizeGPU(7.*sizeof(real)*totalPoints, false);
2318 } else {
2319 setMemsizeGPU(6.*sizeof(real)*totalPoints, false);
2320 }
2321}
2322
2323void CudaMemoryManager::cudaCopyForcesHtoD(ActuatorFarm* actuatorFarm)
2324{
2325 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2326 checkCudaErrors( cudaMemcpy(actuatorFarm->forcesXDCurrentTimestep, actuatorFarm->forcesXH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2327 checkCudaErrors( cudaMemcpy(actuatorFarm->forcesYDCurrentTimestep, actuatorFarm->forcesYH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2328 checkCudaErrors( cudaMemcpy(actuatorFarm->forcesZDCurrentTimestep, actuatorFarm->forcesZH, sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2329 if (actuatorFarm->requiresLocalSmearingWidth()) {
2330 checkCudaErrors( cudaMemcpy(actuatorFarm->localSmearingWidthDCurrentTimestep, actuatorFarm->localSmearingWidthH,
2331 sizeof(real)*totalPoints, cudaMemcpyHostToDevice) );
2332 }
2333}
2334
2335void CudaMemoryManager::cudaCopyForcesDtoH(ActuatorFarm* actuatorFarm)
2336{
2337 const uint totalPoints = actuatorFarm->getTotalNumberOfPoints();
2338 checkCudaErrors( cudaMemcpy(actuatorFarm->forcesXH, actuatorFarm->forcesXDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2339 checkCudaErrors( cudaMemcpy(actuatorFarm->forcesYH, actuatorFarm->forcesYDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2340 checkCudaErrors( cudaMemcpy(actuatorFarm->forcesZH, actuatorFarm->forcesZDCurrentTimestep, sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2341 if (actuatorFarm->requiresLocalSmearingWidth()) {
2342 checkCudaErrors( cudaMemcpy(actuatorFarm->localSmearingWidthH, actuatorFarm->localSmearingWidthDCurrentTimestep,
2343 sizeof(real)*totalPoints, cudaMemcpyDeviceToHost) );
2344 }
2345}
2346
2347void CudaMemoryManager::cudaFreeForces(ActuatorFarm* actuatorFarm)
2348{
2349 checkCudaErrors( cudaFree(actuatorFarm->forcesXDCurrentTimestep) );
2350 checkCudaErrors( cudaFree(actuatorFarm->forcesYDCurrentTimestep) );
2351 checkCudaErrors( cudaFree(actuatorFarm->forcesZDCurrentTimestep) );
2352 if (actuatorFarm->localSmearingWidthDCurrentTimestep != nullptr)
2353 checkCudaErrors( cudaFree(actuatorFarm->localSmearingWidthDCurrentTimestep) );
2354
2355 checkCudaErrors( cudaFree(actuatorFarm->forcesXDPreviousTimestep) );
2356 checkCudaErrors( cudaFree(actuatorFarm->forcesYDPreviousTimestep) );
2357 checkCudaErrors( cudaFree(actuatorFarm->forcesZDPreviousTimestep) );
2358 if (actuatorFarm->localSmearingWidthDPreviousTimestep != nullptr)
2359 checkCudaErrors( cudaFree(actuatorFarm->localSmearingWidthDPreviousTimestep) );
2360
2361 checkCudaErrors( cudaFreeHost(actuatorFarm->forcesXH) );
2362 checkCudaErrors( cudaFreeHost(actuatorFarm->forcesYH) );
2363 checkCudaErrors( cudaFreeHost(actuatorFarm->forcesZH) );
2364 if (actuatorFarm->localSmearingWidthH != nullptr)
2365 checkCudaErrors( cudaFreeHost(actuatorFarm->localSmearingWidthH) );
2366}
2367
2368void CudaMemoryManager::cudaAllocBoundingVolumeIndices(ActuatorFarm* actuatorFarm)
2369{
2370 checkCudaErrors( cudaMallocHost((void**) &(actuatorFarm->boundingVolumeIndicesH), sizeof(int)*actuatorFarm->getNumberOfIndices()));
2371 checkCudaErrors( cudaMalloc((void**) &(actuatorFarm->boundingVolumeIndicesD), sizeof(int)*actuatorFarm->getNumberOfIndices()));
2372 setMemsizeGPU(sizeof(int)*actuatorFarm->getNumberOfIndices(), false);
2373}
2374
2375void CudaMemoryManager::cudaCopyBoundingVolumeIndicesHtoD(ActuatorFarm* actuatorFarm)
2376{
2377 checkCudaErrors( cudaMemcpy(actuatorFarm->boundingVolumeIndicesD, actuatorFarm->boundingVolumeIndicesH, sizeof(int)*actuatorFarm->getNumberOfIndices(), cudaMemcpyHostToDevice) );
2378}
2379
2385void CudaMemoryManager::cudaAllocBuoyancyProviderProfileParameters(BuoyancyProviderPlanarAverage* buoyancyProvider,
2386 int level)
2387{
2388 auto& profileParameters = buoyancyProvider->getProfileParameter(level);
2389 const size_t memSizeIndices = sizeof(size_t) * (profileParameters.numberOfPlanes + 1);
2390 const size_t memSizeTemperature = sizeof(real) * profileParameters.numberOfPlanes;
2391
2392 checkCudaErrors(cudaMalloc(&profileParameters.indicesDevice, memSizeIndices));
2393 checkCudaErrors(cudaMallocHost(&profileParameters.indicesHost, memSizeIndices));
2394 checkCudaErrors(cudaMalloc(&profileParameters.referenceTemperaturesDevice, memSizeTemperature));
2395 checkCudaErrors(cudaMallocHost(&profileParameters.referenceTemperaturesHost, memSizeTemperature));
2396 setMemsizeGPU(memSizeIndices + memSizeTemperature, false);
2397}
2398
2399void CudaMemoryManager::cudaCopyBuoyancyProviderProfileParametersHtoD(BuoyancyProviderPlanarAverage* buoyancyProvider,
2400 int level)
2401{
2402 auto& profileParameters = buoyancyProvider->getProfileParameter(level);
2403 checkCudaErrors(cudaMemcpy(profileParameters.indicesDevice, profileParameters.indicesHost,
2404 sizeof(size_t) * (profileParameters.numberOfPlanes + 1), cudaMemcpyHostToDevice));
2405}
2406
2407void CudaMemoryManager::cudaCopyBuoyancyProviderReferenceTemperaturesDtoHAsync(
2408 BuoyancyProviderPlanarAverage* buoyancyProvider, int level)
2409{
2410 auto& profileParams = buoyancyProvider->getProfileParameter(level);
2411 auto* stream = parameter->getStreamManager()->getStream(CudaStreamIndex::BuoyancyProvider);
2412
2413 checkCudaErrors(cudaMemcpyAsync(profileParams.referenceTemperaturesHost, profileParams.referenceTemperaturesDevice,
2414 profileParams.numberOfPlanes, cudaMemcpyDeviceToHost, stream));
2415}
2416void CudaMemoryManager::cudaCopyBuoyancyProviderReferenceTemperaturesHtoDAsync(
2417 BuoyancyProviderPlanarAverage* buoyancyProvider, int level)
2418{
2419 auto& profileParams = buoyancyProvider->getProfileParameter(level);
2420 auto* stream = parameter->getStreamManager()->getStream(CudaStreamIndex::BuoyancyProvider);
2421
2422 checkCudaErrors(cudaMemcpyAsync(profileParams.referenceTemperaturesDevice, profileParams.referenceTemperaturesHost,
2423 profileParams.numberOfPlanes, cudaMemcpyHostToDevice, stream));
2424}
2425
2426void CudaMemoryManager::cudaFreeBuoyancyProviderProfileParameters(BuoyancyProviderPlanarAverage* buoyancyProvider, int level)
2427{
2428 auto& profileParameters = buoyancyProvider->getProfileParameter(level);
2429
2430 checkCudaErrors(cudaFree(profileParameters.referenceTemperaturesDevice));
2431 checkCudaErrors(cudaFreeHost(profileParameters.referenceTemperaturesHost));
2432 checkCudaErrors(cudaFree(profileParameters.indicesDevice));
2433 checkCudaErrors(cudaFreeHost(profileParameters.indicesHost));
2434}
2435
2436void CudaMemoryManager::cudaAllocBuoyancyProviderReductionParameters(BuoyancyProviderPlanarAverage* buoyancyProvider,
2437 int level)
2438{
2439 auto& reductionParameters = buoyancyProvider->getReductionParameter(level);
2440 const size_t memSize = sizeof(uint) * reductionParameters.numberOfPlanes;
2441
2442 checkCudaErrors(cudaMallocHost(&reductionParameters.numberOfNodesPerPlaneHost, memSize));
2443 checkCudaErrors(cudaMalloc(&reductionParameters.numberOfNodesPerPlaneDevice, memSize));
2444 checkCudaErrors(cudaMalloc(&reductionParameters.temporaryMemory, reductionParameters.sizeOfTemporaryMemory));
2445
2446 setMemsizeGPU(reductionParameters.sizeOfTemporaryMemory + memSize, false);
2447}
2448
2449void CudaMemoryManager::cudaCopyBuoyancyProviderReductionParametersHtoD(BuoyancyProviderPlanarAverage* buoyancyProvider,
2450 int level)
2451{
2452 auto& reductionParameters = buoyancyProvider->getReductionParameter(level);
2453
2454 checkCudaErrors(cudaMemcpy(reductionParameters.numberOfNodesPerPlaneDevice,
2455 reductionParameters.numberOfNodesPerPlaneHost,
2456 sizeof(uint) * reductionParameters.numberOfPlanes, cudaMemcpyHostToDevice));
2457}
2458
2459void CudaMemoryManager::cudaFreeBuoyancyProviderReductionParameters(BuoyancyProviderPlanarAverage* buoyancyProvider,
2460 int level)
2461{
2462 auto& reductionParameters = buoyancyProvider->getReductionParameter(level);
2463
2464 checkCudaErrors(cudaFree(reductionParameters.temporaryMemory));
2465 checkCudaErrors(cudaFree(reductionParameters.numberOfNodesPerPlaneDevice));
2466 checkCudaErrors(cudaFreeHost(reductionParameters.numberOfNodesPerPlaneHost));
2467}
2468
2469void CudaMemoryManager::cudaAllocDampingLayerData(DampingLayer* dampingLayer, int level)
2470{
2471 auto& data = dampingLayer->getDampingLayerData(level);
2472
2473 const size_t sizeReal = sizeof(real) * data.numberOfNodes;
2474 const size_t sizeUint = sizeof(uint) * data.numberOfNodes;
2475 checkCudaErrors(cudaMallocHost((void**)&data.dampingCoefficientsH, sizeReal));
2476 checkCudaErrors(cudaMallocHost((void**)&data.minimumValueH, sizeReal));
2477 checkCudaErrors(cudaMallocHost((void**)&data.indicesH, sizeUint));
2478 checkCudaErrors(cudaMalloc((void**)&data.dampingCoefficientsD, sizeReal));
2479 checkCudaErrors(cudaMalloc((void**)&data.minimumValueD, sizeReal));
2480 checkCudaErrors(cudaMalloc((void**)&data.indicesD, sizeUint));
2481 setMemsizeGPU(2 * sizeReal + sizeUint, false);
2482}
2483
2484void CudaMemoryManager::cudaCopyDampingLayerDataHtoD(DampingLayer* dampingLayer, int level)
2485{
2486 auto& data = dampingLayer->getDampingLayerData(level);
2487 const size_t memSizeReal = sizeof(real) * data.numberOfNodes;
2488 const size_t memSizeUint = sizeof(uint) * data.numberOfNodes;
2489 checkCudaErrors(cudaMemcpy(data.dampingCoefficientsD, data.dampingCoefficientsH, memSizeReal, cudaMemcpyHostToDevice));
2490 checkCudaErrors(cudaMemcpy(data.minimumValueD, data.minimumValueH, memSizeReal, cudaMemcpyHostToDevice));
2491 checkCudaErrors(cudaMemcpy(data.indicesD, data.indicesH, memSizeUint, cudaMemcpyHostToDevice));
2492}
2493void CudaMemoryManager::cudaFreeDampingLayerData(DampingLayer* dampingLayer, int level)
2494{
2495 auto& data = dampingLayer->getDampingLayerData(level);
2496 checkCudaErrors(cudaFreeHost(data.dampingCoefficientsH));
2497 checkCudaErrors(cudaFreeHost(data.minimumValueH));
2498 checkCudaErrors(cudaFreeHost(data.indicesH));
2499 checkCudaErrors(cudaFree(data.dampingCoefficientsD));
2500 checkCudaErrors(cudaFree(data.minimumValueD));
2501 checkCudaErrors(cudaFree(data.indicesD));
2502}
2504// Forest
2506
2507void CudaMemoryManager::cudaAllocForestIndices(Forest* forest)
2508{
2509 checkCudaErrors( cudaMallocHost((void**) &forest->forestIndicesH, sizeof(uint)*forest->getNumberOfIndices()) );
2510
2511 checkCudaErrors( cudaMalloc((void**) &forest->forestIndicesD, sizeof(uint)*forest->getNumberOfIndices()) );
2512
2513 setMemsizeGPU(sizeof(uint)*forest->getNumberOfIndices(), false);
2514}
2515
2516void CudaMemoryManager::cudaCopyForestIndicesHtoD(Forest* forest)
2517{
2518 checkCudaErrors( cudaMemcpy(forest->forestIndicesD, forest->forestIndicesH, sizeof(uint)*forest->getNumberOfIndices(), cudaMemcpyHostToDevice) );
2519}
2520
2521void CudaMemoryManager::cudaFreeForestIndices(Forest* forest)
2522{
2523 checkCudaErrors( cudaFree(forest->forestIndicesD) );
2524
2525 checkCudaErrors( cudaFreeHost(forest->forestIndicesH) );
2526}
2527
2528void CudaMemoryManager::cudaAllocForestVelocities(Forest* forest)
2529{
2530 checkCudaErrors(
2531 cudaMalloc((void**)&forest->forestVelocitiesXPreviousTimestepD, sizeof(real) * forest->getNumberOfIndices()));
2532 checkCudaErrors(
2533 cudaMalloc((void**)&forest->forestVelocitiesYPreviousTimestepD, sizeof(real) * forest->getNumberOfIndices()));
2534 checkCudaErrors(
2535 cudaMalloc((void**)&forest->forestVelocitiesZPreviousTimestepD, sizeof(real) * forest->getNumberOfIndices()));
2536
2537 setMemsizeGPU(3*sizeof(real)*forest->getNumberOfIndices(), false);
2538}
2539
2540void CudaMemoryManager::cudaCopyForestVelocitiesHtoD(Forest* forest,std::vector<real>& velocitiesX,
2541 std::vector<real>& velocitiesY,
2542 std::vector<real>& velocitiesZ)
2543{
2544 checkCudaErrors( cudaMemcpy(forest->forestVelocitiesXPreviousTimestepD, velocitiesX.data() , sizeof(real)*forest->getNumberOfIndices(), cudaMemcpyHostToDevice) );
2545 checkCudaErrors( cudaMemcpy(forest->forestVelocitiesYPreviousTimestepD, velocitiesY.data(), sizeof(real)*forest->getNumberOfIndices(), cudaMemcpyHostToDevice) );
2546 checkCudaErrors( cudaMemcpy(forest->forestVelocitiesZPreviousTimestepD, velocitiesZ.data(), sizeof(real)*forest->getNumberOfIndices(), cudaMemcpyHostToDevice) );
2547}
2548
2549void CudaMemoryManager::cudaFreeForestVelocities(Forest* forest)
2550{
2551 checkCudaErrors(cudaFree(forest->forestVelocitiesXPreviousTimestepD));
2552 checkCudaErrors(cudaFree(forest->forestVelocitiesYPreviousTimestepD));
2553 checkCudaErrors(cudaFree(forest->forestVelocitiesZPreviousTimestepD));
2554}
2555
2556void CudaMemoryManager::cudaAllocLeafAreaDensity(Forest* forest)
2557{
2558 checkCudaErrors(cudaMallocHost(
2559 (void**)&forest->leafAreaDensityH,
2560 sizeof(real) * forest->getNumberOfIndices()));
2561
2562 checkCudaErrors(cudaMalloc(
2563 (void**)&forest->leafAreaDensityD,
2564 sizeof(real) * forest->getNumberOfIndices()));
2565
2566 setMemsizeGPU(sizeof(real) * forest->getNumberOfIndices(), false);
2567}
2568
2569void CudaMemoryManager::cudaCopyLeafAreaDensityHtoD(Forest* forest)
2570{
2571 checkCudaErrors(cudaMemcpy(
2572 forest->leafAreaDensityD,
2573 forest->leafAreaDensityH,
2574 sizeof(real) * forest->getNumberOfIndices(),
2575 cudaMemcpyHostToDevice));
2576}
2577
2578void CudaMemoryManager::cudaFreeLeafAreaDensity(Forest* forest)
2579{
2580 if (forest->leafAreaDensityD)
2581 checkCudaErrors(cudaFree(forest->leafAreaDensityD));
2582
2583 if (forest->leafAreaDensityH)
2584 checkCudaErrors(cudaFreeHost(forest->leafAreaDensityH));
2585}
2586
2588// Probe
2590void CudaMemoryManager::cudaAllocProbeData(Probe* probe, int level)
2591{
2592 auto* probeDataH = &probe->getLevelData(level)->probeDataH;
2593 auto* probeDataD = &probe->getLevelData(level)->probeDataD;
2594 const size_t sizeData = sizeof(real)*probeDataH->numberOfPoints*probeDataH->numberOfTimesteps*probeDataH->numberOfQuantities;
2595 const size_t sizeIndices = sizeof(uint)*probeDataH->numberOfPoints;
2596 size_t totalSize = sizeIndices;
2597
2598 checkCudaErrors( cudaMallocHost((void**) &probeDataH->indices, sizeIndices) );
2599 checkCudaErrors( cudaMalloc((void**) &probeDataD->indices, sizeIndices) );
2600
2601 if(probeDataH->computeInstantaneous)
2602 {
2603 checkCudaErrors( cudaMallocHost((void**) &probeDataH->instantaneous, sizeData) );
2604 checkCudaErrors( cudaMalloc((void**) &probeDataD->instantaneous, sizeData) );
2605 totalSize += sizeData;
2606 }
2607 if(probeDataH->computeMeans)
2608 {
2609 checkCudaErrors( cudaMallocHost((void**) &probeDataH->means, sizeData) );
2610 checkCudaErrors( cudaMalloc((void**) &probeDataD->means, sizeData) );
2611 totalSize += sizeData;
2612 }
2613 if(probeDataH->computeVariances)
2614 {
2615 checkCudaErrors( cudaMallocHost((void**) &probeDataH->variances, sizeData) );
2616 checkCudaErrors( cudaMalloc((void**) &probeDataD->variances, sizeData) );
2617 totalSize += sizeData;
2618 }
2619
2620 setMemsizeGPU(static_cast<double>(totalSize), false);
2621}
2622
2623void CudaMemoryManager::cudaCopyProbeDataHtoD(Probe* probe, int level)
2624{
2625 auto* probeDataH = &probe->getLevelData(level)->probeDataH;
2626 auto* probeDataD = &probe->getLevelData(level)->probeDataD;
2627 const size_t sizeData = sizeof(real)*probeDataH->numberOfPoints*probeDataH->numberOfTimesteps*probeDataH->numberOfQuantities;
2628 const size_t sizeIndices = sizeof(uint)*probeDataH->numberOfPoints;
2629
2630 checkCudaErrors( cudaMemcpy(probeDataD->indices, probeDataH->indices, sizeIndices, cudaMemcpyHostToDevice) );
2631
2632 if(probeDataH->computeInstantaneous)
2633 {
2634 checkCudaErrors( cudaMemcpy(probeDataD->instantaneous, probeDataH->instantaneous, sizeData, cudaMemcpyHostToDevice) );
2635 }
2636 if(probeDataH->computeMeans)
2637 {
2638 checkCudaErrors( cudaMemcpy(probeDataD->means, probeDataH->means, sizeData, cudaMemcpyHostToDevice) );
2639 }
2640 if(probeDataH->computeVariances)
2641 {
2642 checkCudaErrors( cudaMemcpy(probeDataD->variances, probeDataH->variances, sizeData, cudaMemcpyHostToDevice) );
2643 }
2644}
2645
2646void CudaMemoryManager::cudaCopyProbeDataDtoH(Probe* probe, int level)
2647{
2648 auto* probeDataH = &probe->getLevelData(level)->probeDataH;
2649 auto* probeDataD = &probe->getLevelData(level)->probeDataD;
2650 const size_t sizeData = sizeof(real)*probeDataH->numberOfPoints*probeDataH->numberOfTimesteps*probeDataH->numberOfQuantities;
2651 if(probeDataH->computeInstantaneous)
2652 {
2653 checkCudaErrors( cudaMemcpy(probeDataH->instantaneous, probeDataD->instantaneous, sizeData, cudaMemcpyDeviceToHost) );
2654 }
2655 if(probeDataH->computeMeans)
2656 {
2657 checkCudaErrors( cudaMemcpy(probeDataH->means, probeDataD->means, sizeData, cudaMemcpyDeviceToHost) );
2658 }
2659 if(probeDataH->computeVariances)
2660 {
2661 checkCudaErrors( cudaMemcpy(probeDataH->variances, probeDataD->variances, sizeData, cudaMemcpyDeviceToHost) );
2662 }
2663}
2664
2665void CudaMemoryManager::cudaFreeProbeData(Probe* probe, int level)
2666{
2667 auto* probeDataH = &probe->getLevelData(level)->probeDataH;
2668 auto* probeDataD = &probe->getLevelData(level)->probeDataD;
2669 checkCudaErrors( cudaFreeHost(probeDataH->indices) );
2670 checkCudaErrors( cudaFree(probeDataD->indices) );
2671
2672 if(probeDataH->computeInstantaneous)
2673 {
2674 checkCudaErrors( cudaFreeHost(probeDataH->instantaneous) );
2675 checkCudaErrors( cudaFree(probeDataD->instantaneous) );
2676 }
2677 if(probeDataH->computeMeans)
2678 {
2679 checkCudaErrors( cudaFreeHost(probeDataH->means) );
2680 checkCudaErrors( cudaFree(probeDataD->means) );
2681 }
2682 if(probeDataH->computeVariances)
2683 {
2684 checkCudaErrors( cudaFreeHost(probeDataH->variances) );
2685 checkCudaErrors( cudaFree(probeDataD->variances) );
2686 }
2687}
2688
2689void CudaMemoryManager::cudaAllocPlanarAverageProbeIndices(PlanarAverageProbe* planarAverageProbe, int level)
2690{
2691 const size_t size = sizeof(uint)*planarAverageProbe->getLevelData(level)->maxNumberOfPointsPerPlane;
2692 checkCudaErrors( cudaMalloc((void**) &planarAverageProbe->getLevelData(level)->indicesD, size) );
2693 setMemsizeGPU(size, false);
2694}
2695
2700
2701void CudaMemoryManager::cudaAllocPlanarAverageProbeSubgridScaleFluxes(PlanarAverageProbe* planarAverageProbe, int level)
2702{
2703 auto* data = planarAverageProbe->getLevelData(level);
2704 const size_t size = sizeof(real) * data->maxNumberOfPointsPerPlane;
2705
2706 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxXX), size));
2707 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxXY), size));
2708 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxXZ), size));
2709 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxYY), size));
2710 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxYZ), size));
2711 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxZZ), size));
2712 double tmp = 6. * size;
2713 if (planarAverageProbe->getSampleScalar()) {
2714 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxPhiX), size));
2715 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxPhiY), size));
2716 checkCudaErrors(cudaMalloc((void**)&(data->subgridScaleFluxPhiZ), size));
2717 tmp += 3. * size;
2718 }
2719 setMemsizeGPU(tmp, false);
2720}
2721
2722void CudaMemoryManager::cudaFreePlanarAverageProbeSubgridScaleFluxes(PlanarAverageProbe* planarAverageProbe, int level)
2723{
2724 auto* data = planarAverageProbe->getLevelData(level);
2725
2726 checkCudaErrors(cudaFree(data->subgridScaleFluxXX));
2727 checkCudaErrors(cudaFree(data->subgridScaleFluxXY));
2728 checkCudaErrors(cudaFree(data->subgridScaleFluxXZ));
2729 checkCudaErrors(cudaFree(data->subgridScaleFluxYY));
2730 checkCudaErrors(cudaFree(data->subgridScaleFluxYZ));
2731 checkCudaErrors(cudaFree(data->subgridScaleFluxZZ));
2732 if (planarAverageProbe->getSampleScalar()) {
2733 checkCudaErrors(cudaFree(data->subgridScaleFluxPhiX));
2734 checkCudaErrors(cudaFree(data->subgridScaleFluxPhiY));
2735 checkCudaErrors(cudaFree(data->subgridScaleFluxPhiZ));
2736 }
2737}
2738
2739void CudaMemoryManager::cudaAllocPrecursorWriter(PrecursorWriter* writer, int level)
2740{
2741 auto* prec = writer->getPrecursorStruct(level);
2742 size_t indSize = prec->numberOfPointsInBC*sizeof(uint);
2743
2744 checkCudaErrors( cudaMallocHost((void**) &prec->indicesH, indSize));
2745 checkCudaErrors( cudaMalloc((void**) &prec->indicesD, indSize));
2746
2747 size_t dataSize = prec->numberOfPointsInBC*sizeof(real)*prec->numberOfQuantities;
2748 size_t dataSizeH = dataSize * prec->numberOfTimeStepsPerFile;
2749
2750 checkCudaErrors( cudaMallocHost((void**) &prec->dataH, dataSizeH));
2751 checkCudaErrors( cudaMallocHost((void**) &prec->bufferH, dataSizeH));
2752 checkCudaErrors( cudaMalloc((void**) &prec->dataD, dataSize));
2753 checkCudaErrors( cudaMalloc((void**) &prec->bufferD, dataSize));
2754
2755 setMemsizeGPU(indSize+2*dataSize, false);
2756}
2757
2762
2763void CudaMemoryManager::cudaCopyPrecursorWriterOutputVariablesDtoH(PrecursorWriter* writer, int level)
2764{
2765 auto* prec = writer->getPrecursorStruct(level);
2766 const size_t sizeTimestep = prec->numberOfPointsInBC*prec->numberOfQuantities;
2767 auto* stream = parameter->getStreamManager()->getStream(CudaStreamIndex::PrecursorWriter, prec->streamIndex);
2768 checkCudaErrors( cudaMemcpyAsync( &prec->bufferH[prec->numberOfTimeStepsBuffered*sizeTimestep], prec->bufferD, sizeof(real)*sizeTimestep, cudaMemcpyDeviceToHost, stream));
2769}
2770
2781
2782
2783CudaMemoryManager::CudaMemoryManager(std::shared_ptr<Parameter> parameter) : parameter(parameter)
2784{
2785
2786}
2787
2788
2789void CudaMemoryManager::setMemsizeGPU(double admem, bool reset)
2790{
2791 if (reset == true)
2792 {
2793 this->memsizeGPU = 0.;
2794 }
2795 else
2796 {
2797 this->memsizeGPU += admem;
2798 }
2799}
2800
2801double CudaMemoryManager::getMemsizeGPU()
2802{
2803 return this->memsizeGPU;
2804}
2805
2806}
2807
vf::gpu::CudaMemoryManager::cudaCopyDirectionalBoundaryCondition
void cudaCopyDirectionalBoundaryCondition(QforDirectionalBoundaryCondition &boundaryConditionHost, QforDirectionalBoundaryCondition &boundaryConditionDevice)
Definition CudaMemoryManager.cpp:440
vf::gpu::CudaMemoryManager::cudaFreeIndices
void cudaFreeIndices(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2238
vf::gpu::CudaMemoryManager::cudaCopyProcessNeighborFsHtoD
void cudaCopyProcessNeighborFsHtoD(const ProcessNeighbor27 &neighborHost, const ProcessNeighbor27 &neighborDevice) const
Definition CudaMemoryManager.cpp:657
vf::gpu::CudaMemoryManager::cudaCopyVelocitiesDtoH
void cudaCopyVelocitiesDtoH(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2271
vf::gpu::CudaMemoryManager::cudaFreeVelocities
void cudaFreeVelocities(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2279
vf::gpu::CudaMemoryManager::cudaFreeDirectionalBoundaryCondition
void cudaFreeDirectionalBoundaryCondition(int level)
Definition CudaMemoryManager.cpp:452
vf::gpu::CudaMemoryManager::cudaFreeTaggedFluidNodeIndices
void cudaFreeTaggedFluidNodeIndices(CollisionTemplate tag, int lev)
Definition CudaMemoryManager.cpp:2126
vf::gpu::CudaMemoryManager::cudaAllocPlanarAverageProbeIndices
void cudaAllocPlanarAverageProbeIndices(PlanarAverageProbe *planarAverageProbe, int level)
Definition CudaMemoryManager.cpp:2689
vf::gpu::CudaMemoryManager::cudaAlloc3rdMoments
void cudaAlloc3rdMoments(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1566
vf::gpu::CudaMemoryManager::cudaCopyBuoyancyProviderProfileParametersHtoD
void cudaCopyBuoyancyProviderProfileParametersHtoD(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2399
vf::gpu::CudaMemoryManager::cudaCopyFsForCheckPoint
void cudaCopyFsForCheckPoint(int lev) const
copy distributions from device to host
Definition CudaMemoryManager.cpp:1466
vf::gpu::CudaMemoryManager::cudaCopyIndicesHtoD
void cudaCopyIndicesHtoD(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2232
vf::gpu::CudaMemoryManager::cudaCopyTurbulentDiffusivityHostToDevice
void cudaCopyTurbulentDiffusivityHostToDevice(int lev)
Definition CudaMemoryManager.cpp:1832
vf::gpu::CudaMemoryManager::cudaFreeLeafAreaDensity
void cudaFreeLeafAreaDensity(Forest *forest)
Definition CudaMemoryManager.cpp:2578
vf::gpu::CudaMemoryManager::cudaAllocTaggedFluidNodeIndices
void cudaAllocTaggedFluidNodeIndices(CollisionTemplate tag, int lev)
Definition CudaMemoryManager.cpp:2109
vf::gpu::CudaMemoryManager::cudaCopyBoundingVolumeIndicesHtoD
void cudaCopyBoundingVolumeIndicesHtoD(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2375
vf::gpu::CudaMemoryManager::cudaCopyConcentrationDirichletBCHostToDevice
void cudaCopyConcentrationDirichletBCHostToDevice(int lev)
Definition CudaMemoryManager.cpp:1992
vf::gpu::CudaMemoryManager::cudaFreeFsForCheckPointAndRestart
void cudaFreeFsForCheckPointAndRestart(int lev) const
Definition CudaMemoryManager.cpp:1475
vf::gpu::CudaMemoryManager::cudaFreeCoords
void cudaFreeCoords(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2208
vf::gpu::CudaMemoryManager::cudaCopyLeafAreaDensityHtoD
void cudaCopyLeafAreaDensityHtoD(Forest *forest)
Definition CudaMemoryManager.cpp:2569
vf::gpu::CudaMemoryManager::cudaCopyHigherMoments
void cudaCopyHigherMoments(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1647
vf::gpu::CudaMemoryManager::cudaFreeBuoyancyProviderReductionParameters
void cudaFreeBuoyancyProviderReductionParameters(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2459
vf::gpu::CudaMemoryManager::cudaAllocForces
void cudaAllocForces(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2294
vf::gpu::CudaMemoryManager::cudaCopyWallModel
void cudaCopyWallModel(WallModelParameters &wallModelHost, WallModelParameters &wallModelDevice, uint numberOfNodes)
Definition CudaMemoryManager.cpp:1188
vf::gpu::CudaMemoryManager::cudaCopyLocalReferenceTemperatureHostToDevice
void cudaCopyLocalReferenceTemperatureHostToDevice(int lev)
Definition CudaMemoryManager.cpp:1857
vf::gpu::CudaMemoryManager::cudaFreePlanarAverageProbeIndices
void cudaFreePlanarAverageProbeIndices(PlanarAverageProbe *planarAverageProbe, int level)
Definition CudaMemoryManager.cpp:2696
vf::gpu::CudaMemoryManager::cudaAlloc2ndMoments
void cudaAlloc2ndMoments(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1525
vf::gpu::CudaMemoryManager::cudaCopyForcesHtoD
void cudaCopyForcesHtoD(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2323
vf::gpu::CudaMemoryManager::cudaFreeDirectionalADBoundaryCondition
void cudaFreeDirectionalADBoundaryCondition(int level)
Definition CudaMemoryManager.cpp:507
vf::gpu::CudaMemoryManager::cudaAllocLocalReferenceTemperature
void cudaAllocLocalReferenceTemperature(int lev)
Definition CudaMemoryManager.cpp:1847
vf::gpu::CudaMemoryManager::cudaAllocDragLift
void cudaAllocDragLift(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1480
vf::gpu::CudaMemoryManager::cudaCopyTaggedFluidNodeIndices
void cudaCopyTaggedFluidNodeIndices(CollisionTemplate tag, int lev)
Definition CudaMemoryManager.cpp:2119
vf::gpu::CudaMemoryManager::cudaCopy3rdMoments
void cudaCopy3rdMoments(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1592
vf::gpu::CudaMemoryManager::cudaCopyForcesDtoH
void cudaCopyForcesDtoH(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2335
vf::gpu::CudaMemoryManager::cudaCopyProcessNeighborIndex
virtual void cudaCopyProcessNeighborIndex(const ProcessNeighbor27 &neighborHost, const ProcessNeighbor27 &neighborDevice) const
Definition CudaMemoryManager.cpp:638
vf::gpu::CudaMemoryManager::cudaFreeForces
void cudaFreeForces(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2347
vf::gpu::CudaMemoryManager::cudaAllocBuoyancyProviderProfileParameters
void cudaAllocBuoyancyProviderProfileParameters(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2385
vf::gpu::CudaMemoryManager::cudaAllocConcentrationDirichletBC
void cudaAllocConcentrationDirichletBC(int lev)
Definition CudaMemoryManager.cpp:1965
vf::gpu::CudaMemoryManager::cudaCopyProbeDataDtoH
void cudaCopyProbeDataDtoH(Probe *probe, int level)
Definition CudaMemoryManager.cpp:2646
vf::gpu::CudaMemoryManager::cudaFreeProbeData
void cudaFreeProbeData(Probe *probe, int level)
Definition CudaMemoryManager.cpp:2665
vf::gpu::CudaMemoryManager::cudaCopyLevelForcingToDevice
void cudaCopyLevelForcingToDevice(int level)
Definition CudaMemoryManager.cpp:579
vf::gpu::CudaMemoryManager::cudaAllocLeafAreaDensity
void cudaAllocLeafAreaDensity(Forest *forest)
Definition CudaMemoryManager.cpp:2556
vf::gpu::CudaMemoryManager::cudaAllocIndices
void cudaAllocIndices(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2223
vf::gpu::CudaMemoryManager::cudaAllocWallModel
void cudaAllocWallModel(WallModelParameters &wallModelHost, WallModelParameters &wallModelDevice, uint numberOfNodes)
Definition CudaMemoryManager.cpp:1151
vf::gpu::CudaMemoryManager::cudaCopyBuoyancyProviderReferenceTemperaturesDtoHAsync
void cudaCopyBuoyancyProviderReferenceTemperaturesDtoHAsync(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2407
vf::gpu::CudaMemoryManager::cudaCopyTemperatureWallModel
void cudaCopyTemperatureWallModel(TemperatureWallModelParameters &wallModelHost, TemperatureWallModelParameters &wallModelDevice, uint numberOfNodes)
Definition CudaMemoryManager.cpp:1251
vf::gpu::CudaMemoryManager::cudaFreeBuoyancyProviderProfileParameters
void cudaFreeBuoyancyProviderProfileParameters(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2426
vf::gpu::CudaMemoryManager::cudaAllocPrecursorWriter
void cudaAllocPrecursorWriter(PrecursorWriter *writer, int level)
Definition CudaMemoryManager.cpp:2739
vf::gpu::CudaMemoryManager::cudaCopyVelocitiesHtoD
void cudaCopyVelocitiesHtoD(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2263
vf::gpu::CudaMemoryManager::cudaFreeForestIndices
void cudaFreeForestIndices(Forest *forest)
Definition CudaMemoryManager.cpp:2521
vf::gpu::CudaMemoryManager::cudaFreePrecursorWriter
void cudaFreePrecursorWriter(PrecursorWriter *writer, int level)
Definition CudaMemoryManager.cpp:2771
vf::gpu::CudaMemoryManager::cudaAllocPlanarAverageProbeSubgridScaleFluxes
void cudaAllocPlanarAverageProbeSubgridScaleFluxes(PlanarAverageProbe *planarAverageProbe, int level)
Definition CudaMemoryManager.cpp:2701
vf::gpu::CudaMemoryManager::cudaFreeDampingLayerData
void cudaFreeDampingLayerData(DampingLayer *dampingLayer, int level)
Definition CudaMemoryManager.cpp:2493
vf::gpu::CudaMemoryManager::cudaAllocVelocities
void cudaAllocVelocities(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2244
vf::gpu::CudaMemoryManager::CudaMemoryManager
CudaMemoryManager(std::shared_ptr< Parameter > parameter)
Definition CudaMemoryManager.cpp:2783
vf::gpu::CudaMemoryManager::cudaFreeProcessNeighbor
void cudaFreeProcessNeighbor(const ProcessNeighbor27 &neighborHost, const ProcessNeighbor27 &neighborDevice) const
Definition CudaMemoryManager.cpp:644
vf::gpu::CudaMemoryManager::cudaFreeLocalReferenceTemperature
void cudaFreeLocalReferenceTemperature(int lev)
Definition CudaMemoryManager.cpp:1861
vf::gpu::CudaMemoryManager::cudaFreeBoundingVolumeIndices
void cudaFreeBoundingVolumeIndices(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2380
vf::gpu::CudaMemoryManager::cudaFreeTemperatureWallModel
void cudaFreeTemperatureWallModel(TemperatureWallModelParameters &wallModelHost, TemperatureWallModelParameters &wallModelDevice)
Definition CudaMemoryManager.cpp:1264
vf::gpu::CudaMemoryManager::cudaCopyTurbulenceIntensityHD
void cudaCopyTurbulenceIntensityHD(int lev, uint size)
Definition CudaMemoryManager.cpp:753
vf::gpu::CudaMemoryManager::cudaCopyConcentrationHostToDevice
void cudaCopyConcentrationHostToDevice(int lev)
Definition CudaMemoryManager.cpp:1806
vf::gpu::CudaMemoryManager::cudaCopyBuoyancyProviderReferenceTemperaturesHtoDAsync
void cudaCopyBuoyancyProviderReferenceTemperaturesHtoDAsync(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2416
vf::gpu::CudaMemoryManager::cudaAllocCoords
void cudaAllocCoords(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2173
vf::gpu::CudaMemoryManager::cudaCopyCoordsHtoD
void cudaCopyCoordsHtoD(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2192
vf::gpu::CudaMemoryManager::cudaAllocBladeGeometries
void cudaAllocBladeGeometries(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2133
vf::gpu::CudaMemoryManager::setMemsizeGPU
void setMemsizeGPU(double admem, bool reset)
Definition CudaMemoryManager.cpp:2789
vf::gpu::CudaMemoryManager::cudaCopy2ndMoments
void cudaCopy2ndMoments(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1547
vf::gpu::CudaMemoryManager::cudaAllocDirectionalADBoundaryCondition
void cudaAllocDirectionalADBoundaryCondition(QforDirectionalADBoundaryCondition &boundaryConditionHost, QforDirectionalADBoundaryCondition &boundaryConditionDevice)
Definition CudaMemoryManager.cpp:470
vf::gpu::CudaMemoryManager::cudaCopyPrecursorWriterIndicesHtoD
void cudaCopyPrecursorWriterIndicesHtoD(PrecursorWriter *writer, int level)
Definition CudaMemoryManager.cpp:2758
vf::gpu::CudaMemoryManager::cudaAllocBoundingVolumeIndices
void cudaAllocBoundingVolumeIndices(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2368
vf::gpu::CudaMemoryManager::cudaAllocDampingLayerData
void cudaAllocDampingLayerData(DampingLayer *dampingLayer, int level)
Definition CudaMemoryManager.cpp:2469
vf::gpu::CudaMemoryManager::cudaCopyFsForRestart
void cudaCopyFsForRestart(int lev) const
copy distributions from host to device
Definition CudaMemoryManager.cpp:1462
vf::gpu::CudaMemoryManager::cudaCopyPrecursorWriterOutputVariablesDtoH
void cudaCopyPrecursorWriterOutputVariablesDtoH(PrecursorWriter *writer, int level)
Definition CudaMemoryManager.cpp:2763
vf::gpu::CudaMemoryManager::cudaCopyConcentrationNoFluxBCHostToDevice
void cudaCopyConcentrationNoFluxBCHostToDevice(int lev)
Definition CudaMemoryManager.cpp:1886
vf::gpu::CudaMemoryManager::cudaAllocTemperatureWallModel
void cudaAllocTemperatureWallModel(TemperatureWallModelParameters &wallModelHost, TemperatureWallModelParameters &wallModelDevice, uint numberOfNodes)
Definition CudaMemoryManager.cpp:1225
vf::gpu::CudaMemoryManager::cudaFreeBladeGeometries
void cudaFreeBladeGeometries(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2162
vf::gpu::CudaMemoryManager::cudaCopyDampingLayerDataHtoD
void cudaCopyDampingLayerDataHtoD(DampingLayer *dampingLayer, int level)
Definition CudaMemoryManager.cpp:2484
vf::gpu::CudaMemoryManager::cudaCopyForestIndicesHtoD
void cudaCopyForestIndicesHtoD(Forest *forest)
Definition CudaMemoryManager.cpp:2516
vf::gpu::CudaMemoryManager::cudaCopyDirectionalADBoundaryCondition
void cudaCopyDirectionalADBoundaryCondition(QforDirectionalADBoundaryCondition &boundaryConditionHost, QforDirectionalADBoundaryCondition &boundaryConditionDevice)
Definition CudaMemoryManager.cpp:493
vf::gpu::CudaMemoryManager::cudaAllocProbeData
void cudaAllocProbeData(Probe *probe, int level)
Definition CudaMemoryManager.cpp:2590
vf::gpu::CudaMemoryManager::cudaCopyProbeDataHtoD
void cudaCopyProbeDataHtoD(Probe *probe, int level)
Definition CudaMemoryManager.cpp:2623
vf::gpu::CudaMemoryManager::cudaAllocForestIndices
void cudaAllocForestIndices(Forest *forest)
Definition CudaMemoryManager.cpp:2507
vf::gpu::CudaMemoryManager::cudaFreeWallModel
void cudaFreeWallModel(WallModelParameters &wallModelHost, WallModelParameters &wallModelDevice)
Definition CudaMemoryManager.cpp:1199
vf::gpu::CudaMemoryManager::cudaCopyConcentrationDeviceToHost
void cudaCopyConcentrationDeviceToHost(int lev)
Definition CudaMemoryManager.cpp:1802
vf::gpu::CudaMemoryManager::cudaCopyBladeGeometriesDtoH
void cudaCopyBladeGeometriesDtoH(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2154
vf::gpu::CudaMemoryManager::cudaCopyTurbulenceIntensityDH
void cudaCopyTurbulenceIntensityDH(int lev, uint size)
Definition CudaMemoryManager.cpp:767
vf::gpu::CudaMemoryManager::cudaAllocHigherMoments
void cudaAllocHigherMoments(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1615
vf::gpu::CudaMemoryManager::cudaCopyProcessNeighborFsDtoH
void cudaCopyProcessNeighborFsDtoH(const ProcessNeighbor27 &neighborHost, const ProcessNeighbor27 &neighborDevice) const
Definition CudaMemoryManager.cpp:670
vf::gpu::CudaMemoryManager::cudaCopyCoordsDtoH
void cudaCopyCoordsDtoH(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2200
vf::gpu::CudaMemoryManager::cudaCopyLocalReferenceTemperatureDeviceToHost
void cudaCopyLocalReferenceTemperatureDeviceToHost(int lev)
Definition CudaMemoryManager.cpp:1853
vf::gpu::CudaMemoryManager::cudaCopyDragLift
void cudaCopyDragLift(int lev, int numofelem)
Definition CudaMemoryManager.cpp:1504
vf::gpu::CudaMemoryManager::cudaCopyBuoyancyProviderReductionParametersHtoD
void cudaCopyBuoyancyProviderReductionParametersHtoD(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2449
vf::gpu::CudaMemoryManager::cudaAllocProcessNeighbor
virtual void cudaAllocProcessNeighbor(const ProcessNeighbor27 &neighborHost, const ProcessNeighbor27 &neighborDevice)
Definition CudaMemoryManager.cpp:619
vf::gpu::CudaMemoryManager::cudaFreeForestVelocities
void cudaFreeForestVelocities(Forest *forest)
Definition CudaMemoryManager.cpp:2549
vf::gpu::CudaMemoryManager::cudaAllocFsForCheckPointAndRestart
void cudaAllocFsForCheckPointAndRestart(int lev) const
Definition CudaMemoryManager.cpp:1452
vf::gpu::CudaMemoryManager::cudaAllocForestVelocities
void cudaAllocForestVelocities(Forest *forest)
Definition CudaMemoryManager.cpp:2528
vf::gpu::CudaMemoryManager::cudaAllocDirectionalBoundaryCondition
void cudaAllocDirectionalBoundaryCondition(QforDirectionalBoundaryCondition &boundaryConditionHost, QforDirectionalBoundaryCondition &boundaryConditionDevice)
Definition CudaMemoryManager.cpp:417
vf::gpu::CudaMemoryManager::cudaCopyBladeGeometriesHtoD
void cudaCopyBladeGeometriesHtoD(ActuatorFarm *actuatorFarm)
Definition CudaMemoryManager.cpp:2146
vf::gpu::CudaMemoryManager::cudaAllocBuoyancyProviderReductionParameters
void cudaAllocBuoyancyProviderReductionParameters(BuoyancyProviderPlanarAverage *buoyancyProvider, int level)
Definition CudaMemoryManager.cpp:2436
vf::gpu::CudaMemoryManager::cudaCopyForestVelocitiesHtoD
void cudaCopyForestVelocitiesHtoD(Forest *forest, std::vector< real > &velocitiesX, std::vector< real > &velocitiesY, std::vector< real > &velocitiesZ)
Definition CudaMemoryManager.cpp:2540
vf::gpu::CudaMemoryManager::cudaCopyConcentrationFluxBCHostToDevice
void cudaCopyConcentrationFluxBCHostToDevice(int lev)
Definition CudaMemoryManager.cpp:1933
vf::gpu::CudaMemoryManager::cudaFreePlanarAverageProbeSubgridScaleFluxes
void cudaFreePlanarAverageProbeSubgridScaleFluxes(PlanarAverageProbe *planarAverageProbe, int level)
Definition CudaMemoryManager.cpp:2722
vf::gpu::CudaMemoryManager::cudaAllocTurbulenceIntensity
void cudaAllocTurbulenceIntensity(int lev, uint size)
Definition CudaMemoryManager.cpp:726
vf::gpu::CudaMemoryManager::cudaCopyTurbulentDiffusivityDeviceToHost
void cudaCopyTurbulentDiffusivityDeviceToHost(int lev)
Definition CudaMemoryManager.cpp:1837
vf::gpu::CudaMemoryManager::cudaCopyConcentrationNeumannBCHostToDevice
void cudaCopyConcentrationNeumannBCHostToDevice(int lev)
Definition CudaMemoryManager.cpp:2054
vf::gpu::PlanarAverageProbe
Computes spatial statistics across x, y or z-normal planes defined by planeNormal....
Definition PlanarAverageProbe.h:59
vf::gpu::PrecursorWriter
Probe writing planes of data to be used as inflow data in successor simulation using PrecursorBC The ...
Definition PrecursorWriter.h:62
vf::gpu::PrecursorWriter::getPrecursorStruct
PrecursorStruct * getPrecursorStruct(int level)
Definition PrecursorWriter.h:121
vf::gpu::Probe
Computes statistics of pointwise data. Data can be written to vtk-file or timeseries file....
Definition Probe.h:58
SPtr
std::shared_ptr< T > SPtr
Definition PointerDefinitions.h:39
real
float real
Definition DataTypes.h:42
uint
unsigned int uint
Definition DataTypes.h:47
vf::gpu::CollisionTemplate
CollisionTemplate
An enumeration for selecting a template of the collision kernel (CumulantK17)
Definition Calculation.h:57