Loading...
Searching...
No Matches
Public Types |
Public Member Functions |
Public Attributes |
Protected Member Functions |
Private Types |
Private Member Functions |
Private Attributes |
Friends |
List of all members
LbInterfaceDxQy< nDim, nDist, SysEqn > Class Template Reference
Interface class holding all relevant data and methods for treating prolongation, restriction and initialization of new cells for the DxQy lattice model. More...
#include <lbinterfacedxqy.h>
Inheritance diagram for LbInterfaceDxQy< nDim, nDist, SysEqn >:
Collaboration diagram for LbInterfaceDxQy< nDim, nDist, SysEqn >:
Public Types | |
| using | Ld = LbLatticeDescriptor< nDim, nDist > |
Public Member Functions | |
| LbInterfaceDxQy (LbSolver< nDim > *solver) | |
| virtual | ~LbInterfaceDxQy () |
| D'tor for the interface class. More... | |
| void | prolongation () |
| Performing the chosen prolongation method. More... | |
| void | restriction () |
| Performing the chosen restriction method. More... | |
| virtual void | refineCell (const MInt parentId, const MInt *childIds) override final |
| virtual void | removeChildren (const MInt parentId) override final |
 Public Member Functions inherited from LbInterface< nDim > | |
| LbInterface (LbSolver< nDim > *solver) | |
| Base class for the concrete interface treatment. More... | |
| virtual | ~LbInterface () |
| Destructor. More... | |
| virtual void | refineCell (const MInt parentId, const MInt *childIds)=0 |
| virtual void | removeChildren (const MInt parentId)=0 |
| virtual void | printInterfaceCells () |
| void | colorInterface () |
| Sets the interface cells to defined values (to be watched e.g. in DX) More... | |
Public Attributes | |
| LbSolverDxQy< nDim, nDist, SysEqn > * | m_solver |
Protected Member Functions | |
| virtual void | prolongation0 () |
| virtual void | restriction0 () |
| virtual void | prolongation10 () |
| virtual void | restriction10 () |
| template<MBool compressible = false> | |
| void | prolongationDupuis_ () |
| Coarse to fine. More... | |
| template<MBool compressible = false> | |
| void | restrictionDupuis_ () |
| Fine to coarse grid. More... | |
| virtual void | prolongationDupuis () |
| virtual void | restrictionDupuis () |
| void | prolongationDupuisCompressible () |
| void | restrictionDupuisCompressible () |
| virtual void | prolongationRohde () |
| virtual void | restrictionRohde () |
| virtual void | prolongationThermalDupuis () |
| Coarse to fine grid for thermal LB. More... | |
| virtual void | restrictionThermalDupuis () |
| Fine to coarse grid for thermal LB. More... | |
| virtual void | prolongationThermalRohde () |
| Coarse to fine grid for thermal LB. More... | |
| virtual void | restrictionThermalRohde () |
| Fine to coarse grid fot thermal LB. More... | |
| virtual void | refineCellDupuis (const MInt parentId, const MInt *childIds) |
| Initialize child variables from parent. More... | |
| virtual void | refineCellCopyPaste (const MInt parentId, const MInt *childIds) |
| Initialize child variables from parent. More... | |
| virtual void | removeChildsDupuisFilippova (const MInt parentId) |
| Initialize parent variables from children. More... | |
| virtual void | removeChildsCopyPaste (const MInt parentId) |
| Initialize parent variables from children. More... | |
| void | getCellForcing (std::array< MFloat, nDist > &F, const MInt cellId=-1) |
| General accessor for potentially cell dependent forcing. More... | |
Private Types | |
| typedef void(LbInterfaceDxQy::* | InterfaceFunction) () |
| typedef void(LbInterfaceDxQy::* | RefineCellFunction) (const MInt parentId, const MInt *childIds) |
| typedef void(LbInterfaceDxQy::* | RemoveChildrenFunction) (const MInt parentId) |
Private Member Functions | |
| void | setInterfaceFunctions () |
| Setting function pointer to the chosen interface treatment method. More... | |
| void | setAdaptationFunctions () |
| Setting the adaptation functions chosen via property. More... | |
Private Attributes | |
| InterfaceFunction | fProlongation |
| InterfaceFunction | fRestriction |
| RefineCellFunction | fRefineCell |
| RemoveChildrenFunction | fRemoveChildren |
| MFloat | m_static_prolongation10_tmp {} |
| MFloat | m_static_prolongation10_tmp2 {} |
| MFloat | m_static_prolongation10_b [2 *nDim] {} |
| MFloat | m_static_prolongation10_c [nDim *nDim] {} |
| MFloat | m_static_prolongation10_trace {} |
| MInt | m_static_prolongation10_tmpDistId {} |
| MFloat | m_static_restriction10_tmp {} |
| MFloat | m_static_restriction10_tmp2 {} |
| MFloat | m_static_restriction10_b [2 *nDim] {} |
| MFloat | m_static_restriction10_c [nDim *nDim] {} |
| MFloat | m_static_restriction10_trace {} |
| MInt | m_static_restriction10_tmpDistId {} |
Friends | |
| template<MInt nDim_, MInt nDist_, class SysEqn_ > | |
| class | LbSolverDxQy |
Additional Inherited Members | |
| Protected Attributes inherited from LbInterface< nDim > | |
| MInt | m_interfaceId {} |
| MInt | m_noDistributions |
| std::vector< Collector< LbInterfaceCell > * > | m_interfaceChildren |
| std::vector< Collector< LbParentCell > * > | m_interfaceParents |
| MBool | m_cellDependentForcing |
| MBool | m_externalForcing |
| MBool | m_isEELiquid |
| MInt | m_methodId |
| MFloat * | m_Fext {} |
| MFloat * | m_Fg {} |
| MPrimitiveVariables< nDim > * | PV |
| MFloat | m_nu |
| MString | m_interfaceMethod |
| MString | m_adaptationInitMethod |
| MInt | m_noCoefficients {} |
| MInt | m_isThermal |
| MInt | m_innerEnergy |
| LbSolver< nDim > * | m_solver |
Detailed Description
Definition at line 22 of file lbinterfacedxqy.h.
Member Typedef Documentation
◆ InterfaceFunction
|
private |
Definition at line 96 of file lbinterfacedxqy.h.
◆ Ld
| using LbInterfaceDxQy< nDim, nDist, SysEqn >::Ld = LbLatticeDescriptor<nDim, nDist> |
Definition at line 42 of file lbinterfacedxqy.h.
◆ RefineCellFunction
|
private |
Definition at line 103 of file lbinterfacedxqy.h.
◆ RemoveChildrenFunction
|
private |
Definition at line 106 of file lbinterfacedxqy.h.
Constructor & Destructor Documentation
◆ LbInterfaceDxQy()
| LbInterfaceDxQy< nDim, nDist, SysEqn >::LbInterfaceDxQy | ( | LbSolver< nDim > * | solver | ) |
◆ ~LbInterfaceDxQy()
|
virtualdefault |
Member Function Documentation
◆ getCellForcing()
|
inlineprotected |
- Parameters
-
[out] F Forcing term [in] cellId Cell id (-1 if global forcing is needed)
Definition at line 135 of file lbinterfacedxqy.h.
136 {
139 } else {
140#ifdef WAR_NVHPC_PSTL
142 F[d] = 0.0;
143 }
144#else
145 F.fill(0.0);
146#endif
147 }
148 if(cellId < 0) {
149 return;
150 }
155 }
156 }
157}
LbSolverDxQy< nDim, nDist, SysEqn > * m_solver
Definition: lbinterfacedxqy.h:44
◆ prolongation()
| void LbInterfaceDxQy< nDim, nDist, SysEqn >::prolongation |
Definition at line 122 of file lbinterfacedxqy.cpp.
◆ prolongation0()
|
inlineprotectedvirtual |
Definition at line 58 of file lbinterfacedxqy.h.
58{};
◆ prolongation10()
|
protectedvirtual |
coarse to fine grid
trilinear spatial interpolation + linear interpolation in time and transformation of non-eq parts
Definition at line 143 of file lbinterfacedxqy.cpp.
143 {
148
150 level++) { // minLevel+level is the actual coarse resolution
151 // minLevel+level+1 is the actual fine resolution
152
154 == 0) { // perform prolongation WITHOUT temporal interpolation in every second timestep on finest level,
155 // in every fourth timestep on the next coarser level, and so on; starting from t = 1
156
162
164 2.0
165 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
166 // omega_C = 2.0 / ( 1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel()
167 // - level));
168
169 //--------------------------------------------------------------------------------------------
170 // Spatial interpolation and temporal extrapolation of macroscopic variables and stress tensor
171 // f(t+1) = 2*f(t) - f(t-1)
172
173 MFloat rho = 0.0;
174 std::array<MFloat, nDim> u{};
182 IF_CONSTEXPR(nDim == 3)
185 }
186
189 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
191 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->U);
193 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->V);
194 IF_CONSTEXPR(nDim == 3)
196 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->W);
197 }
198
199 // compute strain rate tensor on fine grid: (du/dx)_fine = 1/2*(du/dx)_coarse
200 IF_CONSTEXPR(nDim == 3) {
202 // du[j]/dx
203 c[j + 0 * 3] =
204 2.0 * rho * F1B2
221 // du[j]/dy
222 c[j + 1 * 3] =
223 2.0 * rho * F1B2
240 // du[j]/dz
241 c[j + 2 * 3] =
242 2.0 * rho * F1B2
259 }
260
262 // du[j]/dx
263 c[j + 0 * 3] -=
264 1.0 * rho * F1B2
281 j)));
282 // du[j]/dy
283 c[j + 1 * 3] -=
284 1.0 * rho * F1B2
301 j)));
302 // du[j]/dz
303 c[j + 2 * 3] -=
304 1.0 * rho * F1B2
321 j)));
322 }
323 trace = c[0] + c[4] + c[8];
324 }
325 else {
326 cout << "Strain rate tensor not implemented for 2D yet" << endl;
327 trace = F0;
328 }
329
330 //--------------------------------------------------------------------------------------------
331
332
333 // m_solver->a_variable(currentId, PV->RHO) = rho;
334 // m_solver->a_variable(currentId, PV->U) = u[0];
335 // m_solver->a_variable(currentId, PV->V) = u[1];
336 // m_solver->a_variable(currentId, PV->W) = u[2];
337
338 tmp2 = F0;
340 tmp2 += (u[d] * u[d]);
341 b[2 * d] = -u[d];
342 b[2 * d + 1] = u[d];
343 }
344
345 // Calculate all equilibrium distributions
346 std::array<MFloat, nDist> eqDist;
347 eqDist = m_solver->getEqDists(rho, tmp2, u.data());
348
349 // interpolate and transform
351 // only the missing distributions
354
355 // put together eq-part and rescaled non-eq part; scale factor = (omega_C/omega_F) * F1B2
356
358
363 }
364 }
365 }
366 }
367 } // end of loop over all interface cells
368
369 }
370 // If NOT in sync with parent cells apply linear time interpolation
371 else {
373 == 0) { // perform prolongation WITH temporal interpolation in every second timestep on finest level,
374 // in every fourth timestep on the next coarser level, and so on; starting from t = 2
375
381
383 2.0
384 / (1.0
385 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
386
387 //--------------------------------------------------------------------------------------------
388 // Spatial interpolation and temporal extrapolation of macroscopic variables and stress tensor
389 // f(t+1/2) = 1.5*f(t) - 0.5*f(t-1)
390
391 MFloat rho = 0;
392 std::array<MFloat, nDim> u{};
393
401 IF_CONSTEXPR(nDim == 3)
404 }
405
408 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
410 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->U);
412 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->V);
413 IF_CONSTEXPR(nDim == 3)
415 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->W);
416 }
417
418 // compute strain rate tensor on fine grid: (du/dx)_fine = 1/2*(du/dx)_coarse
419 IF_CONSTEXPR(nDim == 3) {
421 // du[j]/dx
422 c[j + 0 * 3] =
423 1.5 * rho * F1B2
440 j)));
441 // du[j]/dy
442 c[j + 1 * 3] =
443 1.5 * rho * F1B2
460 j)));
461 // du[j]/dz
462 c[j + 2 * 3] =
463 1.5 * rho * F1B2
480 j)));
481 }
482
484 // du[j]/dx
485 c[j + 0 * 3] -=
486 F1B2 * rho * F1B2
495 j))
500 j))
505 j)));
506 // du[j]/dy
507 c[j + 1 * 3] -=
508 F1B2 * rho * F1B2
517 j))
522 j))
527 j)));
528 // du[j]/dz
529 c[j + 2 * 3] -=
530 F1B2 * rho * F1B2
539 j))
544 j))
549 j)));
550 }
551 trace = c[0] + c[4] + c[8];
552 }
553 else {
554 cout << "Strain rate tensor not implemented for 2D yet" << endl;
555 trace = F0;
556 }
557
558 //--------------------------------------------------------------------------------------------
559
560 tmp2 = F0;
562 tmp2 += (u[d] * u[d]);
563 b[2 * d] = -u[d];
564 b[2 * d + 1] = u[d];
565 }
566
567 // Calculation of new distributions
568 std::array<MFloat, nDist> eqDist;
569 eqDist = m_solver->getEqDists(rho, tmp2, u.data());
570
571 // create new incoming distributions
573 // only the missing distributions
576
577 // put together eq-part and rescaled non-eq part; scale factor = (omega_C/omega_F) * F1B2
578
580
585 }
586 }
587 }
588 }
589 } // end of loop over all interface cells
590 }
591 }
592 }
593}
MFloat m_static_prolongation10_b[2 *nDim]
Definition: lbinterfacedxqy.h:115
MFloat m_static_prolongation10_trace
Definition: lbinterfacedxqy.h:117
MFloat m_static_prolongation10_tmp2
Definition: lbinterfacedxqy.h:114
MFloat m_static_prolongation10_c[nDim *nDim]
Definition: lbinterfacedxqy.h:116
std::vector< Collector< LbInterfaceCell > * > m_interfaceChildren
Definition: lbinterface.h:54
constexpr MFloat tp[4]
taylor-polynom coefficients for equilibrium calculation (0:rest, 1:face, 2:edge, 3:corner)
Definition: lblatticedescriptor.h:84
static constexpr MInt idFld(MInt i, MInt j)
Definition: lblatticedescriptor.h:264
static constexpr MInt oppositeDist(MInt i)
Definition: lblatticedescriptor.h:285
static constexpr MInt distType(MInt i)
Type of the distribution (0:rest, 1:face, 2:edge, 3:corner)
Definition: lblatticedescriptor.h:257
Definition: contexttypes.h:19
Definition: geometrycontexttypes.h:23
◆ prolongationDupuis()
|
protectedvirtual |
Definition at line 960 of file lbinterfacedxqy.cpp.
960 {
961 prolongationDupuis_<false>();
962}
◆ prolongationDupuis_()
template<MBool compressible>
|
protected |
trilinear spatial interpolation + linear interpolation in time and transformation of non-eq parts according to Dupuis et al.
Definition at line 772 of file lbinterfacedxqy.cpp.
772 {
773#ifdef WAR_NVHPC_PSTL
775#endif
776
778 level++) { // minLevel+level is the actual coarse resolution
779 // minLevel+level+1 is the actual fine resolution
780
782 == 0) { // perform prolongation WITH temporal interpolation in every second timestep on finest level,
783 // in every fourth timestep on the next coarser level, and so on; starting from t = 2
784
785 //-----------------------------
786 // if in sync with parent:
788 == 0) { // perform prolongation WITHOUT temporal interpolation in every second timestep on finest level,
789 // in every fourth timestep on the next coarser level, and so on; starting from t = 1
790
793#ifdef WAR_NVHPC_PSTL
794 if(currentId >= noInternalCells) return;
795#else
797#endif
798
800 2.0
801 / (1.0
802 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
804 2.0
805 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
806
807 // Spatial interpolation and temporal extrapolation of macroscopic variables
808 // f(t+1) = 2*f(t) - f(t-1)
809 MFloat rho = 0.0;
810 std::array<MFloat, nDim> u{};
811
816 u[d] += 2.0 * m_interfaceChildren[level]->a[id].m_interpolationCoefficients[m]
817 * m_solver->a_variable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], d);
818 }
819 }
820
823 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
827 }
828 }
829
830 // Calculate all equilibrium distributions
831 std::array<MFloat, nDist> eqDist;
832 eqDist = m_solver->getEqDists(rho, u.data());
833
834 // interpolate and transform
836 // only the missing distributions
837#ifdef WAR_NVHPC_PSTL
839#else
841#endif
843 MFloat tmpDist1 = 0.0;
844
848 oppositeDist);
849 }
850
851 m_solver->a_oldDistribution(currentId, oppositeDist) =
853 }
854 }
855 });
856 }
857
858 //---------------------------
859 // if not in sync with parent: apply temporal interpolation
860 else {
863#ifdef WAR_NVHPC_PSTL
864 if(currentId >= noInternalCells) return;
865#else
867#endif
868
870 2.0
871 / (1.0
872 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
874 2.0
875 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
876
877 // spatial and temporal interpolation of variables
878 // f(t+1/2) = 1.5*f(t) - 0.5*f(t-1)
879 MFloat rho = 0;
880 std::array<MFloat, nDim> u{};
881
886 u[d] += 1.5 * m_interfaceChildren[level]->a[id].m_interpolationCoefficients[m]
887 * m_solver->a_variable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], d);
888 }
889 }
890
893 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
897 }
898 }
899
900 // Calculation of new distributions
901 std::array<MFloat, nDist> eqDist;
902 eqDist = m_solver->getEqDists(rho, u.data());
903 std::array<MFloat, nDist> forcing{};
904 getCellForcing(forcing, currentId);
905
906 // Transform and interpolate
908 // only for missing distributions
909#ifdef WAR_NVHPC_PSTL
911#else
913#endif
915 MFloat tmpDist1 = 0.0;
916 MFloat tmpDist2 = 0.0;
917
919 // add the weighted parts to the non-equilibrium distributions using linear temporal interpolation
920 // f(t+1/2) = 1/2*f(t) + 1/2*f(t+1)
922 * m_solver->a_oldDistribution(
924 if(m_solver->a_hasNeighbor(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], dist)) {
925 // the propagation on the coarse grid has not taken place yet,
926 // thus the incoming distribution for the coarse cell can be interpolated as follows 0.5*(tmpDist1 +
927 // tmpDist2)
931 * m_solver->a_distribution(neighborId, oppositeDist);
932 tmpDist2 += tmpDist;
933
934 // add forcing terms for coarse grid before transformation
935 // for tmpDist2 the forcing terms have already been updated
938 } else {
939 // if the interpolation neighbor has no neighbor in actual direction, no temporal interpolation can be
940 // applied this may only occur at a non-periodic boundary
941 tmpDist2 += tmpDist;
942
943 // forcing term is already included
944 tmpDist1 += tmpDist;
945 }
946 }
947
948 m_solver->a_oldDistribution(currentId, oppositeDist) =
949 (0.5 * (tmpDist1 + tmpDist2) - eqDist[oppositeDist]) * (omega_C / omega_F) * F1B2
950 + eqDist[oppositeDist];
951 }
952 }
953 });
954 } // end of else
955 }
956 }
957}
void getCellForcing(std::array< MFloat, nDist > &F, const MInt cellId=-1)
General accessor for potentially cell dependent forcing.
Definition: lbinterfacedxqy.h:135
◆ prolongationDupuisCompressible()
|
protected |
Definition at line 965 of file lbinterfacedxqy.cpp.
965 {
966 prolongationDupuis_<true>();
967}
◆ prolongationRohde()
|
protectedvirtual |
coarse to fine grid
outgoing distributions are handed over from parent to children
Definition at line 1416 of file lbinterfacedxqy.cpp.
1416 {
1417 std::array<MFloat, nDist> forcing{};
1418 getCellForcing(forcing);
1419
1421 level++) { // minLevel+level is the actual coarse resolution
1422 // minLevel+level+1 is the actual fine resolution
1423
1425 //-----------------------
1426 // intermittant prolongation
1432 // compensate collision on fine grid
1435 // remove forcing term
1438
1439 // reset outgoing distributions
1442 }
1443 // copy variables from parent
1445 m_solver->a_variable(m_solver->c_childId(currentId, m), var) = m_solver->a_variable(currentId, var);
1446 }
1447 }
1448 }
1449
1450 }
1451 //--------------------------
1452 // regular prolongation
1453 else {
1457
1458 // overwrite variables and distributions
1460 // hand over distributions
1465
1466 // add half of forcing term for coarse grid
1469 // remove half of forcing term for fine grid
1472 }
1473
1474 // copy variables from parent
1476 m_solver->a_variable(m_solver->c_childId(currentId, m), var) = m_solver->a_variable(currentId, var);
1477 }
1478 }
1479 }
1480 }
1481 }
1482 }
1483}
std::vector< Collector< LbParentCell > * > m_interfaceParents
Definition: lbinterface.h:55
◆ prolongationThermalDupuis()
|
protectedvirtual |
- Date
- 31.07.2012
- Todo:
- labels:LB This is currently not working properly, please use ROHDE method.
Definition at line 978 of file lbinterfacedxqy.cpp.
978 {
979 MFloat* ptr_m_interpolationCoefficients;
981
983 level++) { // minLevel+level is the actual coarse resolution
984 // minLevel+level+1 is the actual fine resolution
985
987 == 0) { // perform prolongation WITH temporal interpolation in every second timestep on finest level,
988 // in every fourth timestep on the next coarser level, and so on; starting from t = 2
989
990 //-----------------------------
991 // if in sync with parent:
993 == 0) { // perform prolongation WITHOUT temporal interpolation in every second timestep on finest level,
994 // in every fourth timestep on the next coarser level, and so on; starting from t = 1
995
999
1000 ptr_m_interpolationCoefficients = m_interfaceChildren[level]->a[id].m_interpolationCoefficients;
1001
1003 2.0
1004 / (1.0
1005 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
1007 2.0
1008 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
1010 / (1.0
1011 + factor * m_solver->a_kappa(currentId)
1014 2.0
1015 / (1.0
1016 + factor * m_solver->a_kappa(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
1017
1018 // Spatial interpolation and temporal extrapolation of macroscopic variables
1019 // f(t+1) = 2*f(t) - f(t-1)
1020 MFloat rho = 0.0;
1021 std::array<MFloat, nDim> u{};
1022 MFloat T = 0.0;
1023
1025 rho += 2.0 * ptr_m_interpolationCoefficients[m]
1026 * m_solver->a_variable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
1027 u[0] += 2.0 * ptr_m_interpolationCoefficients[m]
1029 u[1] += 2.0 * ptr_m_interpolationCoefficients[m]
1031 IF_CONSTEXPR(nDim == 3)
1032 u[2] += 2.0 * ptr_m_interpolationCoefficients[m]
1034 T += 2.0 * ptr_m_interpolationCoefficients[m]
1036 rho -= ptr_m_interpolationCoefficients[m]
1037 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
1038 u[0] -= ptr_m_interpolationCoefficients[m]
1039 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->U);
1040 u[1] -= ptr_m_interpolationCoefficients[m]
1041 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->V);
1042 IF_CONSTEXPR(nDim == 3)
1043 u[2] -= ptr_m_interpolationCoefficients[m]
1044 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->W);
1045 T -= ptr_m_interpolationCoefficients[m]
1046 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->T);
1047 }
1048
1049 // TODO labels:LB sysEqn: make PV primitive again (not storing rho*u)
1050 u[0] /= rho;
1051 u[1] /= rho;
1052 IF_CONSTEXPR(nDim == 3) u[2] /= rho;
1053
1054 std::array<MFloat, nDist> eqDist{};
1055 eqDist = m_solver->getEqDists(rho, u.data());
1056 std::array<MFloat, nDist> eqDistThermal{};
1057 eqDistThermal = m_solver->getEqDistsThermal(T, rho, u.data());
1058
1059 // interpolate and transform
1061 // only the missing distributions
1063 MFloat tmpDist1 = 0.0;
1064 MFloat tmpDist1T = 0.0;
1065
1067 tmpDist1 += ptr_m_interpolationCoefficients[m]
1070 tmpDist1T += ptr_m_interpolationCoefficients[m]
1071 * m_solver->a_oldDistributionThermal(
1073 }
1074
1081 }
1082 }
1083 }
1084 }
1085
1086 //---------------------------
1087 // if not in sync with parent: apply temporal interpolation
1088 else {
1091
1093
1094 ptr_m_interpolationCoefficients = m_interfaceChildren[level]->a[id].m_interpolationCoefficients;
1095
1097 2.0
1098 / (1.0
1099 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
1101 2.0
1102 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
1104 / (1.0
1105 + 6.0 * m_solver->a_kappa(currentId)
1108 2.0
1109 / (1.0
1110 + 6.0 * m_solver->a_kappa(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
1111
1112 // spatial and temporal interpolation of variables
1113 // f(t+1/2) = 1.5*f(t) - 0.5*f(t-1)
1114 MFloat rho = 0;
1115 std::array<MFloat, nDim> u{};
1116 MFloat T = 0.0;
1117
1119 rho += 1.5 * ptr_m_interpolationCoefficients[m]
1120 * m_solver->a_variable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
1121 u[0] += 1.5 * ptr_m_interpolationCoefficients[m]
1123 u[1] += 1.5 * ptr_m_interpolationCoefficients[m]
1125 IF_CONSTEXPR(nDim == 3)
1126 u[2] += 1.5 * ptr_m_interpolationCoefficients[m]
1128 T += 1.5 * ptr_m_interpolationCoefficients[m]
1130 rho -= 0.5 * ptr_m_interpolationCoefficients[m]
1131 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->RHO);
1132 u[0] -= 0.5 * ptr_m_interpolationCoefficients[m]
1133 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->U);
1134 u[1] -= 0.5 * ptr_m_interpolationCoefficients[m]
1135 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->V);
1136 IF_CONSTEXPR(nDim == 3)
1137 u[2] -= 0.5 * ptr_m_interpolationCoefficients[m]
1138 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->W);
1139 T -= 0.5 * ptr_m_interpolationCoefficients[m]
1140 * m_solver->a_oldVariable(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], PV->T);
1141 }
1142
1143 u[0] /= rho;
1144 u[1] /= rho;
1145 IF_CONSTEXPR(nDim == 3) u[2] /= rho;
1146
1147 std::array<MFloat, nDist> eqDist{};
1148 eqDist = m_solver->getEqDists(rho, u.data());
1149 std::array<MFloat, nDist> eqDistThermal{};
1150 eqDistThermal = m_solver->getEqDistsThermal(T, rho, u.data());
1151
1152 std::array<MFloat, nDist> forcing{};
1153 getCellForcing(forcing, currentId);
1154
1155 // Transform and interpolate
1157 // only for missing distributions
1159 MFloat tmpDist1 = 0.0;
1160 MFloat tmpDist2 = 0.0;
1161 MFloat tmpDist1T = 0.0;
1162 MFloat tmpDist2T = 0.0;
1163
1165 // add the weighted parts to the non-equilibrium distributions using linear temporal interpolation
1166 // f(t+1/2) = 1/2*f(t) + 1/2*f(t+1)
1167 if(m_solver->a_hasNeighbor(m_interfaceChildren[level]->a[id].m_interpolationNeighbors[m], dist)) {
1170
1171 // the propagation on the coarse grid has not taken place yet,
1172 // thus the incoming distribution for the coarse cell can be interpolated as follows 0.5*(tmpDist1 +
1173 // tmpDist2)
1174 tmpDist1 +=
1175 ptr_m_interpolationCoefficients[m] * m_solver->a_distribution(neighborId, Ld::oppositeDist(dist));
1176 tmpDist2 +=
1177 ptr_m_interpolationCoefficients[m]
1180 tmpDist1T += ptr_m_interpolationCoefficients[m]
1182 tmpDist2T +=
1183 ptr_m_interpolationCoefficients[m]
1184 * m_solver->a_oldDistributionThermal(
1186
1187 // add forcing terms for coarse grid before transformation
1188 // for tmpDist2 the forcing terms have already been updated
1192 }
1193
1194 // if the interpolation neighbor has no neighbor in actual direction, no temporal interpolation can be
1195 // applied this may only occur at a non-periodic boundary
1196 else {
1197 tmpDist2 +=
1198 ptr_m_interpolationCoefficients[m]
1201 tmpDist2T +=
1202 ptr_m_interpolationCoefficients[m]
1203 * m_solver->a_oldDistributionThermal(
1205
1206 // set tmpDist2=tmpDist1
1207 // forcing term is already included
1208 tmpDist1 = tmpDist2;
1209 tmpDist1T = tmpDist2T;
1210 }
1211 }
1212
1217 (0.5 * (tmpDist1T + tmpDist2T) - eqDistThermal[Ld::oppositeDist(dist)]) * (omegaT_C / omegaT_F) * F1B2
1219 }
1220 }
1221 }
1222 } // end of else
1223 }
1224 }
1225}
◆ prolongationThermalRohde()
|
protectedvirtual |
- Date
- 31.07.2012
Outgoing distributions are handed over from parent to children.
Definition at line 1494 of file lbinterfacedxqy.cpp.
1494 {
1495 std::array<MFloat, nDist> forcing{};
1496 getCellForcing(forcing);
1497
1499 level++) { // minLevel+level is the actual coarse resolution
1500 // minLevel+level+1 is the actual fine resolution
1501
1503 //-----------------------
1504 // intermittant prolongation
1509
1511 // compensate collision on fine grid
1514 // remove forcing term
1517
1518 // reset outgoing distributions
1523 }
1524 // copy variables from parent
1526 m_solver->a_variable(m_solver->c_childId(currentId, m), var) = m_solver->a_variable(currentId, var);
1527 }
1528 }
1529 }
1530
1531 }
1532 //--------------------------
1533 // regular prolongation
1534 else {
1538
1539 // overwrite variables and distributions
1541 // hand over distributions
1548
1549 // add half of forcing term for coarse grid
1552 // remove half of forcing term for fine grid
1555 }
1556
1557 // copy variables from parent
1559 m_solver->a_variable(m_solver->c_childId(currentId, m), var) = m_solver->a_variable(currentId, var);
1560 }
1561 }
1562 }
1563 }
1564 }
1565 }
1566}
◆ refineCell()
|
finaloverridevirtual |
Implements LbInterface< nDim >.
Definition at line 1695 of file lbinterfacedxqy.cpp.
◆ refineCellCopyPaste()
|
protectedvirtual |
Copy parent --> children
- Parameters
-
[in] parentId Solver cell id of parent that will be coarsen childIds: Solver ids of new children
Definition at line 1988 of file lbinterfacedxqy.cpp.
◆ refineCellDupuis()
|
protectedvirtual |
- interpolation
Definition at line 1714 of file lbinterfacedxqy.cpp.
1714 {
1715 // Halo cells are initialized by exchange
1716 // ToDo: This check is unnecessary by now
1717 // because this function should not be called for Halos anymore.
1719 // Find parent neighbors
1720 // ToDo: Check if c_neighbor of solver can be used. Should be possible now because
1721 // this function is calles at the end of reinitAfterAdaptation and c_neighbor is
1722 // updated before.
1723 MInt parentNeighbors[IPOW3[nDim] - 1];
1725 parentNeighbors[n] = m_solver->c_neighborId(parentId, n);
1726 }
1727
1730 const MFloat omega_F = 2.0 / (1.0 + 6.0 * m_solver->a_nu(parentId) * FFPOW2(dParentLevel - 1));
1732 std::array<MFloat, nDist> forcing{};
1733 getCellForcing(forcing);
1734
1735 // Parent and child level have done propagation in the last timestep and will do collision after this...
1737 // Loop over all children that are created by refining the cell
1739 if(childIds[child] < 0) continue;
1741
1743
1744 // Get position of child in parent
1745 MInt position = 0;
1748 position += 0;
1749 } else {
1750 position += IPOW2(dim);
1751 }
1752 }
1753
1754 // Set interpolation neighbors
1755 // All interpolation neighbors are on parent level
1759 if(dir < IPOW3[nDim] - 1) {
1760 interpolationNeighbors[k] = parentNeighbors[dir];
1761 } else {
1762 interpolationNeighbors[k] = parentId;
1763 }
1764 }
1765 // Set interpolation coefficients
1768 interpolationCoefficients[k] = Ld::linearInterpolationCoefficients(position, k);
1769 }
1770
1771 MFloat rho = 0;
1772 std::array<MFloat, nDim> u{};
1773 MFloat rhoOld = 0;
1774 std::array<MFloat, nDim> uOld{};
1775
1776 // Spatial interpolation
1780
1781 // Macroscopic vars at t
1785 }
1786
1787 // Macroscopic vars at t-1
1791 }
1792 }
1793
1794 // Temporal extrapolation: f(t+1) = 2*f(t) - f(t-1)
1795 // Needed for initialization of oldDistribution
1797 std::array<MFloat, nDim> u_tp1{};
1799 u_tp1[d] = 2 * u[d] - uOld[d];
1800 }
1801
1802 // Temporal extrapolation: f(t+1/2) = 1.5*f(t) - 0.5*f(t-1)
1803 // Needed for initialization of macroscopic variables
1804 MFloat rho_tp12 = 1.5 * rho - 0.5 * rhoOld;
1805 std::array<MFloat, nDim> u_tp12{};
1807 u_tp12[d] = 1.5 * u[d] - 0.5 * uOld[d];
1808 }
1809
1810 // Setting macroscopic variables in child cell
1814 }
1818 }
1819
1820 // Calculate all equilibrium distribution for tp1
1821 std::array<MFloat, nDist> eqDist_tp1{};
1822 eqDist_tp1 = m_solver->getEqDists(rho_tp1, u_tp1.data());
1823
1824 // Transform and interpolate all distributions
1826 MFloat tmpDist = 0.0;
1828 tmpDist += interpolationCoefficients[m] * m_solver->a_oldDistribution(interpolationNeighbors[m], dist);
1829 }
1830
1831 // Distribution before next collision
1834
1835 // All cells need to perform collision step next to initialize this variable
1837 }
1838 }
1839 } else {
1840 // Loop over all children that are created by refining the cell
1842 if(childIds[child] < 0) continue;
1844
1846
1847 // Get position of child in parent
1848 MInt position = 0;
1851 position += 0;
1852 } else {
1853 position += IPOW2(dim);
1854 }
1855 }
1856
1857 // Set interpolation neighbors
1858 // All interpolation neighbors are on parent level
1862 if(dir < IPOW3[nDim] - 1) {
1863 interpolationNeighbors[k] = parentNeighbors[dir];
1864 } else {
1865 interpolationNeighbors[k] = parentId;
1866 }
1867 }
1868 // Set interpolation coefficients
1871 interpolationCoefficients[k] = Ld::linearInterpolationCoefficients(position, k);
1872 }
1873
1874 MFloat rho = 0;
1875 std::array<MFloat, nDim> u{};
1876 MFloat rhoOld = 0;
1877 std::array<MFloat, nDim> uOld{};
1878
1879 // Spatial interpolation
1883
1884 // Macroscopic vars at t
1888 }
1889
1890 // Macroscopic vars at t-1
1894 }
1895 }
1896
1897 // Temporal extrapolation: f(t+1/2) = 1.5*f(t) - 0.5*f(t-1)
1898 // Needed for initialization of oldDistribution
1900 std::array<MFloat, nDim> u_tp1{};
1902 u_tp1[d] = 1.5 * u[d] - 0.5 * uOld[d];
1903 }
1904
1905 // Temporal extrapolation: f(t-1/2) = 0.5*f(t) + 0.5*f(t-1)
1906 // Needed for initialization of macroscopic variables
1907 MFloat rho_tp12 = 0.5 * rho + 0.5 * rhoOld;
1908 std::array<MFloat, nDim> u_tp12{};
1910 u_tp12[d] = 0.5 * u[d] + 0.5 * uOld[d];
1911 }
1912
1913 // Setting macroscopic variables in child cell
1917 }
1921 }
1922
1923 // Calculate all equilibrium distribution for tp1
1924 std::array<MFloat, nDist> eqDist_tp1{};
1925 eqDist_tp1 = m_solver->getEqDists(rho_tp1, u_tp1.data());
1926
1927 // Transform and interpolate all distributions
1928 MFloat sumOfOldDist = F0;
1931
1934 propagateNeighborValue = true;
1935 }
1936 }
1937
1938 if(propagateNeighborValue) {
1942 } else {
1943 MFloat tmpDist1 = 0.0;
1944 MFloat tmpDist2 = 0.0;
1946 MFloat tmpDist =
1949 const MInt neighborId = m_solver->c_neighborId(interpolationNeighbors[m], Ld::oppositeDist(dist));
1951 tmpDist1 += interpolationCoefficients[m] * FPOW2(m_solver->maxLevel() - m_solver->a_level(childId) + 1)
1952 * forcing[dist];
1953 tmpDist2 += tmpDist;
1954 } else {
1955 // if the interpolation neighbor has no neighbor in actual direction, no temporal interpolation can be
1956 // applied this may only occur at a non-periodic boundary
1957 tmpDist2 += tmpDist;
1958 tmpDist1 += tmpDist;
1959 }
1960 }
1961
1962 // Distribution before next collision
1964 (0.5 * (tmpDist1 + tmpDist2) - eqDist_tp1[dist]) * (omega_C / omega_F) * F1B2 + eqDist_tp1[dist];
1965 }
1966
1967 // All cells need to perform collision step next to initialize this variable
1969
1971 }
1972 // Dont forget the rest distribution
1975 }
1976 }
1977 }
1978}
static constexpr MInt intNghbrArray(MInt i, MInt j)
Definition: lblatticedescriptor.h:265
static constexpr MFloat linearInterpolationCoefficients(MInt i, MInt j)
Definition: lblatticedescriptor.h:266
◆ removeChildren()
|
finaloverridevirtual |
Implements LbInterface< nDim >.
Definition at line 1700 of file lbinterfacedxqy.cpp.
1700 {
1701 (this->*fRemoveChildren)(parentId);
1702}
RemoveChildrenFunction fRemoveChildren
Definition: lbinterfacedxqy.h:107
◆ removeChildsCopyPaste()
|
protectedvirtual |
Average children --> parent
- Parameters
-
[in] parentId Solver cell id of parent that will be coarsen
Definition at line 2011 of file lbinterfacedxqy.cpp.
2011 {
2013 std::array<MFloat, nDist> forcing{};
2014 getCellForcing(forcing);
2015
2016 // Get children that are to remove
2019 children[m] = m_solver->c_childId(parentId, m);
2020 }
2021
2030 for(MInt i = 0; i < nDist; i++) {
2031 m_solver->a_distribution(parentId, i) = 0.0;
2032 m_solver->a_oldDistribution(parentId, i) = 0.0;
2033 }
2034
2035 // Spatial interpolation: Average all child values
2037 m_solver->a_variable(parentId, PV->RHO) += FFPOW2(nDim) * m_solver->a_variable(children[m], PV->RHO);
2038 m_solver->a_variable(parentId, PV->U) += FFPOW2(nDim) * m_solver->a_variable(children[m], PV->U);
2039 m_solver->a_variable(parentId, PV->V) += FFPOW2(nDim) * m_solver->a_variable(children[m], PV->V);
2040 IF_CONSTEXPR(nDim == 3)
2041 m_solver->a_variable(parentId, PV->W) += FFPOW2(nDim) * m_solver->a_variable(children[m], PV->W);
2042 m_solver->a_oldVariable(parentId, PV->RHO) += FFPOW2(nDim) * m_solver->a_oldVariable(children[m], PV->RHO);
2043 m_solver->a_oldVariable(parentId, PV->U) += FFPOW2(nDim) * m_solver->a_oldVariable(children[m], PV->U);
2044 m_solver->a_oldVariable(parentId, PV->V) += FFPOW2(nDim) * m_solver->a_oldVariable(children[m], PV->V);
2045 IF_CONSTEXPR(nDim == 3)
2046 m_solver->a_oldVariable(parentId, PV->W) += FFPOW2(nDim) * m_solver->a_oldVariable(children[m], PV->W);
2047 for(MInt i = 0; i < nDist; i++) {
2048 m_solver->a_distribution(parentId, i) += FFPOW2(nDim) * m_solver->a_distribution(children[m], i);
2049 m_solver->a_oldDistribution(parentId, i) += FFPOW2(nDim) * m_solver->a_oldDistribution(children[m], i);
2050 }
2051 }
2052 }
2053}
◆ removeChildsDupuisFilippova()
|
protectedvirtual |
- average
- temporal extrapolation
- Dupuis if propagation is in-sync
- Parameters
-
[in] parentId Solver cell id of parent that will be coarsen
Definition at line 2065 of file lbinterfacedxqy.cpp.
2065 {
2069
2070 // Relaxation paramter for parent and child refinement level
2073 std::array<MFloat, nDist> forcing{};
2074 getCellForcing(forcing);
2075
2076 // Get children that are to remove
2079 children[m] = m_solver->c_childId(parentId, m);
2080 }
2081
2082 // Parent and child level have done propagation in the last timestep and will do collision after this...
2084 MFloat rho = F0;
2085 MFloat u[nDim] = {F0};
2086 MFloat rhoOld = F0;
2087 MFloat uOld[nDim] = {F0};
2088 MFloat rho_tp1 = F0;
2089 MFloat u_tp1[nDim] = {F0};
2090 MFloat rho_tm3 = F0;
2091 MFloat u_tm3[nDim] = {F0};
2092
2093 // Spatial interpolation: Sum up all child values
2095 // Macroscopic variables at time t
2099 }
2100 // Macroscopic variables at time t-1
2104 }
2105 }
2106
2107 // Temporal extrapolation: f(t+1) = 2*f(t) - f(t-1)
2108 // Needed for initialization of old distribution
2109 rho_tp1 = 2 * rho - rhoOld;
2111 u_tp1[d] = 2 * u[d] - uOld[d];
2112 }
2113
2114 // Temporal extrapolation: f(t-3) = 3*f(t-1) - 2*f(t)
2115 // Needed for initialization of macroscopic variables
2116 rho_tm3 = 3 * rhoOld - 2 * rho;
2118 u_tm3[d] = 3 * uOld[d] - 2 * u[d];
2119 }
2120
2121 // Setting macroscopic variables on parent level
2125 }
2129 }
2130
2131 // Calculate equilibrium for time t+1
2132 std::array<MFloat, nDist> eqDistTp1{};
2133 eqDistTp1 = m_solver->getEqDists(rho_tp1, u_tp1);
2134
2135 // Transform and interpolate post-propagation distributions according to DUPUIS
2137 // Calculate mean distribution from all children
2138 MFloat tmpDist = 0.0;
2141 }
2142
2145
2146 // Cell need to perform collision step next to initialize this variable
2148 }
2149 } else {
2150 MFloat rho{};
2151 std::array<MFloat, nDim> u{};
2152 MFloat rho_tm1{};
2153 std::array<MFloat, nDim> u_tm1{};
2154
2155 // Spatial interpolation: Sum up all child values
2157 // Macroscopic variables at time t
2161 }
2162 // Macroscopic variables at time t-1
2166 }
2167 }
2168
2169 // Temporal (backward) extrapolation f(t-2) = 2*f(t-1) - f(t)
2170 MFloat rho_tm2{};
2171 std::array<MFloat, nDim> u_tm2{};
2172 rho_tm2 = 2 * rho_tm1 - 1 * rho;
2174 u_tm2[d] = 2 * u_tm1[d] - 1 * u[d];
2175 }
2176
2177 // Setting macroscopic variables for parent cell
2181 }
2185 }
2186
2187 // Calculate equilibirum for time t
2188 std::array<MFloat, nDist> eqDist{};
2189 eqDist = m_solver->getEqDists(rho, u.data());
2190
2191 // Transform and interpolate post-collision distributions according to FILIPPOVA
2195 // Calculate mean distribution from all children
2196 MFloat tmpDist = 0.0;
2199 }
2200
2203
2205 }
2206 }
2207 }
2208}
◆ restriction()
| void LbInterfaceDxQy< nDim, nDist, SysEqn >::restriction |
Definition at line 132 of file lbinterfacedxqy.cpp.
◆ restriction0()
|
inlineprotectedvirtual |
Definition at line 59 of file lbinterfacedxqy.h.
59{};
◆ restriction10()
|
protectedvirtual |
fine to coarse grid
average all child cell values and add appropriate non-eq parts
Definition at line 602 of file lbinterfacedxqy.cpp.
602 {
607
609 level++) { // level is the actual coarse resolution
610 // level+1 is the actual fine resolution
611
613 == 0) { // perform restriction from finest level in every second timestep,
614 // on the next coarser level every fourth timestep, and so on; starting from t = 1
615
619
620 // omega_F = 2.0 / ( 1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel()
621 // - level - 1));
623 2.0 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
624
625 MFloat rho = 0;
626 std::array<MFloat, nDim> u{};
627
628 //------------------------------------------------------------------------------------
629 // temporal extrapolation of the mean macroscopic variables and the mean stress tensor of all child cells
630 // f(t+1) = 2*f(t) - f(t-1)
631
636 IF_CONSTEXPR(nDim == 3)
638 }
643 IF_CONSTEXPR(nDim == 3)
645 }
646
647 // compute strain rate tensor on coarse grid: (du/dx)_coarse = 2*(du/dx)_fine
648 IF_CONSTEXPR(nDim == 3) {
650 // du[j]/dx
651 c[j] = 2.0 * F1B4 * rho * 2.0
660 // du[j]/dy
661 c[j + 3] = 2.0 * F1B4 * rho * 2.0
670 // du[j]/dz
671 c[j + 6] = 2.0 * F1B4 * rho * 2.0
680 }
681
683 // du[j]/dx
684 c[j] -= 1.0 * F1B4 * rho * 2.0
693 // du[j]/dy
694 c[j + 3] -= 1.0 * F1B4 * rho * 2.0
703 // du[j]/dz
704 c[j + 6] -= 1.0 * F1B4 * rho * 2.0
713 }
714 trace = c[0] + c[4] + c[8];
715 }
716 else {
717 cout << "Strain rate tensor not implemented for 2D yet" << endl;
718 trace = F0;
719 }
720 //------------------------------------------------------------------------------------
721
722
723 // set parent values to averaged child values for subsequent prolongation
728
729 tmp2 = F0;
730 for(MInt d = 0; d < nDim; d++) {
731 tmp2 += (u[d] * u[d]);
732 b[2 * d] = -u[d];
733 b[2 * d + 1] = u[d];
734 }
735
736 std::array<MFloat, nDist> eqDist;
737 eqDist = m_solver->getEqDists(rho, tmp2, u.data());
738
739 // create new incoming distributions
741 // only the missing distributions
746
747 // put together eq-part and rescaled non-eq part; scale factor = (omega_C/omega_F) * F1B2
748
750
755 }
756 }
757 }
758 }
759 }
760 }
761 }
762}
MFloat m_static_restriction10_c[nDim *nDim]
Definition: lbinterfacedxqy.h:123
MFloat m_static_restriction10_trace
Definition: lbinterfacedxqy.h:124
MFloat m_static_restriction10_tmp2
Definition: lbinterfacedxqy.h:121
MFloat m_static_restriction10_b[2 *nDim]
Definition: lbinterfacedxqy.h:122
◆ restrictionDupuis()
|
protectedvirtual |
Definition at line 1310 of file lbinterfacedxqy.cpp.
1310 {
1311 restrictionDupuis_<false>();
1312}
◆ restrictionDupuis_()
template<MBool compressible>
|
protected |
average all child cell values and transform the non-eq parts according to Dupuis et al.
Definition at line 1235 of file lbinterfacedxqy.cpp.
1235 {
1236 TRACE();
1237
1238#ifdef WAR_NVHPC_PSTL
1240#endif
1241
1243 level++) { // level is the actual coarse resolution
1244 // level+1 is the actual fine resolution
1245
1252
1253
1255 == 0) { // perform restriction from finest level in every second timestep,
1256 // on the next coarser level every fourth timestep, and so on; starting from t = 1
1257
1260#ifdef WAR_NVHPC_PSTL
1261 if(currentId >= noInternalCells) return;
1262#else
1264#endif
1265
1266 MFloat rho = 0;
1267 std::array<MFloat, nDim> u{};
1268
1269 // temporal extrapolated mean of the macroscopic variables of the child cells
1270 // f(t+1) = 2*f(t) - f(t-1)
1273 rho += FFPOW2(nDim)
1274 * (2.0 * m_solver->a_variable(childCellId, PV->RHO) - m_solver->a_oldVariable(childCellId, PV->RHO));
1276 u[n] +=
1277 FFPOW2(nDim) * (2.0 * m_solver->a_variable(childCellId, n) - m_solver->a_oldVariable(childCellId, n));
1278 }
1279 }
1280
1281 std::array<MFloat, nDist> eqDist;
1282 eqDist = m_solver->getEqDists(rho, u.data());
1283
1284 // Interpolate missing distributions
1286#ifdef WAR_NVHPC_PSTL
1288#else
1290#endif
1293 // Calculate mean distribution from all children
1294 MFloat tmpDist = 0.0;
1296 tmpDist += FFPOW2(nDim) * m_solver->a_oldDistribution(m_solver->c_childId(currentId, m), dist);
1297 }
1298
1299 // transform distribution
1302 }
1303 }
1304 });
1305 }
1306 }
1307}
◆ restrictionDupuisCompressible()
|
protected |
Definition at line 1315 of file lbinterfacedxqy.cpp.
1315 {
1316 restrictionDupuis_<true>();
1317}
◆ restrictionRohde()
|
protectedvirtual |
fine to coarse grid
missing incoming distributions of parent are filled with average child cell values
Definition at line 1576 of file lbinterfacedxqy.cpp.
1576 {
1577 std::array<MFloat, nDist> forcing{};
1578 getCellForcing(forcing);
1579
1581 level++) { // minLevel+level is the actual coarse resolution
1582 // minLevel+level+1 is the actual fine resolution
1583
1589
1594
1598 }
1599
1600 // add half of forcing term for fine grid
1603 // compensate half of forcing term for coarse grid
1606 }
1607 }
1608 }
1609 }
1610 }
1611}
◆ restrictionThermalDupuis()
|
protectedvirtual |
- Date
- 31.07.2012
- Todo:
- labels:LB This is currently not working properly, please use ROHDE method instead.
Definition at line 1328 of file lbinterfacedxqy.cpp.
1328 {
1331 level++) { // level is the actual coarse resolution
1332 // level+1 is the actual fine resolution
1333
1335 == 0) { // perform restriction from finest level in every second timestep,
1336 // on the next coarser level every fourth timestep, and so on; starting from t = 1
1337
1341
1343 2.0
1344 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level - 1));
1346 2.0 / (1.0 + 6.0 * m_solver->a_nu(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
1348 / (1.0
1349 + factor * m_solver->a_kappa(currentId)
1352 2.0
1353 / (1.0
1354 + factor * m_solver->a_kappa(currentId) * FFPOW2(m_solver->maxLevel() - m_solver->minLevel() - level));
1355
1356 MFloat rho = F0;
1357 std::array<MFloat, nDim> u{};
1358 MFloat T = F0;
1359
1360 // temporal extrapolated mean of the macroscopic variables of the child cells
1361 // f(t+1) = 2*f(t) - f(t-1)
1366 IF_CONSTEXPR(nDim == 3)
1372 IF_CONSTEXPR(nDim == 3)
1375 }
1376
1377 for(MInt d = 0; d < nDim; d++) {
1378 u[d] /= rho;
1379 }
1380
1381 std::array<MFloat, nDist> eqDist{};
1382 eqDist = m_solver->getEqDists(rho, u.data());
1383 std::array<MFloat, nDist> eqDistThermal{};
1384 eqDistThermal = m_solver->getEqDistsThermal(T, rho, u.data());
1385
1386 // Interpolate missing distributions
1390 // Calculate mean distribution from all children
1391 MFloat tmpDist = 0.0;
1392 MFloat tmpDistT = 0.0;
1394 tmpDist += FFPOW2(nDim) * m_solver->a_oldDistribution(m_solver->c_childId(currentId, m), dist);
1395 tmpDistT += FFPOW2(nDim) * m_solver->a_oldDistributionThermal(m_solver->c_childId(currentId, m), dist);
1396 }
1397
1398 // transform distribution
1403 }
1404 }
1405 }
1406 }
1407 }
1408}
◆ restrictionThermalRohde()
|
protectedvirtual |
- Date
- 31.07.2012
Missing incoming distributions of parent are filled with average child cell values.
Definition at line 1622 of file lbinterfacedxqy.cpp.
1622 {
1623 std::array<MFloat, nDist> forcing{};
1624 getCellForcing(forcing);
1625
1627 level++) { // minLevel+level is the actual coarse resolution
1628 // minLevel+level+1 is the actual fine resolution
1629
1635
1641
1647 }
1648
1649 // add half of forcing term for fine grid
1652 // compensate half of forcing term for coarse grid
1655 }
1656 }
1657 }
1658 }
1659 }
1660}
◆ setAdaptationFunctions()
|
private |
Definition at line 1670 of file lbinterfacedxqy.cpp.
1670 {
1671 TRACE();
1672
1674 // Default property value
1678 break;
1679 }
1683 break;
1684 }
1685 default: {
1686 stringstream errorMessage;
1687 errorMessage << " LbInterface::setAdaptationFunctions: Specified interface condition: " << m_adaptationInitMethod
1688 << " does not exist. Exiting!";
1689 mTerm(1, AT_, errorMessage.str());
1690 }
1691 }
1692}
virtual void removeChildsDupuisFilippova(const MInt parentId)
Initialize parent variables from children.
Definition: lbinterfacedxqy.cpp:2065
virtual void refineCellDupuis(const MInt parentId, const MInt *childIds)
Initialize child variables from parent.
Definition: lbinterfacedxqy.cpp:1714
virtual void refineCellCopyPaste(const MInt parentId, const MInt *childIds)
Initialize child variables from parent.
Definition: lbinterfacedxqy.cpp:1988
virtual void removeChildsCopyPaste(const MInt parentId)
Initialize parent variables from children.
Definition: lbinterfacedxqy.cpp:2011
MInt string2enum(MString theString)
This global function translates strings in their corresponding enum values (integer values)....
Definition: enums.cpp:20
void mTerm(const MInt errorCode, const MString &location, const MString &message)
Definition: functions.cpp:29
◆ setInterfaceFunctions()
|
private |
Definition at line 78 of file lbinterfacedxqy.cpp.
78 {
79 TRACE();
80
82 // Default property value
90 } else {
93 }
94 break;
95 }
100 } else {
103 }
104 break;
105 }
106
107 default: {
108 stringstream errorMessage;
109 errorMessage << " LbInterface::setInterfaceFunctions: Specified interface condition: " << m_interfaceMethod
110 << " does not exist. Exiting!";
111 mTerm(1, AT_, errorMessage.str());
112 }
113 }
114}
virtual void restrictionThermalRohde()
Fine to coarse grid fot thermal LB.
Definition: lbinterfacedxqy.cpp:1622
virtual void prolongationThermalRohde()
Coarse to fine grid for thermal LB.
Definition: lbinterfacedxqy.cpp:1494
virtual void restrictionDupuis()
Definition: lbinterfacedxqy.cpp:1310
virtual void prolongationRohde()
Definition: lbinterfacedxqy.cpp:1416
void prolongationDupuisCompressible()
Definition: lbinterfacedxqy.cpp:965
virtual void prolongationDupuis()
Definition: lbinterfacedxqy.cpp:960
virtual void restrictionRohde()
Definition: lbinterfacedxqy.cpp:1576
virtual void prolongationThermalDupuis()
Coarse to fine grid for thermal LB.
Definition: lbinterfacedxqy.cpp:978
virtual void restrictionThermalDupuis()
Fine to coarse grid for thermal LB.
Definition: lbinterfacedxqy.cpp:1328
void restrictionDupuisCompressible()
Definition: lbinterfacedxqy.cpp:1315
Friends And Related Function Documentation
◆ LbSolverDxQy
|
friend |
Definition at line 25 of file lbinterfacedxqy.h.
Member Data Documentation
◆ fProlongation
|
private |
Definition at line 97 of file lbinterfacedxqy.h.
◆ fRefineCell
|
private |
Definition at line 104 of file lbinterfacedxqy.h.
◆ fRemoveChildren
|
private |
Definition at line 107 of file lbinterfacedxqy.h.
◆ fRestriction
|
private |
Definition at line 98 of file lbinterfacedxqy.h.
◆ m_solver
| LbSolverDxQy<nDim, nDist, SysEqn>* LbInterfaceDxQy< nDim, nDist, SysEqn >::m_solver |
Definition at line 44 of file lbinterfacedxqy.h.
◆ m_static_prolongation10_b
|
private |
Definition at line 115 of file lbinterfacedxqy.h.
◆ m_static_prolongation10_c
|
private |
Definition at line 116 of file lbinterfacedxqy.h.
◆ m_static_prolongation10_tmp
|
private |
Definition at line 113 of file lbinterfacedxqy.h.
◆ m_static_prolongation10_tmp2
|
private |
Definition at line 114 of file lbinterfacedxqy.h.
◆ m_static_prolongation10_tmpDistId
|
private |
Definition at line 118 of file lbinterfacedxqy.h.
◆ m_static_prolongation10_trace
|
private |
Definition at line 117 of file lbinterfacedxqy.h.
◆ m_static_restriction10_b
|
private |
Definition at line 122 of file lbinterfacedxqy.h.
◆ m_static_restriction10_c
|
private |
Definition at line 123 of file lbinterfacedxqy.h.
◆ m_static_restriction10_tmp
|
private |
Definition at line 120 of file lbinterfacedxqy.h.
◆ m_static_restriction10_tmp2
|
private |
Definition at line 121 of file lbinterfacedxqy.h.
◆ m_static_restriction10_tmpDistId
|
private |
Definition at line 125 of file lbinterfacedxqy.h.
◆ m_static_restriction10_trace
|
private |
Definition at line 124 of file lbinterfacedxqy.h.
The documentation for this class was generated from the following files:
- /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LB/lbinterfacedxqy.h
- /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/LB/lbinterfacedxqy.cpp
