OpenLB 1.7
Loading...
Searching...
No Matches
collisionLES.h
Go to the documentation of this file.
1/* This file is part of the OpenLB library
2 *
3 * Copyright (C) 2012-2015 Mathias J. Krause, Jonas Latt, Patrick Nathen
4 * 2021 Adrian Kummerlaender
5 * E-mail contact: info@openlb.net
6 * The most recent release of OpenLB can be downloaded at
7 * <http://www.openlb.net/>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public
20 * License along with this program; if not, write to the Free
21 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 * Boston, MA 02110-1301, USA.
23*/
24
25#ifndef DYNAMICS_COLLISION_LES_H
26#define DYNAMICS_COLLISION_LES_H
27
28#include "collision.h"
29#include "collisionModifiers.h"
30
31namespace olb {
32
33namespace collision {
34
35namespace LES {
36
37struct Smagorinsky : public descriptors::FIELD_BASE<1> { };
38
39}
40
42
45namespace detail {
46
47template <typename COLLISION, typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
48struct SmagorinskyEffectiveOmega {
49 using MomentaF = typename MOMENTA::template type<DESCRIPTOR>;
50 using CollisionO = typename COLLISION::template type<DESCRIPTOR, MOMENTA, EQUILIBRIUM>;
51
52 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
53 V computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform {
54 V piNeqNormSqr { };
55 MomentaF().computePiNeqNormSqr(cell, piNeqNormSqr);
56 const V rho = MomentaF().computeRho(cell);
57 const V omega = parameters.template get<descriptors::OMEGA>();
58 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
59 V piNeqNorm = util::sqrt(piNeqNormSqr);
60 V preFactor = smagorinsky*smagorinsky
61 * descriptors::invCs2<V,DESCRIPTOR>()*descriptors::invCs2<V,DESCRIPTOR>()
62 * 2 * util::sqrt(2);
64 V tauMol = V{1} / omega;
66 V tauTurb = V{0.5} * (util::sqrt(tauMol*tauMol + preFactor / rho * piNeqNorm) - tauMol);
68 V tauEff = tauMol + tauTurb;
69 return V{1} / tauEff;
70 }
71
72 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
73 CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform {
74 parameters.template set<descriptors::OMEGA>(
75 computeEffectiveOmega(cell, parameters));
76 return CollisionO().apply(cell, parameters);
77 }
78};
79
80template <typename COLLISION, typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
81struct ShearSmagorinskyEffectiveOmega {
82 using MomentaF = typename MOMENTA::template type<DESCRIPTOR>;
83 using CollisionO = typename COLLISION::template type<DESCRIPTOR, MOMENTA, EQUILIBRIUM>;
84
85 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
86 V computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform {
87 V piNeqNormSqr { };
88 MomentaF().computePiNeqNormSqr(cell, piNeqNormSqr);
89 const V rho = MomentaF().computeRho(cell);
90 const auto iT = parameters.template get<descriptors::LATTICE_TIME>();
91 const V omega = parameters.template get<descriptors::OMEGA>();
92 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
93 V avShear = cell.template getField<descriptors::AV_SHEAR>();
94 V piNeqNorm = util::sqrt(piNeqNormSqr);
95 V preFactor = smagorinsky*smagorinsky
96 * descriptors::invCs2<V,DESCRIPTOR>()*descriptors::invCs2<V,DESCRIPTOR>()
97 * 2 * util::sqrt(2);
98 avShear = (avShear*iT + piNeqNorm) / (iT+1);
99 V tauMol = V{1} / omega;
100 V piNeqNormSISM = piNeqNorm - avShear;
101 V tauTurb = V{0.5} * (util::sqrt(tauMol*tauMol+(preFactor*piNeqNormSISM/rho))-tauMol);
102 V tauEff = tauMol + tauTurb;
103 return V{1} / tauEff;
104 }
105
106 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
107 CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform {
108 parameters.template set<descriptors::OMEGA>(
109 computeEffectiveOmega(cell, parameters));
110 const auto iT = parameters.template get<descriptors::LATTICE_TIME>();
111 V piNeqNormSqr { };
112 MomentaF().computePiNeqNormSqr(cell, piNeqNormSqr);
113 V avShear = cell.template getField<descriptors::AV_SHEAR>();
114 avShear = (avShear*iT + util::sqrt(piNeqNormSqr)) / (iT+1);
115 cell.template setField<descriptors::AV_SHEAR>(avShear);
116 return CollisionO().apply(cell, parameters);
117 }
118};
119
120template <typename COLLISION, typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
121struct ConStrainSmagorinskyEffectiveOmega {
122 using MomentaF = typename MOMENTA::template type<DESCRIPTOR>;
123 using CollisionO = typename COLLISION::template type<DESCRIPTOR, MOMENTA, EQUILIBRIUM>;
124
125 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
126 V computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform {
127 V pi[util::TensorVal<DESCRIPTOR>::n] { };
128 MomentaF().computeStress(cell, pi);
129 V piNeqNormSqr { };
130 MomentaF().computePiNeqNormSqr(cell, piNeqNormSqr);
131 const V rho = MomentaF().computeRho(cell);
132 const V omega = parameters.template get<descriptors::OMEGA>();
133 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
134 V piNeqNorm = util::sqrt(2*piNeqNormSqr);
135 V S[util::TensorVal<DESCRIPTOR>::n];
136 V cs2 = V{1} / descriptors::invCs2<V,DESCRIPTOR>();
137 V tauMol = V{1} / omega;
138 //Strain Tensor
139 V Phi = (-0.5*(-rho*tauMol*cs2+util::sqrt(rho*rho*tauMol*tauMol*cs2*cs2+V{2}*(smagorinsky*smagorinsky)*rho*piNeqNorm))/(smagorinsky*smagorinsky*rho*piNeqNorm));
140 for (int n=0; n < util::TensorVal<DESCRIPTOR>::n; ++n) {
141 S[n] = Phi*pi[n];
142 }
143 //Strain Tensor Norm
144 V SNormSqr = S[0]*S[0] + 2.0*S[1]*S[1] + S[2]*S[2];
145 if constexpr (util::TensorVal<DESCRIPTOR>::n == 6) {
146 SNormSqr += S[2]*S[2] + S[3]*S[3] + 2.0*S[4]*S[4] + S[5]*S[5];
147 }
148 V SNorm = util::sqrt(2*SNormSqr);
150 V tauTurb = smagorinsky*smagorinsky*SNorm/cs2;
152 V tauEff = tauMol + tauTurb;
153 return V{1} / tauEff;
154 }
155
156 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
157 CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform{
158 parameters.template set<descriptors::OMEGA>(
159 computeEffectiveOmega(cell, parameters));
160 return CollisionO().apply(cell, parameters);
161 }
162
163};
164
165template <typename COLLISION, typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
166struct ConSmagorinskyEffectiveOmega {
167 using MomentaF = typename MOMENTA::template type<DESCRIPTOR>;
168 using CollisionO = typename COLLISION::template type<DESCRIPTOR, MOMENTA, EQUILIBRIUM>;
169
170 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
171 V computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform {
172 V pi[util::TensorVal<DESCRIPTOR>::n] { };
173 MomentaF().computeStress(cell, pi);
174 V piNeqNormSqr { };
175 MomentaF().computePiNeqNormSqr(cell, piNeqNormSqr);
176 const V rho = MomentaF().computeRho(cell);
177 const V omega = parameters.template get<descriptors::OMEGA>();
178 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
179 V H[util::TensorVal<DESCRIPTOR >::n];
180 V conSmagoR[DESCRIPTOR::q];
181 V S[util::TensorVal<DESCRIPTOR >::n];
182 V tauMol = V{1} / omega;
183 V cs2 = V{1} / descriptors::invCs2<V,DESCRIPTOR>();
184 V piNeqNorm = util::sqrt(2*piNeqNormSqr);
185 V Phi = (-0.5*(-rho*tauMol*cs2+util::sqrt(rho*rho*tauMol*tauMol*cs2*cs2+V{2}*(smagorinsky*smagorinsky)*rho*piNeqNorm))/(smagorinsky*smagorinsky*rho*piNeqNorm));
186 for (int n=0; n < util::TensorVal<DESCRIPTOR>::n; ++n) {
187 S[n] = Phi*pi[n];
188 }
189 //Strain rate Tensor Norm
190 V SNormSqr = S[0]*S[0] + 2.0*S[1]*S[1] + S[2]*S[2];
191 if constexpr (util::TensorVal<DESCRIPTOR>::n == 6) {
192 SNormSqr += S[2]*S[2] + S[3]*S[3] + 2.0*S[4]*S[4] + S[5]*S[5];
193 }
194 V SNorm = util::sqrt(2*SNormSqr);
195 V preFactor = smagorinsky*smagorinsky
196 * descriptors::invCs2<V,DESCRIPTOR>()*descriptors::invCs2<V,DESCRIPTOR>()
197 * 2 * util::sqrt(2);
198 //consistent Samagorinsky additional R term
199 //for (int q=0; q < DESCRIPTOR::q; ++q) {
200 {
201 unsigned q = 0;
202 V t = descriptors::t<V,DESCRIPTOR>(q);
203 //Hermite-Polynom H = c*c-cs^2*kronDelta
204 H[0] = descriptors::c<DESCRIPTOR>(q,0)*descriptors::c<DESCRIPTOR>(q,0)-cs2;
205 H[1] = descriptors::c<DESCRIPTOR>(q,0)*descriptors::c<DESCRIPTOR>(q,1);
206 H[2] = descriptors::c<DESCRIPTOR>(q,1)*descriptors::c<DESCRIPTOR>(q,1)-cs2;
207 if constexpr (util::TensorVal<DESCRIPTOR>::n == 6) {
208 H[2] = descriptors::c<DESCRIPTOR>(q,0)*descriptors::c<DESCRIPTOR>(q,2);
209 H[3] = descriptors::c<DESCRIPTOR>(q,1)*descriptors::c<DESCRIPTOR>(q,1)-cs2;
210 H[4] = descriptors::c<DESCRIPTOR>(q,1)*descriptors::c<DESCRIPTOR>(q,2);
211 H[5] = descriptors::c<DESCRIPTOR>(q,2)*descriptors::c<DESCRIPTOR>(q,2)-cs2;
212 }
213 //contraction or scalar product H*S
214 V contractHS = H[0]*S[0] + 2.0*H[1]*S[1] + H[2]*S[2];
215 if constexpr (util::TensorVal<DESCRIPTOR>::n == 6) {
216 contractHS += H[2]*S[2] + H[3]*S[3] + 2.0*H[4]*S[4] + H[5]*S[5];
217 }
218 //additional term
219 conSmagoR[q] = t*preFactor*SNorm*contractHS;
220 }
221 return conSmagoR[0];
222 }
223
224 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
225 CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform {
226 parameters.template set<descriptors::OMEGA>(
227 computeEffectiveOmega(cell, parameters));
228 return CollisionO().apply(cell, parameters);
229 }
230};
231
232template <typename COLLISION, typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
233struct WaleEffectiveOmega {
234 using MomentaF = typename MOMENTA::template type<DESCRIPTOR>;
235 using CollisionO = typename COLLISION::template type<DESCRIPTOR, MOMENTA, EQUILIBRIUM>;
236
237 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
238 V computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform {
239 V piNeqNormSqr { };
240 MomentaF().computePiNeqNormSqr(cell, piNeqNormSqr);
241 const V omega = parameters.template get<descriptors::OMEGA>();
242 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
243 const auto velocityGradient = cell.template getField<descriptors::VELO_GRAD>();
244 V preFactor = smagorinsky*smagorinsky;
245 // velocity gradient tensor
246 V g[3][3];
247 for (unsigned i=0; i < 3; i++) {
248 for (unsigned j=0; j < 3; j++) {
249 g[i][j] = velocityGradient[i*3 + j];
250 }
251 }
252 // strain rate tensor
253 V s[3][3];
254 for (unsigned i = 0; i < 3; i++) {
255 for (unsigned j = 0; j < 3; j++) {
256 s[i][j] = (g[i][j] + g[j][i]) / V{2};
257 }
258 }
259 // traceless symmetric part of the square of the velocity gradient tensor
260 V G[3][3];
261 for (unsigned i = 0; i < 3; i++) {
262 for (unsigned j = 0; j < 3; j++) {
263 G[i][j] = V{0};
264 }
265 }
266 for (unsigned i = 0; i < 3; i++) {
267 for (unsigned j = 0; j < 3; j++) {
268 for (unsigned k = 0; k < 3; k++) {
269 G[i][j] += (g[i][k]*g[k][j] + g[j][k]*g[k][i]) / V{2};
270 }
271 }
272 }
273 V trace{};
274 for (unsigned i = 0; i < 3; i++) {
275 trace += V{1}/V{3} * g[i][i] * g[i][i];
276 }
277 for (unsigned i = 0; i < 3; i++) {
278 G[i][i] -= trace;
279 }
280 // inner product of the traceless symmetric part of the square of the velocity gradient tensor
281 V G_ip{};
282 for (unsigned i = 0; i < 3; i++) {
283 for (unsigned j = 0; j < 3; j++) {
284 G_ip = G[i][j] * G[i][j];
285 }
286 }
287 // inner product of the strain rate
288 V s_ip{};
289 for (unsigned i = 0; i < 3; i++) {
290 for (unsigned j = 0; j < 3; j++) {
291 s_ip = s[i][j] * s[i][j];
292 }
293 }
294 // Turbulent relaxation time
295 V tauTurb = V{3} * preFactor * (util::pow(G_ip,1.5) / (util::pow(s_ip,2.5) + util::pow(G_ip,1.25)));
296 if ((util::pow(s_ip,2.5) + util::pow(G_ip,1.25)) == 0) {
297 tauTurb = 0;
298 }
299 // Physical turbulent viscosity must be equal or higher that zero
300 if (tauTurb < 0) {
301 tauTurb = 0;
302 }
304 V tauMol = V{1} / omega;
306 V tauEff = tauMol + tauTurb;
307 return V{1} / tauEff;
308 }
309
310 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
311 CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform {
312 parameters.template set<descriptors::OMEGA>(
313 computeEffectiveOmega(cell, parameters));
314 return CollisionO().apply(cell, parameters);
315 }
316};
317
318template <typename COLLISION, typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
319struct KrauseEffectiveOmega {
320 using MomentaF = typename MOMENTA::template type<DESCRIPTOR>;
321 using CollisionO = typename COLLISION::template type<DESCRIPTOR, MOMENTA, EQUILIBRIUM>;
322
323 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
324 V computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform {
325 V rho, u[DESCRIPTOR::d], fNeq[DESCRIPTOR::q] { };
326 MomentaF().computeRhoU(cell, rho, u);
327 lbm<DESCRIPTOR>::computeFneq(cell, fNeq, rho, u);
328 const V omega = parameters.template get<descriptors::OMEGA>();
329 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
330 const V preFactor = smagorinsky*smagorinsky
331 * 3*descriptors::invCs2<V,DESCRIPTOR>()*descriptors::invCs2<V,DESCRIPTOR>()
332 * 2*util::sqrt(2);
333 FieldD<V,DESCRIPTOR,typename COLLISION::OMEGA> omegaEff;
334 const V tauMol = V{1} / omega;
335 for (unsigned iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
336 V tauTurb = V{0.5}*(util::sqrt(tauMol*tauMol + preFactor/rho * util::fabs(fNeq[iPop])) - tauMol);
337 omegaEff[iPop] = V{1} / (tauMol + tauTurb);
338 }
339 V avgOmegaEff = 0.;
340 for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
341 avgOmegaEff += omegaEff[iPop];
342 }
343 avgOmegaEff /= DESCRIPTOR::q;
344 return avgOmegaEff;
345 }
346
347 template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
348 CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform {
349 V rho, u[DESCRIPTOR::d], fNeq[DESCRIPTOR::q] { };
350 MomentaF().computeRhoU(cell, rho, u);
351 lbm<DESCRIPTOR>::computeFneq(cell, fNeq, rho, u); // TODO: Use EQUILIBRIUM instead of 2nd order
352 const V omega = parameters.template get<descriptors::OMEGA>();
353 const V smagorinsky = parameters.template get<collision::LES::Smagorinsky>();
354 const V preFactor = smagorinsky*smagorinsky
355 * 3*descriptors::invCs2<V,DESCRIPTOR>()*descriptors::invCs2<V,DESCRIPTOR>()
356 * 2*util::sqrt(2);
357 FieldD<V,DESCRIPTOR,typename COLLISION::OMEGA> omegaEff;
358 const V tauMol = V{1} / omega;
359 for (unsigned iPop=0; iPop < DESCRIPTOR::q; ++iPop) {
360 V tauTurb = V{0.5}*(util::sqrt(tauMol*tauMol + preFactor/rho * util::fabs(fNeq[iPop])) - tauMol);
361 omegaEff[iPop] = V{1} / (tauMol + tauTurb);
362 }
363 parameters.template set<typename COLLISION::OMEGA>(omegaEff);
364 return CollisionO().apply(cell, parameters);
365 }
366};
367
368
369}
370
372template <typename COLLISION>
373struct SmagorinskyEffectiveOmega {
374 using parameters = typename COLLISION::parameters::template include<
375 descriptors::OMEGA, LES::Smagorinsky
376 >;
377
378 static_assert(COLLISION::parameters::template contains<descriptors::OMEGA>(),
379 "COLLISION must be parametrized using relaxation frequency OMEGA");
380
381 static std::string getName() {
382 return "SmagorinskyEffectiveOmega<" + COLLISION::getName() + ">";
383 }
384
385 template <typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
386 using type = detail::SmagorinskyEffectiveOmega<COLLISION,DESCRIPTOR,MOMENTA,EQUILIBRIUM>;
387};
388
390template <typename COLLISION>
391struct ShearSmagorinskyEffectiveOmega {
392 using parameters = typename COLLISION::parameters::template include<
393 descriptors::LATTICE_TIME, descriptors::OMEGA, LES::Smagorinsky
394 >;
395
396 static_assert(COLLISION::parameters::template contains<descriptors::OMEGA>(),
397 "COLLISION must be parametrized using relaxation frequency OMEGA");
398
399 static std::string getName() {
400 return "ShearSmagorinskyEffectiveOmega<" + COLLISION::getName() + ">";
401 }
402
403 template <typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
404 using type = detail::ShearSmagorinskyEffectiveOmega<COLLISION,DESCRIPTOR,MOMENTA,EQUILIBRIUM>;
405};
406
408template <typename COLLISION>
409struct ConStrainSmagorinskyEffectiveOmega {
410 using parameters = typename COLLISION::parameters::template include<
411 descriptors::OMEGA, LES::Smagorinsky
412 >;
413
414 static_assert(COLLISION::parameters::template contains<descriptors::OMEGA>(),
415 "COLLISION must be parametrized using relaxation frequency OMEGA");
416
417 static std::string getName() {
418 return "ConStrainSmagorinskyEffectiveOmega<" + COLLISION::getName() + ">";
419 }
420
421 template <typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
422 using type = detail::ConStrainSmagorinskyEffectiveOmega<COLLISION,DESCRIPTOR,MOMENTA,EQUILIBRIUM>;
423};
424
426template <typename COLLISION>
427struct ConSmagorinskyEffectiveOmega {
428 using parameters = typename COLLISION::parameters::template include<
429 descriptors::OMEGA, LES::Smagorinsky
430 >;
431
432 static_assert(COLLISION::parameters::template contains<descriptors::OMEGA>(),
433 "COLLISION must be parametrized using relaxation frequency OMEGA");
434
435 static std::string getName() {
436 return "ConSmagorinskyEffectiveOmega<" + COLLISION::getName() + ">";
437 }
438
439 template <typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
440 using type = detail::ConSmagorinskyEffectiveOmega<COLLISION,DESCRIPTOR,MOMENTA,EQUILIBRIUM>;
441};
442
444template <typename COLLISION>
445struct WaleEffectiveOmega {
446 using parameters = typename COLLISION::parameters::template include<
447 descriptors::OMEGA, LES::Smagorinsky
448 >;
449
450 static_assert(COLLISION::parameters::template contains<descriptors::OMEGA>(),
451 "COLLISION must be parametrized using relaxation frequency OMEGA");
452
453 static std::string getName() {
454 return "WaleEffectiveOmega<" + COLLISION::getName() + ">";
455 }
456
457 template <typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
458 using type = detail::WaleEffectiveOmega<COLLISION,DESCRIPTOR,MOMENTA,EQUILIBRIUM>;
459};
460
462template <typename COLLISION>
463struct KrauseEffectiveOmega {
464 using parameters = typename COLLISION::parameters::template include<
465 descriptors::OMEGA, LES::Smagorinsky
466 >;
467
468 static std::string getName() {
469 return "KrauseEffectiveOmega<" + COLLISION::getName() + ">";
470 }
471
472 template <typename DESCRIPTOR, typename MOMENTA, typename EQUILIBRIUM>
473 using type = detail::KrauseEffectiveOmega<COLLISION,DESCRIPTOR,MOMENTA,EQUILIBRIUM>;
474};
475
476}
477
478}
479
480#endif
481
482#include "collisionLES.cse.h"
olb::Vector
Plain old scalar vector.
Definition vector.h:47
olb::util::sqrt
cpu::simd::Pack< T > sqrt(cpu::simd::Pack< T > value)
Definition pack.h:100
olb::util::pow
cpu::simd::Pack< T > pow(cpu::simd::Pack< T > base, cpu::simd::Pack< T > exp)
Definition pack.h:112
olb::util::fabs
cpu::simd::Pack< T > fabs(cpu::simd::Pack< T > value)
Definition pack.h:106
olb
Top level namespace for all of OpenLB.
Definition boundaryPostProcessors2D.h:34
any_platform
#define any_platform
Define preprocessor macros for device-side functions, constant storage.
Definition platform.h:78
olb::CellStatistic
Return value of any collision.
Definition interface.h:43
olb::collision::ConSmagorinskyEffectiveOmega
Compute dynamics parameter OMEGA locally using Consistent Smagorinsky LES model.
Definition collisionLES.h:427
olb::collision::ConSmagorinskyEffectiveOmega::parameters
typename COLLISION::parameters::template include< descriptors::OMEGA, LES::Smagorinsky > parameters
Definition collisionLES.h:428
olb::collision::ConStrainSmagorinskyEffectiveOmega
Compute dynamics parameter OMEGA locally using Consistent Strain Smagorinsky LES model.
Definition collisionLES.h:409
olb::collision::ConStrainSmagorinskyEffectiveOmega::parameters
typename COLLISION::parameters::template include< descriptors::OMEGA, LES::Smagorinsky > parameters
Definition collisionLES.h:410
olb::collision::KrauseEffectiveOmega
Compute dynamics parameter OMEGA locally using Krause LES model.
Definition collisionLES.h:463
olb::collision::KrauseEffectiveOmega::parameters
typename COLLISION::parameters::template include< descriptors::OMEGA, LES::Smagorinsky > parameters
Definition collisionLES.h:464
olb::collision::ShearSmagorinskyEffectiveOmega
Compute dynamics parameter OMEGA locally using Shear Smagorinsky LES model.
Definition collisionLES.h:391
olb::collision::ShearSmagorinskyEffectiveOmega::parameters
typename COLLISION::parameters::template include< descriptors::LATTICE_TIME, descriptors::OMEGA, LES::Smagorinsky > parameters
Definition collisionLES.h:392
olb::collision::SmagorinskyEffectiveOmega
Compute dynamics parameter OMEGA locally using Smagorinsky LES model.
Definition collisionLES.h:373
olb::collision::SmagorinskyEffectiveOmega::parameters
typename COLLISION::parameters::template include< descriptors::OMEGA, LES::Smagorinsky > parameters
Definition collisionLES.h:374
olb::collision::WaleEffectiveOmega
Compute dynamics parameter OMEGA locally using WALE.
Definition collisionLES.h:445
olb::collision::WaleEffectiveOmega::parameters
typename COLLISION::parameters::template include< descriptors::OMEGA, LES::Smagorinsky > parameters
Definition collisionLES.h:446
olb::collision::detail::ConSmagorinskyEffectiveOmega::CollisionO
typename COLLISION::template type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > CollisionO
Definition collisionLES.h:168
olb::collision::detail::ConSmagorinskyEffectiveOmega::MomentaF
typename MOMENTA::template type< DESCRIPTOR > MomentaF
Definition collisionLES.h:167
olb::collision::detail::ConSmagorinskyEffectiveOmega::computeEffectiveOmega
V computeEffectiveOmega(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:171
olb::collision::detail::ConSmagorinskyEffectiveOmega::apply
CellStatistic< V > apply(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:225
olb::collision::detail::ConStrainSmagorinskyEffectiveOmega::computeEffectiveOmega
V computeEffectiveOmega(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:126
olb::collision::detail::ConStrainSmagorinskyEffectiveOmega::MomentaF
typename MOMENTA::template type< DESCRIPTOR > MomentaF
Definition collisionLES.h:122
olb::collision::detail::ConStrainSmagorinskyEffectiveOmega::CollisionO
typename COLLISION::template type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > CollisionO
Definition collisionLES.h:123
olb::collision::detail::ConStrainSmagorinskyEffectiveOmega::apply
CellStatistic< V > apply(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:157
olb::collision::detail::KrauseEffectiveOmega::computeEffectiveOmega
V computeEffectiveOmega(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:324
olb::collision::detail::KrauseEffectiveOmega::CollisionO
typename COLLISION::template type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > CollisionO
Definition collisionLES.h:321
olb::collision::detail::KrauseEffectiveOmega::MomentaF
typename MOMENTA::template type< DESCRIPTOR > MomentaF
Definition collisionLES.h:320
olb::collision::detail::KrauseEffectiveOmega::apply
CellStatistic< V > apply(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:348
olb::collision::detail::ShearSmagorinskyEffectiveOmega::MomentaF
typename MOMENTA::template type< DESCRIPTOR > MomentaF
Definition collisionLES.h:82
olb::collision::detail::ShearSmagorinskyEffectiveOmega::computeEffectiveOmega
V computeEffectiveOmega(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:86
olb::collision::detail::ShearSmagorinskyEffectiveOmega::apply
CellStatistic< V > apply(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:107
olb::collision::detail::ShearSmagorinskyEffectiveOmega::CollisionO
typename COLLISION::template type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > CollisionO
Definition collisionLES.h:83
olb::collision::detail::SmagorinskyEffectiveOmega::computeEffectiveOmega
V computeEffectiveOmega(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:53
olb::collision::detail::SmagorinskyEffectiveOmega::apply
CellStatistic< V > apply(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:73
olb::collision::detail::SmagorinskyEffectiveOmega::MomentaF
typename MOMENTA::template type< DESCRIPTOR > MomentaF
Definition collisionLES.h:49
olb::collision::detail::SmagorinskyEffectiveOmega::CollisionO
typename COLLISION::template type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > CollisionO
Definition collisionLES.h:50
olb::collision::detail::WaleEffectiveOmega::apply
CellStatistic< V > apply(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:311
olb::collision::detail::WaleEffectiveOmega::CollisionO
typename COLLISION::template type< DESCRIPTOR, MOMENTA, EQUILIBRIUM > CollisionO
Definition collisionLES.h:235
olb::collision::detail::WaleEffectiveOmega::MomentaF
typename MOMENTA::template type< DESCRIPTOR > MomentaF
Definition collisionLES.h:234
olb::collision::detail::WaleEffectiveOmega::computeEffectiveOmega
V computeEffectiveOmega(CELL &cell, PARAMETERS &parameters) any_platform
Definition collisionLES.h:238
olb::descriptors::FIELD_BASE
Base of a field whose size is defined by [C,U_1,...,U_N]^T * [1,V_1,...V_N].
Definition descriptorField.h:49
olb::descriptors::LATTICE_TIME
Definition descriptorField.h:177
olb::lbm::computeFneq
static void computeFneq(CELL &cell, FNEQ &fNeq, const RHO &rho, const U &u) any_platform
Computation of non-equilibrium distribution.
Definition lbm.h:271
olb::util::TensorVal
Compute number of elements of a symmetric d-dimensional tensor.
Definition util.h:210
Generated on Tue Mar 5 2024 09:57:46 for OpenLB by doxygen 1.10.0