MAIA bb96820c
Multiphysics at AIA
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
Bc1601Class< nDim > Class Template Reference

#include <fvcartesianbndrycndxd.h>

Public Member Functions

 Bc1601Class (MPI_Comm &communicator, const MInt m_solverId, const MInt domainId, MFloat &u_total, MFloat &invSigmaSponge)
 
 ~Bc1601Class ()
 
void calculateFlucts (const MFloat that, const MFloat xhat, const MFloat yhat, const MFloat zhat, MFloat *fluctChol)
 
void checkRegeneration (const MFloat time)
 

Public Attributes

MFloat m_l_b
 
MFloat m_v_b
 
MFloat m_tau_b
 
MFloat m_invSigmaSponge
 

Private Member Functions

void generateAndCommRandomNumbers ()
 Bc1601Class functions: More...
 
MBool loadRandomNumbers ()
 

Private Attributes

MInt m_oldMode
 
MBool m_commValues
 
MBool m_useUnif
 
MInt m_noOfModes
 
MBool m_regenerateSeeding
 
MInt m_regenerationInterval
 
MInt m_regenerationCounter
 
std::mt19937 randNumGen
 
MPI_Comm m_comm_bc1601
 
MInt m_rank_bc1601 {}
 
const MInt m_domainId
 
MFloat * m_omega = nullptr
 
MFloat * m_p1 = nullptr
 
MFloat * m_p2 = nullptr
 
MFloat * m_p3 = nullptr
 
MFloat * m_q1 = nullptr
 
MFloat * m_q2 = nullptr
 
MFloat * m_q3 = nullptr
 
MFloat * m_dhat1 = nullptr
 
MFloat * m_dhat2 = nullptr
 
MFloat * m_dhat3 = nullptr
 
MFloat uuref
 
MFloat uvref
 
MFloat uwref
 
MFloat vvref
 
MFloat vwref
 
MFloat wwref
 
MFloat * aa = nullptr
 
MBool smirnov
 
MFloat eigvec [3][3] {}
 
MFloat c1
 
MFloat c2
 
MFloat c3
 

Detailed Description

template<MInt nDim>
class Bc1601Class< nDim >

Definition at line 49 of file fvcartesianbndrycndxd.h.

Constructor & Destructor Documentation

◆ Bc1601Class()

template<MInt nDim>
Bc1601Class< nDim >::Bc1601Class ( MPI_Comm &  communicator,
const MInt  m_solverId,
const MInt  domainId,
MFloat &  u_total,
MFloat &  invSigmaSponge 
)

◆ ~Bc1601Class()

template<MInt nDim>
Bc1601Class< nDim >::~Bc1601Class

Definition at line 6531 of file fvcartesianbndrycndxd.cpp.

6531 {
6532 mDeallocate(aa);
6533 mDeallocate(m_omega);
6534 mDeallocate(m_p1);
6535 mDeallocate(m_p2);
6536 mDeallocate(m_p3);
6537 mDeallocate(m_q1);
6538 mDeallocate(m_q2);
6539 mDeallocate(m_q3);
6540 mDeallocate(m_dhat1);
6541 mDeallocate(m_dhat2);
6542 mDeallocate(m_dhat3);
6543}
mDeallocate
MBool mDeallocate(T *&a)
deallocates the memory previously allocated for element 'a'
Definition: alloc.h:544

Member Function Documentation

◆ calculateFlucts()

template<MInt nDim>
void Bc1601Class< nDim >::calculateFlucts ( const MFloat  that,
const MFloat  xhat,
const MFloat  yhat,
const MFloat  zhat,
MFloat *  fluctChol 
)

Definition at line 6547 of file fvcartesianbndrycndxd.cpp.

6548 {
6549 MFloat xfluct = 0.0;
6550 MFloat yfluct = 0.0;
6551 MFloat zfluct = 0.0;
6552 MFloat tmpVar;
6553 MFloat B;
6554 MFloat D;
6555
6556 // -----------------------------------------
6557 // Beginning of Shin's modification
6558 //
6559 if(smirnov == 1) {
6560 MFloat xx;
6561 MFloat yy;
6562 MFloat zz;
6563
6564 for(MInt n = 0; n < m_noOfModes; n++) {
6565 // Counter-rotate the coordinate
6566 // * eigvec, c1, c2, c3 are defined in fvbndrycndxd.h
6567 // and evaluated in Bc1601Class::Bc1601Class
6568 xx = eigvec[0][0] * (xhat - that) + eigvec[1][0] * yhat + eigvec[2][0] * zhat;
6569 yy = eigvec[0][1] * (xhat - that) + eigvec[1][1] * yhat + eigvec[2][1] * zhat;
6570 zz = eigvec[0][2] * (xhat - that) + eigvec[1][2] * yhat + eigvec[2][2] * zhat;
6571
6572 // Here the anisotropic scaling is applied through c1, c2, and c3.
6573 tmpVar = m_dhat1[n] / c1 * xx + m_dhat2[n] / c2 * yy + m_dhat3[n] / c3 * zz;
6574 B = cos(tmpVar);
6575 D = sin(tmpVar);
6576
6577 xfluct += m_p1[n] * B + m_q1[n] * D;
6578 yfluct += m_p2[n] * B + m_q2[n] * D;
6579 zfluct += m_p3[n] * B + m_q3[n] * D;
6580 }
6581 } else {
6582 for(MInt n = 0; n < m_noOfModes; n++) {
6583 tmpVar = m_dhat1[n] * xhat + m_dhat2[n] * yhat + m_dhat3[n] * zhat + m_omega[n] * that;
6584
6585 B = cos(tmpVar);
6586 D = sin(tmpVar);
6587
6588 xfluct += m_p1[n] * B + m_q1[n] * D;
6589 yfluct += m_p2[n] * B + m_q2[n] * D;
6590 zfluct += m_p3[n] * B + m_q3[n] * D;
6591 }
6592 }
6593 //
6594 // End of Shin's modification
6595 // -----------------------------------------
6596
6597
6598 if(m_noOfModes > 0) {
6599 xfluct *= sqrt(2.0 / ((MFloat)m_noOfModes));
6600 yfluct *= sqrt(2.0 / ((MFloat)m_noOfModes));
6601 zfluct *= sqrt(2.0 / ((MFloat)m_noOfModes));
6602 } else {
6603 xfluct = 0.0;
6604 yfluct = 0.0;
6605 zfluct = 0.0;
6606 }
6607
6608 // -----------------------------------------------
6609 // Beginning of Shin's modification
6610 // Need to apply scaling and rotation by
6611 // eigenvalues and eigenvectors
6612 if(smirnov == 1) {
6613 MFloat w1;
6614 MFloat w2;
6615 MFloat w3;
6616
6617 w1 = c1 * xfluct; // w1, w2, w3 are defined locally
6618 w2 = c2 * yfluct; // c1, c2, c3 are defined in fvbndrycndxd.h
6619 w3 = c3 * zfluct;
6620
6621 // The following fluctChol means fluctuation by Smirnov's method.
6622 // * Lazy to change the variable names.
6623 // * eigvec are defined in fvbndrycndxd.h
6624 // and evaluated in Bc1601Class::Bc1601Class
6625 fluctChol[0] = eigvec[0][0] * w1 + eigvec[0][1] * w2 + eigvec[0][2] * w3;
6626 fluctChol[1] = eigvec[1][0] * w1 + eigvec[1][1] * w2 + eigvec[1][2] * w3;
6627 fluctChol[2] = eigvec[2][0] * w1 + eigvec[2][1] * w2 + eigvec[2][2] * w3;
6628
6629 } else {
6630 fluctChol[0] = xfluct * aa[0];
6631 fluctChol[1] = xfluct * aa[1] + yfluct * aa[3];
6632 fluctChol[2] = xfluct * aa[2] + yfluct * aa[4] + zfluct * aa[5];
6633 }
6634 // End of Shin's modification
6635 // -----------------------------------------------
6636}
Bc1601Class::eigvec
MFloat eigvec[3][3]
Definition: fvcartesianbndrycndxd.h:87
MInt
int32_t MInt
Definition: maiatypes.h:62
MFloat
double MFloat
Definition: maiatypes.h:52
maia::filter::slope::cos
T cos(const T a, const T b, const T x)
Cosine slope filter.
Definition: filter.h:125

◆ checkRegeneration()

template<MInt nDim>
void Bc1601Class< nDim >::checkRegeneration ( const MFloat  time)

Definition at line 6639 of file fvcartesianbndrycndxd.cpp.

6639 { // time = m_solver->m_time / m_bc1601->m_tau_b;
6640 if(m_regenerateSeeding) {
6641 MInt dummy = floor(time / m_regenerationInterval);
6642 if(dummy > m_regenerationCounter) {
6643 m_regenerationCounter = dummy;
6644 generateAndCommRandomNumbers();
6645 }
6646 }
6647}
Bc1601Class::generateAndCommRandomNumbers
void generateAndCommRandomNumbers()
Bc1601Class functions:
Definition: fvcartesianbndrycndxd.cpp:5991

◆ generateAndCommRandomNumbers()

template<MInt nDim>
void Bc1601Class< nDim >::generateAndCommRandomNumbers
private

Definition at line 5991 of file fvcartesianbndrycndxd.cpp.

5991 {
5992 if(loadRandomNumbers()) return;
5993
5994 m_log << " generate Random Numbers ..." << endl;
5995
5996 // obtain random numbers from Mersenne Twister and calculate derived values
5997 MFloat d1;
5998 MFloat d2;
5999 MFloat d3;
6000 MFloat xi1;
6001 MFloat xi2;
6002 MFloat xi3;
6003 MFloat zeta1;
6004 MFloat zeta2;
6005 MFloat zeta3;
6006 MFloat vc;
6007 for(MInt n = 0; n < m_noOfModes; n++) {
6008 std::normal_distribution<> dist{1.0, 1.0};
6009 m_omega[n] = dist(randNumGen);
6010
6011 std::normal_distribution<> dist2{0.0, 0.5};
6012 d1 = dist2(randNumGen);
6013 d2 = dist2(randNumGen);
6014 d3 = dist2(randNumGen);
6015
6016 std::normal_distribution<> dist3{0.0, 1.0};
6017 xi1 = dist3(randNumGen);
6018 xi2 = dist3(randNumGen);
6019 xi3 = dist3(randNumGen);
6020 zeta1 = dist3(randNumGen);
6021 zeta2 = dist3(randNumGen);
6022 zeta3 = dist3(randNumGen);
6023
6024 // calculate derived vars
6025 m_p1[n] = zeta2 * d3 - zeta3 * d2;
6026 m_p2[n] = zeta3 * d1 - zeta1 * d3;
6027 m_p3[n] = zeta1 * d2 - zeta2 * d1;
6028 m_q1[n] = xi2 * d3 - xi3 * d2;
6029 m_q2[n] = xi3 * d1 - xi1 * d3;
6030 m_q3[n] = xi1 * d2 - xi2 * d1;
6031
6032 // ---------------------------------------------------
6033 // Beginning of Modification by Shin
6034 // Scaling by vc is not necessary.
6035 //
6036 if(smirnov == 1) {
6037 vc = 1; // The scaling comes later with c1, c2, and c3.
6038 } else {
6039 vc = sqrt(1.5
6040 * ((uuref * d1 * d1 + vvref * d2 * d2 + wwref * d3 * d3
6041 + 2.0 * (uvref * d1 * d2 + uwref * d1 * d3 + vwref * d2 * d3))
6042 / (d1 * d1 + d2 * d2 + d3 * d3)));
6043 }
6044
6045 m_dhat1[n] = d1 * m_v_b / vc;
6046 m_dhat2[n] = d2 * m_v_b / vc;
6047 m_dhat3[n] = d3 * m_v_b / vc;
6048 //
6049 // End of Modification by Shin
6050 // ---------------------------------------------------
6051 }
6052
6053 // in case of multisolver, the random numbers from solver 0 are broadcast to all solvers
6054 if(m_commValues) {
6055 ScratchSpace<MFloat> sendRecvBuffer(m_noOfModes * 10, AT_, "sendRecvBuffer");
6056 if(m_rank_bc1601 == 0) {
6057 for(MInt n = 0; n < m_noOfModes; n++) {
6058 sendRecvBuffer[n + 0 * m_noOfModes] = m_omega[n];
6059 }
6060 for(MInt n = 0; n < m_noOfModes; n++) {
6061 sendRecvBuffer[n + 1 * m_noOfModes] = m_p1[n];
6062 }
6063 for(MInt n = 0; n < m_noOfModes; n++) {
6064 sendRecvBuffer[n + 2 * m_noOfModes] = m_p2[n];
6065 }
6066 for(MInt n = 0; n < m_noOfModes; n++) {
6067 sendRecvBuffer[n + 3 * m_noOfModes] = m_p3[n];
6068 }
6069 for(MInt n = 0; n < m_noOfModes; n++) {
6070 sendRecvBuffer[n + 4 * m_noOfModes] = m_q1[n];
6071 }
6072 for(MInt n = 0; n < m_noOfModes; n++) {
6073 sendRecvBuffer[n + 5 * m_noOfModes] = m_q2[n];
6074 }
6075 for(MInt n = 0; n < m_noOfModes; n++) {
6076 sendRecvBuffer[n + 6 * m_noOfModes] = m_q3[n];
6077 }
6078 for(MInt n = 0; n < m_noOfModes; n++) {
6079 sendRecvBuffer[n + 7 * m_noOfModes] = m_dhat1[n];
6080 }
6081 for(MInt n = 0; n < m_noOfModes; n++) {
6082 sendRecvBuffer[n + 8 * m_noOfModes] = m_dhat2[n];
6083 }
6084 for(MInt n = 0; n < m_noOfModes; n++) {
6085 sendRecvBuffer[n + 9 * m_noOfModes] = m_dhat3[n];
6086 }
6087 }
6088
6089 MPI_Bcast(&sendRecvBuffer[0], 10 * m_noOfModes, MPI_DOUBLE, 0, m_comm_bc1601, AT_, "sendRecvBuffer[0]");
6090
6091 if(m_rank_bc1601 != 0) {
6092 for(MInt n = 0; n < m_noOfModes; n++) {
6093 m_omega[n] = sendRecvBuffer[n];
6094 }
6095 for(MInt n = 0; n < m_noOfModes; n++) {
6096 m_p1[n] = sendRecvBuffer[n + 1 * m_noOfModes];
6097 }
6098 for(MInt n = 0; n < m_noOfModes; n++) {
6099 m_p2[n] = sendRecvBuffer[n + 2 * m_noOfModes];
6100 }
6101 for(MInt n = 0; n < m_noOfModes; n++) {
6102 m_p3[n] = sendRecvBuffer[n + 3 * m_noOfModes];
6103 }
6104 for(MInt n = 0; n < m_noOfModes; n++) {
6105 m_q1[n] = sendRecvBuffer[n + 4 * m_noOfModes];
6106 }
6107 for(MInt n = 0; n < m_noOfModes; n++) {
6108 m_q2[n] = sendRecvBuffer[n + 5 * m_noOfModes];
6109 }
6110 for(MInt n = 0; n < m_noOfModes; n++) {
6111 m_q3[n] = sendRecvBuffer[n + 6 * m_noOfModes];
6112 }
6113 for(MInt n = 0; n < m_noOfModes; n++) {
6114 m_dhat1[n] = sendRecvBuffer[n + 7 * m_noOfModes];
6115 }
6116 for(MInt n = 0; n < m_noOfModes; n++) {
6117 m_dhat2[n] = sendRecvBuffer[n + 8 * m_noOfModes];
6118 }
6119 for(MInt n = 0; n < m_noOfModes; n++) {
6120 m_dhat3[n] = sendRecvBuffer[n + 9 * m_noOfModes];
6121 }
6122 }
6123 }
6124
6125 if((m_rank_bc1601 == 0) || (!m_commValues)) { // write the random numbers into a file (only domain 0)
6126 ofstream writeRnd;
6127 MString file = "randVars";
6128 if(!m_commValues) {
6129 stringstream test;
6130 test << file;
6131 struct stat st {};
6132 if(stat((test.str()).c_str(), &st) != 0) {
6133#if defined(MAIA_MS_COMPILER)
6134#pragma message("WARNING: Not compatible")
6135 mTerm(0, "ERROR: Not implemented!");
6136#else
6137 mkdir((test.str()).c_str(), 0744);
6138#endif
6139 m_log << endl << "creating folder " << test.str() << " for random numbers" << endl;
6140 }
6141 test << "/" << file << "_D" << m_domainId;
6142 file.clear();
6143 file.append(test.str());
6144 }
6145 writeRnd.open(file.c_str(), ios_base::out | ios_base::trunc | ios_base::binary);
6146
6147 MFloat fnumber;
6148
6149 for(MInt n = 0; n < m_noOfModes; n++) {
6150 fnumber = m_omega[n];
6151#ifdef SWAP_ENDIAN
6152 fnumber = doubleSwap(fnumber);
6153#endif
6154 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6155 fnumber = m_p1[n];
6156#ifdef SWAP_ENDIAN
6157 fnumber = doubleSwap(fnumber);
6158#endif
6159 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6160 fnumber = m_p2[n];
6161#ifdef SWAP_ENDIAN
6162 fnumber = doubleSwap(fnumber);
6163#endif
6164 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6165 fnumber = m_p3[n];
6166#ifdef SWAP_ENDIAN
6167 fnumber = doubleSwap(fnumber);
6168#endif
6169 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6170 fnumber = m_q1[n];
6171#ifdef SWAP_ENDIAN
6172 fnumber = doubleSwap(fnumber);
6173#endif
6174 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6175 fnumber = m_q2[n];
6176#ifdef SWAP_ENDIAN
6177 fnumber = doubleSwap(fnumber);
6178#endif
6179 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6180 fnumber = m_q3[n];
6181#ifdef SWAP_ENDIAN
6182 fnumber = doubleSwap(fnumber);
6183#endif
6184 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6185 fnumber = m_dhat1[n];
6186#ifdef SWAP_ENDIAN
6187 fnumber = doubleSwap(fnumber);
6188#endif
6189 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6190 fnumber = m_dhat2[n];
6191#ifdef SWAP_ENDIAN
6192 fnumber = doubleSwap(fnumber);
6193#endif
6194 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6195 fnumber = m_dhat3[n];
6196#ifdef SWAP_ENDIAN
6197 fnumber = doubleSwap(fnumber);
6198#endif
6199 writeRnd.write(reinterpret_cast<char*>(&fnumber), sizeof(MFloat));
6200 }
6201 writeRnd.close();
6202 }
6203}
Bc1601Class::randNumGen
std::mt19937 randNumGen
Definition: fvcartesianbndrycndxd.h:58
Bc1601Class::m_domainId
const MInt m_domainId
Definition: fvcartesianbndrycndxd.h:63
ScratchSpace
This class is a ScratchSpace.
Definition: scratch.h:758
mTerm
void mTerm(const MInt errorCode, const MString &location, const MString &message)
Definition: functions.cpp:29
doubleSwap
double doubleSwap(double f)
Definition: functions.h:379
m_log
InfoOutFile m_log
Definition: globalvariables.cpp:57
MString
std::basic_string< char > MString
Definition: maiatypes.h:55
MPI_Bcast
int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm, const MString &name, const MString &varname)
same as MPI_Bcast
Definition: mpioverride.cpp:1114
dist
MFloat dist(const Point< DIM > &p, const Point< DIM > &q)
Definition: pointbox.h:54

◆ loadRandomNumbers()

template<MInt nDim>
MBool Bc1601Class< nDim >::loadRandomNumbers
private

Definition at line 6206 of file fvcartesianbndrycndxd.cpp.

6206 {
6207 ifstream readRnd;
6208 MString file = "randVars";
6209 if(!m_commValues) {
6210 stringstream test;
6211 test << file << "/" << file << "_D" << m_domainId;
6212 file.clear();
6213 file.append(test.str());
6214 }
6215 readRnd.open(file.c_str(), ios_base::in | ios_base::binary);
6216
6217 if(!readRnd) {
6218 return false;
6219 }
6220
6221 m_log << " read Random numbers from restartFile " << file << " ..." << endl;
6222
6223 MFloat fnumber;
6224
6225 for(MInt n = 0; n < m_noOfModes; n++) {
6226 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6227#ifdef SWAP_ENDIAN
6228 fnumber = doubleSwap(fnumber);
6229#endif
6230 m_omega[n] = fnumber;
6231 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6232#ifdef SWAP_ENDIAN
6233 fnumber = doubleSwap(fnumber);
6234#endif
6235 m_p1[n] = fnumber;
6236 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6237#ifdef SWAP_ENDIAN
6238 fnumber = doubleSwap(fnumber);
6239#endif
6240 m_p2[n] = fnumber;
6241 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6242#ifdef SWAP_ENDIAN
6243 fnumber = doubleSwap(fnumber);
6244#endif
6245 m_p3[n] = fnumber;
6246 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6247#ifdef SWAP_ENDIAN
6248 fnumber = doubleSwap(fnumber);
6249#endif
6250 m_q1[n] = fnumber;
6251 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6252#ifdef SWAP_ENDIAN
6253 fnumber = doubleSwap(fnumber);
6254#endif
6255 m_q2[n] = fnumber;
6256 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6257#ifdef SWAP_ENDIAN
6258 fnumber = doubleSwap(fnumber);
6259#endif
6260 m_q3[n] = fnumber;
6261 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6262#ifdef SWAP_ENDIAN
6263 fnumber = doubleSwap(fnumber);
6264#endif
6265 m_dhat1[n] = fnumber;
6266 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6267#ifdef SWAP_ENDIAN
6268 fnumber = doubleSwap(fnumber);
6269#endif
6270 m_dhat2[n] = fnumber;
6271 readRnd.read((char*)(&fnumber), sizeof(MFloat));
6272#ifdef SWAP_ENDIAN
6273 fnumber = doubleSwap(fnumber);
6274#endif
6275 m_dhat3[n] = fnumber;
6276 }
6277 readRnd.close();
6278
6279 return true;
6280}

Member Data Documentation

◆ aa

template<MInt nDim>
MFloat* Bc1601Class< nDim >::aa = nullptr
private

Definition at line 83 of file fvcartesianbndrycndxd.h.

◆ c1

template<MInt nDim>
MFloat Bc1601Class< nDim >::c1
private

Definition at line 88 of file fvcartesianbndrycndxd.h.

◆ c2

template<MInt nDim>
MFloat Bc1601Class< nDim >::c2
private

Definition at line 88 of file fvcartesianbndrycndxd.h.

◆ c3

template<MInt nDim>
MFloat Bc1601Class< nDim >::c3
private

Definition at line 88 of file fvcartesianbndrycndxd.h.

◆ eigvec

template<MInt nDim>
MFloat Bc1601Class< nDim >::eigvec[3][3] {}
private

Definition at line 87 of file fvcartesianbndrycndxd.h.

◆ m_comm_bc1601

template<MInt nDim>
MPI_Comm Bc1601Class< nDim >::m_comm_bc1601
private

Definition at line 60 of file fvcartesianbndrycndxd.h.

◆ m_commValues

template<MInt nDim>
MBool Bc1601Class< nDim >::m_commValues
private

Definition at line 52 of file fvcartesianbndrycndxd.h.

◆ m_dhat1

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_dhat1 = nullptr
private

Definition at line 72 of file fvcartesianbndrycndxd.h.

◆ m_dhat2

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_dhat2 = nullptr
private

Definition at line 73 of file fvcartesianbndrycndxd.h.

◆ m_dhat3

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_dhat3 = nullptr
private

Definition at line 74 of file fvcartesianbndrycndxd.h.

◆ m_domainId

template<MInt nDim>
const MInt Bc1601Class< nDim >::m_domainId
private

Definition at line 63 of file fvcartesianbndrycndxd.h.

◆ m_invSigmaSponge

template<MInt nDim>
MFloat Bc1601Class< nDim >::m_invSigmaSponge

Definition at line 101 of file fvcartesianbndrycndxd.h.

◆ m_l_b

template<MInt nDim>
MFloat Bc1601Class< nDim >::m_l_b

Definition at line 98 of file fvcartesianbndrycndxd.h.

◆ m_noOfModes

template<MInt nDim>
MInt Bc1601Class< nDim >::m_noOfModes
private

Definition at line 54 of file fvcartesianbndrycndxd.h.

◆ m_oldMode

template<MInt nDim>
MInt Bc1601Class< nDim >::m_oldMode
private

Definition at line 51 of file fvcartesianbndrycndxd.h.

◆ m_omega

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_omega = nullptr
private

Definition at line 65 of file fvcartesianbndrycndxd.h.

◆ m_p1

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_p1 = nullptr
private

Definition at line 66 of file fvcartesianbndrycndxd.h.

◆ m_p2

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_p2 = nullptr
private

Definition at line 67 of file fvcartesianbndrycndxd.h.

◆ m_p3

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_p3 = nullptr
private

Definition at line 68 of file fvcartesianbndrycndxd.h.

◆ m_q1

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_q1 = nullptr
private

Definition at line 69 of file fvcartesianbndrycndxd.h.

◆ m_q2

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_q2 = nullptr
private

Definition at line 70 of file fvcartesianbndrycndxd.h.

◆ m_q3

template<MInt nDim>
MFloat* Bc1601Class< nDim >::m_q3 = nullptr
private

Definition at line 71 of file fvcartesianbndrycndxd.h.

◆ m_rank_bc1601

template<MInt nDim>
MInt Bc1601Class< nDim >::m_rank_bc1601 {}
private

Definition at line 61 of file fvcartesianbndrycndxd.h.

◆ m_regenerateSeeding

template<MInt nDim>
MBool Bc1601Class< nDim >::m_regenerateSeeding
private

Definition at line 55 of file fvcartesianbndrycndxd.h.

◆ m_regenerationCounter

template<MInt nDim>
MInt Bc1601Class< nDim >::m_regenerationCounter
private

Definition at line 57 of file fvcartesianbndrycndxd.h.

◆ m_regenerationInterval

template<MInt nDim>
MInt Bc1601Class< nDim >::m_regenerationInterval
private

Definition at line 56 of file fvcartesianbndrycndxd.h.

◆ m_tau_b

template<MInt nDim>
MFloat Bc1601Class< nDim >::m_tau_b

Definition at line 100 of file fvcartesianbndrycndxd.h.

◆ m_useUnif

template<MInt nDim>
MBool Bc1601Class< nDim >::m_useUnif
private

Definition at line 53 of file fvcartesianbndrycndxd.h.

◆ m_v_b

template<MInt nDim>
MFloat Bc1601Class< nDim >::m_v_b

Definition at line 99 of file fvcartesianbndrycndxd.h.

◆ randNumGen

template<MInt nDim>
std::mt19937 Bc1601Class< nDim >::randNumGen
private

Definition at line 58 of file fvcartesianbndrycndxd.h.

◆ smirnov

template<MInt nDim>
MBool Bc1601Class< nDim >::smirnov
private

Definition at line 86 of file fvcartesianbndrycndxd.h.

◆ uuref

template<MInt nDim>
MFloat Bc1601Class< nDim >::uuref
private

Definition at line 76 of file fvcartesianbndrycndxd.h.

◆ uvref

template<MInt nDim>
MFloat Bc1601Class< nDim >::uvref
private

Definition at line 77 of file fvcartesianbndrycndxd.h.

◆ uwref

template<MInt nDim>
MFloat Bc1601Class< nDim >::uwref
private

Definition at line 78 of file fvcartesianbndrycndxd.h.

◆ vvref

template<MInt nDim>
MFloat Bc1601Class< nDim >::vvref
private

Definition at line 79 of file fvcartesianbndrycndxd.h.

◆ vwref

template<MInt nDim>
MFloat Bc1601Class< nDim >::vwref
private

Definition at line 80 of file fvcartesianbndrycndxd.h.

◆ wwref

template<MInt nDim>
MFloat Bc1601Class< nDim >::wwref
private

Definition at line 81 of file fvcartesianbndrycndxd.h.

The documentation for this class was generated from the following files: