fvcartesianbndrycndxd_8h_source.html

// Copyright (C) 2024 The m-AIA AUTHORS

//

// This file is part of m-AIA (https://git.rwth-aachen.de/aia/m-AIA/m-AIA)

//

// SPDX-License-Identifier: LGPL-3.0-only


#ifndef FVBNDRYCNDXD_H

#define FVBNDRYCNDXD_H


#include <map>

#include <random>

#include <set>

#include <sys/stat.h>

#include <type_traits>

#include <vector>

#include "COMM/mpioverride.h"

#include "GEOM/geometryintersection.h"

#include "GRID/cartesiangridcellproperties.h"

#include "MEMORY/scratch.h"

#include "UTIL/maiamath.h"

#include "fvcartesiancellcollector.h"

#include "fvcartesiansurfacecollector.h"

#include "fvcartesiansyseqntraits.h"


template <MInt nDim, class SysEqn>

class FvCartesianSolverXD;

template <class T>

class Collector;

template <class T>

class List;

template <MInt nDim>

class FvSurface;

template <MInt nDim>

class FvSurfaceCollector;

template <MInt nDim, class SysEqn>

class FvBndryCell;

template <MInt nDim>

class CartesianGrid;

template <MInt nDim, SolverType SolverTypeR, SolverType SolverTypeL>

class MSTG;

template <MInt nDim, class SysEqn>

class FvZonalSTG;

template <MInt nDim>

class FvSysEqnNS;

template <MInt nDim, class RANSModel>

class FvSysEqnRANS;


template <MInt nDim>

class Bc1601Class {

  // members used by turbulent inflow boundary condition 1601

  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 communicator

  MPI_Comm m_comm_bc1601;

  MInt m_rank_bc1601{};

  // Domain id of solver

  const MInt m_domainId;

  // to store random numbers

  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;

  // to store Reynolds stress tensor:

  MFloat uuref;

  MFloat uvref;

  MFloat uwref;

  MFloat vvref;

  MFloat vwref;

  MFloat wwref;

  // to store cholesky decomposed Reynolds stress tensor:

  MFloat* aa = nullptr;


  // Shin's addition

  MBool smirnov;

  MFloat eigvec[3][3]{};

  MFloat c1, c2, c3;


  // end members used by bc1601


  // functions

  void generateAndCommRandomNumbers();

  MBool loadRandomNumbers();


 public:

  // precalculated values

  MFloat m_l_b;

  MFloat m_v_b;

  MFloat m_tau_b;

  MFloat m_invSigmaSponge;


  // 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);

};


template <MInt nDim, class SysEqn>

class FvBndryCndXD {

 public:

  // Type for cell properties

  using Cell = GridCell;

  using SolverCell = FvCell;


  MInt m_noDirs = 2 * nDim;

  MInt m_noEdges = nDim == 2 ? 4 : 12;

  MInt m_noCorners = nDim == 2 ? 4 : 8;


  friend class FvCartesianSolverXD<nDim, SysEqn>;

  friend class FvZonalSTG<nDim, SysEqn>;


 private:

  SysEqn* m_sysEqn;


 public:

  // collectors...

  maia::fv::collector::FvCellCollector<nDim>& m_cells;

  maia::fv::surface_collector::FvSurfaceCollector<nDim>& m_surfaces;

  List<MInt>* m_smallBndryCells = nullptr;

  List<MInt>* m_sortedBndryCells = nullptr;

  List<MInt>* m_sortedSpongeBndryCells = nullptr;

  std::vector<List<MInt>*> m_sortedCutOffCells{};

  // pointers

  FvCartesianSolverXD<nDim, SysEqn>* m_solver = nullptr;

  FvBndryCell<nDim, SysEqn>* m_bndryCell = nullptr;

  MInt* m_splitSurfaces = nullptr;

  MInt* m_bndryNghbrs = nullptr;

  MInt* m_splitParents = nullptr;

  MInt* m_splitChildren = nullptr;

  MInt m_solverId = -1;

  MBool m_changeAdiabBCToTemp;


  // claudia addition -> not nice, but necessary:

  MInt m_noLevelSetsUsedForMb;

  MBool m_complexBoundaryMB;

  MBool m_cellCoordinatesCorrected;


  typename SysEqn::ConservativeVariables* CV{};

  typename SysEqn::FluxVariables* FV{};

  typename SysEqn::PrimitiveVariables* PV{};

  typename SysEqn::AdditionalVariables* AV{};


  MInt m_minLevel;

  MInt m_maxLevel;


  FvBndryCndXD(FvCartesianSolverXD<nDim, SysEqn>* solver);


  virtual ~FvBndryCndXD();


  Collector<FvBndryCell<nDim, SysEqn>>* m_bndryCells = nullptr;


  SysEqn sysEqn() const { return *m_sysEqn; };


  virtual void writeStlFileOfCell(MInt, const MChar*){};

  void addBoundarySurfaces();

  void addBoundarySurfacesMGC();

  // virtual void correctBoundarySurfaceVariables() = 0;

  void correctBoundarySurfaceVariablesMGC();

  void correctBoundarySurfaceVariablesMGCSurface();

  //  void applyNonReflectingBC();

  void applyNonReflectingBCCutOff();

  void applyNonReflectingBCAfterTreatmentCutOff();

  void computeGhostCells();

  void computeGhostCellsMGC();

  //  void correctGhostCells();

  void computeMirrorCoordinates(MInt, MFloat*, MInt);

  void computeMirrorCoordinates(MInt, MFloat*);

  void computeReverseMap();


  // WMLES

  void initWMBndryCells();

  void initWMSurfaces();

  template <MBool MGC>

  void bc3399(MInt);

  std::list<std::pair<MInt, MInt>> m_wmSrfcToCellId;


  // virtual void copySlopesToSmallCells() = 0;

  void copyRHSIntoGhostCells();

  void correctCellCoordinates();

  void createSortedBndryCellList();

  void createBndryCndHandler();

  void createSpongeAtSpongeBndryCnds();

  void recorrectCellCoordinates();

  void rerecorrectCellCoordinates();

  void applyNeumannBoundaryCondition();

  void storeBoundaryVariables();

  void updateGhostCellVariables();

  void updateCutOffCellVariables();

  void initCutOffBndryCnds();

  void allocateCutOffMemory();

  void exchangeCutOffBoundaryCells();

  void updateGhostCellSlopesInviscid();

  void updateCutOffSlopesInviscid();

  void updateGhostCellSlopesViscous();

  void correctGhostCellSlopesViscous();

  void updateCutOffSlopesViscous();

  void initBndryCnds();

  void setBCTypes(MInt updateOnlyBndryCndId = -1);

  virtual void cmptGhostCells(){};


  void saveBc7901(){};


  void bc0(MInt){/*do nothing*/};

  void bc0Var(MInt){/*do nothing*/};


  void bcInit0001(MInt);

  template <MBool MGC>

  void bcInit0002(MInt);

  template <MBool MGC>

  void bcInit4000(MInt);

  void bcInit0004(MInt);

  void bcNeumann(MInt);

  void bcNeumannIso(MInt);

  void initBndryCommunications();

  void createBoundaryAtCutoff();

  MInt isCutOffInterface(MInt cellId);

  void markCutOff(MIntScratchSpace& cutOffCells);


  template <MBool MGC>

  void sbc2000(MInt);

  template <MInt dir>

  void sbc2001(MInt);

  template <MInt dir>

  void sbc2901(MInt);


  void bc17110(MInt);

  void bc17516(MInt);

  void bc19516(MInt);

  void bc1753(MInt);

  void bc1755(MInt);


  void bc1251(MInt);


  virtual void bc2770(MInt){};

  virtual void sbc2710co(MInt){};

  virtual void bc1001coflowY(MInt){};

  virtual void bc10910(MInt){};

  virtual void bc10990(MInt){};

  virtual void bc1901(MInt){};

  virtual void bc1801(MInt){};

  virtual void bc19520(MInt){};

  virtual void bc1003(MInt){};

  virtual void bc1004(MInt){};

  virtual void bc1005(MInt){};

  virtual void bc1401(MInt){};

  virtual void bc1791(MInt){};

  virtual void bc2001(MInt){};

  virtual void bc2002(MInt){};

  virtual void bc2003(MInt){};


  void bc3002(MInt);

  void bc30021(MInt);

  template <MBool MGC>

  void bc3003(MInt);

  void bc3011(MInt);

  void bc4000(MInt);

  void bc4001(MInt);


  // pointers to the boundary condition methods

  typedef void (FvBndryCndXD::*BndryCndHandler)(MInt);

  typedef void (FvBndryCndXD::*BndryCndHandlerVar)(MInt);

  BndryCndHandler* bndryCndHandlerInit = nullptr;

  BndryCndHandler* bndryCndHandlerCutOffInit = nullptr;

  BndryCndHandlerVar* bndryCndHandlerNeumann = nullptr;

  // variables

  BndryCndHandler* bndryCndHandlerVariables = nullptr;

  BndryCndHandler* bndryCndHandlerCutOffVariables = nullptr;

  BndryCndHandler* bndryCndHandlerSpongeVariables = nullptr;

  // BndryCndHandler* nonReflectingBoundaryCondition = nullptr;

  BndryCndHandler* nonReflectingBoundaryConditionAfterTreatmentCutOff = nullptr;

  BndryCndHandler* nonReflectingCutOffBoundaryCondition = nullptr;

  // gradient (inviscid flux)

  BndryCndHandler* bndryCndHandlerSlopesInviscid = nullptr;

  BndryCndHandler* bndryCndHandlerCutOffSlopesInviscid = nullptr;

  // gradient (viscous flux)

  BndryCndHandler* bndryViscousSlopes = nullptr;

  BndryCndHandler* bndryCutOffViscousSlopes = nullptr;


  // reconstruction

  MFloat** m_reconstructionConstants = nullptr;

  MInt** m_reconstructionNghbrs = nullptr;

  std::vector<MInt> m_smallCutCells;

  std::vector<MInt>* m_nearBoundaryWindowCells = nullptr;

  std::vector<MInt>* m_nearBoundaryHaloCells = nullptr;

  // Azimuthal priodicity near boundary exchange

  std::vector<std::vector<MInt>> m_azimuthalNearBoundaryWindowCells;

  std::vector<std::vector<MInt>> m_azimuthalNearBoundaryWindowMap;

  std::vector<std::vector<MInt>> m_azimuthalNearBoundaryHaloCells;


  MBool m_cellMerging = false;

  MBool m_secondOrderRec;

  MInt m_noFluxRedistributionLayers;


  // properties

  MFloat m_4000timeStepOffset;

  MFloat m_4000timeInterval;

  MFloat m_wFactor;

  MFloat m_pressureRatioChannel;


  MFloat m_sigmaNonRefl;

  MFloat m_sigmaNonReflInflow;

  MBool m_createBoundaryAtCutoff;

  MBool m_createSpongeBoundary;

  MBool m_outputIGPoints;

  MInt* m_bndryCndIds = nullptr;

  MInt* m_cutOffBndryCndIds = nullptr;

  MInt* m_cellsInsideSpongeLayer = nullptr;

  MInt m_noCellsInsideSpongeLayer;

  MInt* m_spongeBndryCndIds = nullptr;

  MFloat* m_spongeFactor = nullptr;

  MInt* m_spongeDirections = nullptr;

  MFloat* m_sigmaSpongeBndryId = nullptr;

  MFloat* m_sigmaEndSpongeBndryId = nullptr;

  MFloat m_spongeLayerThickness;

  MInt m_spongeLayerLayout;

  MBool m_spongeTimeDep;

  MFloat* m_spongeStartIteration = nullptr;

  MFloat* m_spongeEndIteration = nullptr;

  MInt* m_spongeTimeDependent = nullptr;

  MInt* m_bndryCndCells = nullptr;

  MInt* m_spongeBndryCells = nullptr;

  MInt* m_boundarySurfaces = nullptr;

  MInt m_multipleGhostCells = 0;

  MInt m_ipVariableIterative;

  MInt m_surfaceGhostCell;

  MInt m_noBoundarySurfaces{};

  MInt m_noBndryCndIds;

  MInt m_noSpongeBndryCndIds;

  MInt m_noCutOffBndryCndIds;

  MBool m_cbcCutOff = false;

  MBool m_cbcSmallCellCorrection = false;

  MInt m_noMaxSpongeBndryCells;

  MFloat m_spongeBeta;

  MFloat* m_spongeCoord = nullptr;

  MInt m_maxNoBndryCells;

  MInt m_maxNoBndryCndIds;

  MInt m_noImagePointIterations;

  MFloat m_volumeLimitWall;

  MBool m_smallCellRHSCorrection = false;

  MFloat m_volumeLimitOther;

  MFloat m_meanCoord[3]{};

  // ---

  MFloat** m_shockBcVars = nullptr;

  MInt m_noShockBcCells{};

  MBool m_shockFromInnerSolution{};

  MInt* m_Bc2770TargetCells = nullptr;

  MFloat m_sigmaShock{};

  MFloat m_ys{};

  // ---

  MFloat* m_modeOmega = nullptr;

  MFloat* m_modeAmp = nullptr;

  MInt* m_modeType = nullptr;

  MFloat** m_modeK = nullptr;

  MBool m_clusterCutOffBcs{};

  MInt* m_nmbrOfModes = nullptr;

  MFloat* m_modePhi = nullptr;

  MFloat* m_modeEtaMin = nullptr;

  MInt m_modes{};

  MInt m_besselModes;

  MFloat* m_besselTrig = nullptr;

  MFloat m_Bc3011WallTemperature = NAN;


  // members used by combustion boundary conditions

  MFloat m_radiusFlameTube;

  MFloat m_radiusVelFlameTube;

  MFloat m_shearLayerThickness;

  MFloat m_jetHeight;

  MFloat m_primaryJetRadius;

  MFloat m_secondaryJetRadius;

  MFloat m_targetVelocityFactor;

  MFloat m_momentumThickness;

  MFloat m_shearLayerStrength;

  MFloat m_Ma;

  MFloat m_deltaP{};

  MFloat m_deltaPL{};

  MFloat m_inflowTemperatureRatio;

  MInt m_noSpecies;

  MInt m_noRansEquations;

  MBool m_combustion;

  MBool m_isEEGas;

  MFloat m_nu[10]{};


  MInt m_bc1601_bcId = -1;

  Bc1601Class<nDim>* m_bc1601 = nullptr;

  MBool m_bc1601MoveGenOutOfSponge = false;

  MBool m_jetInletTurbulence = false;


  // BC1251

  MFloat m_bc1251ForcingAmplitude;

  MFloat m_bc1251ForcingWavelength;

  MFloat m_bc1251ForcingFrequency;

  MInt m_bc1251ForcingDirection;


  // BC7901

  MInt m_7901faceNormalDir;

  MInt m_7901BcActive;

  MInt m_7901StartTimeStep;

  MInt m_7901periodicDir;

  MInt m_7901wallDir;

  MInt m_7901globalNoWallNormalLocations = -1;

  MInt* m_7901globalNoPeriodicLocations = nullptr;

  MFloat** m_7901LESAverage = nullptr;

  MFloat** m_7901LESAverageOld = nullptr;

  MInt* m_7901periodicIndex = nullptr;

  // std::vector<MInt> m_7901BcCells;

  std::vector<MFloat>* m_7901periodicLocations = nullptr;

  std::vector<MFloat> m_7901wallNormalLocations;

  std::vector<MFloat> m_7901globalWallNormalLocations;

  /* MInt m_7901StartTimeStep; */

  /* std::vector<MFloat>* m_7901LESAverage = nullptr; */


  // BC7902

  MInt m_rntRoot;

  MInt m_7902faceNormalDir;

  MInt m_7902BcActive;

  MInt m_7902StartTimeStep;

  MInt m_7902periodicDir;

  MInt m_7902wallDir;

  MInt m_7902globalNoWallNormalLocations = -1;

  MInt* m_7902globalNoPeriodicLocations = nullptr;

  MFloat** m_7902LESAverage = nullptr;

  MFloat** m_7902LESAverageOld = nullptr;

  MInt* m_7902periodicIndex = nullptr;

  // std::vector<MInt> m_7902BcCells;

  std::vector<MFloat>* m_7902periodicLocations = nullptr;

  std::vector<MFloat> m_7902wallNormalLocations;

  std::vector<MFloat> m_7902globalWallNormalLocations;


  // BC7903

  // BC7904

  // BC7909

  std::map<MInt, MSTG<nDim, MAIA_FINITE_VOLUME, MAIA_FINITE_VOLUME>*> m_stgBC;

  std::map<MInt, MSTG<nDim, MAIA_STRUCTURED, MAIA_FINITE_VOLUME>*> m_stgBCStrcd;

  std::map<MInt, MBool> m_stgLocal;

  std::vector<MInt> m_stgBcCells;

  MInt m_startSTGTimeStep;

  /* MBool m_cylinderTransformation = false; */

  // std::vector<std::pair<MInt,MInt>> m_stgBcCellIds;

  MPI_Comm m_commStg;


  // cbc

  std::vector<MFloat> m_cbcInflowArea;

  std::vector<std::vector<MFloat>> m_cbcReferencePoint;

  std::vector<MInt> m_cbcBndryCndIds;

  std::vector<std::vector<MFloat>> m_cbcRelax;

  std::vector<std::vector<MFloat>> m_dirTangent;

  std::vector<std::vector<MFloat>> m_dirNormal;

  std::vector<MFloat> m_cbcLref;

  std::vector<std::vector<MInt>> m_cbcDir;

  std::vector<MInt> m_cbcDomainMin;

  MBool m_cbcTurbulence = false;

  MBool m_cbcViscous = false;

  MFloat** m_oldFluctChol = nullptr;

  MFloat m_oldTime = F0;


 protected:

  // parallelization

  MString m_gridCutTest;


  MPI_Comm* m_comm_bc = nullptr;

  MInt m_comm_bc_init = 0;

  MInt* m_bc_comm_pointer = nullptr;

  MPI_Comm* m_comm_bcCo = nullptr;

  MInt m_comm_bcCo_init = 0;

  MInt* m_bcCo_comm_pointer = nullptr;


  std::vector<CutCandidate<nDim>> m_cutCandidates;

  GeometryIntersection<nDim>* m_geometryIntersection;


  MPI_Comm mpiComm() const { return m_solver->mpiComm(); }


  MInt domainId() const { return m_solver->domainId(); }


  MInt noDomains() const { return m_solver->noDomains(); }


  // Data members used to replace local static variables

 private:

  MBool m_firstUseSetBCTypes = true;

  // Data members used to replace local static variables for fvbndrycndxd.h


 protected:

  // sbc1000co

  MBool m_static_sbc1000co_first = true;

  static constexpr MInt s_sbc1000co_fixedMaxNoBndryCndIds = 10;

  MInt m_static_sbc1000co_directions[s_sbc1000co_fixedMaxNoBndryCndIds]{};

  // initSmallCellCorrection

  MBool m_static_initSmallCellCorrection_firstRun = true;

  // m_static_computeImagePointRecConst_firstRun

  MBool m_static_computeImagePointRecConst_firstRun = true;


 public:

  // output routines to check the cut cell generation

  void plotAllCutPoints();

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void writeStlFileOfCell(MInt, const char*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void plotSurface();

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void plotEdges(MInt&, MFloat**&);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void plotIntersectionPoints(MInt*, MFloat***&);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void writeStlOfNodes(MInt, MInt*&, const char*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void plotTriangle(std::ofstream&, MFloat*, MFloat*, MFloat*, MFloat*);


  // TODO labels:FV cleanup and replace with calls to maiamath.h

  // geometric help routines

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  MFloat* vecSub(MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  MFloat* vecScalarMul(MFloat, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computeTri(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computeTri(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computeTrapez(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computePoly3(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computePoly4(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computePoly5(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computePoly6(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computeTetra(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void computePyra(MFloat*, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void correctFace(MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void correctCell(MFloat*, MFloat*, MFloat*, MFloat*);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void correctNormal(MFloat*);


  // other help routines for cut cell generation

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void getFeatureEdges(MInt&, MFloat**&, MInt, MInt*&, MFloat*&, MFloat*&);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void getIntersectionPoints(MFloat**&, MFloat**&, MInt, MInt, MFloat**&, MInt&);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void getSortedElements(const std::vector<MInt>&, MInt&, MInt*&, MInt&, MInt*&, MInt);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void correctInflowBoundary(MInt);

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void correctInflowBoundary(MInt, MFloat*&, MFloat*&);

  template <class X = void, std::enable_if_t<nDim == 2, X*> = nullptr>

  void correctInflowBoundary(MInt, MBool = false) {}

  template <class X = void, std::enable_if_t<nDim == 2, X*> = nullptr>

  void correctInflowBoundary(MInt, MFloat*&, MFloat*&, MBool = false) {}

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  MInt createSplitCell_MGC(MInt, MInt);

  MBool checkInside(MInt);

  MBool checkOutside(MInt);

  MBool checkOutside(const MFloat*, const MInt);


  // cut cell generation main routines

  virtual void generateBndryCells();

  void createBndryCells();

  void computeCutPoints();

  void exchangeComputedCutPoints();

  void checkCutPointsValidity();

  void checkCutPointsValidityParGeom();

  template <class X = void, std::enable_if_t<nDim == 2, X*> = nullptr>

  void createCutFace();

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void createCutFace();

  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void createCutFaceMGC();

  template <class X = void, std::enable_if_t<nDim == 2, X*> = nullptr>

  void createCutFaceMGC() {

    TERMM(1, "MGC in 2D not implemented yet!");

  }

  void checkBoundaryCells();

  void computePlaneVectors();

  void deleteBndryCell(MInt);


  // other boundary cell related routines

  ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void copySlopesToSmallCells();

  // ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_ALWAYS_INLINE) inline void copySlopesToSmallCells_(const MUint);

  ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void copyVarsToSmallCells();

  // ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_ALWAYS_INLINE) inline void copyVarsToSmallCells_(const MUint);

  ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void correctBoundarySurfaceVariables();

  // ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_ALWAYS_INLINE) inline void correctBoundarySurfaceVariables_(const MUint);

  void correctCoarseBndryCells();

  void correctMasterSlaveSurfaces();

  void detectSmallBndryCells();

  void detectSmallBndryCellsMGC();

  void setNearBoundaryRecNghbrs(MInt updateOnlyBndryCndId = -1);

  void computeImagePointRecConst(MInt updateOnlyBndryCndId = -1);

  void initSmallCellCorrection(MInt updateOnlyBndryCndId = -1);

  void initSmallCellRHSCorrection(MInt updateOnlyBndryCndId = -1);

  void mergeCells();

  void mergeCellsMGC();

  void updateRHSSmallCells();

  void resetCutOff();

  void resetCutOffFirst();

  void resetBndryCommunication();

  void cutOffBcMissingNeighbor(const MInt cellId, const MString bcName);


  void setGapGhostCellVariables(MInt bcId);


  template <class X = void, std::enable_if_t<nDim == 2, X*> = nullptr>

  void computePolygon(MFloat* x, const MInt N, MFloat* centroid, MFloat* area);

  // boundary conditions

  void computeNeumannLSConstants(MInt);

  void computeReconstructionConstants_interpolation();

  void bcNeumann3600(MInt);

  void bcNeumannIsothermal(MInt);

  void bcNeumannIsothermalBurntProfile(MInt);

  void bcNeumannIsothermalBurntProfileH(MInt);

  void bcNeumannIsothermalUnburnt(MInt);

  void bcNeumannIsothermalUnburntProfile(MInt);

  void bcNeumannIsothermalUnburntProfileH(MInt);

  void bcNeumannMb(MInt);

  MFloat updateImagePointVariables(MInt);


  // slopes

  ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void sbc1000(const MInt);

  void sbc1000co(const MInt);

  void sbc00co(const MInt);

  // ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_ALWAYS_INLINE) inline void sbc1000_(const MInt, const MUint);

  void sbc1002(MInt);

  void sbc2801x(MInt);

  void sbc2801y(MInt);


  void bc1001(MInt);

  void bc100100(MInt);

  void bc1000(MInt);

  void bc1009(MInt);

  void bc01(MInt);

  void bc1002(MInt);

  void bc1091(MInt);

  void bc1101(MInt);

  void bc1102(MInt);

  void bc1601(MInt);

  void bc1602(MInt);

  void bc1603(MInt);

  void bc1604(MInt);

  void bc1606(MInt);

  void bcInit1601(MInt);

  void bc10970(MInt);

  void bc10980(MInt);

  void bc11110(MInt);

  void bc16010(MInt);

  void bc16011(MInt);

  void bc16012(MInt);

  void bc16013(MInt);

  void bc16014(MInt);

  void bc16015(MInt);


  // STG

  // Only 3D TODO labels:FV template std::enable_if_t can be removed once FV/fvstg.h is trully generalized

  //               for the templated argument 'nDim'. Otherwise, leads to compilation errors.

  //               std::enable_if_t<nDim == (3) or (2)... is used here to avoid such errors.

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bcInit7901(MInt);

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bcInit7902(MInt);

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bcInit7905(MInt);

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bcInit7909(MInt);

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bcInit7809(MInt);


  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bc7901(MInt);

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bc7902(MInt);

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bc7905(MInt);

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bc7903(MInt);


  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bc7909(MInt);

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 3, _*> = nullptr>

  void bc7809(MInt);


  // Only 2D

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bcInit7901(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bcInit7902(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bcInit7905(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bcInit7909(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bcInit7809(MInt) {

    TERMM(-1, "");

  }


  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bc7901(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bc7902(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bc7905(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bc7903(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bc7909(MInt) {

    TERMM(-1, "");

  }

  template <class _ = void, std::enable_if_t<!hasPV_N<SysEqn>::value, _*> = nullptr,

            std::enable_if_t<nDim == 2, _*> = nullptr>

  void bc7809(MInt) {

    TERMM(-1, "");

  }


  void bcInit30022(MInt);

  void bc30022(MInt);


  void bc1792(MInt);

  void bc1156(MInt);

  void bc1952(MInt);


  void bcInit1050(MInt);


  void initModes(MInt);

  void addModes(MInt);

  void initBesselModes(MInt);

  void addBesselModes(MInt);

  void calcBesselFractions(const MFloat, const MFloat, const MFloat, MFloat&, MFloat&);

  void precomputeBesselTrigonometry(MInt);

  void bc2700(MInt);

  void bcInit1251(MInt);

  void bcInit2770(MInt);

  void bcInit2700(MInt);

  void bc2710(MInt);

  void bc2720(MInt);

  void sbc2720co(MInt);

  void bc3006(MInt);

  void bc3007(MInt);

  void bc2907(MInt);

  void bc29050(MInt);

  void bc3466(MInt);

  void bc3600(MInt);


  MFloat computeCutoffBoundaryGeometry(const MInt, const MInt, MFloat*);


  // cbc

  void cbcTurbulenceInjection(MInt, MFloat*, MInt);

  void cbcRHS(MInt, MInt, MFloat*, MFloat*, MFloat*);

  void cbcDampingOutflow(MInt, MInt, MFloat, MFloat*);

  void cbcDampingInflow(MInt, MInt, MFloat, MFloat*, MString);

  template <unsigned char vTerms>

  void cbcViscousTerms(MInt, MInt, MFloat*, MFloat*, MFloat*, MFloat*, MInt*, MFloat*);

  template <unsigned char tTerms>

  void cbcTransversalTerms(MInt, MInt, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  template <MInt side>

  void cbcOutgoingAmplitudeVariation(MInt, MInt, MFloat*, MFloat*, MFloat*, MFloat*, MFloat*);

  void cbcGradients(MInt, MInt, MFloat*, MFloat*, MFloat*, MFloat*);

  void cbcGradientsViscous(MInt, MInt, MFloat*, MFloat*, MFloat*, MFloat*, MInt*);

  void cbcTauQ(MInt, MFloat*, MFloat*, MInt*);

  void cbcMachCo(MInt, MFloat*);

  void cbcMeanPressureCo(MInt, MFloat*);

  void bcInitCbc(MInt);


  void cbc1099(MInt);

  void cbc109910(MInt);

  void cbc109911(MInt);

  void cbc109921(MInt);

  void cbc1099a(MInt);

  void cbc1099a_after(MInt);

  void cbc1091(MInt);

  void cbc1091a(MInt);

  void cbc3091a(MInt);

  void cbc1091b(MInt);

  void cbc1091c(MInt);

  void cbc1091d(MInt);

  void cbc1091b_after(MInt);

  void cbc1091c_after(MInt);

  void cbc1091d_after(MInt);

  void cbc1091e(MInt);

  void cbc1091e_after(MInt);

  void cbc1099_1091_local(MInt);

  void cbc1099_1091_local_comb(MInt);

  void cbc1291(MInt);

  void cbc1291a(MInt);

  void cbc1291b(MInt);

  void cbc1291tm(MInt);

  void cbc1291tma(MInt);

  void cbc1291tmb(MInt);

  void cbc1291tmc(MInt);

  void cbc1299(MInt);

  void cbc1299tm(MInt);

  void cbc1299a(MInt);

  void cbc2091a(MInt);

  void cbc2091b(MInt);

  void cbc2091b_after(MInt);

  void cbc2091d(MInt);

  void cbc2091d_after(MInt);

  void cbc2099_1091_local_comb(MInt);

  void cbc1099_1091_engine(MInt);


  template <class X = void, std::enable_if_t<nDim == 3, X*> = nullptr>

  void cbc1099_1091_engineOld(MInt);


  virtual void bc3037MGC(MInt){};

  void bc1091MGC(MInt);

  void bc1099MGC(MInt);

  void cbc1099_1091d(MInt);

  void cbc1099_1091d_after(MInt);


  // Data members used to replace local static variables

 private:

  // plotEdges

  MInt m_static_plotEdges_iter = 0;

  // plotIntersectionPoints

  MInt m_static_plotIntersectionPoints_iter = 0;

  // writeStlOfNodes

  MInt m_static_writeStlOfNodes_iter = 0;

  // correctInflowBoundary

  MInt m_static_correctInflowBoundary_iter = 0;

  // bc1091MGC

  MInt m_static_bc1091MGC_minTimeSteps = 0;

  MInt m_static_bc1091MGC_nghbrDir = -1;

  MInt m_static_bc1091MGC_edgeCellCounter = 0;

  MInt m_static_bc1091MGC_first = true;

  MInt m_static_bc1091MGC_first2 = true;

  // bc1099MGC

  MFloat m_static_bc1099MGC_timeOfMaxPdiff = 0;

  bool m_static_bc1099MGC_first = true;

  // bc10970

  MBool m_firstUseBc10970 = true;

  MInt m_dirNBc10970 = -1;

  MInt m_pModeBc10970 = 0;

  // bc10980

  MBool m_firstUseBc10980 = true;

  MInt m_dirNBc10980 = -1;

  // bc11110

  MFloat** m_targetValuesBC11110 = nullptr;

  MInt* m_dirNBc11110 = nullptr;

  MBool m_firstUseBc11110 = true;

  // cbc1099

  MBool m_static_cbc1099_first = true;

  MInt m_static_cbc1099_dirN = -1;

  MInt m_static_cbc1099_dimN = -1;

  MInt m_static_cbc1099_dimT1 = -1;

  MInt m_static_cbc1099_dimT2 = -1;

  MFloat m_static_cbc1099_outFlowArea;

  MFloat m_static_cbc1099_referencePoint[3];

  MInt m_static_cbc1099_domainMin;

  // cbc1099_1091_local

  MBool m_static_cbc1099_1091_local_first = true;

  MInt m_static_cbc1099_1091_local_dirN = -1;

  MInt m_static_cbc1099_1091_local_dimN = -1;

  MInt m_static_cbc1099_1091_local_dimT1 = -1;

  MInt m_static_cbc1099_1091_local_dimT2 = -1;

  MFloat m_static_cbc1099_1091_local_inflowArea;

  MFloat m_static_cbc1099_1091_local_referencePoint[3];

  MFloat m_static_cbc1099_1091_local_targetPressure;

  MInt m_static_cbc1099_1091_local_domainMin = 0;

  MFloat m_static_cbc1099_1091_local_R = 0; // 3D

  MFloat m_static_cbc1099_1091_local_H;     // 2D

  // cbc1099_1091_local_comb

  MBool m_static_cbc1099_1091_local_comb_first = true;

  MInt m_static_cbc1099_1091_local_comb_dirN = -1;

  MInt m_static_cbc1099_1091_local_comb_dimN = -1;

  MInt m_static_cbc1099_1091_local_comb_dimT1 = -1;

  MInt m_static_cbc1099_1091_local_comb_dimT2 = -1;

  MFloat m_static_cbc1099_1091_local_comb_outFlowArea;

  MFloat m_static_cbc1099_1091_local_comb_referencePoint[3];

  // cbc1091

  MBool m_static_cbc1091_first = true;

  MInt m_static_cbc1091_dirN = -1;

  MInt m_static_cbc1091_dimN = -1;

  MInt m_static_cbc1091_dimT1 = -1;

  MInt m_static_cbc1091_dimT2 = -1;

  MFloat m_static_cbc1091_inflowArea;

  MFloat m_static_cbc1091_referencePoint[3];

  MInt m_static_cbc1091_domainMin;

  // cbc1091a

  MBool m_static_cbc1091a_solverProfile = false;

  // cbc3091a

  MBool m_static_cbc3091a_first = true;

  MInt m_static_cbc3091a_dirN = -1;

  MInt m_static_cbc3091a_dimN = -1;

  MInt m_static_cbc3091a_dimT1 = -1;

  MInt m_static_cbc3091a_dimT2 = -1;

  MBool m_static_cbc3091a_solverProfile = false;

  MFloat m_static_cbc3091a_inflowArea;

  MFloat m_static_cbc3091a_R;

  MFloat m_static_cbc3091a_referencePoint[3];

  // cbc1091b

  MBool m_static_cbc1091b_first = true;

  MInt m_static_cbc1091b_dirN = -1;

  MInt m_static_cbc1091b_dimN = -1;

  MInt m_static_cbc1091b_dimT1 = -1;

  MBool m_static_cbc1091b_solverProfile = false;

  MFloat m_static_cbc1091b_inflowArea;

  MFloat m_static_cbc1091b_referencePoint[3];

  // cbc1091c

  MBool m_static_cbc1091c_first = true;

  MInt m_static_cbc1091c_dirN = -1;

  MInt m_static_cbc1091c_dimN = -1;

  MInt m_static_cbc1091c_dimT1 = -1;

  MFloat m_static_cbc1091c_inflowArea;

  MFloat m_static_cbc1091c_referencePoint[3];

  // cbc1091c_after

  MBool m_static_cbc1091c_after_first = true;

  MInt m_static_cbc1091c_after_dirN = -1;

  MInt m_static_cbc1091c_after_dimN = -1;

  MInt m_static_cbc1091c_after_dimT1 = -1;

  MInt m_static_cbc1091c_after_dimT2 = -1;

  // cbc1091d

  MBool m_static_cbc1091d_first = true;

  MInt m_static_cbc1091d_dirN = -1;

  MInt m_static_cbc1091d_dimN = -1;

  MInt m_static_cbc1091d_dimT1 = -1;

  MFloat m_static_cbc1091d_inflowArea;

  MFloat m_static_cbc1091d_referencePoint[3];

  MBool m_static_cbc1091d_solverProfile = false; // 2D

  MInt m_static_cbc1091d_minDom = 0;

  // cbc1091d_after

  MBool m_static_cbc1091d_after_first = true;

  MInt m_static_cbc1091d_after_dirN = -1;

  MInt m_static_cbc1091d_after_dimN = -1;

  MInt m_static_cbc1091d_after_dimT1 = -1;

  MInt m_static_cbc1091d_after_dimT2 = -1;

  // cbc1091e

  MBool m_static_cbc1091e_first = true;

  MInt m_static_cbc1091e_dirN = -1;

  MInt m_static_cbc1091e_dimN = -1;

  MInt m_static_cbc1091e_dimT1 = -1;

  MBool m_static_cbc1091e_solverProfile = false;

  MFloat m_static_cbc1091e_inflowArea;

  // cbc2091a

  MBool m_static_cbc2091a_first = true;

  MInt m_static_cbc2091a_dirN = -1;

  MInt m_static_cbc2091a_dimN = -1;

  MInt m_static_cbc2091a_dimT1 = -1;

  MBool m_static_cbc2091a_solverProfile = false;

  MFloat m_static_cbc2091a_inflowArea;

  MFloat m_static_cbc2091a_H;

  MFloat m_static_cbc2091a_referencePoint[nDim];

  // cbc2091b

  MBool m_static_cbc2091b_first = true;

  MInt m_static_cbc2091b_dirN = -1;

  MInt m_static_cbc2091b_dimN = -1;

  MInt m_static_cbc2091b_dimT1 = -1;

  MBool m_static_cbc2091b_solverProfile = false;

  MFloat m_static_cbc2091b_inflowArea;

  MFloat m_static_cbc2091b_H;

  MFloat m_static_cbc2091b_referencePoint[nDim];

  // cbc2091d

  MBool m_static_cbc2091d_first = true;

  MInt m_static_cbc2091d_dirN = -1;

  MInt m_static_cbc2091d_dimN = -1;

  MInt m_static_cbc2091d_dimT1 = -1;

  MFloat m_static_cbc2091d_inflowArea;

  MFloat m_static_cbc2091d_H;

  MFloat m_static_cbc2091d_referencePoint[nDim];

  MBool m_static_cbc2091d_solverProfile = false;

  // cbc2091d_after

  MBool m_static_cbc2091d_after_first = true;

  MInt m_static_cbc2091d_after_dirN = -1;

  MInt m_static_cbc2091d_after_dimN = -1;

  MInt m_static_cbc2091d_after_dimT1 = -1;

  // cbc2099_1091_local_comb

  MBool m_static_cbc2099_1091_local_comb_first = true;

  MInt m_static_cbc2099_1091_local_comb_dirN = -1;

  MInt m_static_cbc2099_1091_local_comb_dimN = -1;

  MInt m_static_cbc2099_1091_local_comb_dimT1 = -1;

  MFloat m_static_cbc2099_1091_local_comb_outFlowArea;

  MFloat m_static_cbc2099_1091_local_comb_referencePoint[nDim];

  // cbc1099_1091d

  MBool m_static_cbc1099_1091d_first = true;

  MInt m_static_cbc1099_1091d_dirN = -1;

  MInt m_static_cbc1099_1091d_dimN = -1;

  MInt m_static_cbc1099_1091d_dimT1 = -1;

  MInt m_static_cbc1099_1091d_dimT2 = -1;

  MFloat m_static_cbc1099_1091d_inflowArea;

  MFloat m_static_cbc1099_1091d_referencePoint[nDim];

  MFloat m_static_cbc1099_1091d_targetPressure;

  // cbc1099_1091d_after

  MBool m_static_cbc1099_1091d_after_first = true;

  MInt m_static_cbc1099_1091d_after_dirN = -1;

  MInt m_static_cbc1099_1091d_after_dimN = -1;

  MFloat m_static_cbc1099_1091d_after_interpolationFactor;

  // cbc1099_1091_engine

  MBool m_static_cbc1099_1091_engine_first = true;

  MInt m_static_cbc1099_1091_engine_dirN;

  MInt m_static_cbc1099_1091_engine_dimN;

  MInt m_static_cbc1099_1091_engine_dimT1;

  MFloat m_static_cbc1099_1091_engine_inflowArea;

  MInt m_static_cbc1099_1091_engine_domainMin = 0;

  MInt m_static_cbc1099_1091_engine_dimT2;

  MFloat m_static_cbc1099_1091_engine_normal[3];

  MFloat m_static_cbc1099_1091_engine_tangent[3];


  // JANNIK: 109910, 109911

  std::pair<MFloat, MFloat>* m_unTargetData = nullptr;

  std::pair<MFloat, MFloat>* m_vnTargetData = nullptr;

  MInt m_unTargetDataCount;

  MInt m_vnTargetDataCount;

  MFloat** m_horTargetData = nullptr;

  MInt m_horTargetDataCount;

};


#endif

cartesiangridcellproperties.h

GridCell
GridCell
Grid cell Property Labels.
Definition: cartesiangridcellproperties.h:14

Bc1601Class
Definition: fvcartesianbndrycndxd.h:49

Bc1601Class::m_tau_b
MFloat m_tau_b
Definition: fvcartesianbndrycndxd.h:100

Bc1601Class::c2
MFloat c2
Definition: fvcartesianbndrycndxd.h:88

Bc1601Class::m_regenerationInterval
MInt m_regenerationInterval
Definition: fvcartesianbndrycndxd.h:56

Bc1601Class::m_regenerateSeeding
MBool m_regenerateSeeding
Definition: fvcartesianbndrycndxd.h:55

Bc1601Class::m_commValues
MBool m_commValues
Definition: fvcartesianbndrycndxd.h:52

Bc1601Class::m_omega
MFloat * m_omega
Definition: fvcartesianbndrycndxd.h:65

Bc1601Class::~Bc1601Class
~Bc1601Class()
Definition: fvcartesianbndrycndxd.cpp:6531

Bc1601Class::randNumGen
std::mt19937 randNumGen
Definition: fvcartesianbndrycndxd.h:58

Bc1601Class::uuref
MFloat uuref
Definition: fvcartesianbndrycndxd.h:76

Bc1601Class::uwref
MFloat uwref
Definition: fvcartesianbndrycndxd.h:78

Bc1601Class::checkRegeneration
void checkRegeneration(const MFloat time)
Definition: fvcartesianbndrycndxd.cpp:6639

Bc1601Class::Bc1601Class
Bc1601Class(MPI_Comm &communicator, const MInt m_solverId, const MInt domainId, MFloat &u_total, MFloat &invSigmaSponge)

Bc1601Class::m_rank_bc1601
MInt m_rank_bc1601
Definition: fvcartesianbndrycndxd.h:61

Bc1601Class::m_q2
MFloat * m_q2
Definition: fvcartesianbndrycndxd.h:70

Bc1601Class::m_useUnif
MBool m_useUnif
Definition: fvcartesianbndrycndxd.h:53

Bc1601Class::aa
MFloat * aa
Definition: fvcartesianbndrycndxd.h:83

Bc1601Class::c1
MFloat c1
Definition: fvcartesianbndrycndxd.h:88

Bc1601Class::m_domainId
const MInt m_domainId
Definition: fvcartesianbndrycndxd.h:63

Bc1601Class::c3
MFloat c3
Definition: fvcartesianbndrycndxd.h:88

Bc1601Class::m_comm_bc1601
MPI_Comm m_comm_bc1601
Definition: fvcartesianbndrycndxd.h:60

Bc1601Class::generateAndCommRandomNumbers
void generateAndCommRandomNumbers()
Bc1601Class functions:
Definition: fvcartesianbndrycndxd.cpp:5991

Bc1601Class::calculateFlucts
void calculateFlucts(const MFloat that, const MFloat xhat, const MFloat yhat, const MFloat zhat, MFloat *fluctChol)
Definition: fvcartesianbndrycndxd.cpp:6547

Bc1601Class::m_dhat2
MFloat * m_dhat2
Definition: fvcartesianbndrycndxd.h:73

Bc1601Class::m_q1
MFloat * m_q1
Definition: fvcartesianbndrycndxd.h:69

Bc1601Class::m_l_b
MFloat m_l_b
Definition: fvcartesianbndrycndxd.h:98

Bc1601Class::uvref
MFloat uvref
Definition: fvcartesianbndrycndxd.h:77

Bc1601Class::m_p2
MFloat * m_p2
Definition: fvcartesianbndrycndxd.h:67

Bc1601Class::vwref
MFloat vwref
Definition: fvcartesianbndrycndxd.h:80

Bc1601Class::m_p3
MFloat * m_p3
Definition: fvcartesianbndrycndxd.h:68

Bc1601Class::m_v_b
MFloat m_v_b
Definition: fvcartesianbndrycndxd.h:99

Bc1601Class::m_dhat1
MFloat * m_dhat1
Definition: fvcartesianbndrycndxd.h:72

Bc1601Class::m_dhat3
MFloat * m_dhat3
Definition: fvcartesianbndrycndxd.h:74

Bc1601Class::vvref
MFloat vvref
Definition: fvcartesianbndrycndxd.h:79

Bc1601Class::m_p1
MFloat * m_p1
Definition: fvcartesianbndrycndxd.h:66

Bc1601Class::m_oldMode
MInt m_oldMode
Definition: fvcartesianbndrycndxd.h:51

Bc1601Class::smirnov
MBool smirnov
Definition: fvcartesianbndrycndxd.h:86

Bc1601Class::eigvec
MFloat eigvec[3][3]
Definition: fvcartesianbndrycndxd.h:87

Bc1601Class::m_noOfModes
MInt m_noOfModes
Definition: fvcartesianbndrycndxd.h:54

Bc1601Class::loadRandomNumbers
MBool loadRandomNumbers()
Definition: fvcartesianbndrycndxd.cpp:6206

Bc1601Class::wwref
MFloat wwref
Definition: fvcartesianbndrycndxd.h:81

Bc1601Class::m_invSigmaSponge
MFloat m_invSigmaSponge
Definition: fvcartesianbndrycndxd.h:101

Bc1601Class::m_q3
MFloat * m_q3
Definition: fvcartesianbndrycndxd.h:71

Bc1601Class::m_regenerationCounter
MInt m_regenerationCounter
Definition: fvcartesianbndrycndxd.h:57

CartesianGrid
Definition: cartesiangrid.h:47

Collector
Definition: collector.h:14

FvBndryCell
Definition: fvcartesianbndrycell.h:16

FvBndryCndXD
Definition: fvcartesianbndrycndxd.h:113

FvBndryCndXD::storeBoundaryVariables
void storeBoundaryVariables()
Definition: fvcartesianbndrycndxd.cpp:1313

FvBndryCndXD::m_7901LESAverageOld
MFloat ** m_7901LESAverageOld
Definition: fvcartesianbndrycndxd.h:417

FvBndryCndXD::addBesselModes
void addBesselModes(MInt)
Definition: fvcartesianbndrycndxd.cpp:7586

FvBndryCndXD::m_bc1251ForcingAmplitude
MFloat m_bc1251ForcingAmplitude
Definition: fvcartesianbndrycndxd.h:403

FvBndryCndXD::m_jetHeight
MFloat m_jetHeight
Definition: fvcartesianbndrycndxd.h:381

FvBndryCndXD::m_static_cbc1091e_inflowArea
MFloat m_static_cbc1091e_inflowArea
Definition: fvcartesianbndrycndxd.h:991

FvBndryCndXD::bndryCndHandlerVariables
BndryCndHandler * bndryCndHandlerVariables
Definition: fvcartesianbndrycndxd.h:280

FvBndryCndXD::m_primaryJetRadius
MFloat m_primaryJetRadius
Definition: fvcartesianbndrycndxd.h:382

FvBndryCndXD::m_static_cbc1099_1091d_first
MBool m_static_cbc1099_1091d_first
Definition: fvcartesianbndrycndxd.h:1032

FvBndryCndXD::generateBndryCells
virtual void generateBndryCells()
generate finite-volume boundary cells

FvBndryCndXD::cbc1291a
void cbc1291a(MInt)

FvBndryCndXD::bcInit4000
void bcInit4000(MInt)
Definition: fvcartesianbndrycndxd.cpp:5349

FvBndryCndXD::m_sigmaSpongeBndryId
MFloat * m_sigmaSpongeBndryId
Definition: fvcartesianbndrycndxd.h:326

FvBndryCndXD::cbc1099_1091_local_comb
void cbc1099_1091_local_comb(MInt)
Definition: fvcartesianbndrycndxd.cpp:19133

FvBndryCndXD::m_static_cbc3091a_R
MFloat m_static_cbc3091a_R
Definition: fvcartesianbndrycndxd.h:947

FvBndryCndXD::m_cbcBndryCndIds
std::vector< MInt > m_cbcBndryCndIds
Definition: fvcartesianbndrycndxd.h:458

FvBndryCndXD::cbc1091b_after
void cbc1091b_after(MInt)
Subsonic fully reflecting characteristic inflow condition - cut off - sets T0,u,v to prescribed value...
Definition: fvcartesianbndrycndxd.cpp:18209

FvBndryCndXD::m_static_cbc1099_1091_local_comb_dimT2
MInt m_static_cbc1099_1091_local_comb_dimT2
Definition: fvcartesianbndrycndxd.h:925

FvBndryCndXD::cbc1099_1091_local
void cbc1099_1091_local(MInt)
Definition: fvcartesianbndrycndxd.cpp:18820

FvBndryCndXD::m_spongeBndryCndIds
MInt * m_spongeBndryCndIds
holds the sponge boundary IDs
Definition: fvcartesianbndrycndxd.h:323

FvBndryCndXD::allocateCutOffMemory
void allocateCutOffMemory()
allocates the cut off list memory
Definition: fvcartesianbndrycndxd.cpp:1823

FvBndryCndXD::cbcRHS
void cbcRHS(MInt, MInt, MFloat *, MFloat *, MFloat *)
Calculates the right hand side.
Definition: fvcartesianbndrycndxd.cpp:20291

FvBndryCndXD::bndryCndHandlerSlopesInviscid
BndryCndHandler * bndryCndHandlerSlopesInviscid
Definition: fvcartesianbndrycndxd.h:287

FvBndryCndXD::bc1755
void bc1755(MInt)
Definition: fvcartesianbndrycndxd.cpp:5194

FvBndryCndXD::m_sigmaNonRefl
MFloat m_sigmaNonRefl
Definition: fvcartesianbndrycndxd.h:314

FvBndryCndXD::m_modePhi
MFloat * m_modePhi
Definition: fvcartesianbndrycndxd.h:370

FvBndryCndXD::bc19520
virtual void bc19520(MInt)
Definition: fvcartesianbndrycndxd.h:255

FvBndryCndXD::m_radiusFlameTube
MFloat m_radiusFlameTube
Definition: fvcartesianbndrycndxd.h:378

FvBndryCndXD::recorrectCellCoordinates
void recorrectCellCoordinates()
Definition: fvcartesianbndrycndxd.cpp:538

FvBndryCndXD::m_oldTime
MFloat m_oldTime
Definition: fvcartesianbndrycndxd.h:468

FvBndryCndXD::m_dirNormal
std::vector< std::vector< MFloat > > m_dirNormal
Definition: fvcartesianbndrycndxd.h:461

FvBndryCndXD::bndryCndHandlerCutOffInit
BndryCndHandler * bndryCndHandlerCutOffInit
Definition: fvcartesianbndrycndxd.h:277

FvBndryCndXD::m_7901globalNoPeriodicLocations
MInt * m_7901globalNoPeriodicLocations
Definition: fvcartesianbndrycndxd.h:415

FvBndryCndXD::sbc2801y
void sbc2801y(MInt)
Solid wall Navier-Stokes boundary condition Computes ghost cell slopes for the viscous flux computati...
Definition: fvcartesianbndrycndxd.cpp:22152

FvBndryCndXD::m_sortedBndryCells
List< MInt > * m_sortedBndryCells
Definition: fvcartesianbndrycndxd.h:134

FvBndryCndXD::sbc1000co
void sbc1000co(const MInt)
Cut off condition for the slopes.
Definition: fvcartesianbndrycndxd.cpp:19434

FvBndryCndXD::m_7901periodicIndex
MInt * m_7901periodicIndex
Definition: fvcartesianbndrycndxd.h:418

FvBndryCndXD::sbc00co
void sbc00co(const MInt)
Cut off condition for the slopes.
Definition: fvcartesianbndrycndxd.cpp:19371

FvBndryCndXD::bcInit7809
void bcInit7809(MInt)
Definition: fvcartesianbndrycndxd.cpp:17142

FvBndryCndXD::m_bndryCells
Collector< FvBndryCell< nDim, SysEqn > > * m_bndryCells
Definition: fvcartesianbndrycndxd.h:164

FvBndryCndXD::m_static_cbc1091e_dimN
MInt m_static_cbc1091e_dimN
Definition: fvcartesianbndrycndxd.h:988

FvBndryCndXD::computeTetra
void computeTetra(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::m_static_cbc2099_1091_local_comb_dimT1
MInt m_static_cbc2099_1091_local_comb_dimT1
Definition: fvcartesianbndrycndxd.h:1028

FvBndryCndXD::BndryCndHandler
void(FvBndryCndXD::* BndryCndHandler)(MInt)
Definition: fvcartesianbndrycndxd.h:274

FvBndryCndXD::bc17516
void bc17516(MInt)
Definition: fvcartesianbndrycndxd.cpp:4730

FvBndryCndXD::m_cbcDomainMin
std::vector< MInt > m_cbcDomainMin
Definition: fvcartesianbndrycndxd.h:464

FvBndryCndXD::bndryCndHandlerNeumann
BndryCndHandlerVar * bndryCndHandlerNeumann
Definition: fvcartesianbndrycndxd.h:278

FvBndryCndXD::cbc1299
void cbc1299(MInt)

FvBndryCndXD::m_pModeBc10970
MInt m_pModeBc10970
Definition: fvcartesianbndrycndxd.h:891

FvBndryCndXD::m_cbcReferencePoint
std::vector< std::vector< MFloat > > m_cbcReferencePoint
Definition: fvcartesianbndrycndxd.h:457

FvBndryCndXD::m_static_cbc2091d_solverProfile
MBool m_static_cbc2091d_solverProfile
Definition: fvcartesianbndrycndxd.h:1018

FvBndryCndXD::m_static_cbc1091d_dimT1
MInt m_static_cbc1091d_dimT1
Definition: fvcartesianbndrycndxd.h:974

FvBndryCndXD::noDomains
MInt noDomains() const
Return the total number of domains (total number of ranks in current MPI communicator)
Definition: fvcartesianbndrycndxd.h:491

FvBndryCndXD::m_spongeEndIteration
MFloat * m_spongeEndIteration
Definition: fvcartesianbndrycndxd.h:332

FvBndryCndXD::m_static_cbc1099_1091_engine_tangent
MFloat m_static_cbc1099_1091_engine_tangent[3]
Definition: fvcartesianbndrycndxd.h:1054

FvBndryCndXD::updateCutOffSlopesViscous
void updateCutOffSlopesViscous()
Definition: fvcartesianbndrycndxd.cpp:2238

FvBndryCndXD::m_static_cbc1091e_dimT1
MInt m_static_cbc1091e_dimT1
Definition: fvcartesianbndrycndxd.h:989

FvBndryCndXD::nonReflectingCutOffBoundaryCondition
BndryCndHandler * nonReflectingCutOffBoundaryCondition
Definition: fvcartesianbndrycndxd.h:285

FvBndryCndXD::bc7909
void bc7909(MInt)
Definition: fvcartesianbndrycndxd.cpp:17595

FvBndryCndXD::cbc1091e_after
void cbc1091e_after(MInt)
Subsonic fully reflecting characteristic inflow condition - cut off - sets T0,u,v to prescribed value...
Definition: fvcartesianbndrycndxd.cpp:19618

FvBndryCndXD::m_noSpongeBndryCndIds
MInt m_noSpongeBndryCndIds
number of sponge boundary condition IDs
Definition: fvcartesianbndrycndxd.h:342

FvBndryCndXD::m_azimuthalNearBoundaryWindowMap
std::vector< std::vector< MInt > > m_azimuthalNearBoundaryWindowMap
Definition: fvcartesianbndrycndxd.h:301

FvBndryCndXD::m_combustion
MBool m_combustion
Definition: fvcartesianbndrycndxd.h:393

FvBndryCndXD::m_bcCo_comm_pointer
MInt * m_bcCo_comm_pointer
Definition: fvcartesianbndrycndxd.h:479

FvBndryCndXD::m_static_cbc1099_outFlowArea
MFloat m_static_cbc1099_outFlowArea
Definition: fvcartesianbndrycndxd.h:905

FvBndryCndXD::m_complexBoundaryMB
MBool m_complexBoundaryMB
Definition: fvcartesianbndrycndxd.h:149

FvBndryCndXD::cbc1099a_after
void cbc1099a_after(MInt)
Subsonic fully reflecting characteristic outflow condition - cut off - sets pstat to prescribed value...
Definition: fvcartesianbndrycndxd.cpp:18783

FvBndryCndXD::m_unTargetData
std::pair< MFloat, MFloat > * m_unTargetData
Definition: fvcartesianbndrycndxd.h:1057

FvBndryCndXD::m_static_cbc1099_1091_local_dirN
MInt m_static_cbc1099_1091_local_dirN
Definition: fvcartesianbndrycndxd.h:910

FvBndryCndXD::bc7902
void bc7902(MInt)
Definition: fvcartesianbndrycndxd.cpp:17416

FvBndryCndXD::m_static_cbc1099_1091_local_comb_dimT1
MInt m_static_cbc1099_1091_local_comb_dimT1
Definition: fvcartesianbndrycndxd.h:924

FvBndryCndXD::m_targetValuesBC11110
MFloat ** m_targetValuesBC11110
Definition: fvcartesianbndrycndxd.h:896

FvBndryCndXD::m_static_cbc1091_dimT1
MInt m_static_cbc1091_dimT1
Definition: fvcartesianbndrycndxd.h:932

FvBndryCndXD::calcBesselFractions
void calcBesselFractions(const MFloat, const MFloat, const MFloat, MFloat &, MFloat &)
Definition: fvcartesianbndrycndxd.cpp:7635

FvBndryCndXD::m_7901StartTimeStep
MInt m_7901StartTimeStep
Definition: fvcartesianbndrycndxd.h:411

FvBndryCndXD::plotAllCutPoints
void plotAllCutPoints()
writes a .vtk file containing all cut points stored on the cut cells
Definition: fvcartesianbndrycndxd.cpp:12262

FvBndryCndXD::initCutOffBndryCnds
void initCutOffBndryCnds()
Definition: fvcartesianbndrycndxd.cpp:1639

FvBndryCndXD::m_static_cbc3091a_dimN
MInt m_static_cbc3091a_dimN
Definition: fvcartesianbndrycndxd.h:942

FvBndryCndXD::m_static_cbc1091c_first
MBool m_static_cbc1091c_first
Definition: fvcartesianbndrycndxd.h:958

FvBndryCndXD::m_spongeCoord
MFloat * m_spongeCoord
Definition: fvcartesianbndrycndxd.h:348

FvBndryCndXD::m_static_cbc1099_1091_engine_inflowArea
MFloat m_static_cbc1099_1091_engine_inflowArea
Definition: fvcartesianbndrycndxd.h:1050

FvBndryCndXD::m_smallCellRHSCorrection
MBool m_smallCellRHSCorrection
Definition: fvcartesianbndrycndxd.h:353

FvBndryCndXD::m_static_cbc1091d_dirN
MInt m_static_cbc1091d_dirN
Definition: fvcartesianbndrycndxd.h:972

FvBndryCndXD::bc1601
void bc1601(MInt)
Definition: fvcartesianbndrycndxd.cpp:14410

FvBndryCndXD::sbc2720co
void sbc2720co(MInt)
Cut off condition for the slopes copys the slopes, and sets pressure slope to sero NOTIMPLEMENTED ver...
Definition: fvcartesianbndrycndxd.cpp:22015

FvBndryCndXD::cbc1291tma
void cbc1291tma(MInt)

FvBndryCndXD::m_surfaceGhostCell
MInt m_surfaceGhostCell
Definition: fvcartesianbndrycndxd.h:339

FvBndryCndXD::m_cbcViscous
MBool m_cbcViscous
Definition: fvcartesianbndrycndxd.h:466

FvBndryCndXD::cbcDampingOutflow
void cbcDampingOutflow(MInt, MInt, MFloat, MFloat *)
Calculates the outflow damping terms.
Definition: fvcartesianbndrycndxd.cpp:20273

FvBndryCndXD::cbc1099_1091d_after
void cbc1099_1091d_after(MInt)

FvBndryCndXD::m_static_cbc2091d_after_dimN
MInt m_static_cbc2091d_after_dimN
Definition: fvcartesianbndrycndxd.h:1022

FvBndryCndXD::m_static_cbc1099_first
MBool m_static_cbc1099_first
Definition: fvcartesianbndrycndxd.h:900

FvBndryCndXD::m_static_cbc1091b_first
MBool m_static_cbc1091b_first
Definition: fvcartesianbndrycndxd.h:950

FvBndryCndXD::m_commStg
MPI_Comm m_commStg
Definition: fvcartesianbndrycndxd.h:453

FvBndryCndXD::m_static_cbc1099_1091_engine_normal
MFloat m_static_cbc1099_1091_engine_normal[3]
Definition: fvcartesianbndrycndxd.h:1053

FvBndryCndXD::m_static_cbc1099_1091_engine_domainMin
MInt m_static_cbc1099_1091_engine_domainMin
Definition: fvcartesianbndrycndxd.h:1051

FvBndryCndXD::bc4001
void bc4001(MInt)
Definition: fvcartesianbndrycndxd.cpp:5416

FvBndryCndXD::bc16010
void bc16010(MInt)
Definition: fvcartesianbndrycndxd.cpp:16249

FvBndryCndXD::m_static_cbc3091a_referencePoint
MFloat m_static_cbc3091a_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:948

FvBndryCndXD::m_static_cbc1091d_after_dirN
MInt m_static_cbc1091d_after_dirN
Definition: fvcartesianbndrycndxd.h:981

FvBndryCndXD::m_firstUseBc10970
MBool m_firstUseBc10970
Only 3D ends ///.
Definition: fvcartesianbndrycndxd.h:889

FvBndryCndXD::bc2907
void bc2907(MInt)
Definition: fvcartesianbndrycndxd.cpp:15590

FvBndryCndXD::bcNeumannMb
void bcNeumannMb(MInt)
Moving boundary Neumann condition.
Definition: fvcartesianbndrycndxd.cpp:13638

FvBndryCndXD::bcNeumann
void bcNeumann(MInt)
Definition: fvcartesianbndrycndxd.cpp:5611

FvBndryCndXD::m_7902globalNoWallNormalLocations
MInt m_7902globalNoWallNormalLocations
Definition: fvcartesianbndrycndxd.h:433

FvBndryCndXD::cbc109911
void cbc109911(MInt)
Characteristic boundary condition. Outflow. Prescribed: p. Partially Refelecting.
Definition: fvcartesianbndrycndxd.cpp:20947

FvBndryCndXD::m_static_cbc1091c_dirN
MInt m_static_cbc1091c_dirN
Definition: fvcartesianbndrycndxd.h:959

FvBndryCndXD::copyRHSIntoGhostCells
void copyRHSIntoGhostCells()
Definition: fvcartesianbndrycndxd.cpp:5771

FvBndryCndXD::m_static_cbc1091c_referencePoint
MFloat m_static_cbc1091c_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:963

FvBndryCndXD::PV
SysEqn::PrimitiveVariables * PV
Definition: fvcartesianbndrycndxd.h:154

FvBndryCndXD::FV
SysEqn::FluxVariables * FV
Definition: fvcartesianbndrycndxd.h:153

FvBndryCndXD::m_maxNoBndryCndIds
MInt m_maxNoBndryCndIds
Definition: fvcartesianbndrycndxd.h:350

FvBndryCndXD::m_7902wallNormalLocations
std::vector< MFloat > m_7902wallNormalLocations
Definition: fvcartesianbndrycndxd.h:440

FvBndryCndXD::bc2001
virtual void bc2001(MInt)
Definition: fvcartesianbndrycndxd.h:261

FvBndryCndXD::cbc1299tm
void cbc1299tm(MInt)

FvBndryCndXD::m_static_plotIntersectionPoints_iter
MInt m_static_plotIntersectionPoints_iter
Definition: fvcartesianbndrycndxd.h:873

FvBndryCndXD::m_static_cbc2099_1091_local_comb_dirN
MInt m_static_cbc2099_1091_local_comb_dirN
Definition: fvcartesianbndrycndxd.h:1026

FvBndryCndXD::m_modeK
MFloat ** m_modeK
Definition: fvcartesianbndrycndxd.h:367

FvBndryCndXD::saveBc7901
void saveBc7901()
Definition: fvcartesianbndrycndxd.h:215

FvBndryCndXD::initBndryCnds
void initBndryCnds()
Definition: fvcartesianbndrycndxd.cpp:2247

FvBndryCndXD::initBesselModes
void initBesselModes(MInt)

FvBndryCndXD::m_bc1251ForcingWavelength
MFloat m_bc1251ForcingWavelength
Definition: fvcartesianbndrycndxd.h:404

FvBndryCndXD::bc1000
void bc1000(MInt)
Definition: fvcartesianbndrycndxd.cpp:13812

FvBndryCndXD::bcNeumannIsothermalUnburntProfileH
void bcNeumannIsothermalUnburntProfileH(MInt)
Computes the p and rho slopes on boundary cells using the least-squares method and setting implicitel...
Definition: fvcartesianbndrycndxd.cpp:13503

FvBndryCndXD::m_oldFluctChol
MFloat ** m_oldFluctChol
Definition: fvcartesianbndrycndxd.h:467

FvBndryCndXD::m_static_correctInflowBoundary_iter
MInt m_static_correctInflowBoundary_iter
Definition: fvcartesianbndrycndxd.h:877

FvBndryCndXD::initWMBndryCells
void initWMBndryCells()

FvBndryCndXD::m_7902BcActive
MInt m_7902BcActive
Definition: fvcartesianbndrycndxd.h:429

FvBndryCndXD::m_static_computeImagePointRecConst_firstRun
MBool m_static_computeImagePointRecConst_firstRun
Definition: fvcartesianbndrycndxd.h:506

FvBndryCndXD::m_static_cbc1099_1091_local_inflowArea
MFloat m_static_cbc1099_1091_local_inflowArea
Definition: fvcartesianbndrycndxd.h:914

FvBndryCndXD::m_volumeLimitWall
MFloat m_volumeLimitWall
Definition: fvcartesianbndrycndxd.h:352

FvBndryCndXD::bc1801
virtual void bc1801(MInt)
Definition: fvcartesianbndrycndxd.h:254

FvBndryCndXD::m_solver
FvCartesianSolverXD< nDim, SysEqn > * m_solver
Definition: fvcartesianbndrycndxd.h:138

FvBndryCndXD::m_static_cbc1099_1091_engine_dimT2
MInt m_static_cbc1099_1091_engine_dimT2
Definition: fvcartesianbndrycndxd.h:1052

FvBndryCndXD::m_cbcCutOff
MBool m_cbcCutOff
Definition: fvcartesianbndrycndxd.h:344

FvBndryCndXD::m_Bc3011WallTemperature
MFloat m_Bc3011WallTemperature
Definition: fvcartesianbndrycndxd.h:375

FvBndryCndXD::sbc2001
void sbc2001(MInt)
Solid wall Navier-Stokes boundary condition Computes ghost cell slopes for the viscous flux computati...
Definition: fvcartesianbndrycndxd.cpp:6786

FvBndryCndXD::m_static_cbc1099_1091d_after_first
MBool m_static_cbc1099_1091d_after_first
Definition: fvcartesianbndrycndxd.h:1041

FvBndryCndXD::bcInit2700
void bcInit2700(MInt)
init for the acoustic and entropy waves

FvBndryCndXD::bc1604
void bc1604(MInt)
Definition: fvcartesianbndrycndxd.cpp:14852

FvBndryCndXD::mpiComm
MPI_Comm mpiComm() const
Return the MPI communicator used by the corresponding solver.
Definition: fvcartesianbndrycndxd.h:485

FvBndryCndXD::sbc2710co
virtual void sbc2710co(MInt)
Definition: fvcartesianbndrycndxd.h:249

FvBndryCndXD::m_static_cbc1091b_dirN
MInt m_static_cbc1091b_dirN
Definition: fvcartesianbndrycndxd.h:951

FvBndryCndXD::initSmallCellCorrection
void initSmallCellCorrection(MInt updateOnlyBndryCndId=-1)
Initialize the small-cell correction for the flux-redistribution method The cell vars are computed us...
Definition: fvcartesianbndrycndxd.cpp:9549

FvBndryCndXD::sysEqn
SysEqn sysEqn() const
Definition: fvcartesianbndrycndxd.h:166

FvBndryCndXD::m_bndryCell
FvBndryCell< nDim, SysEqn > * m_bndryCell
Definition: fvcartesianbndrycndxd.h:139

FvBndryCndXD::m_stgBcCells
std::vector< MInt > m_stgBcCells
Definition: fvcartesianbndrycndxd.h:449

FvBndryCndXD::m_static_cbc2091a_dimN
MInt m_static_cbc2091a_dimN
Definition: fvcartesianbndrycndxd.h:995

FvBndryCndXD::m_stgBCStrcd
std::map< MInt, MSTG< nDim, MAIA_STRUCTURED, MAIA_FINITE_VOLUME > * > m_stgBCStrcd
Definition: fvcartesianbndrycndxd.h:447

FvBndryCndXD::m_ipVariableIterative
MInt m_ipVariableIterative
Definition: fvcartesianbndrycndxd.h:338

FvBndryCndXD::m_static_cbc1099_1091d_after_interpolationFactor
MFloat m_static_cbc1099_1091d_after_interpolationFactor
Definition: fvcartesianbndrycndxd.h:1044

FvBndryCndXD::m_4000timeInterval
MFloat m_4000timeInterval
Definition: fvcartesianbndrycndxd.h:310

FvBndryCndXD::bc1901
virtual void bc1901(MInt)
Definition: fvcartesianbndrycndxd.h:253

FvBndryCndXD::bc3466
void bc3466(MInt)
Definition: fvcartesianbndrycndxd.cpp:15878

FvBndryCndXD::updateCutOffSlopesInviscid
void updateCutOffSlopesInviscid()
Definition: fvcartesianbndrycndxd.cpp:2103

FvBndryCndXD::updateGhostCellSlopesViscous
void updateGhostCellSlopesViscous()
Definition: fvcartesianbndrycndxd.cpp:2117

FvBndryCndXD::cbcViscousTerms
void cbcViscousTerms(MInt, MInt, MFloat *, MFloat *, MFloat *, MFloat *, MInt *, MFloat *)
Calculates the outgoing viscous terms V.
Definition: fvcartesianbndrycndxd.cpp:20160

FvBndryCndXD::m_7902periodicIndex
MInt * m_7902periodicIndex
Definition: fvcartesianbndrycndxd.h:437

FvBndryCndXD::bcInit7901
void bcInit7901(MInt)
Definition: fvcartesianbndrycndxd.cpp:16487

FvBndryCndXD::m_bc_comm_pointer
MInt * m_bc_comm_pointer
Definition: fvcartesianbndrycndxd.h:476

FvBndryCndXD::~FvBndryCndXD
virtual ~FvBndryCndXD()
Definition: fvcartesianbndrycndxd.cpp:449

FvBndryCndXD::m_static_sbc1000co_directions
MInt m_static_sbc1000co_directions[s_sbc1000co_fixedMaxNoBndryCndIds]
Definition: fvcartesianbndrycndxd.h:502

FvBndryCndXD::m_static_cbc2099_1091_local_comb_referencePoint
MFloat m_static_cbc2099_1091_local_comb_referencePoint[nDim]
Definition: fvcartesianbndrycndxd.h:1030

FvBndryCndXD::m_noEdges
MInt m_noEdges
Definition: fvcartesianbndrycndxd.h:120

FvBndryCndXD::m_solverId
MInt m_solverId
Definition: fvcartesianbndrycndxd.h:144

FvBndryCndXD::m_static_cbc2091d_dimT1
MInt m_static_cbc2091d_dimT1
Definition: fvcartesianbndrycndxd.h:1014

FvBndryCndXD::m_static_cbc2091d_referencePoint
MFloat m_static_cbc2091d_referencePoint[nDim]
Definition: fvcartesianbndrycndxd.h:1017

FvBndryCndXD::m_cellCoordinatesCorrected
MBool m_cellCoordinatesCorrected
Definition: fvcartesianbndrycndxd.h:150

FvBndryCndXD::m_static_cbc1099_1091_local_R
MFloat m_static_cbc1099_1091_local_R
Definition: fvcartesianbndrycndxd.h:918

FvBndryCndXD::ATTRIBUTES2
ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void sbc1000(const MInt)

FvBndryCndXD::bc1606
void bc1606(MInt)
Definition: fvcartesianbndrycndxd.cpp:14925

FvBndryCndXD::checkBoundaryCells
void checkBoundaryCells()
Definition: fvcartesianbndrycndxd.cpp:7762

FvBndryCndXD::setGapGhostCellVariables
void setGapGhostCellVariables(MInt bcId)
update ghostCell variables for gap-Cells
Definition: fvcartesianbndrycndxd.cpp:15737

FvBndryCndXD::bcInit0004
void bcInit0004(MInt)
Sets up the reconstruction stencil for boundary cells (quadratic least-squares reconstruction)
Definition: fvcartesianbndrycndxd.cpp:4529

FvBndryCndXD::m_static_cbc1099_1091d_dimT1
MInt m_static_cbc1099_1091d_dimT1
Definition: fvcartesianbndrycndxd.h:1035

FvBndryCndXD::bc1251
void bc1251(MInt)
Definition: fvcartesianbndrycndxd.cpp:4655

FvBndryCndXD::bcInit7905
void bcInit7905(MInt)
Definition: fvcartesianbndrycndxd.cpp:16905

FvBndryCndXD::m_static_cbc1099_1091_local_dimT2
MInt m_static_cbc1099_1091_local_dimT2
Definition: fvcartesianbndrycndxd.h:913

FvBndryCndXD::m_shockFromInnerSolution
MBool m_shockFromInnerSolution
Definition: fvcartesianbndrycndxd.h:359

FvBndryCndXD::deleteBndryCell
void deleteBndryCell(MInt)
Deletes a boundary cell (without collector fragmentation)
Definition: fvcartesianbndrycndxd.cpp:12766

FvBndryCndXD::cbcGradients
void cbcGradients(MInt, MInt, MFloat *, MFloat *, MFloat *, MFloat *)
Calculates the gradients of the cbcCell.
Definition: fvcartesianbndrycndxd.cpp:19916

FvBndryCndXD::cbc2099_1091_local_comb
void cbc2099_1091_local_comb(MInt)
Definition: fvcartesianbndrycndxd.cpp:21814

FvBndryCndXD::m_7901wallDir
MInt m_7901wallDir
Definition: fvcartesianbndrycndxd.h:413

FvBndryCndXD::m_spongeLayerThickness
MFloat m_spongeLayerThickness
Definition: fvcartesianbndrycndxd.h:328

FvBndryCndXD::m_static_cbc1099_1091_local_domainMin
MInt m_static_cbc1099_1091_local_domainMin
Definition: fvcartesianbndrycndxd.h:917

FvBndryCndXD::m_noSpecies
MInt m_noSpecies
Definition: fvcartesianbndrycndxd.h:391

FvBndryCndXD::ATTRIBUTES2
ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void correctBoundarySurfaceVariables()

FvBndryCndXD::m_static_cbc1091_dirN
MInt m_static_cbc1091_dirN
Definition: fvcartesianbndrycndxd.h:930

FvBndryCndXD::bcNeumannIsothermalUnburntProfile
void bcNeumannIsothermalUnburntProfile(MInt)
Computes the p and rho slopes on boundary cells using the least-squares method and setting implicitel...
Definition: fvcartesianbndrycndxd.cpp:13430

FvBndryCndXD::m_comm_bcCo
MPI_Comm * m_comm_bcCo
Definition: fvcartesianbndrycndxd.h:477

FvBndryCndXD::bc2700
void bc2700(MInt)
Definition: fvcartesianbndrycndxd.cpp:15108

FvBndryCndXD::m_static_cbc1099_dirN
MInt m_static_cbc1099_dirN
Definition: fvcartesianbndrycndxd.h:901

FvBndryCndXD::cbc1099
void cbc1099(MInt)
Definition: fvcartesianbndrycndxd.cpp:21038

FvBndryCndXD::updateCutOffCellVariables
void updateCutOffCellVariables()
Definition: fvcartesianbndrycndxd.cpp:1630

FvBndryCndXD::m_static_cbc1091_first
MBool m_static_cbc1091_first
Definition: fvcartesianbndrycndxd.h:929

FvBndryCndXD::m_static_cbc1091e_first
MBool m_static_cbc1091e_first
Definition: fvcartesianbndrycndxd.h:986

FvBndryCndXD::bcNeumannIsothermalBurntProfileH
void bcNeumannIsothermalBurntProfileH(MInt)
Computes the p and rho slopes on boundary cells using the least-squares method and setting implicitel...
Definition: fvcartesianbndrycndxd.cpp:13341

FvBndryCndXD::m_createSpongeBoundary
MBool m_createSpongeBoundary
Definition: fvcartesianbndrycndxd.h:317

FvBndryCndXD::vecScalarMul
MFloat * vecScalarMul(MFloat, MFloat *, MFloat *)

FvBndryCndXD::bc1002
void bc1002(MInt)
Definition: fvcartesianbndrycndxd.cpp:13925

FvBndryCndXD::m_bndryNghbrs
MInt * m_bndryNghbrs
Definition: fvcartesianbndrycndxd.h:141

FvBndryCndXD::bc30021
void bc30021(MInt)
Definition: fvcartesianbndrycndxd.cpp:5563

FvBndryCndXD::m_splitSurfaces
MInt * m_splitSurfaces
Definition: fvcartesianbndrycndxd.h:140

FvBndryCndXD::m_azimuthalNearBoundaryHaloCells
std::vector< std::vector< MInt > > m_azimuthalNearBoundaryHaloCells
Definition: fvcartesianbndrycndxd.h:302

FvBndryCndXD::bc3011
void bc3011(MInt)
Definition: fvcartesianbndrycndxd.cpp:5463

FvBndryCndXD::bc2770
virtual void bc2770(MInt)
Definition: fvcartesianbndrycndxd.h:248

FvBndryCndXD::bcNeumannIso
void bcNeumannIso(MInt)
Definition: fvcartesianbndrycndxd.cpp:5659

FvBndryCndXD::m_7901periodicLocations
std::vector< MFloat > * m_7901periodicLocations
Definition: fvcartesianbndrycndxd.h:420

FvBndryCndXD::bc16014
void bc16014(MInt)
Definition: fvcartesianbndrycndxd.cpp:16423

FvBndryCndXD::bc1003
virtual void bc1003(MInt)
Definition: fvcartesianbndrycndxd.h:256

FvBndryCndXD::m_static_bc1099MGC_first
bool m_static_bc1099MGC_first
Definition: fvcartesianbndrycndxd.h:886

FvBndryCndXD::bc1603
void bc1603(MInt)
Definition: fvcartesianbndrycndxd.cpp:14777

FvBndryCndXD::m_dirNBc11110
MInt * m_dirNBc11110
Definition: fvcartesianbndrycndxd.h:897

FvBndryCndXD::m_7902globalNoPeriodicLocations
MInt * m_7902globalNoPeriodicLocations
Definition: fvcartesianbndrycndxd.h:434

FvBndryCndXD::m_comm_bc_init
MInt m_comm_bc_init
Definition: fvcartesianbndrycndxd.h:475

FvBndryCndXD::createBndryCells
void createBndryCells()
Definition: fvcartesianbndrycndxd.cpp:12416

FvBndryCndXD::bndryCndHandlerInit
BndryCndHandler * bndryCndHandlerInit
Definition: fvcartesianbndrycndxd.h:276

FvBndryCndXD::m_sigmaShock
MFloat m_sigmaShock
Definition: fvcartesianbndrycndxd.h:361

FvBndryCndXD::m_dirTangent
std::vector< std::vector< MFloat > > m_dirTangent
Definition: fvcartesianbndrycndxd.h:460

FvBndryCndXD::computeTri
void computeTri(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::m_7901periodicDir
MInt m_7901periodicDir
Definition: fvcartesianbndrycndxd.h:412

FvBndryCndXD::cbcMeanPressureCo
void cbcMeanPressureCo(MInt, MFloat *)
Definition: fvcartesianbndrycndxd.cpp:20105

FvBndryCndXD::m_cutCandidates
std::vector< CutCandidate< nDim > > m_cutCandidates
Definition: fvcartesianbndrycndxd.h:481

FvBndryCndXD::m_static_cbc1091c_after_dirN
MInt m_static_cbc1091c_after_dirN
Definition: fvcartesianbndrycndxd.h:966

FvBndryCndXD::m_static_cbc2091b_H
MFloat m_static_cbc2091b_H
Definition: fvcartesianbndrycndxd.h:1008

FvBndryCndXD::m_static_cbc3091a_dimT2
MInt m_static_cbc3091a_dimT2
Definition: fvcartesianbndrycndxd.h:944

FvBndryCndXD::m_multipleGhostCells
MInt m_multipleGhostCells
Definition: fvcartesianbndrycndxd.h:337

FvBndryCndXD::computeGhostCells
void computeGhostCells()
Definition: fvcartesianbndrycndxd.cpp:625

FvBndryCndXD::m_bndryCndCells
MInt * m_bndryCndCells
Definition: fvcartesianbndrycndxd.h:334

FvBndryCndXD::detectSmallBndryCells
void detectSmallBndryCells()
Detects small cells and identifies a master cell Calls mergeCell to merge master and small cell.
Definition: fvcartesianbndrycndxd.cpp:7851

FvBndryCndXD::markCutOff
void markCutOff(MIntScratchSpace &cutOffCells)
Definition: fvcartesianbndrycndxd.cpp:1975

FvBndryCndXD::m_cbcTurbulence
MBool m_cbcTurbulence
Definition: fvcartesianbndrycndxd.h:465

FvBndryCndXD::m_static_cbc2099_1091_local_comb_first
MBool m_static_cbc2099_1091_local_comb_first
Definition: fvcartesianbndrycndxd.h:1025

FvBndryCndXD::computePlaneVectors
void computePlaneVectors()
uses Gram-Schmidt to compute orthonormal vectors in the cut plane
Definition: fvcartesianbndrycndxd.cpp:12599

FvBndryCndXD::m_static_cbc2091a_inflowArea
MFloat m_static_cbc2091a_inflowArea
Definition: fvcartesianbndrycndxd.h:998

FvBndryCndXD::bc16015
void bc16015(MInt)
Definition: fvcartesianbndrycndxd.cpp:16456

FvBndryCndXD::bc3399
void bc3399(MInt)
Definition: fvcartesianbndrycndxd.cpp:6940

FvBndryCndXD::ATTRIBUTES2
ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void copySlopesToSmallCells()

FvBndryCndXD::bc7903
void bc7903(MInt)
Definition: fvcartesianbndrycndxd.cpp:17550

FvBndryCndXD::createCutFace
void createCutFace()
computes the geometry of each the cut cells (2D version) 2 cut points are assumed for each boundary c...
Definition: fvcartesianbndrycndxd.cpp:23691

FvBndryCndXD::FvBndryCndXD
FvBndryCndXD(FvCartesianSolverXD< nDim, SysEqn > *solver)

FvBndryCndXD::m_7901faceNormalDir
MInt m_7901faceNormalDir
Definition: fvcartesianbndrycndxd.h:409

FvBndryCndXD::checkInside
MBool checkInside(MInt)
checks if all corners of a cell are located in the computational domain
Definition: fvcartesianbndrycndxd.cpp:9985

FvBndryCndXD::bc16012
void bc16012(MInt)
Definition: fvcartesianbndrycndxd.cpp:16358

FvBndryCndXD::m_static_cbc1091d_after_dimT1
MInt m_static_cbc1091d_after_dimT1
Definition: fvcartesianbndrycndxd.h:983

FvBndryCndXD::m_static_cbc1099_1091_local_H
MFloat m_static_cbc1099_1091_local_H
Definition: fvcartesianbndrycndxd.h:919

FvBndryCndXD::m_static_cbc3091a_dirN
MInt m_static_cbc3091a_dirN
Definition: fvcartesianbndrycndxd.h:941

FvBndryCndXD::m_static_cbc1091d_after_first
MBool m_static_cbc1091d_after_first
Definition: fvcartesianbndrycndxd.h:980

FvBndryCndXD::m_static_cbc1099_1091_local_dimN
MInt m_static_cbc1099_1091_local_dimN
Definition: fvcartesianbndrycndxd.h:911

FvBndryCndXD::bcInit0002
void bcInit0002(MInt)
Sets up the reconstruction stencil for boundary cells.
Definition: fvcartesianbndrycndxd.cpp:4410

FvBndryCndXD::bc1091
void bc1091(MInt)
Definition: fvcartesianbndrycndxd.cpp:14084

FvBndryCndXD::m_static_cbc1091b_dimN
MInt m_static_cbc1091b_dimN
Definition: fvcartesianbndrycndxd.h:952

FvBndryCndXD::m_static_cbc1099_dimT2
MInt m_static_cbc1099_dimT2
Definition: fvcartesianbndrycndxd.h:904

FvBndryCndXD::bc30022
void bc30022(MInt)
Definition: fvcartesianbndrycndxd.cpp:17713

FvBndryCndXD::bc1099MGC
void bc1099MGC(MInt)
Definition: fvcartesianbndrycndxd.cpp:22833

FvBndryCndXD::m_static_cbc1091c_after_dimT1
MInt m_static_cbc1091c_after_dimT1
Definition: fvcartesianbndrycndxd.h:968

FvBndryCndXD::m_isEEGas
MBool m_isEEGas
Definition: fvcartesianbndrycndxd.h:394

FvBndryCndXD::m_static_cbc1091b_referencePoint
MFloat m_static_cbc1091b_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:956

FvBndryCndXD::cbcTurbulenceInjection
void cbcTurbulenceInjection(MInt, MFloat *, MInt)
Turbulence injection (identical to bc1601) adjusted for Taylor's Hypothesis for cbc.
Definition: fvcartesianbndrycndxd.cpp:20381

FvBndryCndXD::computeCutPoints
void computeCutPoints()
computes the cut points where a boundary cell intersects with the geometry computes the following bou...

FvBndryCndXD::correctCellCoordinates
void correctCellCoordinates()
Definition: fvcartesianbndrycndxd.cpp:517

FvBndryCndXD::m_static_cbc1091d_first
MBool m_static_cbc1091d_first
Definition: fvcartesianbndrycndxd.h:971

FvBndryCndXD::m_static_cbc1099_1091_local_first
MBool m_static_cbc1099_1091_local_first
Definition: fvcartesianbndrycndxd.h:909

FvBndryCndXD::computeReconstructionConstants_interpolation
void computeReconstructionConstants_interpolation()

FvBndryCndXD::m_outputIGPoints
MBool m_outputIGPoints
Definition: fvcartesianbndrycndxd.h:318

FvBndryCndXD::cbc1291
void cbc1291(MInt)

FvBndryCndXD::m_sortedCutOffCells
std::vector< List< MInt > * > m_sortedCutOffCells
Definition: fvcartesianbndrycndxd.h:136

FvBndryCndXD::m_static_cbc2091d_after_first
MBool m_static_cbc2091d_after_first
Definition: fvcartesianbndrycndxd.h:1020

FvBndryCndXD::cbc1099_1091_engineOld
void cbc1099_1091_engineOld(MInt)

FvBndryCndXD::m_static_bc1091MGC_minTimeSteps
MInt m_static_bc1091MGC_minTimeSteps
Definition: fvcartesianbndrycndxd.h:879

FvBndryCndXD::m_7901LESAverage
MFloat ** m_7901LESAverage
Definition: fvcartesianbndrycndxd.h:416

FvBndryCndXD::m_static_cbc2091a_referencePoint
MFloat m_static_cbc2091a_referencePoint[nDim]
Definition: fvcartesianbndrycndxd.h:1000

FvBndryCndXD::m_static_cbc2091d_dimN
MInt m_static_cbc2091d_dimN
Definition: fvcartesianbndrycndxd.h:1013

FvBndryCndXD::m_static_cbc1091_dimN
MInt m_static_cbc1091_dimN
Definition: fvcartesianbndrycndxd.h:931

FvBndryCndXD::m_nu
MFloat m_nu[10]
Definition: fvcartesianbndrycndxd.h:395

FvBndryCndXD::m_Ma
MFloat m_Ma
Definition: fvcartesianbndrycndxd.h:387

FvBndryCndXD::exchangeCutOffBoundaryCells
void exchangeCutOffBoundaryCells()
exchanges the cut off boundary cells and adds them to the accordings cut off boundary lists
Definition: fvcartesianbndrycndxd.cpp:1873

FvBndryCndXD::cbcGradientsViscous
void cbcGradientsViscous(MInt, MInt, MFloat *, MFloat *, MFloat *, MFloat *, MInt *)
Calculates the viscous gradients of the cbcCell.
Definition: fvcartesianbndrycndxd.cpp:19875

FvBndryCndXD::m_cellMerging
MBool m_cellMerging
Definition: fvcartesianbndrycndxd.h:304

FvBndryCndXD::m_volumeLimitOther
MFloat m_volumeLimitOther
Definition: fvcartesianbndrycndxd.h:354

FvBndryCndXD::m_7902StartTimeStep
MInt m_7902StartTimeStep
Definition: fvcartesianbndrycndxd.h:430

FvBndryCndXD::correctBoundarySurfaceVariablesMGC
void correctBoundarySurfaceVariablesMGC()
corrects the left and right variables values on the boundary surface
Definition: fvcartesianbndrycndxd.cpp:1171

FvBndryCndXD::cbc1091a
void cbc1091a(MInt)
Definition: fvcartesianbndrycndxd.cpp:20457

FvBndryCndXD::m_azimuthalNearBoundaryWindowCells
std::vector< std::vector< MInt > > m_azimuthalNearBoundaryWindowCells
Definition: fvcartesianbndrycndxd.h:300

FvBndryCndXD::computeCutoffBoundaryGeometry
MFloat computeCutoffBoundaryGeometry(const MInt, const MInt, MFloat *)
computes centroid and radius (return parameter) of a cut-off boundary surface assumes that the surfac...
Definition: fvcartesianbndrycndxd.cpp:12324

FvBndryCndXD::correctBoundarySurfaceVariablesMGCSurface
void correctBoundarySurfaceVariablesMGCSurface()
corrects the left and right variables values on the boundary surface
Definition: fvcartesianbndrycndxd.cpp:1258

FvBndryCndXD::bc3002
void bc3002(MInt)
Definition: fvcartesianbndrycndxd.cpp:5510

FvBndryCndXD::m_cbcRelax
std::vector< std::vector< MFloat > > m_cbcRelax
Definition: fvcartesianbndrycndxd.h:459

FvBndryCndXD::m_shearLayerStrength
MFloat m_shearLayerStrength
Definition: fvcartesianbndrycndxd.h:386

FvBndryCndXD::AV
SysEqn::AdditionalVariables * AV
Definition: fvcartesianbndrycndxd.h:155

FvBndryCndXD::bc1156
void bc1156(MInt)
Definition: fvcartesianbndrycndxd.cpp:14324

FvBndryCndXD::computePoly5
void computePoly5(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::bc16011
void bc16011(MInt)
Definition: fvcartesianbndrycndxd.cpp:16305

FvBndryCndXD::correctMasterSlaveSurfaces
void correctMasterSlaveSurfaces()
Removes surfaces between master-slave pairs and reassigns slave cell surfaces.
Definition: fvcartesianbndrycndxd.cpp:12816

FvBndryCndXD::m_radiusVelFlameTube
MFloat m_radiusVelFlameTube
Definition: fvcartesianbndrycndxd.h:379

FvBndryCndXD::m_geometryIntersection
GeometryIntersection< nDim > * m_geometryIntersection
Definition: fvcartesianbndrycndxd.h:482

FvBndryCndXD::m_static_cbc1099_1091d_dirN
MInt m_static_cbc1099_1091d_dirN
Definition: fvcartesianbndrycndxd.h:1033

FvBndryCndXD::m_static_cbc1091c_after_dimT2
MInt m_static_cbc1091c_after_dimT2
Definition: fvcartesianbndrycndxd.h:969

FvBndryCndXD::m_clusterCutOffBcs
MBool m_clusterCutOffBcs
Definition: fvcartesianbndrycndxd.h:368

FvBndryCndXD::bc3037MGC
virtual void bc3037MGC(MInt)
Definition: fvcartesianbndrycndxd.h:861

FvBndryCndXD::m_spongeTimeDep
MBool m_spongeTimeDep
Definition: fvcartesianbndrycndxd.h:330

FvBndryCndXD::m_7902LESAverage
MFloat ** m_7902LESAverage
Definition: fvcartesianbndrycndxd.h:435

FvBndryCndXD::m_static_cbc1091c_dimN
MInt m_static_cbc1091c_dimN
Definition: fvcartesianbndrycndxd.h:960

FvBndryCndXD::m_static_cbc2099_1091_local_comb_dimN
MInt m_static_cbc2099_1091_local_comb_dimN
Definition: fvcartesianbndrycndxd.h:1027

FvBndryCndXD::m_noDirs
MInt m_noDirs
Definition: fvcartesianbndrycndxd.h:119

FvBndryCndXD::cbc1099_1091d
void cbc1099_1091d(MInt)
Definition: fvcartesianbndrycndxd.cpp:22905

FvBndryCndXD::computeImagePointRecConst
void computeImagePointRecConst(MInt updateOnlyBndryCndId=-1)
Definition: fvcartesianbndrycndxd.cpp:9293

FvBndryCndXD::bc2003
virtual void bc2003(MInt)
Definition: fvcartesianbndrycndxd.h:263

FvBndryCndXD::bc29050
void bc29050(MInt)
Definition: fvcartesianbndrycndxd.cpp:17815

FvBndryCndXD::m_static_cbc1099_referencePoint
MFloat m_static_cbc1099_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:906

FvBndryCndXD::m_splitChildren
MInt * m_splitChildren
Definition: fvcartesianbndrycndxd.h:143

FvBndryCndXD::m_vnTargetData
std::pair< MFloat, MFloat > * m_vnTargetData
Definition: fvcartesianbndrycndxd.h:1058

FvBndryCndXD::bndryCndHandlerCutOffVariables
BndryCndHandler * bndryCndHandlerCutOffVariables
Definition: fvcartesianbndrycndxd.h:281

FvBndryCndXD::bc10990
virtual void bc10990(MInt)
Definition: fvcartesianbndrycndxd.h:252

FvBndryCndXD::m_static_bc1091MGC_nghbrDir
MInt m_static_bc1091MGC_nghbrDir
Definition: fvcartesianbndrycndxd.h:880

FvBndryCndXD::bc3003
void bc3003(MInt)
Definition: fvcartesianbndrycndxd.cpp:5257

FvBndryCndXD::bc1602
void bc1602(MInt)
Definition: fvcartesianbndrycndxd.cpp:14601

FvBndryCndXD::nonReflectingBoundaryConditionAfterTreatmentCutOff
BndryCndHandler * nonReflectingBoundaryConditionAfterTreatmentCutOff
Definition: fvcartesianbndrycndxd.h:284

FvBndryCndXD::sbc2000
void sbc2000(MInt)
Definition: fvcartesianbndrycndxd.cpp:6659

FvBndryCndXD::writeStlFileOfCell
void writeStlFileOfCell(MInt, const char *)
Only 3D ///.

FvBndryCndXD::bcInit7902
void bcInit7902(MInt)
Definition: fvcartesianbndrycndxd.cpp:16697

FvBndryCndXD::m_spongeStartIteration
MFloat * m_spongeStartIteration
Definition: fvcartesianbndrycndxd.h:331

FvBndryCndXD::m_static_cbc1099_dimT1
MInt m_static_cbc1099_dimT1
Definition: fvcartesianbndrycndxd.h:903

FvBndryCndXD::updateGhostCellVariables
void updateGhostCellVariables()
Definition: fvcartesianbndrycndxd.cpp:1618

FvBndryCndXD::m_smallBndryCells
List< MInt > * m_smallBndryCells
Definition: fvcartesianbndrycndxd.h:133

FvBndryCndXD::m_static_bc1099MGC_timeOfMaxPdiff
MFloat m_static_bc1099MGC_timeOfMaxPdiff
Definition: fvcartesianbndrycndxd.h:885

FvBndryCndXD::m_static_cbc2091a_dimT1
MInt m_static_cbc2091a_dimT1
Definition: fvcartesianbndrycndxd.h:996

FvBndryCndXD::bc1101
void bc1101(MInt)
Definition: fvcartesianbndrycndxd.cpp:14197

FvBndryCndXD::correctNormal
void correctNormal(MFloat *)

FvBndryCndXD::writeStlOfNodes
void writeStlOfNodes(MInt, MInt *&, const char *)

FvBndryCndXD::m_sigmaEndSpongeBndryId
MFloat * m_sigmaEndSpongeBndryId
Definition: fvcartesianbndrycndxd.h:327

FvBndryCndXD::m_static_initSmallCellCorrection_firstRun
MBool m_static_initSmallCellCorrection_firstRun
Definition: fvcartesianbndrycndxd.h:504

FvBndryCndXD::ATTRIBUTES2
ATTRIBUTES2(ATTRIBUTE_HOT, ATTRIBUTE_FLATTEN) void copyVarsToSmallCells()

FvBndryCndXD::bc11110
void bc11110(MInt)

FvBndryCndXD::m_nearBoundaryHaloCells
std::vector< MInt > * m_nearBoundaryHaloCells
Definition: fvcartesianbndrycndxd.h:298

FvBndryCndXD::getFeatureEdges
void getFeatureEdges(MInt &, MFloat **&, MInt, MInt *&, MFloat *&, MFloat *&)

FvBndryCndXD::bc7809
void bc7809(MInt)
Definition: fvcartesianbndrycndxd.cpp:17637

FvBndryCndXD::cbc1099_1091_engine
void cbc1099_1091_engine(MInt)
Definition: fvcartesianbndrycndxd.cpp:23219

FvBndryCndXD::bc01
void bc01(MInt)
Definition: fvcartesianbndrycndxd.cpp:13774

FvBndryCndXD::m_static_cbc1099_1091d_targetPressure
MFloat m_static_cbc1099_1091d_targetPressure
Definition: fvcartesianbndrycndxd.h:1039

FvBndryCndXD::m_static_cbc1099_dimN
MInt m_static_cbc1099_dimN
Definition: fvcartesianbndrycndxd.h:902

FvBndryCndXD::bc16013
void bc16013(MInt)
Definition: fvcartesianbndrycndxd.cpp:16390

FvBndryCndXD::correctCell
void correctCell(MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::bndryViscousSlopes
BndryCndHandler * bndryViscousSlopes
Definition: fvcartesianbndrycndxd.h:290

FvBndryCndXD::computeMirrorCoordinates
void computeMirrorCoordinates(MInt, MFloat *, MInt)
Definition: fvcartesianbndrycndxd.cpp:933

FvBndryCndXD::bc1102
void bc1102(MInt)
Definition: fvcartesianbndrycndxd.cpp:14262

FvBndryCndXD::addBoundarySurfacesMGC
void addBoundarySurfacesMGC()
adds a surface for the ghost-boundary cell intersections
Definition: fvcartesianbndrycndxd.cpp:1068

FvBndryCndXD::m_4000timeStepOffset
MFloat m_4000timeStepOffset
Definition: fvcartesianbndrycndxd.h:309

FvBndryCndXD::m_noFluxRedistributionLayers
MInt m_noFluxRedistributionLayers
Definition: fvcartesianbndrycndxd.h:306

FvBndryCndXD::m_Bc2770TargetCells
MInt * m_Bc2770TargetCells
Definition: fvcartesianbndrycndxd.h:360

FvBndryCndXD::cbc109921
void cbc109921(MInt)
Characteristic boundary condition. Outflow. Prescribed: p. Partially Refelecting.
Definition: fvcartesianbndrycndxd.cpp:20695

FvBndryCndXD::m_static_cbc2091a_solverProfile
MBool m_static_cbc2091a_solverProfile
Definition: fvcartesianbndrycndxd.h:997

FvBndryCndXD::m_static_cbc1091b_solverProfile
MBool m_static_cbc1091b_solverProfile
Definition: fvcartesianbndrycndxd.h:954

FvBndryCndXD::m_static_cbc1099_1091_engine_dimN
MInt m_static_cbc1099_1091_engine_dimN
Definition: fvcartesianbndrycndxd.h:1048

FvBndryCndXD::m_noRansEquations
MInt m_noRansEquations
Definition: fvcartesianbndrycndxd.h:392

FvBndryCndXD::m_changeAdiabBCToTemp
MBool m_changeAdiabBCToTemp
Definition: fvcartesianbndrycndxd.h:145

FvBndryCndXD::m_besselTrig
MFloat * m_besselTrig
Definition: fvcartesianbndrycndxd.h:374

FvBndryCndXD::getIntersectionPoints
void getIntersectionPoints(MFloat **&, MFloat **&, MInt, MInt, MFloat **&, MInt &)

FvBndryCndXD::m_dirNBc10970
MInt m_dirNBc10970
Definition: fvcartesianbndrycndxd.h:890

FvBndryCndXD::m_deltaPL
MFloat m_deltaPL
Definition: fvcartesianbndrycndxd.h:389

FvBndryCndXD::m_static_cbc3091a_inflowArea
MFloat m_static_cbc3091a_inflowArea
Definition: fvcartesianbndrycndxd.h:946

FvBndryCndXD::m_static_cbc1091_referencePoint
MFloat m_static_cbc1091_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:935

FvBndryCndXD::m_static_cbc3091a_dimT1
MInt m_static_cbc3091a_dimT1
Definition: fvcartesianbndrycndxd.h:943

FvBndryCndXD::updateImagePointVariables
MFloat updateImagePointVariables(MInt)
Updates the image point variables used with multiple ghost cell formulation.
Definition: fvcartesianbndrycndxd.cpp:13083

FvBndryCndXD::m_static_cbc1099_1091d_dimT2
MInt m_static_cbc1099_1091d_dimT2
Definition: fvcartesianbndrycndxd.h:1036

FvBndryCndXD::m_surfaces
maia::fv::surface_collector::FvSurfaceCollector< nDim > & m_surfaces
Definition: fvcartesianbndrycndxd.h:132

FvBndryCndXD::m_static_cbc1099_1091_local_comb_dirN
MInt m_static_cbc1099_1091_local_comb_dirN
Definition: fvcartesianbndrycndxd.h:922

FvBndryCndXD::bcNeumannIsothermal
void bcNeumannIsothermal(MInt)
Computes the p and rho slopes on boundary cells using the least-squares method and setting implicitel...
Definition: fvcartesianbndrycndxd.cpp:13187

FvBndryCndXD::bc1792
void bc1792(MInt)
Definition: fvcartesianbndrycndxd.cpp:15005

FvBndryCndXD::plotIntersectionPoints
void plotIntersectionPoints(MInt *, MFloat ***&)

FvBndryCndXD::m_static_cbc1099_1091_local_targetPressure
MFloat m_static_cbc1099_1091_local_targetPressure
Definition: fvcartesianbndrycndxd.h:916

FvBndryCndXD::createCutFaceMGC
void createCutFaceMGC()
ONLY 3D VERSIONS.
Definition: fvcartesianbndrycndxd.cpp:24899

FvBndryCndXD::m_static_cbc2091d_first
MBool m_static_cbc2091d_first
Definition: fvcartesianbndrycndxd.h:1011

FvBndryCndXD::m_deltaP
MFloat m_deltaP
Definition: fvcartesianbndrycndxd.h:388

FvBndryCndXD::correctCoarseBndryCells
void correctCoarseBndryCells()
Definition: fvcartesianbndrycndxd.cpp:8908

FvBndryCndXD::correctFace
void correctFace(MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::m_static_cbc3091a_first
MBool m_static_cbc3091a_first
Definition: fvcartesianbndrycndxd.h:940

FvBndryCndXD::m_static_cbc1099_1091d_after_dimN
MInt m_static_cbc1099_1091d_after_dimN
Definition: fvcartesianbndrycndxd.h:1043

FvBndryCndXD::bcNeumannIsothermalBurntProfile
void bcNeumannIsothermalBurntProfile(MInt)
Computes the p and rho slopes on boundary cells using the least-squares method and setting implicitel...
Definition: fvcartesianbndrycndxd.cpp:13253

FvBndryCndXD::m_static_cbc1099_1091_engine_dimT1
MInt m_static_cbc1099_1091_engine_dimT1
Definition: fvcartesianbndrycndxd.h:1049

FvBndryCndXD::bc1401
virtual void bc1401(MInt)
Definition: fvcartesianbndrycndxd.h:259

FvBndryCndXD::updateRHSSmallCells
void updateRHSSmallCells()
Definition: fvcartesianbndrycndxd.cpp:9016

FvBndryCndXD::m_static_bc1091MGC_first2
MInt m_static_bc1091MGC_first2
Definition: fvcartesianbndrycndxd.h:883

FvBndryCndXD::m_static_cbc2091b_inflowArea
MFloat m_static_cbc2091b_inflowArea
Definition: fvcartesianbndrycndxd.h:1007

FvBndryCndXD::m_sortedSpongeBndryCells
List< MInt > * m_sortedSpongeBndryCells
Definition: fvcartesianbndrycndxd.h:135

FvBndryCndXD::correctInflowBoundary
void correctInflowBoundary(MInt)

FvBndryCndXD::m_7901BcActive
MInt m_7901BcActive
Definition: fvcartesianbndrycndxd.h:410

FvBndryCndXD::vecSub
MFloat * vecSub(MFloat *, MFloat *, MFloat *)

FvBndryCndXD::BndryCndHandlerVar
void(FvBndryCndXD::* BndryCndHandlerVar)(MInt)
Definition: fvcartesianbndrycndxd.h:275

FvBndryCndXD::m_gridCutTest
MString m_gridCutTest
Definition: fvcartesianbndrycndxd.h:472

FvBndryCndXD::cbc1091
void cbc1091(MInt)
Definition: fvcartesianbndrycndxd.cpp:17891

FvBndryCndXD::correctInflowBoundary
void correctInflowBoundary(MInt, MBool=false)
Definition: fvcartesianbndrycndxd.h:568

FvBndryCndXD::resetCutOffFirst
void resetCutOffFirst()
reset first for cutOffBndryCnd, this is necessary after a balance!
Definition: fvcartesianbndrycndxd.cpp:23614

FvBndryCndXD::m_static_cbc2091a_H
MFloat m_static_cbc2091a_H
Definition: fvcartesianbndrycndxd.h:999

FvBndryCndXD::cbc2091b
void cbc2091b(MInt)
Definition: fvcartesianbndrycndxd.cpp:21323

FvBndryCndXD::m_noCutOffBndryCndIds
MInt m_noCutOffBndryCndIds
Definition: fvcartesianbndrycndxd.h:343

FvBndryCndXD::m_static_cbc1091c_after_dimN
MInt m_static_cbc1091c_after_dimN
Definition: fvcartesianbndrycndxd.h:967

FvBndryCndXD::m_secondOrderRec
MBool m_secondOrderRec
Definition: fvcartesianbndrycndxd.h:305

FvBndryCndXD::m_static_cbc1099_1091d_after_dirN
MInt m_static_cbc1099_1091d_after_dirN
Definition: fvcartesianbndrycndxd.h:1042

FvBndryCndXD::m_rntRoot
MInt m_rntRoot
Definition: fvcartesianbndrycndxd.h:427

FvBndryCndXD::m_horTargetData
MFloat ** m_horTargetData
Definition: fvcartesianbndrycndxd.h:1061

FvBndryCndXD::plotTriangle
void plotTriangle(std::ofstream &, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::cbc1091c
void cbc1091c(MInt)
Definition: fvcartesianbndrycndxd.cpp:18255

FvBndryCndXD::cbc1091c_after
void cbc1091c_after(MInt)
Subsonic fully reflecting characteristic inflow condition - cut off - sets T0,u,v to prescribed value...
Definition: fvcartesianbndrycndxd.cpp:18358

FvBndryCndXD::m_horTargetDataCount
MInt m_horTargetDataCount
Definition: fvcartesianbndrycndxd.h:1062

FvBndryCndXD::checkCutPointsValidity
void checkCutPointsValidity()
checks the validity of a boundary cell
Definition: fvcartesianbndrycndxd.cpp:11890

FvBndryCndXD::m_shockBcVars
MFloat ** m_shockBcVars
Definition: fvcartesianbndrycndxd.h:357

FvBndryCndXD::m_meanCoord
MFloat m_meanCoord[3]
Definition: fvcartesianbndrycndxd.h:355

FvBndryCndXD::cbc2091a
void cbc2091a(MInt)
Definition: fvcartesianbndrycndxd.cpp:21134

FvBndryCndXD::m_momentumThickness
MFloat m_momentumThickness
Definition: fvcartesianbndrycndxd.h:385

FvBndryCndXD::m_modes
MInt m_modes
Definition: fvcartesianbndrycndxd.h:372

FvBndryCndXD::m_comm_bcCo_init
MInt m_comm_bcCo_init
Definition: fvcartesianbndrycndxd.h:478

FvBndryCndXD::plotEdges
void plotEdges(MInt &, MFloat **&)

FvBndryCndXD::addModes
void addModes(MInt)
supersonic inflow with imposed onlique shock wave version: cut-off boundary condition author: Thomas ...
Definition: fvcartesianbndrycndxd.cpp:7055

FvBndryCndXD::computeNeumannLSConstants
void computeNeumannLSConstants(MInt)
Sets up the reconstruction stencil for boundary cells.
Definition: fvcartesianbndrycndxd.cpp:12867

FvBndryCndXD::m_static_cbc1091c_dimT1
MInt m_static_cbc1091c_dimT1
Definition: fvcartesianbndrycndxd.h:961

FvBndryCndXD::m_noCellsInsideSpongeLayer
MInt m_noCellsInsideSpongeLayer
Definition: fvcartesianbndrycndxd.h:322

FvBndryCndXD::m_static_cbc2091b_solverProfile
MBool m_static_cbc2091b_solverProfile
Definition: fvcartesianbndrycndxd.h:1006

FvBndryCndXD::m_wFactor
MFloat m_wFactor
Definition: fvcartesianbndrycndxd.h:311

FvBndryCndXD::cbcTransversalTerms
void cbcTransversalTerms(MInt, MInt, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)
Calculates the transversal correction terms T.
Definition: fvcartesianbndrycndxd.cpp:20045

FvBndryCndXD::m_noLevelSetsUsedForMb
MInt m_noLevelSetsUsedForMb
Definition: fvcartesianbndrycndxd.h:148

FvBndryCndXD::m_boundarySurfaces
MInt * m_boundarySurfaces
Definition: fvcartesianbndrycndxd.h:336

FvBndryCndXD::m_cbcDir
std::vector< std::vector< MInt > > m_cbcDir
Definition: fvcartesianbndrycndxd.h:463

FvBndryCndXD::computePoly4
void computePoly4(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::m_reconstructionConstants
MFloat ** m_reconstructionConstants
Definition: fvcartesianbndrycndxd.h:294

FvBndryCndXD::m_static_cbc1091b_inflowArea
MFloat m_static_cbc1091b_inflowArea
Definition: fvcartesianbndrycndxd.h:955

FvBndryCndXD::applyNonReflectingBCCutOff
void applyNonReflectingBCCutOff()
Definition: fvcartesianbndrycndxd.cpp:2065

FvBndryCndXD::plotSurface
void plotSurface()

FvBndryCndXD::bc2002
virtual void bc2002(MInt)
Definition: fvcartesianbndrycndxd.h:262

FvBndryCndXD::computePoly6
void computePoly6(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::detectSmallBndryCellsMGC
void detectSmallBndryCellsMGC()
Detects small cells and identifies a master cell Calls mergeCell to merge master and small cell.

FvBndryCndXD::cbc1299a
void cbc1299a(MInt)

FvBndryCndXD::cbc1091b
void cbc1091b(MInt)
Definition: fvcartesianbndrycndxd.cpp:18023

FvBndryCndXD::createSplitCell_MGC
MInt createSplitCell_MGC(MInt, MInt)
produces an exact copy of a fvcell and the respective boundary cell
Definition: fvcartesianbndrycndxd.cpp:29206

FvBndryCndXD::m_noBndryCndIds
MInt m_noBndryCndIds
Definition: fvcartesianbndrycndxd.h:341

FvBndryCndXD::m_static_cbc2091d_after_dimT1
MInt m_static_cbc2091d_after_dimT1
Definition: fvcartesianbndrycndxd.h:1023

FvBndryCndXD::cbc1091e
void cbc1091e(MInt)
Definition: fvcartesianbndrycndxd.cpp:19530

FvBndryCndXD::m_static_cbc1099_1091_engine_first
MBool m_static_cbc1099_1091_engine_first
Definition: fvcartesianbndrycndxd.h:1046

FvBndryCndXD::m_nmbrOfModes
MInt * m_nmbrOfModes
Definition: fvcartesianbndrycndxd.h:369

FvBndryCndXD::m_spongeTimeDependent
MInt * m_spongeTimeDependent
Definition: fvcartesianbndrycndxd.h:333

FvBndryCndXD::cbcOutgoingAmplitudeVariation
void cbcOutgoingAmplitudeVariation(MInt, MInt, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)
Calculates the outgoing terms wave amplitude variation L.
Definition: fvcartesianbndrycndxd.cpp:19994

FvBndryCndXD::bc3006
void bc3006(MInt)
Definition: fvcartesianbndrycndxd.cpp:15660

FvBndryCndXD::m_static_cbc1091b_dimT1
MInt m_static_cbc1091b_dimT1
Definition: fvcartesianbndrycndxd.h:953

FvBndryCndXD::m_static_cbc1091c_after_first
MBool m_static_cbc1091c_after_first
Definition: fvcartesianbndrycndxd.h:965

FvBndryCndXD::setBCTypes
void setBCTypes(MInt updateOnlyBndryCndId=-1)
Definition: fvcartesianbndrycndxd.cpp:2266

FvBndryCndXD::cbcDampingInflow
void cbcDampingInflow(MInt, MInt, MFloat, MFloat *, MString)
Calculates the inflow damping terms.
Definition: fvcartesianbndrycndxd.cpp:20221

FvBndryCndXD::m_static_cbc1091d_solverProfile
MBool m_static_cbc1091d_solverProfile
Definition: fvcartesianbndrycndxd.h:977

FvBndryCndXD::m_static_cbc1091e_dirN
MInt m_static_cbc1091e_dirN
Definition: fvcartesianbndrycndxd.h:987

FvBndryCndXD::m_modeType
MInt * m_modeType
Definition: fvcartesianbndrycndxd.h:366

FvBndryCndXD::m_spongeFactor
MFloat * m_spongeFactor
Definition: fvcartesianbndrycndxd.h:324

FvBndryCndXD::m_jetInletTurbulence
MBool m_jetInletTurbulence
Definition: fvcartesianbndrycndxd.h:400

FvBndryCndXD::m_static_bc1091MGC_edgeCellCounter
MInt m_static_bc1091MGC_edgeCellCounter
Definition: fvcartesianbndrycndxd.h:881

FvBndryCndXD::m_static_cbc1099_domainMin
MInt m_static_cbc1099_domainMin
Definition: fvcartesianbndrycndxd.h:907

FvBndryCndXD::exchangeComputedCutPoints
void exchangeComputedCutPoints()
Definition: fvcartesianbndrycndxd.cpp:12099

FvBndryCndXD::m_smallCutCells
std::vector< MInt > m_smallCutCells
Definition: fvcartesianbndrycndxd.h:296

FvBndryCndXD::m_modeOmega
MFloat * m_modeOmega
Definition: fvcartesianbndrycndxd.h:364

FvBndryCndXD::m_maxLevel
MInt m_maxLevel
Definition: fvcartesianbndrycndxd.h:158

FvBndryCndXD::bndryCndHandlerCutOffSlopesInviscid
BndryCndHandler * bndryCndHandlerCutOffSlopesInviscid
Definition: fvcartesianbndrycndxd.h:288

FvBndryCndXD::m_firstUseSetBCTypes
MBool m_firstUseSetBCTypes
Definition: fvcartesianbndrycndxd.h:495

FvBndryCndXD::createBndryCndHandler
void createBndryCndHandler()
creates pointers to the boundary conditions
Definition: fvcartesianbndrycndxd.cpp:2460

FvBndryCndXD::m_reconstructionNghbrs
MInt ** m_reconstructionNghbrs
Definition: fvcartesianbndrycndxd.h:295

FvBndryCndXD::m_static_cbc2091b_dirN
MInt m_static_cbc2091b_dirN
Definition: fvcartesianbndrycndxd.h:1003

FvBndryCndXD::m_targetVelocityFactor
MFloat m_targetVelocityFactor
Definition: fvcartesianbndrycndxd.h:384

FvBndryCndXD::computeTri
void computeTri(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::bc10970
void bc10970(MInt)
Definition: fvcartesianbndrycndxd.cpp:15972

FvBndryCndXD::applyNeumannBoundaryCondition
void applyNeumannBoundaryCondition()
Definition: fvcartesianbndrycndxd.cpp:1297

FvBndryCndXD::updateGhostCellSlopesInviscid
void updateGhostCellSlopesInviscid()
Definition: fvcartesianbndrycndxd.cpp:2089

FvBndryCndXD::checkCutPointsValidityParGeom
void checkCutPointsValidityParGeom()
checks the validity of a boundary cell using parallel geometry
Definition: fvcartesianbndrycndxd.cpp:11960

FvBndryCndXD::m_static_cbc1091_dimT2
MInt m_static_cbc1091_dimT2
Definition: fvcartesianbndrycndxd.h:933

FvBndryCndXD::sbc2801x
void sbc2801x(MInt)
Solid wall Navier-Stokes boundary condition Computes ghost cell slopes for the viscous flux computati...
Definition: fvcartesianbndrycndxd.cpp:22081

FvBndryCndXD::cbc1091d_after
void cbc1091d_after(MInt)
Subsonic fully reflecting characteristic inflow condition - cut off - sets un to prescribed value aft...
Definition: fvcartesianbndrycndxd.cpp:18619

FvBndryCndXD::m_spongeBeta
MFloat m_spongeBeta
Definition: fvcartesianbndrycndxd.h:347

FvBndryCndXD::bc2720
void bc2720(MInt)
Definition: fvcartesianbndrycndxd.cpp:15518

FvBndryCndXD::m_static_cbc1091_domainMin
MInt m_static_cbc1091_domainMin
Definition: fvcartesianbndrycndxd.h:936

FvBndryCndXD::addBoundarySurfaces
void addBoundarySurfaces()
adds a surface for the ghost-boundary cell intersections
Definition: fvcartesianbndrycndxd.cpp:963

FvBndryCndXD::m_createBoundaryAtCutoff
MBool m_createBoundaryAtCutoff
Definition: fvcartesianbndrycndxd.h:316

FvBndryCndXD::cbc1099a
void cbc1099a(MInt)
Definition: fvcartesianbndrycndxd.cpp:18700

FvBndryCndXD::checkOutside
MBool checkOutside(MInt)
Definition: fvcartesianbndrycndxd.cpp:10014

FvBndryCndXD::correctInflowBoundary
void correctInflowBoundary(MInt, MFloat *&, MFloat *&)

FvBndryCndXD::cmptGhostCells
virtual void cmptGhostCells()
Definition: fvcartesianbndrycndxd.h:213

FvBndryCndXD::cbcMachCo
void cbcMachCo(MInt, MFloat *)
Returns the mean and maximum Mach number of the cut off cells.
Definition: fvcartesianbndrycndxd.cpp:19656

FvBndryCndXD::m_stgLocal
std::map< MInt, MBool > m_stgLocal
Definition: fvcartesianbndrycndxd.h:448

FvBndryCndXD::m_bndryCndIds
MInt * m_bndryCndIds
Definition: fvcartesianbndrycndxd.h:319

FvBndryCndXD::sbc2901
void sbc2901(MInt)
Definition: fvcartesianbndrycndxd.cpp:6848

FvBndryCndXD::bc0Var
void bc0Var(MInt)
Definition: fvcartesianbndrycndxd.h:218

FvBndryCndXD::computePolygon
void computePolygon(MFloat *x, const MInt N, MFloat *centroid, MFloat *area)

FvBndryCndXD::m_static_cbc2099_1091_local_comb_outFlowArea
MFloat m_static_cbc2099_1091_local_comb_outFlowArea
Definition: fvcartesianbndrycndxd.h:1029

FvBndryCndXD::m_static_cbc1091e_solverProfile
MBool m_static_cbc1091e_solverProfile
Definition: fvcartesianbndrycndxd.h:990

FvBndryCndXD::mergeCells
void mergeCells()
Definition: fvcartesianbndrycndxd.cpp:8632

FvBndryCndXD::m_besselModes
MInt m_besselModes
Definition: fvcartesianbndrycndxd.h:373

FvBndryCndXD::bc10980
void bc10980(MInt)
Definition: fvcartesianbndrycndxd.cpp:16036

FvBndryCndXD::bcInit7909
void bcInit7909(MInt)
Definition: fvcartesianbndrycndxd.cpp:16934

FvBndryCndXD::bc7905
void bc7905(MInt)
Definition: fvcartesianbndrycndxd.cpp:17497

FvBndryCndXD::m_secondaryJetRadius
MFloat m_secondaryJetRadius
Definition: fvcartesianbndrycndxd.h:383

FvBndryCndXD::m_firstUseBc10980
MBool m_firstUseBc10980
Definition: fvcartesianbndrycndxd.h:893

FvBndryCndXD::m_7901globalWallNormalLocations
std::vector< MFloat > m_7901globalWallNormalLocations
Definition: fvcartesianbndrycndxd.h:422

FvBndryCndXD::m_ys
MFloat m_ys
Definition: fvcartesianbndrycndxd.h:362

FvBndryCndXD::bc3600
void bc3600(MInt)
Definition: fvcartesianbndrycndxd.cpp:15915

FvBndryCndXD::setNearBoundaryRecNghbrs
void setNearBoundaryRecNghbrs(MInt updateOnlyBndryCndId=-1)
Definition: fvcartesianbndrycndxd.cpp:9157

FvBndryCndXD::bc1001coflowY
virtual void bc1001coflowY(MInt)
Definition: fvcartesianbndrycndxd.h:250

FvBndryCndXD::m_static_cbc1099_1091_local_referencePoint
MFloat m_static_cbc1099_1091_local_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:915

FvBndryCndXD::bc1753
void bc1753(MInt)
Definition: fvcartesianbndrycndxd.cpp:5007

FvBndryCndXD::m_static_cbc1099_1091d_inflowArea
MFloat m_static_cbc1099_1091d_inflowArea
Definition: fvcartesianbndrycndxd.h:1037

FvBndryCndXD::m_cellsInsideSpongeLayer
MInt * m_cellsInsideSpongeLayer
Definition: fvcartesianbndrycndxd.h:321

FvBndryCndXD::m_7902periodicLocations
std::vector< MFloat > * m_7902periodicLocations
Definition: fvcartesianbndrycndxd.h:439

FvBndryCndXD::correctInflowBoundary
void correctInflowBoundary(MInt, MFloat *&, MFloat *&, MBool=false)
Definition: fvcartesianbndrycndxd.h:570

FvBndryCndXD::m_cells
maia::fv::collector::FvCellCollector< nDim > & m_cells
Definition: fvcartesianbndrycndxd.h:131

FvBndryCndXD::m_sigmaNonReflInflow
MFloat m_sigmaNonReflInflow
Definition: fvcartesianbndrycndxd.h:315

FvBndryCndXD::m_vnTargetDataCount
MInt m_vnTargetDataCount
Definition: fvcartesianbndrycndxd.h:1060

FvBndryCndXD::s_sbc1000co_fixedMaxNoBndryCndIds
static constexpr MInt s_sbc1000co_fixedMaxNoBndryCndIds
Definition: fvcartesianbndrycndxd.h:501

FvBndryCndXD::bcInit30022
void bcInit30022(MInt)

FvBndryCndXD::m_nearBoundaryWindowCells
std::vector< MInt > * m_nearBoundaryWindowCells
Definition: fvcartesianbndrycndxd.h:297

FvBndryCndXD::m_static_cbc1091a_solverProfile
MBool m_static_cbc1091a_solverProfile
Definition: fvcartesianbndrycndxd.h:938

FvBndryCndXD::cbc3091a
void cbc3091a(MInt)
Definition: fvcartesianbndrycndxd.cpp:22231

FvBndryCndXD::correctGhostCellSlopesViscous
void correctGhostCellSlopesViscous()
Definition: fvcartesianbndrycndxd.cpp:2145

FvBndryCndXD::bcInit1601
void bcInit1601(MInt)
Initialize bc1601.

FvBndryCndXD::m_static_cbc1091d_minDom
MInt m_static_cbc1091d_minDom
Definition: fvcartesianbndrycndxd.h:978

FvBndryCndXD::m_static_cbc1099_1091_local_comb_outFlowArea
MFloat m_static_cbc1099_1091_local_comb_outFlowArea
Definition: fvcartesianbndrycndxd.h:926

FvBndryCndXD::m_maxNoBndryCells
MInt m_maxNoBndryCells
Definition: fvcartesianbndrycndxd.h:349

FvBndryCndXD::isCutOffInterface
MInt isCutOffInterface(MInt cellId)
Definition: fvcartesianbndrycndxd.cpp:2016

FvBndryCndXD::createBoundaryAtCutoff
void createBoundaryAtCutoff()

FvBndryCndXD::m_7901globalNoWallNormalLocations
MInt m_7901globalNoWallNormalLocations
Definition: fvcartesianbndrycndxd.h:414

FvBndryCndXD::applyNonReflectingBCAfterTreatmentCutOff
void applyNonReflectingBCAfterTreatmentCutOff()
Definition: fvcartesianbndrycndxd.cpp:2077

FvBndryCndXD::createSpongeAtSpongeBndryCnds
void createSpongeAtSpongeBndryCnds()
creates Sponge Cells at spongeBndryCnds
Definition: fvcartesianbndrycndxd.cpp:3561

FvBndryCndXD::mergeCellsMGC
void mergeCellsMGC()
merges master and small cells - for multiple ghost cells formulation
Definition: fvcartesianbndrycndxd.cpp:8807

FvBndryCndXD::m_bc1601_bcId
MInt m_bc1601_bcId
Definition: fvcartesianbndrycndxd.h:397

FvBndryCndXD::m_static_cbc1099_1091_local_comb_referencePoint
MFloat m_static_cbc1099_1091_local_comb_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:927

FvBndryCndXD::m_bc1251ForcingDirection
MInt m_bc1251ForcingDirection
Definition: fvcartesianbndrycndxd.h:406

FvBndryCndXD::bc4000
void bc4000(MInt)
Definition: fvcartesianbndrycndxd.cpp:5364

FvBndryCndXD::bndryCndHandlerSpongeVariables
BndryCndHandler * bndryCndHandlerSpongeVariables
Definition: fvcartesianbndrycndxd.h:282

FvBndryCndXD::resetCutOff
void resetCutOff()
reset sorterdCutOff Cells and cutOff communicator before balancing and adaptation!
Definition: fvcartesianbndrycndxd.cpp:23597

FvBndryCndXD::m_noMaxSpongeBndryCells
MInt m_noMaxSpongeBndryCells
Definition: fvcartesianbndrycndxd.h:346

FvBndryCndXD::m_shearLayerThickness
MFloat m_shearLayerThickness
Definition: fvcartesianbndrycndxd.h:380

FvBndryCndXD::m_static_cbc2091d_inflowArea
MFloat m_static_cbc2091d_inflowArea
Definition: fvcartesianbndrycndxd.h:1015

FvBndryCndXD::computeGhostCellsMGC
void computeGhostCellsMGC()
Computes one ghost cell for each boundary surface.
Definition: fvcartesianbndrycndxd.cpp:729

FvBndryCndXD::createSortedBndryCellList
void createSortedBndryCellList()
Definition: fvcartesianbndrycndxd.cpp:474

FvBndryCndXD::cbc1291b
void cbc1291b(MInt)

FvBndryCndXD::precomputeBesselTrigonometry
void precomputeBesselTrigonometry(MInt)
Definition: fvcartesianbndrycndxd.cpp:7549

FvBndryCndXD::bc1001
void bc1001(MInt)
Definition: fvcartesianbndrycndxd.cpp:13853

FvBndryCndXD::m_startSTGTimeStep
MInt m_startSTGTimeStep
Definition: fvcartesianbndrycndxd.h:450

FvBndryCndXD::m_bc1251ForcingFrequency
MFloat m_bc1251ForcingFrequency
Definition: fvcartesianbndrycndxd.h:405

FvBndryCndXD::bc17110
void bc17110(MInt)
Definition: fvcartesianbndrycndxd.cpp:5713

FvBndryCndXD::m_7902globalWallNormalLocations
std::vector< MFloat > m_7902globalWallNormalLocations
Definition: fvcartesianbndrycndxd.h:441

FvBndryCndXD::initModes
void initModes(MInt)

FvBndryCndXD::cbc1091d
void cbc1091d(MInt)
Definition: fvcartesianbndrycndxd.cpp:18436

FvBndryCndXD::m_static_cbc1091d_after_dimT2
MInt m_static_cbc1091d_after_dimT2
Definition: fvcartesianbndrycndxd.h:984

FvBndryCndXD::getSortedElements
void getSortedElements(const std::vector< MInt > &, MInt &, MInt *&, MInt &, MInt *&, MInt)

FvBndryCndXD::sbc1002
void sbc1002(MInt)
Symmetry boundary condition about x-axis (slopes)
Definition: fvcartesianbndrycndxd.cpp:19500

FvBndryCndXD::m_7902periodicDir
MInt m_7902periodicDir
Definition: fvcartesianbndrycndxd.h:431

FvBndryCndXD::cbc1291tmb
void cbc1291tmb(MInt)

FvBndryCndXD::bc19516
void bc19516(MInt)
Definition: fvcartesianbndrycndxd.cpp:4934

FvBndryCndXD::m_static_cbc1091d_inflowArea
MFloat m_static_cbc1091d_inflowArea
Definition: fvcartesianbndrycndxd.h:975

FvBndryCndXD::cbc2091b_after
void cbc2091b_after(MInt)
Subsonic fully reflecting characteristic inflow condition - cut off - sets T0,u,v to prescribed value...
Definition: fvcartesianbndrycndxd.cpp:21525

FvBndryCndXD::domainId
MInt domainId() const
Return the domain id of this solver on the current MPI communicator.
Definition: fvcartesianbndrycndxd.h:488

FvBndryCndXD::bcInit1050
void bcInit1050(MInt)
Definition: fvcartesianbndrycndxd.cpp:14029

FvBndryCndXD::m_static_cbc1091d_after_dimN
MInt m_static_cbc1091d_after_dimN
Definition: fvcartesianbndrycndxd.h:982

FvBndryCndXD::m_static_plotEdges_iter
MInt m_static_plotEdges_iter
Only 3D ///.
Definition: fvcartesianbndrycndxd.h:871

FvBndryCndXD::m_static_cbc2091a_first
MBool m_static_cbc2091a_first
Definition: fvcartesianbndrycndxd.h:993

FvBndryCndXD::m_cbcLref
std::vector< MFloat > m_cbcLref
Definition: fvcartesianbndrycndxd.h:462

FvBndryCndXD::cbc1291tmc
void cbc1291tmc(MInt)

FvBndryCndXD::bc1791
virtual void bc1791(MInt)
Definition: fvcartesianbndrycndxd.h:260

FvBndryCndXD::m_7901wallNormalLocations
std::vector< MFloat > m_7901wallNormalLocations
Definition: fvcartesianbndrycndxd.h:421

FvBndryCndXD::m_firstUseBc11110
MBool m_firstUseBc11110
Definition: fvcartesianbndrycndxd.h:898

FvBndryCndXD::m_spongeBndryCells
MInt * m_spongeBndryCells
Definition: fvcartesianbndrycndxd.h:335

FvBndryCndXD::writeStlFileOfCell
virtual void writeStlFileOfCell(MInt, const MChar *)
Definition: fvcartesianbndrycndxd.h:168

FvBndryCndXD::m_cbcInflowArea
std::vector< MFloat > m_cbcInflowArea
Definition: fvcartesianbndrycndxd.h:456

FvBndryCndXD::bc3007
void bc3007(MInt)
Definition: fvcartesianbndrycndxd.cpp:15768

FvBndryCndXD::m_comm_bc
MPI_Comm * m_comm_bc
Definition: fvcartesianbndrycndxd.h:474

FvBndryCndXD::m_static_cbc2091b_referencePoint
MFloat m_static_cbc2091b_referencePoint[nDim]
Definition: fvcartesianbndrycndxd.h:1009

FvBndryCndXD::cbc1291tm
void cbc1291tm(MInt)

FvBndryCndXD::bcInit2770
void bcInit2770(MInt)
supersonic inflow with imposed onlique shock wave and linear waves version: cut-off boundary conditio...

FvBndryCndXD::m_static_cbc1099_1091_local_comb_first
MBool m_static_cbc1099_1091_local_comb_first
Definition: fvcartesianbndrycndxd.h:921

FvBndryCndXD::m_cutOffBndryCndIds
MInt * m_cutOffBndryCndIds
Definition: fvcartesianbndrycndxd.h:320

FvBndryCndXD::cbc2091d_after
void cbc2091d_after(MInt)
Subsonic fully reflecting characteristic inflow condition - cut off - sets un to prescribed value aft...
Definition: fvcartesianbndrycndxd.cpp:21748

FvBndryCndXD::bcInitCbc
void bcInitCbc(MInt)

FvBndryCndXD::bc10910
virtual void bc10910(MInt)
Definition: fvcartesianbndrycndxd.h:251

FvBndryCndXD::bc1091MGC
void bc1091MGC(MInt)
Definition: fvcartesianbndrycndxd.cpp:22497

FvBndryCndXD::m_sysEqn
SysEqn * m_sysEqn
Definition: fvcartesianbndrycndxd.h:127

FvBndryCndXD::m_static_cbc1099_1091d_dimN
MInt m_static_cbc1099_1091d_dimN
Definition: fvcartesianbndrycndxd.h:1034

FvBndryCndXD::m_static_cbc2091d_H
MFloat m_static_cbc2091d_H
Definition: fvcartesianbndrycndxd.h:1016

FvBndryCndXD::bc0
void bc0(MInt)
Definition: fvcartesianbndrycndxd.h:217

FvBndryCndXD::bc7901
void bc7901(MInt)
Definition: fvcartesianbndrycndxd.cpp:17360

FvBndryCndXD::bcInit1251
void bcInit1251(MInt)

FvBndryCndXD::m_static_cbc1099_1091_engine_dirN
MInt m_static_cbc1099_1091_engine_dirN
Definition: fvcartesianbndrycndxd.h:1047

FvBndryCndXD::bc1009
void bc1009(MInt)
Definition: fvcartesianbndrycndxd.cpp:13977

FvBndryCndXD::m_static_cbc1091d_referencePoint
MFloat m_static_cbc1091d_referencePoint[3]
Definition: fvcartesianbndrycndxd.h:976

FvBndryCndXD::m_inflowTemperatureRatio
MFloat m_inflowTemperatureRatio
Definition: fvcartesianbndrycndxd.h:390

FvBndryCndXD::m_noShockBcCells
MInt m_noShockBcCells
Definition: fvcartesianbndrycndxd.h:358

FvBndryCndXD::m_static_cbc1099_1091_local_comb_dimN
MInt m_static_cbc1099_1091_local_comb_dimN
Definition: fvcartesianbndrycndxd.h:923

FvBndryCndXD::m_pressureRatioChannel
MFloat m_pressureRatioChannel
Definition: fvcartesianbndrycndxd.h:312

FvBndryCndXD::m_bc1601MoveGenOutOfSponge
MBool m_bc1601MoveGenOutOfSponge
Definition: fvcartesianbndrycndxd.h:399

FvBndryCndXD::cbc109910
void cbc109910(MInt)
Characteristic boundary condition. Outflow. Prescribed: p. Partially Refelecting.
Definition: fvcartesianbndrycndxd.cpp:20803

FvBndryCndXD::m_static_bc1091MGC_first
MInt m_static_bc1091MGC_first
Definition: fvcartesianbndrycndxd.h:882

FvBndryCndXD::cbcTauQ
void cbcTauQ(MInt, MFloat *, MFloat *, MInt *)
Calculates the stress tensor tau and the heat flux q and the mean velocity on the construction stenci...
Definition: fvcartesianbndrycndxd.cpp:19737

FvBndryCndXD::bc1005
virtual void bc1005(MInt)
Definition: fvcartesianbndrycndxd.h:258

FvBndryCndXD::bc1004
virtual void bc1004(MInt)
Definition: fvcartesianbndrycndxd.h:257

FvBndryCndXD::m_bc1601
Bc1601Class< nDim > * m_bc1601
Definition: fvcartesianbndrycndxd.h:398

FvBndryCndXD::m_noImagePointIterations
MInt m_noImagePointIterations
Definition: fvcartesianbndrycndxd.h:351

FvBndryCndXD::bc2710
void bc2710(MInt)
Definition: fvcartesianbndrycndxd.cpp:15455

FvBndryCndXD::bc1952
void bc1952(MInt)
Subsonic outflow boundary condition (applied directly to the (boundary) cell). Set of variables: Stan...
Definition: fvcartesianbndrycndxd.cpp:15053

FvBndryCndXD::initSmallCellRHSCorrection
void initSmallCellRHSCorrection(MInt updateOnlyBndryCndId=-1)

FvBndryCndXD::m_7902faceNormalDir
MInt m_7902faceNormalDir
Definition: fvcartesianbndrycndxd.h:428

FvBndryCndXD::m_7902wallDir
MInt m_7902wallDir
Definition: fvcartesianbndrycndxd.h:432

FvBndryCndXD::cutOffBcMissingNeighbor
void cutOffBcMissingNeighbor(const MInt cellId, const MString bcName)
Definition: fvcartesianbndrycndxd.cpp:17756

FvBndryCndXD::m_static_cbc2091a_dirN
MInt m_static_cbc2091a_dirN
Definition: fvcartesianbndrycndxd.h:994

FvBndryCndXD::bcNeumannIsothermalUnburnt
void bcNeumannIsothermalUnburnt(MInt)
Computes the p and rho slopes on boundary cells using the least-squares method, and setting implicite...
Definition: fvcartesianbndrycndxd.cpp:13577

FvBndryCndXD::m_dirNBc10980
MInt m_dirNBc10980
Definition: fvcartesianbndrycndxd.h:894

FvBndryCndXD::m_splitParents
MInt * m_splitParents
Definition: fvcartesianbndrycndxd.h:142

FvBndryCndXD::m_minLevel
MInt m_minLevel
Definition: fvcartesianbndrycndxd.h:157

FvBndryCndXD::m_static_cbc1091d_dimN
MInt m_static_cbc1091d_dimN
Definition: fvcartesianbndrycndxd.h:973

FvBndryCndXD::m_modeEtaMin
MFloat * m_modeEtaMin
Definition: fvcartesianbndrycndxd.h:371

FvBndryCndXD::m_static_cbc1091_inflowArea
MFloat m_static_cbc1091_inflowArea
Definition: fvcartesianbndrycndxd.h:934

FvBndryCndXD::computeReverseMap
void computeReverseMap()
Creates a mapping (boundary cell id) -> (cell id) in m_bndryCellIds.
Definition: fvcartesianbndrycndxd.cpp:606

FvBndryCndXD::bcNeumann3600
void bcNeumann3600(MInt)
Simple and fast fixed adiabatic wall boundary condition for use with the flux-redistribution method.
Definition: fvcartesianbndrycndxd.cpp:15941

FvBndryCndXD::m_static_cbc1091c_inflowArea
MFloat m_static_cbc1091c_inflowArea
Definition: fvcartesianbndrycndxd.h:962

FvBndryCndXD::CV
SysEqn::ConservativeVariables * CV
Definition: fvcartesianbndrycndxd.h:152

FvBndryCndXD::m_static_cbc2091d_after_dirN
MInt m_static_cbc2091d_after_dirN
Definition: fvcartesianbndrycndxd.h:1021

FvBndryCndXD::initBndryCommunications
void initBndryCommunications()
inits the commnicators for the boundaries
Definition: fvcartesianbndrycndxd.cpp:5799

FvBndryCndXD::bndryCutOffViscousSlopes
BndryCndHandler * bndryCutOffViscousSlopes
Definition: fvcartesianbndrycndxd.h:291

FvBndryCndXD::computeTrapez
void computeTrapez(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::rerecorrectCellCoordinates
void rerecorrectCellCoordinates()
Definition: fvcartesianbndrycndxd.cpp:568

FvBndryCndXD::cbc2091d
void cbc2091d(MInt)
Definition: fvcartesianbndrycndxd.cpp:21566

FvBndryCndXD::initWMSurfaces
void initWMSurfaces()
Definition: fvcartesianbndrycndxd.cpp:7007

FvBndryCndXD::m_cbcSmallCellCorrection
MBool m_cbcSmallCellCorrection
Definition: fvcartesianbndrycndxd.h:345

FvBndryCndXD::m_static_cbc2091d_dirN
MInt m_static_cbc2091d_dirN
Definition: fvcartesianbndrycndxd.h:1012

FvBndryCndXD::bc100100
void bc100100(MInt)
Definition: fvcartesianbndrycndxd.cpp:17777

FvBndryCndXD::bcInit0001
void bcInit0001(MInt)
Sets up the reconstruction stencil for boundary cells.
Definition: fvcartesianbndrycndxd.cpp:4285

FvBndryCndXD::m_7902LESAverageOld
MFloat ** m_7902LESAverageOld
Definition: fvcartesianbndrycndxd.h:436

FvBndryCndXD::m_spongeLayerLayout
MInt m_spongeLayerLayout
Definition: fvcartesianbndrycndxd.h:329

FvBndryCndXD::m_static_cbc2091b_dimN
MInt m_static_cbc2091b_dimN
Definition: fvcartesianbndrycndxd.h:1004

FvBndryCndXD::m_noBoundarySurfaces
MInt m_noBoundarySurfaces
Definition: fvcartesianbndrycndxd.h:340

FvBndryCndXD::m_wmSrfcToCellId
std::list< std::pair< MInt, MInt > > m_wmSrfcToCellId
Definition: fvcartesianbndrycndxd.h:189

FvBndryCndXD::m_static_cbc1099_1091_local_dimT1
MInt m_static_cbc1099_1091_local_dimT1
Definition: fvcartesianbndrycndxd.h:912

FvBndryCndXD::m_noCorners
MInt m_noCorners
Definition: fvcartesianbndrycndxd.h:121

FvBndryCndXD::m_unTargetDataCount
MInt m_unTargetDataCount
Definition: fvcartesianbndrycndxd.h:1059

FvBndryCndXD::resetBndryCommunication
void resetBndryCommunication()
Definition: fvcartesianbndrycndxd.cpp:23642

FvBndryCndXD::m_static_cbc3091a_solverProfile
MBool m_static_cbc3091a_solverProfile
Definition: fvcartesianbndrycndxd.h:945

FvBndryCndXD::m_static_cbc1099_1091d_referencePoint
MFloat m_static_cbc1099_1091d_referencePoint[nDim]
Definition: fvcartesianbndrycndxd.h:1038

FvBndryCndXD::computePyra
void computePyra(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::m_static_writeStlOfNodes_iter
MInt m_static_writeStlOfNodes_iter
Definition: fvcartesianbndrycndxd.h:875

FvBndryCndXD::m_stgBC
std::map< MInt, MSTG< nDim, MAIA_FINITE_VOLUME, MAIA_FINITE_VOLUME > * > m_stgBC
Definition: fvcartesianbndrycndxd.h:446

FvBndryCndXD::m_spongeDirections
MInt * m_spongeDirections
Definition: fvcartesianbndrycndxd.h:325

FvBndryCndXD::m_static_cbc2091b_first
MBool m_static_cbc2091b_first
Definition: fvcartesianbndrycndxd.h:1002

FvBndryCndXD::m_static_sbc1000co_first
MBool m_static_sbc1000co_first
Definition: fvcartesianbndrycndxd.h:500

FvBndryCndXD::m_static_cbc2091b_dimT1
MInt m_static_cbc2091b_dimT1
Definition: fvcartesianbndrycndxd.h:1005

FvBndryCndXD::computePoly3
void computePoly3(MFloat *, MFloat *, MFloat *, MFloat *, MFloat *, MFloat *)

FvBndryCndXD::m_modeAmp
MFloat * m_modeAmp
Definition: fvcartesianbndrycndxd.h:365

FvCartesianSolverXD
Definition: fvcartesiansolverxd.h:197

FvSurfaceCollector
Definition: fvcartesianbndrycndxd.h:34

FvSurface
Definition: fvcartesianbndrycndxd.h:32

FvSysEqnNS
Definition: fvcartesiansyseqnns.h:31

FvSysEqnRANS
Definition: fvcartesiansyseqnrans.h:29

FvZonalSTG
Definition: fvzonalstg.h:27

GeometryIntersection
Definition: geometryintersection.h:56

List
Definition: list.h:16

MSTG
Definition: fvstg.h:609

ScratchSpace
This class is a ScratchSpace.
Definition: scratch.h:758

Solver::domainId
virtual MInt domainId() const
Return the domainId (rank)
Definition: solver.h:383

Solver::mpiComm
MPI_Comm mpiComm() const
Return the MPI communicator used by this solver.
Definition: solver.h:380

Solver::noDomains
virtual MInt noDomains() const
Definition: solver.h:387

maia::fv::collector::FvCellCollector
Class that represents FV cell collector.
Definition: fvcartesiancellcollector.h:184

maia::fv::surface_collector::FvSurfaceCollector
Class that represents FV surface collector.
Definition: fvcartesiansurfacecollector.h:122

fvcartesiancellcollector.h

FvCell
FvCell
FV cell Property Labels.
Definition: fvcartesiancellproperties.h:14

fvcartesiansurfacecollector.h

fvcartesiansyseqntraits.h

geometryintersection.h

maiamath.h

MInt
int32_t MInt
Definition: maiatypes.h:62

MString
std::basic_string< char > MString
Definition: maiatypes.h:55

MFloat
double MFloat
Definition: maiatypes.h:52

MBool
bool MBool
Definition: maiatypes.h:58

MChar
char MChar
Definition: maiatypes.h:56

mpioverride.h

scratch.h