fvmbcartesiansolverxd_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 FVMBCARTESIANSOLVERXD_H

#define FVMBCARTESIANSOLVERXD_H


#include <algorithm>

#include <map>

#include <random>

#include <set>

#include <unordered_map>

#include <utility>

#include <vector>

#include "GEOM/geometryintersection.h"

#include "GRID/cartesiangridgenpar.h"

#include "GRID/partition.h"

#include "UTIL/kdtree.h"

#include "UTIL/pointbox.h"

#include "fvcartesiancellcollector.h"

#include "fvcartesiansolverxd.h"


//#include "/pds/opt/fftw-3.3.4-mpi/include/fftw3-mpi.h"


#ifndef MAIA_MS_COMPILER

#include <netdb.h>

#include <sys/socket.h>

#endif


#define FINITE_VOLUME_METHOD

#include "GRID/cartesiannetcdf.h"

#undef FINITE_VOLUME_METHOD


#ifndef MB_EXTRA_STUFF_

#define MB_EXTRA_STUFF_

//#define DEBUG(a,b) {if((globalTimeStep%100==0)||(globalTimeStep%100==99)){if(b==16)m_log << "in:

//"<< a<<endl; else if(b==32)m_log << "out: "<< a<<endl;}} #define DEBUG(a,b) {if(b==16)m_log <<

//"in: "<< a<<endl; else if(b==32)m_log << "out: "<< a<<endl;} #define DEBUG(a,b) {if(b==16){cerr

//<< "in: "<<g_domainId<<" "<<a<<endl;cerr.flush();}else if(b==32){cerr << "out: "<<g_domainId<<"

//"<< a<<endl;cerr.flush();}} #define DEBUG_LOG(a) {m_log << a << endl;}

#define DEBUG_LOG(a)


const MInt m_revDir[6] = {1, 0, 3, 2, 5, 4};


#endif


template <MInt nDim, class SysEqn>

class FvCartesianSolverXD;


template <MInt nDim, class SysEqn>

class FvMbCartesianSolverXD : public FvCartesianSolverXD<nDim, SysEqn> {

 public:

  using Base = FvCartesianSolverXD<nDim, SysEqn>;

  using SolverCell = FvCell;

  using Cell = typename maia::grid::tree::Tree<nDim>::Cell;

  using Base::a_associatedBodyIds;

  using Base::a_bndryId;

  using Base::a_cellVolume;

  using Base::a_coordinate;

  using Base::a_hasNeighbor;

  using Base::a_hasProperty;

  using Base::a_isBndryGhostCell;

  using Base::a_isGapCell;

  using Base::a_isHalo;

  using Base::a_isPeriodic;

  using Base::a_isWindow;

  using Base::a_level;

  using Base::a_levelSetValuesMb;

  using Base::a_noCells;

  using Base::a_noReconstructionNeighbors;

  using Base::a_noSurfaces;

  using Base::a_oldVariable;

  using Base::a_properties;

  using Base::a_pvariable;

  using Base::a_rightHandSide;

  using Base::a_slope;

  using Base::a_spongeFactor;

  using Base::a_surfaceArea;

  using Base::a_surfaceBndryCndId;

  using Base::a_surfaceCoordinate;

  using Base::a_surfaceDeltaX;

  using Base::a_surfaceFactor;

  using Base::a_surfaceFlux;

  using Base::a_surfaceNghbrCellId;

  using Base::a_surfaceOrientation;

  using Base::a_surfaceUpwindCoefficient;

  using Base::a_surfaceVariable;

  using Base::a_variable;

  using Base::allocateCommunicationMemory;

  using Base::assertValidGridCellId;

  using Base::c_cellLengthAtCell;

  using Base::c_cellLengthAtLevel;

  using Base::c_childId;

  using Base::c_globalId;

  using Base::c_isLeafCell;

  using Base::c_isToDelete;

  using Base::c_neighborId;

  using Base::c_noCells;

  using Base::c_noChildren;

  using Base::c_parentId;

  using Base::calcSlopesAfterStep;

  using Base::computeDomainAndSpongeDimensions;

  using Base::computeDomainLength;

  using Base::computePrimitiveVariables;

  using Base::copyGridProperties;

  using Base::CV;

  using Base::domainId;

  using Base::entropy;

  using Base::exchangeData;

  using Base::exchangeDataFV;

  using Base::exchangeGapInfo;

  using Base::findNghbrIds;

  using Base::FV;

  using Base::getAssociatedInternalCell;

  using Base::getIdentifier;

  using Base::grid;

  using Base::haloCellId;

  using Base::initNearBoundaryExchange;

  using Base::initSpongeLayer;

  using Base::isActive;

  using Base::isMultilevel;

  using Base::isMultilevelLowestSecondary;

  using Base::isMultilevelPrimary;

  using Base::m_activeCellIds;

  using Base::m_adaptation;

  using Base::m_adaptationInterval;

  using Base::m_associatedBodyIds;

  using Base::m_bndryCells;

  using Base::m_bndryCellSurfacesOffset;

  using Base::m_bndryGhostCellsOffset;

  using Base::m_bndrySurfacesOffset;

  using Base::m_bodyAcceleration;

  using Base::m_bodyAngularAcceleration;

  using Base::m_bodyAngularVelocity;

  using Base::m_bodyCenter;

  using Base::m_bodyHeatFlux;

  using Base::m_bodyTemperature;

  using Base::m_bodyTemperatureDt1;

  using Base::m_bodyVelocity;

  using Base::m_cells;

  using Base::m_cellsInsideSpongeLayer;

  using Base::m_cfl;

  using Base::m_chi;

  using Base::m_closeGaps;

  using Base::m_constructGField;

  using Base::m_createSpongeBoundary;

  using Base::m_deleteNeighbour;

  using Base::m_DInfinity;

  using Base::m_dragOutputInterval;

  using Base::m_DthInfinity;

  using Base::m_dualTimeStepping;

  using Base::m_eps;

  using Base::m_euler;

  using Base::m_gamma;

  using Base::m_gapCellId;

  using Base::m_gapCells;

  using Base::m_gapInitMethod;

  using Base::m_geometry;

  using Base::m_globalUpwindCoefficient;

  using Base::m_hInfinity;

  using Base::m_identNghbrIds;

  using Base::m_initialCondition;

  using Base::m_internalBodyId;

  using Base::m_kInfinityFactor;

  using Base::m_levelSet;

  using Base::m_levelSetAdaptationScheme;

  using Base::m_levelSetMb;

  using Base::m_levelSetRans;

  using Base::m_levelSetValuesMb;

  using Base::m_loadBalancingReinitStage;

  using Base::m_LsRotate;

  using Base::m_Ma;

  using Base::m_maxLevelBeforeAdaptation;

  using Base::m_mpi_receiveRequest;

  using Base::m_mpi_sendRequest;

  using Base::m_noActiveCells;

  using Base::m_noActiveHaloCellOffset;

  using Base::m_noDirs;

  using Base::m_noEmbeddedBodies;

  using Base::m_noGapRegions;

  using Base::m_noLevelSetsUsedForMb;

  using Base::m_noPeriodicGhostBodies;

  using Base::m_noRansEquations;

  using Base::m_noRKSteps;

  using Base::m_noSets;

  using Base::m_noSpecies;

  using Base::m_nuTildeInfinity;

  using Base::m_omegaInfinity;

  using Base::m_omegaInfinityFactor;

  using Base::m_orderOfReconstruction;

  using Base::m_outerBandWidth;

  using Base::m_outputOffset;

  using Base::m_physicalTime;

  using Base::m_physicalTimeStep;

  using Base::m_PInfinity;

  using Base::m_pipeRadius;

  using Base::m_Pr;

  using Base::m_Re;

  using Base::m_reconstructionDataSize;

  using Base::m_recordBodyData;

  using Base::m_referenceLength;

  using Base::m_restart;

  using Base::m_restartInterval;

  using Base::m_rhoInfinity;

  using Base::m_rhoUInfinity;

  using Base::m_rhoVVInfinity;

  using Base::m_rhoWInfinity;

  using Base::m_rhs0;

  using Base::m_SInfinity;

  using Base::m_slopeMemory;

  using Base::m_solutionOffset;

  using Base::m_solutionOutput;

  using Base::m_solverId;

  using Base::m_splitCells;

  using Base::m_splitChilds;

  using Base::m_splitChildToSplitCell;

  using Base::m_splitMpiCommRecv;

  using Base::m_static_getDistanceSplitSphere_first;

  using Base::m_static_getDistanceSplitSphere_h;

  using Base::m_static_updateBodyProperties_c453_firstRun;

  using Base::m_static_updateBodyProperties_firstTime;

  using Base::m_storeNghbrIds;

  using Base::m_surfaces;

  using Base::m_sutherlandPlusOne;

  using Base::m_sysEqn;

  using Base::m_time;

  using Base::m_timeRef;

  using Base::m_totalnosplitchilds;

  using Base::m_UInfinity;

  using Base::m_useCentralDifferencingSlopes;

  using Base::m_VInfinity;

  using Base::m_volumeAcceleration;

  using Base::m_volumeForcingDir;

  using Base::m_volumeThreshold;

  using Base::m_VVInfinity;

  using Base::m_wasAdapted;

  using Base::m_wasBalancedZonal;

  using Base::m_weightActiveCell;

  using Base::m_weightBaseCell;

  using Base::m_weightBndryCell;

  using Base::m_weightLeafCell;

  using Base::m_weightMulitSolverFactor;

  using Base::m_weightNearBndryCell;

  using Base::m_WInfinity;

  using Base::maxNoGridCells;

  using Base::maxUniformRefinementLevel;

  using Base::minLevel;

  using Base::mpiComm;

  using Base::noDomains;

  using Base::noHaloLayers;

  using Base::noInternalCells;

  using Base::noNeighborDomains;

  using Base::PV;

  using Base::resetCutOffCells;

  using Base::setActiveFlag;

  using Base::setConservativeVariables;

  using Base::setPrimitiveVariables;

  using Base::sysEqn;

  using Base::timeStep;


  using Base::a_copyPropertiesSolver;

  using Base::a_cutCellLevel;

  using Base::a_dt1Variable;

  using Base::a_dt2Variable;

  using Base::a_externalSource;

  using Base::a_FcellVolume;

  using Base::a_isBndryCell;

  using Base::a_reconstructionData;

  using Base::a_reconstructionNeighborId;

  using Base::a_resetPropertiesSolver;

  using Base::a_wasGapCell;

  using Base::applyInitialCondition;

  using Base::azimuthalNearBoundaryExchange;

  using Base::buildLeastSquaresStencilSimple;

  using Base::c_coordinate;

  using Base::c_level;

  using Base::checkCells;

  using Base::checkNeighborActive;

  using Base::collectParameters;

  using Base::collectVariables;

  using Base::computeCellSurfaceDistanceVectors;

  using Base::computeCellVolumes;

  using Base::computeConservativeVariables;

  using Base::computePV;

  using Base::computeRecConstSVD;

  using Base::computeVolumeForces;

  using Base::createBoundaryCells;

  using Base::cutOffBoundaryCondition;

  using Base::determineStructuredCells;

  using Base::domainOffset;

  using Base::exchangeAll;

  using Base::exchangeFloatDataAzimuthal;

  using Base::extractPointIdsFromGrid;

  using Base::forceTimeStep;

  using Base::getAdjacentLeafCells;

  using Base::getVorticity;

  using Base::initAzimuthalCartesianHaloInterpolation;

  using Base::initAzimuthalMaxLevelExchange;

  using Base::initAzimuthalNearBoundaryExchange;

  using Base::initAzimuthalReconstruction;

  using Base::initCutOffBoundaryCondition;

  using Base::initViscousFluxComputation;

  using Base::m_A;

  using Base::m_adaptationDampingDistance;

  using Base::m_adaptationLevel;

  using Base::m_adaptationSinceLastRestart;

  using Base::m_adaptationSinceLastRestartBackup;

  using Base::m_angle;

  using Base::m_associatedInternalCells;

  using Base::m_averageVorticity;

  using Base::m_azimuthalBndrySide;

  using Base::m_azimuthalCutRecCoord;

  using Base::m_azimuthalHaloActive;

  using Base::m_azimuthalMaxLevelHaloCells;

  using Base::m_azimuthalMaxLevelWindowCells;

  using Base::m_azimuthalMaxLevelWindowMap;

  using Base::m_azimuthalNearBndryInit;

  using Base::m_azimuthalNearBoundaryBackupMaxCount;

  using Base::m_azimuthalRecConsts;

  using Base::m_azimuthalRecConstSet;

  using Base::m_azimuthalReconstNghbrIds;

  using Base::m_azimuthalRemappedNeighborDomains;

  using Base::m_azimuthalRemappedWindowCells;

  using Base::m_bandWidth;

  using Base::m_bndryLevelJumps;

  using Base::m_bodyIdOutput;

  using Base::m_cellSurfaceMapping;

  using Base::m_computeViscousFlux;

  using Base::m_currentGridFileName;

  using Base::m_dataBlockSize;

  using Base::m_engineSetup;

  using Base::m_externalSourceDt1;

  using Base::m_extractedCells;

  using Base::m_forceRestartGrid;

  using Base::m_forcing;

  using Base::m_gridPoints;

  using Base::m_hasExternalSource;

  using Base::m_levelSetOutput;

  using Base::m_linerLvlJump;

  using Base::m_lsCutCellBaseLevel;

  using Base::m_masterCellIds;

  using Base::m_maxIterations;

  using Base::m_maxLevelHaloCells;

  using Base::m_maxLevelWindowCells;

  using Base::m_maxNearestBodies;

  using Base::m_maxNoAzimuthalRecConst;

  using Base::m_maxNoSets;

  using Base::m_movingAvgInterval;

  using Base::m_multilevel;

  using Base::m_multipleFvSolver;

  using Base::m_noAzimuthalReconstNghbrs;

  using Base::m_noCellsInsideSpongeLayer;

  using Base::m_noCorners;

  using Base::m_noEdges;

  using Base::m_noMaxLevelHaloCells;

  using Base::m_noMaxLevelWindowCells;

  using Base::m_nonBlockingComm;

  using Base::m_noOuterBndryCells;

  using Base::m_noSamples;

  using Base::m_noTimeStepsBetweenSamples;

  using Base::m_outputFormat;

  using Base::m_recalcIds;

  using Base::m_receiveBuffers;

  using Base::m_receiveBuffersNoBlocking;

  using Base::m_reconstructionCellIds;

  using Base::m_reconstructionConstants;

  using Base::m_reconstructionNghbrIds;

  using Base::m_reconstructSurfaceData;

  using Base::m_residualInterval;

  using Base::m_restartFile;

  using Base::m_restartFileOutputTimeStep;

  using Base::m_restartOffset;

  using Base::m_restartOldVariables;

  using Base::m_restartTimeBc2800;

  using Base::m_restartTimeStep;

  using Base::m_revDir;

  using Base::m_rhoEInfinity;

  using Base::m_rhoVInfinity;

  using Base::m_RKalpha;

  using Base::m_RKStep;

  using Base::m_rotIndVarsCV;

  using Base::m_rotIndVarsPV;

  using Base::m_saveVorticityToRestart;

  using Base::m_sendBuffers;

  using Base::m_sendBuffersNoBlocking;

  using Base::m_setToBodiesTable;

  using Base::m_sigmaSponge;

  using Base::m_singleAdaptation;

  using Base::m_smallCellIds;

  using Base::m_solutionInterval;

  using Base::m_solutionTimeSteps;

  using Base::m_splitSurfaces;

  using Base::m_spongeLayerThickness;

  using Base::m_static_advanceSolution_dragCnt;

  using Base::m_static_advanceSolution_firstRun;

  using Base::m_static_advanceSolution_meanDrag;

  using Base::m_static_advanceSolution_meanDragCoeff;

  using Base::m_static_applyBoundaryCondition_ERhoL1;

  using Base::m_static_applyBoundaryCondition_ERhoL2;

  using Base::m_static_applyBoundaryCondition_ERhoLoo;

  using Base::m_static_applyBoundaryCondition_EVelL1;

  using Base::m_static_applyBoundaryCondition_EVelL2;

  using Base::m_static_applyBoundaryCondition_EVelLoo;

  using Base::m_static_applyBoundaryCondition_firstRun;

  using Base::m_static_applyBoundaryCondition_oldMass;

  using Base::m_static_applyBoundaryCondition_oldVol2;

  using Base::m_static_applyBoundaryCondition_refMass;

  using Base::m_static_constructGFieldPredictor_adaptiveGravity;

  using Base::m_static_constructGFieldPredictor_firstRun;

  using Base::m_static_logCellxd_firstRun;

  using Base::m_static_logData_firstRun4;

  using Base::m_static_logData_ic45299_amplitude;

  using Base::m_static_logData_ic45299_cutOffAngle;

  using Base::m_static_logData_ic45299_freqFactor;

  using Base::m_static_logData_ic45299_maxA;

  using Base::m_static_logData_ic45299_maxF;

  using Base::m_static_logData_ic45299_xCutOff;

  using Base::m_static_logData_ic45301_containingCellIds;

  using Base::m_static_logData_ic45301_first;

  using Base::m_static_logData_ic45301_freqFactor;

  using Base::m_static_logData_ic45301_maxF;

  using Base::m_static_logData_ic45301_noPressurePoints;

  using Base::m_static_logData_ic45301_pressurePoints;

  using Base::m_static_logData_ic45301_Strouhal;

  using Base::m_static_redistributeMass_firstRun;

  using Base::m_static_saveSolverSolutionxd_firstRun;

  using Base::m_static_updateBodyProperties_c455_firstRun;

  using Base::m_static_updateSpongeLayer_first;

  using Base::m_static_updateSpongeLayer_mbSpongeLayer;

  using Base::m_static_writeVtkXmlFiles_firstCall;

  using Base::m_static_writeVtkXmlFiles_firstCall2;

  using Base::m_surfaceVarMemory;

  using Base::m_sutherlandConstant;

  using Base::m_sutherlandConstantThermal;

  using Base::m_sutherlandPlusOneThermal;

  using Base::m_targetDensityFactor;

  using Base::m_timerGroup;

  using Base::m_timers;

  using Base::m_TInfinity;

  using Base::m_totalnoghostcells;

  using Base::m_useNonSpecifiedRestartFile;

  using Base::m_variablesName;

  using Base::m_vorticityName;

  using Base::m_vorticitySize;

  using Base::m_vtuCoordinatesThreshold;

  using Base::m_vtuDomainIdOutput;

  using Base::m_vtuGeometryOutput;

  using Base::m_vtuGeometryOutputExtended;

  using Base::m_vtuGlobalIdOutput;

  using Base::m_vtuLevelSetOutput;

  using Base::m_vtuLevelThreshold;

  using Base::m_vtuVelocityGradientOutput;

  using Base::m_vtuWriteGeometryFile;

  using Base::m_writeOutData;

  using Base::maxLevel;

  using Base::maxRefinementLevel;

  using Base::minCell;

  using Base::neighborDomain;

  using Base::noHaloCells;

  using Base::noMinCells;

  using Base::noVariables;

  using Base::noWindowCells;

  using Base::outputDir;

  using Base::rebuildAzimuthalReconstructionConstants;

  using Base::reduceData;

  using Base::reduceVariables;

  using Base::restartDir;

  using Base::saveGridFlowVarsPar;

  using Base::setInfinityState;

  using Base::setRestartFileOutputTimeStep;

  using Base::setTimeStep;

  using Base::setUpwindCoefficient;

  using Base::solverId;

  using Base::tagCellsNeededForSurfaceFlux;

  using Base::windowCellId;

  using Base::writeListOfActiveFlowCells;


  using Timers = maia::fv::Timers_;


  using Base::computeTimeStepEulerDirectional;

  using Base::m_reComputedBndry;

  using Base::m_resetInitialCondition;


  using Base::a_localTimeStep;

  using Base::m_localTS;

  using Base::m_refineDiagonals;

  using Base::reInitActiveCellIdsMemory;


  //================================== WMLES ======================================

  using Base::m_wmDistance;

  using Base::m_wmDomainId;

  using Base::m_wmGlobalNoSrfcProbeIds;

  using Base::m_wmLES;

  using Base::m_wmNoDomains;

  using Base::m_wmOutput;

  using Base::m_wmSurfaceProbeInterval;

  using Base::m_wmUseInterpolation;


  using Base::m_wmIterator;


  using Base::m_comm_wm;


  using Base::m_mpi_wmRecvReq;

  using Base::m_mpi_wmRequest;

  using Base::m_mpi_wmSendReq;

  using Base::m_noWMImgPointsRecv;

  using Base::m_noWMImgPointsSend;

  using Base::m_wmImgRecvBuffer;

  using Base::m_wmImgRecvIdMap;

  using Base::m_wmImgSendBuffer;

  using Base::m_wmLocalNoSrfcProbeIds;

  using Base::m_wmSrfcProbeRecvBuffer;

  using Base::m_wmSrfcProbeSendBuffer;

  using Base::m_wmSurfaces;


  using Base::m_wmImgCellIds;

  using Base::m_wmImgCoords;

  using Base::m_wmImgWMSrfcIds;


  using Base::m_wmSurfaceProbeIds;

  using Base::m_wmSurfaceProbeSrfcs;


  using Base::m_sweptVolume;

  using Base::m_sweptVolumeBal;


  // zonal method

  using Base::determineLESAverageCells;

  using Base::m_LESAverageCells;

  using Base::m_LESNoVarAverage;

  using Base::m_LESValues;

  using Base::m_LESVarAverage;

  using Base::m_LESVarAverageBal;

  using Base::m_noLESVariables;

  using Base::m_noRANSVariables;

  using Base::m_RANSValues;

  using Base::m_zonal;

  using Base::m_zonalAveragingTimeStep;

  using Base::resetZonalLESAverage;

  using Base::resetZonalSolverData;


  KDtree<nDim>* m_bodyTree = nullptr;

  KDtree<nDim>* m_bodyTreeLocal = nullptr;

  std::vector<Point<nDim>> m_bodyCenters;

  std::vector<Point<nDim>> m_bodyCentersLocal;


  friend FvBndryCndXD<nDim, SysEqn>;

  FvMbCartesianSolverXD(MInt, MInt, const MBool*, maia::grid::Proxy<nDim>& gridProxy_, Geometry<nDim>& geometry_,

                        const MPI_Comm comm);

  ~FvMbCartesianSolverXD() override;


  // destructor / constructor

  void initializeMb();

  void initAnalyticalLevelSet();

  void allocateBodyMemory(MInt mode = 0);


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

  static MInt locatenear(const Point<nDim>& /*pt*/, MFloat /*r*/, MInt* /*list*/, MInt /*nmax*/,

                         MBool returnCellId = true) {

    std::ignore = returnCellId;

    return 0;

  }


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

  MInt locatenear(const Point<nDim>& pt, MFloat r, MInt* list, MInt nmax, MBool returnCellId = true) {

    return m_bodyTree->locatenear(pt, r, &list[0], nmax, returnCellId);

  }


  std::vector<MFloat> m_oldBodyPosition;


  std::vector<MFloat> m_movingPosDiff;


  MInt m_tCutGroup{};

  MInt m_tCutGroupTotal{};


  // settings

  MBool m_trackMovingBndry{};

  MBool m_logBoundaryData{};

  MInt m_motionEquation{};

  MInt m_movingBndryCndId{};

  MInt m_loggingInterval{};

  MInt m_bodySamplingInterval{};

  MInt m_particleSamplingInterval{};

  MInt m_onlineRestartInterval{};

  MInt m_maxBndryLayerLevel{};

  MInt m_maxBndryLayerWidth{};

  MInt m_trackMbStart{};

  MInt m_FSIStart{};

  MInt m_trackMbEnd{};

  MInt m_bodyTypeMb{};

  MFloat m_FSIToleranceU{};

  MFloat m_FSIToleranceX{};

  MFloat m_FSIToleranceW{};

  MFloat m_FSIToleranceR{};

  MFloat m_outsideFactor{};

  MInt m_killSwitchCheckInterval{};

  MInt m_solutionDiverged{};

  SolverType m_solverType;

  MBool m_maxLevelDecrease = false;

  MFloat m_Fr{};

  MFloat m_g{};

  MBool m_haloCellOutput{};

  MBool m_complexBoundary{};

  MBool m_conservationCheck{};

  MBool m_writeCenterLineData{};

  MBool m_gclIntermediate{};

  MBool m_onlineRestart{};

  MFloat m_physicalTimeDt1{};

  MInt m_timeStepAdaptationStart{};

  MInt m_timeStepAdaptationEnd{};

  MFloat m_cflInitial{};

  MFloat m_cflTarget{};

  MFloat m_previousTimeStep{};

  MInt m_centralizeSurfaceVariables{};

  MBool m_generateOuterBndryCells{};

  MBool m_applyCollisionModel{};

  MBool m_applyRotationalCollisionModel{};

  MBool m_LsMovement{};

  MBool m_alwaysResetCutOff{};


  MBool m_standardRK = false;

  MInt m_reConstSVDWeightMode{};


  MInt m_lsCutCellMinLevel;

  MInt* m_lsCutCellLevel = nullptr;

  MBool m_maxLevelChange = false;

  MBool m_dynamicStencil{};


  std::map<MInt, MFloat> m_oldGeomBndryCells;

  MBool* m_geometryChange = nullptr;


  // Gap-Handling

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

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

  MBool m_gapCellExchangeInit = false;

  MBool m_noneGapRegions = true;

  MBool m_initGapCell = true;

  MInt* m_gapState = nullptr;


  // offsets & counters

  MInt m_noFlowCells{};

  MInt m_noGCells{};

  MInt m_noSurfaces{};

  MInt m_noBndryCells{};

  MInt m_maxNoEmbeddedBodiesPeriodic{};

  MInt m_initialSurfacesOffset{};

  MInt m_noOuterBoundarySurfaces{};

  MInt m_noLsMbBndryCells{};

  MInt m_noEmergedCells{};

  MInt m_noEmergedWindowCells{};

  MInt m_noBndryCandidates{};

  MInt m_noAzimuthalBndryCandidates{};

  MInt m_noNearBndryCells{};

  MInt m_reconstructionOffset{};

  MInt m_structureStep{};

  MInt m_maxStructureSteps{};

  MInt m_noSurfacePointSamples{};

  MInt m_maxNoSurfacePointSamples{};

  MInt m_noPointParticles{};

  MInt m_noPointParticlesLocal{};

  MInt* m_sampleNghbrs = nullptr;

  MInt* m_sampleNghbrOffsets = nullptr;

  MBool m_gapOpened{};

  MBool m_trackBodySurfaceData = true;

  MBool m_buildCollectedLevelSetFunction = false;

  MInt m_startSet{};

  // MInt m_noSets{};

  MInt* m_noBodiesInSet = nullptr;

  MInt* m_bodyToSetTable = nullptr;


  // constants and pseudo constants

  const clock_t m_t0;

  static constexpr MFloat FD = nDim;

  static constexpr MInt m_noCellNodes = IPOW2(nDim);

  const MInt m_noCVars;

  const MInt m_noFVars;

  const MInt m_noPVars;

  const MInt m_noSlopes;

  const MFloat m_gammaMinusOne;

  MInt m_maxNoSampleNghbrs{};

  MFloat m_U2{};

  MFloat m_rhoU2{};

  MFloat m_bodyDistThreshold{};

  MFloat m_periodicGhostBodyDist{};

  MFloat* m_gridCellArea = nullptr;

  MFloat* m_gravity = nullptr;


  // body properties

  MFloat* m_bodyRadius = nullptr;

  MFloat m_minBodyRadius{};

  MFloat m_maxBodyRadius{};

  MFloat* m_bodyRadii = nullptr;

  MFloat* m_bodyDiameter = nullptr;

  MFloat* m_bodyVolume = nullptr;

  MFloat* m_bodyMass = nullptr;

  MFloat* m_projectedArea = nullptr;

  MFloat m_addedMassCoefficient{};

  MFloat m_densityRatio{};

  MFloat m_capacityConstantVolumeRatio{};

  MFloat m_couplingRate{};

  MFloat** m_coupling = nullptr;

  MFloat m_couplingRateLinear{};

  MFloat m_couplingRatePressure{};

  MFloat m_couplingRateViscous{};

  MFloat* m_bodyQuaternion = nullptr;

  MFloat* m_bodyQuaternionDt1 = nullptr;

  MFloat* m_bodyDensity = nullptr;

  MFloat* m_bodyMomentOfInertia = nullptr;

  MFloat* m_bodyAccelerationDt1 = nullptr;

  MFloat* m_bodyAccelerationDt2 = nullptr;

  MFloat* m_bodyAccelerationDt3 = nullptr;

  MFloat* m_bodyVelocityDt1 = nullptr;

  MFloat* m_bodyVelocityDt2 = nullptr;

  MFloat* m_bodyTorque = nullptr;

  MFloat* m_bodyTorqueDt1 = nullptr;

  MFloat* m_bodyForce = nullptr;

  MFloat* m_bodyForceDt1 = nullptr;

  MFloat* m_bodyAngularVelocityDt1 = nullptr;

  MFloat* m_bodyAngularAccelerationDt1 = nullptr;

  MFloat* m_hydroForce = nullptr;

  MFloat* m_bodyCenterDt1 = nullptr;

  MFloat* m_bodyCenterDt2 = nullptr;

  MFloat* m_bodyCenterInitial = nullptr;

  MFloat* m_bodyTerminalVelocity = nullptr;

  MInt* m_fixedBodyComponents = nullptr;

  MInt* m_fixedBodyComponentsRotation = nullptr;

  MFloat* m_bodyNeutralCenter = nullptr;

  MInt* m_bodyEquation = nullptr;

  MInt* m_bodyInCollision = nullptr;

  MBool* m_bodyNearDomain = nullptr;

  MFloat* m_bodyDataAverage = nullptr;

  MFloat* m_bodyDataAverage2 = nullptr;

  MFloat* m_bodyDataDevAverage = nullptr;

  MFloat* m_bodySumAverage = nullptr;

  MBool* m_bodyDataCollision = nullptr;


  MBool m_forceAdaptation = false;


  // Lagrange particles

  MInt m_pointParticleTwoWayCoupling{};

  MInt m_pointParticleType{};

  MFloat* m_particleTerminalVelocity = nullptr;

  std::vector<MFloat> m_particleCoords;

  std::vector<MFloat> m_particleCoordsDt1;

  std::vector<MFloat> m_particleCoordsInitial;

  std::vector<MFloat> m_particleVelocity;

  std::vector<MFloat> m_particleTemperature;

  std::vector<MFloat> m_particleTemperatureDt1;

  std::vector<MFloat> m_particleHeatFlux;

  std::vector<MFloat> m_particleVelocityDt1;

  std::vector<MFloat> m_particleVelocityFluid;

  std::vector<MFloat> m_particleFluidTemperature;

  std::vector<MFloat> m_particleAcceleration;

  std::vector<MFloat> m_particleAccelerationDt1;

  std::vector<MFloat> m_particleQuaternions;

  std::vector<MFloat> m_particleQuaternionsDt1;

  std::vector<MFloat> m_particleAngularVelocity;

  std::vector<MFloat> m_particleAngularVelocityDt1;

  std::vector<MFloat> m_particleVelocityGradientFluid;

  std::vector<MFloat> m_particleAngularAcceleration;

  std::vector<MFloat> m_particleAngularAccelerationDt1;

  std::vector<MFloat> m_particleShapeParams;

  std::vector<MFloat> m_particleRadii;

  std::vector<MInt> m_particleCellLink;

  std::vector<MInt> m_particleGlobalId;

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

  std::set<MInt> m_bodyWasInCollision;

  std::set<MInt> m_bodyWasActuallyInCollision;


  // collectors

  std::vector<MInt> m_bndryCandidates;

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

  std::vector<MInt> m_bndryCandidateIds;

  MBool m_wasBalanced = false;

  std::vector<MInt> m_azimuthalBndryCandidates;

  std::vector<MInt> m_azimuthalBndryCandidateIds;

  std::vector<MFloat> m_candidateNodeValues;

  std::vector<MInt> m_candidateNodeSet;

  std::vector<MInt> m_bndryLayerCells;

  MFloat* m_bodyReducedVelocity = nullptr;

  MFloat* m_bodyReducedMass = nullptr;

  MFloat* m_bodyReducedFrequency = nullptr;

  MFloat* m_bodyDampingCoefficient = nullptr;

  MFloat** m_maxBndryLayerDistances = nullptr;

  MFloat* m_volumeFraction = nullptr;

  MFloat m_stableVolumeFraction{};

  MFloat* m_stableCellVolume = nullptr;

  // MFloat* m_sweptVolume = nullptr;

  MFloat* m_sweptVolumeDt1 = nullptr;

  MFloat** m_rhsViscous = nullptr;

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

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


  MFloat* m_cellVolumesDt1 = nullptr;

  MFloat* m_cellVolumesDt2 = nullptr;

  MFloat* m_boundaryPressureDt1 = nullptr;

  MFloat* m_boundaryDensityDt1 = nullptr;

  MBool** m_pointIsInside = nullptr;

  MInt* m_noCutCellFaces = nullptr;

  MInt** m_noCutFacePoints = nullptr;

  MInt** m_cutFacePointIds = nullptr;

  MFloat** m_cutFaceArea = nullptr;

  MFloat* m_sampleCoordinates = nullptr;

  MFloat* m_sampleNormals = nullptr;

  MFloat* m_bbox = nullptr;

  MFloat* m_bboxLocal = nullptr;

  MInt* m_nghbrList = nullptr;

  //  MInt* m_periodicDir;

  MPI_Request* g_mpiRequestMb = nullptr;

  MInt* m_sendBufferSize = nullptr;

  MInt* m_receiveBufferSize = nullptr;

  std::set<MInt> m_freeSurfaceIndices;


  std::map<MInt, MFloat> m_oldBndryCells;

  std::map<MInt, std::vector<MFloat>> m_nearBoundaryBackup;

  std::vector<std::tuple<MInt, MInt, MInt>> m_temporarilyLinkedCells;

  std::vector<MInt> m_massRedistributionIds;

  std::vector<MFloat> m_massRedistributionVariables;

  std::vector<MFloat> m_massRedistributionRhs;

  std::vector<MFloat> m_massRedistributionVolume;

  std::vector<MFloat> m_massRedistributionSweptVol;

  std::vector<MInt> m_refOldBndryCells;

  std::set<MInt> m_coarseOldBndryCells;


  std::vector<std::vector<MInt>> m_azimuthalLinkedHaloCells;

  std::vector<std::vector<MInt>> m_azimuthalLinkedWindowCells;

  std::multimap<MLong, std::pair<std::vector<MFloat>, std::vector<MUlong>>> m_azimuthalNearBoundaryBackup;

  std::vector<MInt> m_azimuthalWasNearBndryIds;

  MFloat* m_azimuthalNearBoundaryBackupBalFloat;

  MLong* m_azimuthalNearBoundaryBackupBalLong;

  MInt m_noFloatDataBalance = 0;

  MInt m_noFloatDataAdaptation = 0;

  MInt m_noLongData = 0;

  MInt m_noLongDataBalance = 0;

  const MFloat m_azimuthalCornerEps = 0.01; // Used to determine if recCoords match


  // array pointers

  MFloat* m_slope = nullptr;

  MFloat* m_area = nullptr;

  MFloat* m_surfaceVariables = nullptr;

  MFloat* m_cellCoordinates = nullptr;

  MFloat* m_surfaceCoordinates = nullptr;

  MFloat* m_cellSlopes = nullptr;

  MFloat* m_vars = nullptr;

  MFloat* m_oldVars = nullptr;


  // post processing

  MBool m_firstStats = true;

  static constexpr MInt m_noMeanStatistics = 6;

  static constexpr MFloat m_distThresholdStat[m_noMeanStatistics] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};

  MFloat m_oldMeanState[m_noMeanStatistics][4]{};

  MBool m_printHeaderCorr = true;

  MBool m_printHeaderSlip = true;

  static constexpr MInt m_noAngleSetups = 3;

  static constexpr MInt m_noDistSetups = 3;

  MBool m_saveSlipData;

  MInt m_slipInterval;

  MInt m_saveSlipInterval;

  MInt m_noSlipDataOutputs;

  std::vector<MInt> m_particleOffsets;

  MInt* m_slipDataParticleCollision = nullptr;

  MFloat* m_slipDataParticleQuaternion = nullptr;

  MFloat* m_slipDataParticleVel = nullptr;

  MFloat* m_slipDataParticleAngularVel = nullptr;

  MFloat* m_slipDataParticleForce = nullptr;

  MFloat* m_slipDataParticleTorque = nullptr;

  MFloat* m_slipDataParticleFluidVel = nullptr;

  MFloat* m_slipDataParticleFluidVelGrad = nullptr;

  MFloat* m_slipDataParticleFluidVelRot = nullptr;

  MFloat* m_slipDataParticleFluidVelRnd = nullptr;

  MFloat* m_slipDataParticleFluidVelGradRnd = nullptr;

  MFloat* m_slipDataParticleFluidVelRotRnd = nullptr;

  MFloat* m_slipDataParticlePosition = nullptr;

  std::vector<MFloat> m_slipDataTimeSteps;


  // timw-engine specific:

  MFloat* m_gapAngleClose = nullptr;

  MFloat* m_gapAngleOpen = nullptr;

  MFloat* m_gapSign = nullptr;

  MInt m_forceNoGaps;


  // global functions

  void setLevelSetMbCellProperties();

  void writeListOfActiveFlowCells() override;

  void setTimeStep() override;

  void initSolver() override;

  void finalizeInitSolver() override;

  void initSolutionStep(MInt mode) override;

  void reInitSolutionStep(const MInt mode);

  void updateInfinityVariables();

  void advanceSolution();

  void advanceBodies();

  void advanceTimeStep();

  void prepareNextTimeStep() override;

  void computeBoundarySurfaceForces();

  void applyInitialCondition() override;

  void applyExternalSource() override;

  void applyExternalOldSource() override;

  void advanceExternalSource() override;

  MBool maxResidual(MInt mode = 0) override;

  MLong getNumberOfCells(MInt mode);


  // initialisation

  void initGField();

  void initBndryLayer();


  void updateGeometry();

  void constructGField(MBool updateBody = true);

  MInt constructDistance(const MFloat deltaMax, MIntScratchSpace& nearestBodies, MFloatScratchSpace& nearestDist);

  void transferLevelSetFieldValues(MBool);

  void updateLevelSetOutsideBand();

  MFloat CalculateLSV(MInt, MIntScratchSpace&);

  void setParticleFluidVelocities(MFloat* = nullptr);

  void advancePointParticles();

  MBool constructGFieldCorrector();

  void constructGFieldPredictor();

  void initBodyProperties();

  void initPointParticleProperties();

  void initBodyVelocities();

  void updateBodyProperties();

  void transferBodyState(MInt k, MInt b);

  void createPeriodicGhostBodies();

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

  void createBodyTree();

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

  void createBodyTree();

  void computeBodyMomentOfInertia();

  static void computeRotationMatrix(MFloatScratchSpace&, MFloat* q);

  static void matrixProduct(MFloatScratchSpace& C, MFloatScratchSpace& A, MFloatScratchSpace& B);

  static void matrixProductTranspose(MFloatScratchSpace& C, MFloatScratchSpace& A, MFloatScratchSpace& B);

  static void matrixProductTranspose2(MFloatScratchSpace& C, MFloatScratchSpace& A, MFloatScratchSpace& B);

  static void matrixVectorProduct(MFloat* c, MFloatScratchSpace& A, MFloat* b);

  static void matrixVectorProductTranspose(MFloat* c, MFloatScratchSpace& A, MFloat* b);

  void integrateBodyRotation();

  void getBodyRotation(const MInt bodyId, MFloat* bodyRotation);

  void getBodyRotationDt1(const MInt bodyId, MFloat* bodyRotation);

  void setBodyQuaternions(const MInt bodyId, MFloat* bodyRotation);


  void setGapOpened();

  void gapHandling();

  void initGapCellExchange();

  void gapCellExchange(MInt);

  MInt checkNeighborActivity(MInt);

  void updateGapBoundaryCells();

  void checkGapCells();

  void interpolateGapBodyVelocity();

  MFloat interpolateLevelSet(MInt*, MFloat*, MInt);

  void setGapCellId();


  // boundary generation

  void logBoundaryData(const MChar* fileName, MBool forceOutput);

  void generateBndryCellsMb(const MInt mode);

  void checkHaloBndryCells(MBool sweptVol);

  void determineBndryCandidates();

  void computeNodalLSValues();

  void exchangeNodalLSValues();


  void initAzimuthalLinkedHaloExc();

  void exchangeLinkedHaloCellsForAzimuthalReconstruction();

  void storeAzimuthalPeriodicData(MInt mode = 0);

  void commAzimuthalPeriodicData(MInt mode = 0);

  void computeAzimuthalReconstructionConstants(MInt mode = 0) override;

  void buildAdditionalAzimuthalReconstructionStencil(MInt mode = 0);

  void updateAzimuthalMaxLevelRecCoords();

  void updateAzimuthalNearBoundaryExchange();

  void computeAzimuthalHaloNodalValues();

  void exchangeAzimuthalOuterNodalValues(std::vector<CutCandidate<nDim>>& candidates, std::vector<MInt>& candidateIds);


  void computeCutPointsMb_MGC();

  MBool createCutFaceMb();

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

  void createCutFaceMb_MGC();

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

  void createCutFaceMb_MGC();

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

  void checkNormalVectors();

  void determineNearBndryCells();

  void computeGhostCellsMb();

  void setOuterBoundaryGhostCells();

  void setOuterBoundarySurfaces();

  void setupBoundaryCandidatesAnalytical();

  void checkBoundaryCells();

  void linkBndryCells();

  void redistributeMass();

  MInt createSplitCell(MInt cellId, MInt noSplitChilds);

  MFloat updateCellVolumeGCL(MInt bndryId);

  void correctRefinedBndryCell();

  void correctRefinedBndryCellVolume();

  void correctCoarsenedBndryCellVolume();


  void rebuildKDTreeLocal();

  void rebuildKDTree();


  // reinitialization routines

  void resetSolverFull() override;

  void resetSolverMb();

  void resetSolver() override;

  void resetSurfaces() override;

  void balance(const MInt* const noCellsToReceiveByDomain, const MInt* const noCellsToSendByDomain,

               const MInt* const targetDomainsByCell, const MInt oldNoCells) override;

  void balancePre() override;

  void balancePost() override;

  void finalizeBalance() override;


  MBool hasSplitBalancing() const override { return true; }

  void localToGlobalIds() override;


  MInt noCellDataDlb() const override {

    if(grid().isActive()) {

      return CellDataDlb::count;

    } else {

      return 0;

    }

  };

  MInt cellDataTypeDlb(const MInt dataId) const override {

    MInt dataType = -1;

    if(dataId < CellDataDlb::count) {

      dataType = s_cellDataTypeDlb[dataId];

    } else {

      TERMM(1, "solverCelldataType: invalid data id " + std::to_string(dataId));

    }

    return dataType;

  };

  MInt cellDataSizeDlb(const MInt dataId, const MInt gridCellId) override;


  void getCellDataDlb(const MInt dataId, const MInt oldNoCells, const MInt* const bufferIdToCellId,

                      MFloat* const data) override;

  void getCellDataDlb(const MInt dataId, const MInt oldNoCells, const MInt* const bufferIdToCellId, MLong* const data);

  void setCellDataDlb(const MInt dataId, const MFloat* const data) override;

  void setCellDataDlb(const MInt dataId, const MLong* const data);


  MBool adaptationTrigger() override;

  void resetMbBoundaryCells();

  void deleteNeighbourLinks();

  void restoreNeighbourLinks();

  void initializeEmergedCells();

  void initEmergingGapCells();

  void updateCellSurfaceDistanceVectors();

  void updateCellSurfaceDistanceVector(MInt srfcId);

  void updateViscousFluxComputation();

  void leastSquaresReconstruction();

  void buildAdditionalReconstructionStencil();

  void computeVolumeFraction();

  void computeReconstructionConstants() override;


  void prepareAdaptation() override;

  void setSensors(std::vector<std::vector<MFloat>>& sensors,

                  std::vector<MFloat>& sensorWeight,

                  std::vector<std::bitset<64>>& sensorCellFlag,

                  std::vector<MInt>& sensorSolverId) override;

  void postAdaptation() override;

  void finalizeAdaptation() override;

  void sensorPatch(std::vector<std::vector<MFloat>>&, std::vector<std::bitset<64>>&, std::vector<MFloat>&, MInt,

                   MInt) override;


  void removeChilds(const MInt) override;

  void refineCell(const MInt) override;

  void setCellWeights(MFloat*) override;

  void descendLevelSetValue(const MInt cellId, const MInt* const bodyIds, const MInt bodyCnt);

  void descendDistance(const MInt cellId, const MInt* const bodyIds, const MInt bodyCnt,

                       MIntScratchSpace& nearestBodies, MFloatScratchSpace& nearestDist);

  void getBoundaryDistance(MFloatScratchSpace&) override;

  void swapCells(const MInt, const MInt) override;

  void moveSurface(const MInt toSrfcId, const MInt fromSrfcId);

  void compactSurfaces();

  void correctMasterSlaveSurfaces();

  void restoreSurfaces(const MInt cellId);

  void resetSurfaces(MInt cellId);

  void removeSurfaces(MInt cellId);

  void deleteSurface(MInt srfcId);

  void createSurface(MInt srfcId, MInt nghbrId0, MInt nghbrId1, MInt orientation);

  void createSurfaceSplit(MInt srfcId, MInt cellId, MInt splitChildId, MInt direction);

  MInt getNewSurfaceId();

  void rebuildReconstructionConstants(MInt cellId);

  void setCellProperties() override;

  static void setAdditionalCellProperties();

  void setAdditionalActiveFlag(MIntScratchSpace&) override;

  void computeLocalBoundingBox();


  // surface generation

  void createInitialSrfcs();

  void correctSrfcsMb();

  void addBoundarySurfacesMb();


  // MUSCL

  void Muscl(MInt timerId = -1) override;

  ATTRIBUTES1(ATTRIBUTE_HOT) void LSReconstructCellCenter() override;

  ATTRIBUTES1(ATTRIBUTE_HOT) void computeSurfaceValues(MInt timerId = -1) override;

  ATTRIBUTES1(ATTRIBUTE_HOT) void computeSurfaceValuesLimited(MInt timerId = -1) override;


  // base solver

  ATTRIBUTES1(ATTRIBUTE_HOT) void Ausm() override;

  ATTRIBUTES1(ATTRIBUTE_HOT) void viscousFlux() override;

  ATTRIBUTES1(ATTRIBUTE_HOT) void resetRHS() override;

  ATTRIBUTES1(ATTRIBUTE_HOT) void distributeFluxToCells() override;

  void initializeRungeKutta() override;

  void setRungeKuttaFunctionPointer();

  MBool rungeKuttaStep() override;

  MBool (FvMbCartesianSolverXD::*execRungeKuttaStep)();

  template <MInt timeStepMethod>

  ATTRIBUTES1(ATTRIBUTE_HOT)

  MBool rungeKuttaStepStandard();

  template <MInt timeStepMethod>

  ATTRIBUTES1(ATTRIBUTE_HOT)

  MBool rungeKuttaStepNew();

  ATTRIBUTES1(ATTRIBUTE_HOT) MBool rungeKuttaStepNewLocalTimeStepping();

  void computeTimeStep();

  void adaptTimeStep();

  void updateSplitParentVariables() override;

  void updateSpongeLayer() override;

  virtual void generateBndryCells();

  ATTRIBUTES1(ATTRIBUTE_HOT) void exchange() override;

  void initializeMaxLevelExchange() override;

  void updateMultiSolverInformation(MBool fullReset = false) override;

  void exchangeLevelSetData();

  void applyALECorrection();

  void resetRHSCutOffCells() override;


  // boundary conditions

  void applyBoundaryCondition() override;

  void applyBoundaryConditionMb();

  void applyBoundaryConditionSlope();

  void updateGhostCellSlopesInviscid();

  void updateGhostCellSlopesViscous();

  void applyDirichletCondition();

  void applyNeumannCondition();

  void setBoundaryVelocity();

  void copyVarsToSmallCells() override;

  void correctBoundarySurfaceVariablesMb();

  void computeBodySurfaceData(MFloat* pressureForce = nullptr);

  void resetRHSNonInternalCells() override;

  void updateLinkedCells();


  // input/output functions

  void saveSolverSolution(const MBool forceOutput = false, const MBool finalTimeStep = false) override;

  void recordBodyData(const MBool& firstRun);

  void crankAngleSolutionOutput();

  void writeStencil(const MInt bndryId);

  void computeForceCoefficients(MFloat*&);

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

  MInt writeGeometryToVtkXmlFile(const MString& fileName);

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

  static MInt writeGeometryToVtkXmlFile(const MString& fileName);

  void saveRestartFile(const MBool) override;

  void loadRestartFile() override;

  void loadBodyRestartFile(MInt);

  void setOldGeomBndryCellVolume();

  void saveBodyRestartFile(const MBool backup);

  void saveBodySamples();

  void saveParticleSamples();

  void writeVtkDebug(const MString suffix);

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

  void writeVtkXmlOutput(const MString& fileName, MBool debugOutput = false);

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

  void writeVtkXmlOutput(const MString& fileName, MBool debugOutput = false);

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

  void writeVtkXmlOutput_MGC(const MString& fileName);

  void writeVtkXmlFiles(const MString fileName, const MString GFileName, MBool regularOutput, MBool diverged) override;

  void writeVtkErrorFile();

  void printDynamicCoefficients(MBool firstRun, MFloat* pressureForce);

  std::vector<MInt> m_forceFVMBStatistics;

  void computeFlowStatistics(MBool force);

  void saveParticleSlipData();

  void computeSlipStatistics(const MIntScratchSpace& nearestBodies, const MFloatScratchSpace& nearestDist,

                             const MFloat maxDistConstructed);

  void computeNearBodyFluidVelocity(const MIntScratchSpace& nearestBodies, const MFloatScratchSpace& nearestDist,

                                    MFloat* vel, MFloat* velGrad, MFloat* rotation,

                                    const std::vector<MFloat>& setup = std::vector<MFloat>(),

                                    MInt* skipBodies = nullptr, MFloat* meanBodyState = nullptr,

                                    MFloat* pressure = nullptr, MFloat* velDt = nullptr, MFloat* rotationDt = nullptr,

                                    MFloat* nearestFac = nullptr);

  void computeBodyVolume(MFloatScratchSpace& partVol);

  void saveInitCorrData(const std::vector<MInt>& saveInitCorrDataTimeSteps, const MFloatScratchSpace& bodyVelocityInit,

                        const MFloatScratchSpace& bodyAngularVelocityInit, const MFloatScratchSpace& bodyQuaternionInit,

                        const MFloatScratchSpace& velMeanInit, const MFloatScratchSpace& velGradMeanInit,

                        const MFloatScratchSpace& particleFluidRotationMeanInit, const MIntScratchSpace& corrBodies,

                        const MFloatScratchSpace& bodyForceInit, const MFloatScratchSpace& bodyTorqueInit,

                        const MIntScratchSpace& bodyOffsets);

  MInt loadInitCorrData(const std::vector<MInt>& saveInitCorrDataTimeSteps, MFloatScratchSpace& bodyVelocityInit,

                        MFloatScratchSpace& bodyAngularVelocityInit, MFloatScratchSpace& bodyQuaternionInit,

                        MFloatScratchSpace& velMeanInit, MFloatScratchSpace& velGradMeanInit,

                        MFloatScratchSpace& particleFluidRotationMeanInit, MIntScratchSpace& corrBodies,

                        MFloatScratchSpace& bodyForceInit, MFloatScratchSpace& bodyTorqueInit,

                        const MIntScratchSpace& bodyOffsets);

  MFloat determineCoupling(MFloatScratchSpace& coupling);

  void writeCenterLineVel(const MChar* fileName);

  void readStlFile(const MChar* fileName, MBool readNormals);

  MBool prepareRestart(MBool, MBool&) override;

  void reIntAfterRestart(MBool) override;


  //  time-step and solution Step functions:

  void preTimeStep() override;

  void preSolutionStep(const MInt = -1) override;

  MBool solutionStep() override;

  MBool postSolutionStep() override;

  void postTimeStep() override;

  // postTimeStep is not overloaded from fv-cartesian-solver


  // help functions

  void logOutput();

  void resetSlopes();

  void logData();

  MInt createBndryCellMb(MInt cellId);

  MInt getAdjacentCells(MInt cellId, MInt* adjacentCells);

  MInt getAdjacentGridCells(MInt cellId, MInt* adjacentCells);

  MInt getAdjacentCellsAllLevels(MInt cellId, MInt* adjacentCells);

  MInt getAdjacentCellsExtended(MInt cellId, MInt* adjacentCells);

  MInt getEqualLevelNeighbors(MInt cellId, MInt (&nghbrs)[27]);

  MInt broadcastSignal(const MInt sender, const MInt signal);

  inline MInt getFacingNghbrs(const MInt cellId, const MBool includeAllChilds);

  inline MFloat temperature(MInt cellId);

  static inline void crossProduct(MFloat* c, MFloat* a, MFloat* b);

  inline MFloat filterFloat(MFloat number);

  static inline MFloat CdLaw(MFloat Re) { return 24.0 * (F1 + (0.15 * pow(Re, 0.687))) / Re; }

  MBool gridPointIsInside(MInt, MInt) override;

  MString getConservativeVarName(MInt i);

  MString getPrimitiveVarName(MInt i);

  MInt inverseGJ();

  template <typename T>

  MBool isNan(T val);


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

  MFloat getDistance(const MInt, const MInt);

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

  MFloat getDistanceSphere(const MInt, const MInt);

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

  MFloat getDistancePiston(const MInt, const MInt);

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

  MFloat getDistanceEllipsoid(const MInt, const MInt);

  MFloat getDistanceNaca00XX(const MInt, const MInt);

  MFloat getDistanceSplitSphere(const MInt, const MInt);

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

  void getNormal(const MInt, const MInt, MFloat[]);

  void getNormalSphere(const MInt, const MInt, MFloat[]);

  void getNormalEllipsoid(const MInt, const MInt, MFloat[]);

  MFloat getLevelSetValueNaca00XX(const MFloat* const, const MFloat sign);

  MFloat distancePointEllipsoidSpecial(const MFloat e[3], const MFloat y[3], MFloat x[3]);

  MFloat distancePointEllipsoidSpecial2(const MFloat e[3], const MFloat y[3], MFloat x[3]);

  MFloat distancePointEllipsoid(const MFloat e[3], const MFloat y[3], MFloat x[3]);

  static MFloat distancePointEllipseSpecial(const MFloat e[2], const MFloat y[2], MFloat x[2]);

  MFloat distEllipsoidEllipsoid(const MInt k0, const MInt k1, MFloat* xc0, MFloat* xc1);


  void checkCellState(); // claudia

  inline MBool inside(MFloat x, MFloat a, MFloat b);

  MString printTime(const MFloat t);

  MBool fileExists(const MChar* fileName);

  MInt copyFile(const MChar* fromName, const MChar* toName);

  void checkHaloCells(MInt mode = 0);


  GeometryIntersection<nDim>* m_geometryIntersection = nullptr;

  FvBndryCndXD<nDim, SysEqn>* m_fvBndryCnd = nullptr;

  MInt returnNoActiveCorners(MInt);


 private:

  static inline MFloat sgn(MFloat val) { return (val < F0) ? -F1 : F1; }

  void checkDiv() override;


  class surfBase {

   public:

    MInt bodyId{};

    MFloat area{};

    MFloat normal[nDim]{};

    MFloat center[nDim]{};

    surfBase() = default;

    explicit surfBase(MInt _bodyId) : bodyId(_bodyId) {}

  };


  class polyVertex {

   public:

    MFloat coordinates[nDim]{};

    MInt pointId{};

    MInt pointType{}; // 0: corner point; 1: cut points; 2: additional MC vertex; 3: additional

                      // polyhedron clipping vertex

    MInt cartSrfcId{};

    std::vector<MInt> edges;

    std::set<MInt> surfaceIdentificators;

    polyVertex(MInt pId, MInt pType) : pointId(pId), pointType(pType), cartSrfcId(-1) {}

    polyVertex(MFloat* coords, MInt pId, MInt pType) : polyVertex(pId, pType) {

      std::copy(coords, coords + nDim, coordinates);

    }

  };


  class polyEdgeBase {

   public:

    MInt vertices[2];

    MInt edgeType; // 0: Cartesian uncut, 1: Cartesian cut, 2: cut line on face, 3: cut line in cell

    MInt edgeId;   // for edgeType 0/1: Cartesian edge, for edgeType 2/3: cartesian face or -1 if

                   // pure body line

    polyEdgeBase(MInt v0, MInt v1, MInt eId, MInt eType) : vertices{v0, v1}, edgeType(eType), edgeId(eId) {}

  };


  class polyEdge2D : public surfBase, public polyEdgeBase {

   public:

    MInt cutCell;

    MFloat w{};

    polyEdge2D(MInt v0, MInt v1, MInt eId, MInt eType, MInt _bodyId)

      : surfBase(_bodyId), polyEdgeBase(v0, v1, eId, eType), cutCell(-1) {}

  };


  class polyEdge3D : public polyEdgeBase {

   public:

    MInt face[2];

    polyEdge3D(MInt v0, MInt v1, MInt eId, MInt eType) : polyEdgeBase(v0, v1, eId, eType), face{-1, -1} {}

  };


  class polyFace : public surfBase {

   public:

    std::vector<std::pair<MInt, MInt>>

        edges; // contains 1. the edge and 2. the direction of the edge (1: as is, -1: reversed)

    MInt cutCell;

    MInt faceId{};

    MInt faceType{}; // 0: cartesian face; 1: body face

    MFloat w{};

    MInt tmpSetIndex;

    MInt isLine;

    polyFace(MInt fId, MInt fType, MInt _bodyId)

      : surfBase(_bodyId), cutCell(-1), faceId(fId), faceType(fType), tmpSetIndex(-1), isLine(false) {}


   private:

    polyFace() : surfBase(-1), cutCell(-1), tmpSetIndex(-1), isLine(false) {}

  };


  // 3D

  class polyMultiFace : public surfBase {

   public:

    std::vector<MInt> faces;

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

        edges; // contains 1. the edge and 2. the direction of the edge (1: as is, -1: reversed)

  };


  class polyCutCellBase {

   public:

    MInt cartesianCell;

    MFloat volume{};

    MFloat center[nDim]{};

    polyCutCellBase(MInt cartCell, MFloat* _center) : cartesianCell(cartCell) {

      std::copy(_center, _center + nDim, center);

    }

  };


  class polyCutCell : public polyCutCellBase {

   public:

    // The following naming is sick, but I don't care: in 2D these are edges and 3D faces

    std::vector<MInt> faces_edges;

    polyCutCell(MInt cartCell, MFloat* _center) : polyCutCellBase(cartCell, _center) {}

  };


  // 3D

  class splitCartesianFace {

   public:

    MInt direction;

    std::vector<MInt> srfcIds;

    explicit splitCartesianFace(MInt dir) : direction(dir) {}

  };


  // 3D

  class cellWithSplitFace {

   public:

    MInt cellId;

    std::vector<splitCartesianFace> splitFaces;

    explicit cellWithSplitFace(MInt id) : cellId(id) {}

  };


  MBool test_face(MInt, MInt, MInt);

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

  void writeVTKFileOfCell(MInt, const std::vector<polyEdge2D>*, const std::vector<polyVertex>*, MInt);

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

  void writeVTKFileOfCutCell(MInt, std::vector<polyCutCell>*, const std::vector<polyEdge2D>*,

                             const std::vector<polyVertex>*, MInt);

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

  void outputPolyData(const MInt, const std::vector<polyCutCell>*, const std::vector<polyEdge2D>*,

                      const std::vector<polyVertex>*, MInt);

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

  void outputPolyData(const MInt, const std::vector<polyCutCell>*, const std::vector<polyFace>*,

                      const std::vector<polyEdge3D>*, const std::vector<polyVertex>*, MInt);

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

  void compVolumeIntegrals(std::vector<polyCutCell>*, std::vector<polyEdge2D>*, const std::vector<polyVertex>*);

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

  void compFaceIntegrals(polyCutCell*, std::vector<polyEdge2D>*, const std::vector<polyVertex>*, MInt, MInt);

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

  void compProjectionIntegrals(polyCutCell*, std::vector<polyEdge2D>*, const std::vector<polyVertex>*, MInt, MInt,

                               MFloat*);


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

  static inline void computeNormal(const MFloat* p0, const MFloat* p1, MFloat* res, MFloat& w) {

    const MFloat dx = p1[0] - p0[0];

    const MFloat dy = p1[1] - p0[1];

    res[0] = -dy;

    res[1] = dx;

    const MFloat abs = sqrt(res[0] * res[0] + res[1] * res[1]);

    res[0] /= abs;

    res[1] /= abs;

    w = -res[0] * p0[0] - res[1] * p0[1];

  }


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

  static inline MFloat computeNormal(const MFloat* p0, const MFloat* p1, const MFloat* p2, MFloat* res, MFloat& w) {

    const MFloat a0 = p1[0] - p0[0], a1 = p1[1] - p0[1], a2 = p1[2] - p0[2], b0 = p2[0] - p0[0], b1 = p2[1] - p0[1],

                 b2 = p2[2] - p0[2];

    res[0] = a1 * b2 - a2 * b1;

    res[1] = a2 * b0 - a0 * b2;

    res[2] = a0 * b1 - a1 * b0;

    const MFloat abs = sqrt(res[0] * res[0] + res[1] * res[1] + res[2] * res[2]);

    res[0] /= abs;

    res[1] /= abs;

    res[2] /= abs;

    w = -res[0] * p0[0] - res[1] * p0[1] - res[2] * p0[2];

    return abs;

  }


  inline MFloat checkCentroidDiff(MInt srfcId1, MInt srfcId2);

  inline MFloat checkAreaDiff(MInt srfcId1, MInt srfcId2);


  class CsgVector {

   public:

    MFloat xx[3] = {F0, F0, F0};

    CsgVector() { std::fill(xx, xx + nDim, F0); }

    explicit CsgVector(const MFloat* X) { std::copy(X, X + nDim, xx); }

    CsgVector(const CsgVector& Y) { std::copy(Y.xx, Y.xx + nDim, xx); }

    CsgVector(CsgVector&&) noexcept = default;

    CsgVector& operator=(const CsgVector&) = default;

    CsgVector& operator=(CsgVector&&) = default;


    inline CsgVector clone() const {

      CsgVector tmp;

      std::copy(this->xx, this->xx + nDim, tmp.xx);

      return tmp;

    }

    inline CsgVector plus(const CsgVector& a) const {

      CsgVector tmp;

      for(MInt i = 0; i < nDim; i++)

        tmp.xx[i] = this->xx[i] + a.xx[i];

      return tmp;

    }

    inline CsgVector minus(const CsgVector& a) const {

      CsgVector tmp;

      for(MInt i = 0; i < nDim; i++)

        tmp.xx[i] = this->xx[i] - a.xx[i];

      return tmp;

    }

    inline CsgVector times(const MFloat a) const {

      CsgVector tmp;

      for(MInt i = 0; i < nDim; i++)

        tmp.xx[i] = this->xx[i] * a;

      return tmp;

    }

    inline CsgVector dividedBy(const MFloat a) const {

      CsgVector tmp;

      for(MInt i = 0; i < nDim; i++)

        tmp.xx[i] = this->xx[i] / a;

      return tmp;

    }

    inline MFloat dot(const CsgVector& a) const {

      MFloat dotp = F0;

      for(MInt i = 0; i < nDim; i++)

        dotp += this->xx[i] * a.xx[i];

      return dotp;

    }

    inline CsgVector lerp(const CsgVector& a, const MFloat t) const { return this->plus((a.minus(*this)).times(t)); }

    inline MFloat length() const { return sqrt(this->dot(*this)); }

    inline CsgVector unit() const { return this->dividedBy(this->length()); }

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

    inline CsgVector cross(const CsgVector& a) const {

      CsgVector tmp;

      tmp.xx[0] = this->xx[1] * a.xx[2] - this->xx[2] * a.xx[1];

      tmp.xx[1] = this->xx[2] * a.xx[0] - this->xx[0] * a.xx[2];

      tmp.xx[2] = this->xx[0] * a.xx[1] - this->xx[1] * a.xx[0];

      return tmp;

    }

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

    inline CsgVector cross(const CsgVector&) const {

      TERMM(1, "Get your ass out of this function. This is 3D code!");

    }

    inline void negate() {

      for(MInt i = 0; i < nDim; i++)

        this->xx[i] = -this->xx[i];

    }

  };


  class CsgVertex {

   public:

    CsgVector pos;

    MInt vertexId;

    MInt setIndex;

    CsgVertex(const CsgVector& _pos, MInt _vertexId, MInt _setIndex) : pos(_pos) {

      vertexId = _vertexId;

      setIndex = _setIndex;

    }

    CsgVertex clone() const {

      CsgVertex tmp(this->pos.clone(), vertexId, setIndex);

      return tmp;

    }

    CsgVertex interpolate(CsgVertex* other, MFloat t) const { return CsgVertex(this->pos.lerp(other->pos, t), -1, -1); }

  };


  class CsgPolygon;


  class CsgPlane {

   public:

    static constexpr MFloat eps = (nDim == 3) ? 10000 * MFloatEps : 1000 * MFloatEps;

    CsgVector normal;

    MFloat w{};


    CsgPlane() = default;

    CsgPlane(CsgVector* _normal, MFloat _w) {

      std::copy(_normal->xx, _normal->xx + nDim, normal.xx);

      w = _w;

    }

    explicit CsgPlane(CsgVector abc[nDim]) {

      IF_CONSTEXPR(nDim == 3) {

        CsgVector tmp = abc[1].minus(abc[0]).cross(abc[nDim - 1 /*2*/].minus(abc[0])).unit();

        normal = tmp;

        w = normal.dot(abc[0]);

      }

      else IF_CONSTEXPR(nDim == 2) {

        CsgVector tmp = abc[1].minus(abc[0]).unit();

        normal.xx[0] = -tmp.xx[1];

        normal.xx[1] = tmp.xx[0];

        w = normal.dot(abc[0]);

      }

    }

    ~CsgPlane() = default;

    CsgPlane clone() {

      CsgPlane tmp(&this->normal, this->w);

      return tmp;

    }

    void flip() {

      this->normal.negate();

      this->w = -this->w;

    }

    void splitPolygon(CsgPolygon* polygon,

                      std::vector<CsgPolygon>* coplanarFront,

                      std::vector<CsgPolygon>* coplanarBack,

                      std::vector<CsgPolygon>* front,

                      std::vector<CsgPolygon>* back) const;

    void insertCoplanarPolygon(CsgPolygon* polygon,

                               std::vector<CsgPolygon>* coplanarFront,

                               std::vector<CsgPolygon>* coplanarBack) const;

  };


  class CsgPolygon {

   public:

    std::vector<CsgVertex> vertices;

    // helpers: edgeType[0] corresponds to edge between vertices[0] and vertices[1],...

    CsgPlane plane;

    MInt setIndex{};

    MInt bodyId{};

    MInt faceId{};

    MInt faceType{}; // 0: cartesian face; 1: body face


    CsgPolygon(std::vector<CsgVertex> _vertices, MInt _setIndex, MInt _faceId, MInt _faceType, MInt _bodyId) {

      for(MInt i = 0; (unsigned)i < _vertices.size(); i++) {

        vertices.push_back(_vertices[i].clone());

      }

      setIndex = _setIndex;

      faceId = _faceId;

      faceType = _faceType;

      bodyId = _bodyId;

      CsgVector abc[nDim];

      for(MInt i = 0; i < nDim; i++)

        abc[i] = vertices[i].pos;

      CsgPlane tmp = CsgPlane(abc);

      plane = tmp;

    }


    CsgPolygon(std::vector<CsgVertex> _vertices, MInt _setIndex, MInt _faceId, MInt _faceType, MInt _bodyId,

               CsgPlane _plane) {

      for(MInt i = 0; (unsigned)i < _vertices.size(); i++) {

        vertices.push_back(_vertices[i].clone());

      }

      setIndex = _setIndex;

      faceId = _faceId;

      faceType = _faceType;

      bodyId = _bodyId;

      plane = _plane.clone();

    }


    ~CsgPolygon() = default;


    CsgPolygon clone() const {

      CsgPolygon tmp(vertices, setIndex, faceId, faceType, bodyId, plane);

      return tmp;

    }


    void flip() {

      this->plane.flip();

      std::vector<CsgVertex> tmp;

      for(auto rit = vertices.rbegin(); rit != vertices.rend(); ++rit) {

        tmp.push_back((*rit));

      }

      vertices.swap(tmp);

    }


   private:

    CsgPolygon() = default;

  };


  class CsgNode {

   public:

    CsgPlane plane;

    MBool planeValid;

    CsgNode* front;

    CsgNode* back;

    std::vector<CsgPolygon> polygons;


    explicit CsgNode(std::vector<CsgPolygon> _polygons) {

      planeValid = false;

      front = nullptr;

      back = nullptr;

      polygons.clear();

      this->build(std::move(_polygons));

    }


    CsgNode() {

      planeValid = false;

      front = nullptr;

      back = nullptr;

      polygons.clear();

    }


    ~CsgNode() {

      this->polygons.clear();

      delete this->front;

      delete this->back;

    }


    void invert() {

      for(MInt i = 0; (unsigned)i < this->polygons.size(); i++) {

        this->polygons[i].flip();

      }

      this->plane.flip();

      if(this->front) this->front->invert();

      if(this->back) this->back->invert();

      CsgNode* temp = this->front;

      this->front = this->back;

      this->back = temp;

    }


    std::vector<CsgPolygon> clipPolygons(std::vector<CsgPolygon> _polygons) {

      if(!planeValid) {

        return _polygons;

      }

      std::vector<CsgPolygon> _front;

      std::vector<CsgPolygon> _back;

      for(MInt i = 0; (unsigned)i < _polygons.size(); i++) {

        this->plane.splitPolygon(&_polygons[i], &_front, &_back, &_front, &_back);

      }

      if(this->front) _front = this->front->clipPolygons(_front);

      if(this->back)

        _back = this->back->clipPolygons(_back);

      else

        _back.clear();

      for(MInt i = 0; (unsigned)i < _back.size(); i++)

        _front.push_back(_back[i]);

      return _front;

    }


    void clipTo(CsgNode& bsp) {

      this->polygons = bsp.clipPolygons(this->polygons);

      if(this->front) this->front->clipTo(bsp);

      if(this->back) this->back->clipTo(bsp);

    }


    std::vector<CsgPolygon> allPolygons() {

      std::vector<CsgPolygon> _polygons(this->polygons);

      if(this->front) {

        std::vector<CsgPolygon> _polygons_front = this->front->allPolygons();

        for(MInt i = 0; (unsigned)i < _polygons_front.size(); i++)

          _polygons.push_back(_polygons_front[i]);

      }

      if(this->back) {

        std::vector<CsgPolygon> _polygons_back = this->back->allPolygons();

        for(MInt i = 0; (unsigned)i < _polygons_back.size(); i++)

          _polygons.push_back(_polygons_back[i]);

      }

      return _polygons;

    }


    void build(std::vector<CsgPolygon> _polygons);


    // This function originally only existed in 3D

    void plot(MInt tabCounter, const MChar* fileName) {

      std::ofstream ofl;

      if(tabCounter == 0) {

        ofl.open(fileName);

        ofl.close();

      }


      if(this->front) this->front->plot(tabCounter + 1, fileName);


      ofl.open(fileName, std::ofstream::app);


      if(ofl) {

        for(MInt count = 0; count < tabCounter; count++)

          ofl << "      ";

        ofl << "node plane normal, w:";

        for(MInt dim = 0; dim < nDim; ++dim)

          ofl << " " << this->plane.normal.xx[dim];

        ofl << ", " << this->plane.w << std::endl;


        for(MInt p = 0; (unsigned)p < this->polygons.size(); p++) {

          for(MInt count = 0; count < tabCounter; count++)

            ofl << "      ";

          ofl << "polygon " << p << " plane normal, w:";

          for(MInt dim = 0; dim < nDim; ++dim)

            ofl << " " << this->polygons[p].plane.normal.xx[dim];

          ofl << ", " << this->polygons[p].plane.w << std::endl;


          for(MInt count = 0; count < tabCounter; count++)

            ofl << "      ";

          ofl << "polygon setIndex: " << this->polygons[p].setIndex << ", bodyId: " << this->polygons[p].bodyId

              << ", faceId: " << this->polygons[p].faceId << ", faceType: " << this->polygons[p].faceType << std::endl;

        }

        ofl << std::endl << std::endl;

        ofl.close();

      }


      if(this->back) this->back->plot(tabCounter + 1, fileName);

    }

  };


  class Csg {

   public:

    std::vector<CsgPolygon> polygons;


    Csg() { polygons.clear(); }


    explicit Csg(std::vector<CsgPolygon> _polygons) {

      for(MInt i = 0; (unsigned)i < _polygons.size(); i++) {

        polygons.push_back(_polygons[i].clone());

      }

    }


    ~Csg() = default;


    std::vector<CsgPolygon> intersect(const Csg& csg) const {

      CsgNode a(this->polygons);

      CsgNode b(csg.polygons);


      b.invert();

      b.clipTo(a);

      b.invert();

      a.clipTo(b);

      b.clipTo(a);

      a.build(b.allPolygons());


      return a.allPolygons();

    }


    void inverse() {

      for(MInt i = 0; (unsigned)i < this->polygons.size(); i++) {

        this->polygons[i].flip();

      }

    }

  };


  // Data members used to replace local static variables

  MBool m_static_initSolutionStep_firstRun = true;

  MBool m_static_initSolutionStep_frstrn = true;

  MInt m_static_createCutFaceMb_MGC_bodyFaceJoinMode = 1;

  MFloat m_static_createCutFaceMb_MGC_maxA = 0.1;

  MBool m_static_createCutFaceMb_MGC_first = true;


 private:

  struct CellDataDlb;

  static const std::array<MInt, CellDataDlb::count> s_cellDataTypeDlb;

};


// Struct to differentiate cell (element) data

template <MInt nDim_, class SysEqn>

struct FvMbCartesianSolverXD<nDim_, SysEqn>::CellDataDlb {

  static constexpr const MInt count = 8;


  static constexpr const MInt ELEM_AVARIABLE = 0;

  static constexpr const MInt ELEM_CELLVOLUMES = 1;

  static constexpr const MInt ELEM_RIGHTHANDSIDE = 2;

  static constexpr const MInt ELEM_CELLVOLUMESDT1 = 3;

  static constexpr const MInt ELEM_SWEPTVOLUMES = 4;

  static constexpr const MInt ELEM_PROPERTIES = 5;

  static constexpr const MInt ELEM_AZIMUTHAL_LONG = 6;

  static constexpr const MInt ELEM_AZIMUTHAL_FLOAT = 7;

  static constexpr const MInt ELEM_LESAVERAGE = 8;

};


// Data types of cell data

template <MInt nDim, class SysEqn>

const std::array<MInt, FvMbCartesianSolverXD<nDim, SysEqn>::CellDataDlb::count>

    FvMbCartesianSolverXD<nDim, SysEqn>::s_cellDataTypeDlb = {

        {MFLOAT, MFLOAT, MFLOAT, MFLOAT, MFLOAT, MLONG, MLONG, MFLOAT}};


template <MInt nDim_, class SysEqn>

MInt FvMbCartesianSolverXD<nDim_, SysEqn>::cellDataSizeDlb(const MInt dataId, const MInt gridCellId) {

  // Inactive ranks do not have any data to communicate

  if(!isActive()) {

    return 0;

  }


  // Convert to solver cell id and check

  const MInt cellId = grid().tree().grid2solver(gridCellId);

  if(cellId < 0 || cellId >= noInternalCells()) {

    return 0;

  }


  MInt dataSize = 1;


  switch(dataId) {

    case CellDataDlb::ELEM_AVARIABLE: {

      dataSize = m_noCVars;

      break;

    }

    case CellDataDlb::ELEM_CELLVOLUMES: {

      dataSize = 1;

      break;

    }

    case CellDataDlb::ELEM_RIGHTHANDSIDE: {

      dataSize = m_noFVars;

      break;

    }

    case CellDataDlb::ELEM_CELLVOLUMESDT1: {

      dataSize = 1;

      break;

    }

    case CellDataDlb::ELEM_SWEPTVOLUMES: {

      dataSize = 1;

      break;

    }

    case CellDataDlb::ELEM_PROPERTIES: {

      dataSize = 1;

      break;

    }

    case CellDataDlb::ELEM_AZIMUTHAL_LONG: {

      if(grid().azimuthalPeriodicity()) {

        dataSize = m_azimuthalNearBoundaryBackupMaxCount * m_noLongDataBalance;

      } else {

        dataSize = 0;

      }

      break;

    }

    case CellDataDlb::ELEM_AZIMUTHAL_FLOAT: {

      if(grid().azimuthalPeriodicity()) {

        dataSize = m_azimuthalNearBoundaryBackupMaxCount * (nDim_ + m_noFloatDataBalance);

      } else {

        dataSize = 0;

      }

      break;

    }

    default: {

      TERMM(1, "Unknown data id.");

      break;

    }

  }


  return dataSize;

}


template <MInt nDim_, class SysEqn_>

void FvMbCartesianSolverXD<nDim_, SysEqn_>::getCellDataDlb(const MInt dataId, const MInt oldNoCells,

                                                           const MInt* const bufferIdToCellId, MFloat* const data) {

  TRACE();


  MInt localBufferId = 0;

  for(MInt i = 0; i < oldNoCells; i++) {

    const MInt gridCellId = bufferIdToCellId[i];


    if(gridCellId < 0) continue;


    const MInt cellId = grid().tree().grid2solver(gridCellId);

    if(cellId < 0 || cellId >= noInternalCells()) {

      continue;

    }


    switch(dataId) {

      case CellDataDlb::ELEM_AVARIABLE: {

        std::copy_n(&a_variable(cellId, 0), m_noCVars, &data[localBufferId * m_noCVars]);

        break;

      }

      case CellDataDlb::ELEM_CELLVOLUMES: {

        std::copy_n(&a_cellVolume(cellId), 1, &data[localBufferId]);

        break;

      }

      case CellDataDlb::ELEM_RIGHTHANDSIDE: {

        std::copy_n(&a_rightHandSide(cellId, 0), m_noFVars, &data[localBufferId * m_noFVars]);

        break;

      }

      case CellDataDlb::ELEM_CELLVOLUMESDT1: {

        std::copy_n(&m_cellVolumesDt1[cellId], 1, &data[localBufferId]);

        break;

      }

      case CellDataDlb::ELEM_SWEPTVOLUMES: {

        MInt bndryId_ = a_bndryId(cellId);

        if(bndryId_ > -1) {

          data[localBufferId] = m_sweptVolume[bndryId_];

        } else {

          data[localBufferId] = -1;

        }

        break;

      }

      case CellDataDlb::ELEM_AZIMUTHAL_FLOAT: {

        if(grid().azimuthalPeriodicity()) {

          MInt noFloatData = m_azimuthalNearBoundaryBackupMaxCount * (nDim_ + m_noFloatDataBalance);

          std::copy_n(&m_azimuthalNearBoundaryBackupBalFloat[cellId * noFloatData], noFloatData,

                      &data[localBufferId * noFloatData]);

        }

        break;

      }

      default:

        TERMM(1, "Unknown data id.");

        break;

    }

    localBufferId++;

  }

}


template <MInt nDim_, class SysEqn_>

void FvMbCartesianSolverXD<nDim_, SysEqn_>::getCellDataDlb(const MInt dataId, const MInt oldNoCells,

                                                           const MInt* const bufferIdToCellId, MLong* const data) {

  TRACE();


  MInt localBufferId = 0;

  for(MInt i = 0; i < oldNoCells; i++) {

    const MInt gridCellId = bufferIdToCellId[i];


    if(gridCellId < 0) continue;


    const MInt cellId = grid().tree().grid2solver(gridCellId);

    if(cellId < 0 || cellId >= noInternalCells()) {

      continue;

    }


    switch(dataId) {

      case CellDataDlb::ELEM_PROPERTIES: {

        data[localBufferId] = (MLong)a_properties(cellId).to_ulong();

        break;

      }

      case CellDataDlb::ELEM_AZIMUTHAL_LONG: {

        if(grid().azimuthalPeriodicity()) {

          MInt noLongData = m_azimuthalNearBoundaryBackupMaxCount * m_noLongDataBalance;

          std::copy_n(&m_azimuthalNearBoundaryBackupBalLong[cellId * noLongData], noLongData,

                      &data[localBufferId * noLongData]);

        }

        break;

      }

      default:

        TERMM(1, "Unknown data id.");

        break;

    }

    localBufferId++;

  }

}


template <MInt nDim_, class SysEqn_>

void FvMbCartesianSolverXD<nDim_, SysEqn_>::setCellDataDlb(const MInt dataId, const MFloat* const data) {

  TRACE();


  // Nothing to do if solver is not active

  if(!isActive()) {

    return;

  }


  // Set the variables if this is the correct reinitialization stage

  if(m_loadBalancingReinitStage == 0) {

    switch(dataId) {

      case CellDataDlb::ELEM_AVARIABLE: {

        std::copy_n(data, noInternalCells() * m_noCVars, &a_variable(0, 0));

        break;

      }

      case CellDataDlb::ELEM_CELLVOLUMES: {

        std::copy_n(data, noInternalCells(), &a_cellVolume(0));

        break;

      }

      case CellDataDlb::ELEM_RIGHTHANDSIDE: {

        std::copy_n(data, noInternalCells() * m_noFVars, &a_rightHandSide(0, 0));

        break;

      }

      case CellDataDlb::ELEM_CELLVOLUMESDT1: {

        std::copy_n(data, noInternalCells(), &m_cellVolumesDt1[0]);

        break;

      }

      case CellDataDlb::ELEM_SWEPTVOLUMES: {

        std::copy_n(data, noInternalCells(), &m_sweptVolumeBal[0]);

        break;

      }

      case CellDataDlb::ELEM_AZIMUTHAL_FLOAT: {

        if(grid().azimuthalPeriodicity()) {

          MInt noFloatData = m_azimuthalNearBoundaryBackupMaxCount * (nDim_ + m_noFloatDataBalance);

          std::copy_n(data, noInternalCells() * noFloatData, &m_azimuthalNearBoundaryBackupBalFloat[0]);

        }

        break;

      }

      default:

        TERMM(1, "Unknown data id.");

    }

  }

}


template <MInt nDim_, class SysEqn_>

void FvMbCartesianSolverXD<nDim_, SysEqn_>::setCellDataDlb(const MInt dataId, const MLong* const data) {

  TRACE();


  // Nothing to do if solver is not active

  if(!isActive()) {

    return;

  }


  // Set the variables if this is the correct reinitialization stage

  if(m_loadBalancingReinitStage == 0) {

    switch(dataId) {

      case CellDataDlb::ELEM_PROPERTIES: {

        for(MInt i = 0; i < noInternalCells(); i++) {

          a_properties(i) = maia::fv::cell::BitsetType((MUlong)data[i]);

        }

        break;

      }

      case CellDataDlb::ELEM_AZIMUTHAL_LONG: {

        if(grid().azimuthalPeriodicity()) {

          MInt noLongData = m_azimuthalNearBoundaryBackupMaxCount * m_noLongDataBalance;

          std::copy_n(data, noInternalCells() * noLongData, &m_azimuthalNearBoundaryBackupBalLong[0]);

        }

        break;

      }

      default:

        TERMM(1, "Unknown data id.");

    }

  }

}


#endif

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

cartesiangridgenpar.h

cartesiannetcdf.h

CutCandidate
Definition: geometryintersection.h:1069

FvBndryCndXD
Definition: fvcartesianbndrycndxd.h:113

FvCartesianSolverXD
Definition: fvcartesiansolverxd.h:197

FvCartesianSolverXD< nDim, SysEqn >::m_outputFormat
MString m_outputFormat
Definition: fvcartesiansolverxd.h:1691

FvCartesianSolverXD< nDim, SysEqn >::m_PInfinity
MFloat m_PInfinity
Definition: fvcartesiansolverxd.h:2461

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_freqFactor
MFloat m_static_logData_ic45301_freqFactor[s_logData_ic45301_maxNoEmbeddedBodies]
Definition: fvcartesiansolverxd.h:2652

FvCartesianSolverXD< nDim, SysEqn >::m_reconstructSurfaceData
void(FvCartesianSolverXD::* m_reconstructSurfaceData)(MInt)
Definition: fvcartesiansolverxd.h:2938

FvCartesianSolverXD< nDim, SysEqn >::m_splitChilds
std::vector< std::vector< MInt > > m_splitChilds
Definition: fvcartesiansolverxd.h:1458

FvCartesianSolverXD< nDim, SysEqn >::m_variablesName
const MChar ** m_variablesName
Definition: fvcartesiansolverxd.h:1665

FvCartesianSolverXD< nDim, SysEqn >::m_static_updateBodyProperties_c453_firstRun
MBool m_static_updateBodyProperties_c453_firstRun
Definition: fvcartesiansolverxd.h:2618

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalRecConstSet
MBool m_azimuthalRecConstSet
Definition: fvcartesiansolverxd.h:1478

FvCartesianSolverXD< nDim, SysEqn >::m_vtuVelocityGradientOutput
MBool m_vtuVelocityGradientOutput
Definition: fvcartesiansolverxd.h:1683

FvCartesianSolverXD< nDim, SysEqn >::computeConservativeVariables
virtual void computeConservativeVariables()
Dispatches the computation of the conservative variables for different number of species.
Definition: fvcartesiansolverxd.cpp:20232

FvCartesianSolverXD< nDim, SysEqn >::c_level
MInt c_level(const MInt cellId) const
Returns the grid level of the cell cellId.
Definition: fvcartesiansolverxd.h:528

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalMaxLevelWindowCells
std::vector< std::vector< MInt > > m_azimuthalMaxLevelWindowCells
Definition: fvcartesiansolverxd.h:1473

FvCartesianSolverXD< nDim, SysEqn >::m_noMaxLevelWindowCells
MInt * m_noMaxLevelWindowCells
Definition: fvcartesiansolverxd.h:1451

FvCartesianSolverXD< nDim, SysEqn >::LSReconstructCellCenter
virtual void LSReconstructCellCenter()
Dispatch the reconstruction computation to the appropiate loop.
Definition: fvcartesiansolverxd.cpp:18743

FvCartesianSolverXD< nDim, SysEqn >::m_associatedInternalCells
std::vector< MInt > m_associatedInternalCells
Definition: fvcartesiansolverxd.h:2315

FvCartesianSolverXD< nDim, SysEqn >::m_useCentralDifferencingSlopes
MBool m_useCentralDifferencingSlopes
Definition: fvcartesiansolverxd.h:2035

FvCartesianSolverXD< nDim, SysEqn >::resetRHS
virtual void resetRHS()
Definition: fvcartesiansolverxd.cpp:6120

FvCartesianSolverXD< nDim, SysEqn >::c_neighborId
MLong c_neighborId(const MInt cellId, const MInt dir, const MBool assertNeighborState=true) const
Returns the grid neighbor id of the grid cell cellId dir.
Definition: fvcartesiansolverxd.h:570

FvCartesianSolverXD< nDim, SysEqn >::m_mpi_wmRequest
MPI_Request * m_mpi_wmRequest
Definition: fvcartesiansolverxd.h:1895

FvCartesianSolverXD< nDim, SysEqn >::m_noOuterBndryCells
MInt m_noOuterBndryCells
Definition: fvcartesiansolverxd.h:1375

FvCartesianSolverXD< nDim, SysEqn >::a_noSurfaces
MInt a_noSurfaces()
Returns the number of surfaces.
Definition: fvcartesiansolverxd.h:793

FvCartesianSolverXD< nDim, SysEqn >::m_reconstructionCellIds
std::vector< MInt > m_reconstructionCellIds
Definition: fvcartesiansolverxd.h:1468

FvCartesianSolverXD< nDim, SysEqn >::m_wmImgRecvBuffer
MFloat * m_wmImgRecvBuffer
Definition: fvcartesiansolverxd.h:1892

FvCartesianSolverXD< nDim, SysEqn >::m_WInfinity
MFloat m_WInfinity
Definition: fvcartesiansolverxd.h:2460

FvCartesianSolverXD< nDim, SysEqn >::m_noCorners
static constexpr const MInt m_noCorners
Definition: fvcartesiansolverxd.h:202

FvCartesianSolverXD< nDim, SysEqn >::m_timeRef
MFloat m_timeRef
Definition: fvcartesiansolverxd.h:2030

FvCartesianSolverXD< nDim, SysEqn >::m_timerGroup
MInt m_timerGroup
Definition: fvcartesiansolverxd.h:2441

FvCartesianSolverXD< nDim, SysEqn >::initNearBoundaryExchange
virtual void initNearBoundaryExchange(const MInt mode=0, const MInt offset=0)
Setup the near-boundary communicator needed for the flux-redistribution method.
Definition: fvcartesiansolverxd.cpp:12688

FvCartesianSolverXD< nDim, SysEqn >::m_deleteNeighbour
MBool m_deleteNeighbour
Definition: fvcartesiansolverxd.h:1367

FvCartesianSolverXD< nDim, SysEqn >::a_isPeriodic
MBool a_isPeriodic(const MInt cellId) const
Returns IsPeriodic of the cell cellId.
Definition: fvcartesiansolverxd.h:374

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_refMass
MFloat m_static_applyBoundaryCondition_refMass
Definition: fvcartesiansolverxd.h:2631

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_pressurePoints
MFloat m_static_logData_ic45301_pressurePoints[s_logData_ic45301_maxNoPressurePoints *nDim]
Definition: fvcartesiansolverxd.h:2654

FvCartesianSolverXD< nDim, SysEqn >::m_cfl
MFloat m_cfl
Definition: fvcartesiansolverxd.h:1980

FvCartesianSolverXD< nDim, SysEqn >::m_levelSetAdaptationScheme
MInt m_levelSetAdaptationScheme
Definition: fvcartesiansolverxd.h:2263

FvCartesianSolverXD< nDim, SysEqn >::m_sendBuffers
MFloat ** m_sendBuffers
Definition: fvcartesiansolverxd.h:2219

FvCartesianSolverXD< nDim, SysEqn >::m_wmImgSendBuffer
MFloat * m_wmImgSendBuffer
Definition: fvcartesiansolverxd.h:1891

FvCartesianSolverXD< nDim, SysEqn >::m_maxLevelHaloCells
MInt ** m_maxLevelHaloCells
Definition: fvcartesiansolverxd.h:1452

FvCartesianSolverXD< nDim, SysEqn >::m_cellsInsideSpongeLayer
MInt * m_cellsInsideSpongeLayer
Definition: fvcartesiansolverxd.h:1446

FvCartesianSolverXD< nDim, SysEqn >::m_sigmaSponge
MFloat m_sigmaSponge
Definition: fvcartesiansolverxd.h:2006

FvCartesianSolverXD< nDim, SysEqn >::exchangeFloatDataAzimuthal
void exchangeFloatDataAzimuthal(MFloat *data, MInt noVars, const std::vector< MInt > &rotIndices)

FvCartesianSolverXD< nDim, SysEqn >::m_setToBodiesTable
MInt ** m_setToBodiesTable
Definition: fvcartesiansolverxd.h:2247

FvCartesianSolverXD< nDim, SysEqn >::m_adaptationDampingDistance
MFloat m_adaptationDampingDistance
Definition: fvcartesiansolverxd.h:1724

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45299_amplitude
MFloat m_static_logData_ic45299_amplitude[s_logData_ic45299_maxNoEmbeddedBodies]
Definition: fvcartesiansolverxd.h:2642

FvCartesianSolverXD< nDim, SysEqn >::m_wasBalancedZonal
MBool m_wasBalancedZonal
Definition: fvcartesiansolverxd.h:2984

FvCartesianSolverXD< nDim, SysEqn >::determineLESAverageCells
virtual void determineLESAverageCells()
Definition: fvcartesiansolverxd.cpp:38271

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_EVelL2
MFloat m_static_applyBoundaryCondition_EVelL2
Definition: fvcartesiansolverxd.h:2629

FvCartesianSolverXD< nDim, SysEqn >::m_bndryCells
Collector< FvBndryCell< nDim, SysEqn > > * m_bndryCells
Definition: fvcartesiansolverxd.h:2314

FvCartesianSolverXD< nDim, SysEqn >::m_reconstructionNghbrIds
std::vector< MInt > m_reconstructionNghbrIds
Definition: fvcartesiansolverxd.h:1469

FvCartesianSolverXD< nDim, SysEqn >::reduceData
MFloat reduceData(const MInt cellId, MFloat *data, const MInt dataBlockSize=1, const MBool average=true)
determines the value of 'data' in the given cell by recusively volumetric averaging among all its off...
Definition: fvcartesiansolverxd.cpp:11084

FvCartesianSolverXD< nDim, SysEqn >::m_rhoInfinity
MFloat m_rhoInfinity
Definition: fvcartesiansolverxd.h:2474

FvCartesianSolverXD< nDim, SysEqn >::m_bndrySurfacesOffset
MInt m_bndrySurfacesOffset
Definition: fvcartesiansolverxd.h:1694

FvCartesianSolverXD< nDim, SysEqn >::c_childId
MLong c_childId(const MInt cellId, const MInt pos) const
Returns the grid child id of the grid cell cellId at position pos.
Definition: fvcartesiansolverxd.h:564

FvCartesianSolverXD< nDim, SysEqn >::m_vorticityName
const MChar ** m_vorticityName
Definition: fvcartesiansolverxd.h:1666

FvCartesianSolverXD< nDim, SysEqn >::m_SInfinity
MFloat m_SInfinity
Definition: fvcartesiansolverxd.h:2468

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalRemappedWindowCells
std::vector< std::vector< MInt > > m_azimuthalRemappedWindowCells
Definition: fvcartesiansolverxd.h:1475

FvCartesianSolverXD< nDim, SysEqn >::m_zonal
MBool m_zonal
Definition: fvcartesiansolverxd.h:1788

FvCartesianSolverXD< nDim, SysEqn >::a_rightHandSide
MFloat & a_rightHandSide(const MInt cellId, MInt const varId)
Returns the right hand side of the cell cellId for the variable varId.
Definition: fvcartesiansolverxd.h:785

FvCartesianSolverXD< nDim, SysEqn >::m_wmImgRecvIdMap
MInt * m_wmImgRecvIdMap
Definition: fvcartesiansolverxd.h:1890

FvCartesianSolverXD< nDim, SysEqn >::m_static_advanceSolution_firstRun
MBool m_static_advanceSolution_firstRun
Definition: fvcartesiansolverxd.h:2616

FvCartesianSolverXD< nDim, SysEqn >::m_splitMpiCommRecv
MBool m_splitMpiCommRecv
Definition: fvcartesiansolverxd.h:2232

FvCartesianSolverXD< nDim, SysEqn >::m_volumeForcingDir
MInt m_volumeForcingDir
Definition: fvcartesiansolverxd.h:2258

FvCartesianSolverXD< nDim, SysEqn >::m_wmSrfcProbeSendBuffer
MFloat * m_wmSrfcProbeSendBuffer
Definition: fvcartesiansolverxd.h:1893

FvCartesianSolverXD< nDim, SysEqn >::reInitActiveCellIdsMemory
void reInitActiveCellIdsMemory()
Allocate memory to arrays according to the current number of cells.
Definition: fvcartesiansolverxd.cpp:23511

FvCartesianSolverXD< nDim, SysEqn >::m_noEmbeddedBodies
MInt m_noEmbeddedBodies
Definition: fvcartesiansolverxd.h:2260

FvCartesianSolverXD< nDim, SysEqn >::m_receiveBuffersNoBlocking
MFloat ** m_receiveBuffersNoBlocking
Definition: fvcartesiansolverxd.h:2224

FvCartesianSolverXD< nDim, SysEqn >::m_rhoVVInfinity
MFloat m_rhoVVInfinity[3]
Definition: fvcartesiansolverxd.h:2475

FvCartesianSolverXD< nDim, SysEqn >::m_kInfinityFactor
MFloat m_kInfinityFactor
Definition: fvcartesiansolverxd.h:1865

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalNearBndryInit
MBool m_azimuthalNearBndryInit
Definition: fvcartesiansolverxd.h:1479

FvCartesianSolverXD< nDim, SysEqn >::writeListOfActiveFlowCells
virtual void writeListOfActiveFlowCells()
Definition: fvcartesiansolverxd.cpp:7656

FvCartesianSolverXD< nDim, SysEqn >::m_loadBalancingReinitStage
MInt m_loadBalancingReinitStage
Definition: fvcartesiansolverxd.h:2420

FvCartesianSolverXD< nDim, SysEqn >::m_mpi_receiveRequest
MPI_Request * m_mpi_receiveRequest
Definition: fvcartesiansolverxd.h:2228

FvCartesianSolverXD< nDim, SysEqn >::m_totalnoghostcells
MInt m_totalnoghostcells
Definition: fvcartesiansolverxd.h:1365

FvCartesianSolverXD< nDim, SysEqn >::c_cellLengthAtCell
MFloat c_cellLengthAtCell(const MInt cellId) const
Returns the length of the cell for level.
Definition: fvcartesiansolverxd.h:577

FvCartesianSolverXD< nDim, SysEqn >::m_wmSurfaceProbeInterval
MInt m_wmSurfaceProbeInterval
Definition: fvcartesiansolverxd.h:1873

FvCartesianSolverXD< nDim, SysEqn >::c_cellLengthAtLevel
MFloat c_cellLengthAtLevel(const MInt level) const
Returns the length of the cell for level.
Definition: fvcartesiansolverxd.h:582

FvCartesianSolverXD< nDim, SysEqn >::m_omegaInfinity
MFloat m_omegaInfinity
Definition: fvcartesiansolverxd.h:2466

FvCartesianSolverXD< nDim, SysEqn >::copyGridProperties
void copyGridProperties()
Definition: fvcartesiansolverxd.cpp:994

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalRecConsts
std::vector< MFloat > m_azimuthalRecConsts
Definition: fvcartesiansolverxd.h:1483

FvCartesianSolverXD< nDim, SysEqn >::m_static_redistributeMass_firstRun
MBool m_static_redistributeMass_firstRun
Definition: fvcartesiansolverxd.h:2622

FvCartesianSolverXD< nDim, SysEqn >::setConservativeVariables
virtual void setConservativeVariables(MInt cellId)
computes conservative from primitive variables for given cell id
Definition: fvcartesiansolverxd.cpp:12652

FvCartesianSolverXD< nDim, SysEqn >::a_slope
MFloat & a_slope(const MInt cellId, MInt const varId, const MInt dir) override
Returns the slope of the cell cellId for the variable varId in direction dir.
Definition: fvcartesiansolverxd.h:765

FvCartesianSolverXD< nDim, SysEqn >::m_static_advanceSolution_dragCnt
MFloat m_static_advanceSolution_dragCnt
Definition: fvcartesiansolverxd.h:2615

FvCartesianSolverXD< nDim, SysEqn >::m_wmGlobalNoSrfcProbeIds
MInt m_wmGlobalNoSrfcProbeIds
Definition: fvcartesiansolverxd.h:1874

FvCartesianSolverXD< nDim, SysEqn >::m_targetDensityFactor
MFloat m_targetDensityFactor
Definition: fvcartesiansolverxd.h:2027

FvCartesianSolverXD< nDim, SysEqn >::m_wmLES
MBool m_wmLES
Definition: fvcartesiansolverxd.h:1877

FvCartesianSolverXD< nDim, SysEqn >::m_vtuGeometryOutputExtended
MBool m_vtuGeometryOutputExtended
Definition: fvcartesiansolverxd.h:1684

FvCartesianSolverXD< nDim, SysEqn >::initSpongeLayer
void initSpongeLayer()
Definition: fvcartesiansolverxd.cpp:7844

FvCartesianSolverXD< nDim, SysEqn >::setTimeStep
void setTimeStep()
Definition: fvcartesiansolverxd.cpp:21677

FvCartesianSolverXD< nDim, SysEqn >::m_nonBlockingComm
MBool m_nonBlockingComm
Definition: fvcartesiansolverxd.h:2222

FvCartesianSolverXD< nDim, SysEqn >::m_sutherlandConstantThermal
MFloat m_sutherlandConstantThermal
Definition: fvcartesiansolverxd.h:2309

FvCartesianSolverXD< nDim, SysEqn >::a_oldVariable
MFloat & a_oldVariable(const MInt cellId, const MInt varId)
Returns oldVariablesv of the cell cellId variables varId.
Definition: fvcartesiansolverxd.h:759

FvCartesianSolverXD< nDim, SysEqn >::m_mpi_wmRecvReq
MPI_Request * m_mpi_wmRecvReq
Definition: fvcartesiansolverxd.h:1897

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45299_xCutOff
MFloat m_static_logData_ic45299_xCutOff
Definition: fvcartesiansolverxd.h:2646

FvCartesianSolverXD< nDim, SysEqn >::m_weightLeafCell
MFloat m_weightLeafCell
Definition: fvcartesiansolverxd.h:2431

FvCartesianSolverXD< nDim, SysEqn >::m_surfaces
FvSurfaceCollector m_surfaces
Definition: fvcartesiansolverxd.h:1416

FvCartesianSolverXD< nDim, SysEqn >::m_noWMImgPointsSend
MInt * m_noWMImgPointsSend
Definition: fvcartesiansolverxd.h:1888

FvCartesianSolverXD< nDim, SysEqn >::m_wmDistance
MFloat m_wmDistance
Definition: fvcartesiansolverxd.h:1881

FvCartesianSolverXD< nDim, SysEqn >::m_rotIndVarsCV
std::vector< MInt > m_rotIndVarsCV
Definition: fvcartesiansolverxd.h:1493

FvCartesianSolverXD< nDim, SysEqn >::a_copyPropertiesSolver
void a_copyPropertiesSolver(const MInt fromCellId, const MInt toCellId)
Returns property p of the cell cellId.
Definition: fvcartesiansolverxd.h:639

FvCartesianSolverXD< nDim, SysEqn >::initAzimuthalReconstruction
void initAzimuthalReconstruction()

FvCartesianSolverXD< nDim, SysEqn >::m_wmImgCellIds
std::vector< std::vector< MInt > > m_wmImgCellIds
Definition: fvcartesiansolverxd.h:1899

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceVariable
MFloat & a_surfaceVariable(const MInt srfcId, const MInt dir, const MInt varId)
Returns the variable varId of surface srfcId in direction dir.
Definition: fvcartesiansolverxd.h:831

FvCartesianSolverXD< nDim, SysEqn >::m_static_updateSpongeLayer_first
MBool m_static_updateSpongeLayer_first
Definition: fvcartesiansolverxd.h:2636

FvCartesianSolverXD< nDim, SysEqn >::exchangeAll
void exchangeAll()
Definition: fvcartesiansolverxd.cpp:6344

FvCartesianSolverXD< nDim, SysEqn >::m_DInfinity
MFloat m_DInfinity
Definition: fvcartesiansolverxd.h:2467

FvCartesianSolverXD< nDim, SysEqn >::m_LESVarAverageBal
std::vector< MFloat > * m_LESVarAverageBal
Definition: fvcartesiansolverxd.h:1805

FvCartesianSolverXD< nDim, SysEqn >::a_externalSource
MFloat & a_externalSource(MInt cellId, MInt var)
Return external source.
Definition: fvcartesiansolverxd.h:968

FvCartesianSolverXD< nDim, SysEqn >::m_splitChildToSplitCell
std::map< MInt, MInt > m_splitChildToSplitCell
Definition: fvcartesiansolverxd.h:2316

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceOrientation
MInt & a_surfaceOrientation(const MInt srfcId)
Returns the orientation of surface srfcId.
Definition: fvcartesiansolverxd.h:801

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalCutRecCoord
std::vector< MFloat > m_azimuthalCutRecCoord
Definition: fvcartesiansolverxd.h:1486

FvCartesianSolverXD< nDim, SysEqn >::cutOffBoundaryCondition
virtual void cutOffBoundaryCondition()
Definition: fvcartesiansolverxd.cpp:14262

FvCartesianSolverXD< nDim, SysEqn >::a_isBndryCell
MBool a_isBndryCell(const MInt cellId) const override
Returns isBndryCell of the cell cellId.
Definition: fvcartesiansolverxd.h:381

FvCartesianSolverXD< nDim, SysEqn >::m_hasExternalSource
MBool m_hasExternalSource
Definition: fvcartesiansolverxd.h:2051

FvCartesianSolverXD< nDim, SysEqn >::m_cells
maia::fv::collector::FvCellCollector< nDim > m_cells
Collector for FV cells.
Definition: fvcartesiansolverxd.h:1421

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_ERhoL1
MFloat m_static_applyBoundaryCondition_ERhoL1
Definition: fvcartesiansolverxd.h:2625

FvCartesianSolverXD< nDim, SysEqn >::m_gapCellId
std::vector< MInt > m_gapCellId
Definition: fvcartesiansolverxd.h:2286

FvCartesianSolverXD< nDim, SysEqn >::m_RANSValues
std::vector< MFloat > * m_RANSValues
Definition: fvcartesiansolverxd.h:1800

FvCartesianSolverXD< nDim, SysEqn >::findNghbrIds
virtual void findNghbrIds()
Definition: fvcartesiansolverxd.cpp:25536

FvCartesianSolverXD< nDim, SysEqn >::PV
SysEqn::PrimitiveVariables * PV
Definition: fvcartesiansolverxd.h:2078

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_oldVol2
MFloat m_static_applyBoundaryCondition_oldVol2
Definition: fvcartesiansolverxd.h:2633

FvCartesianSolverXD< nDim, SysEqn >::m_DthInfinity
MFloat m_DthInfinity
Definition: fvcartesiansolverxd.h:2463

FvCartesianSolverXD< nDim, SysEqn >::m_time
MFloat m_time
Definition: fvcartesiansolverxd.h:2029

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_containingCellIds
MInt m_static_logData_ic45301_containingCellIds[s_logData_ic45301_maxNoPressurePoints]
Definition: fvcartesiansolverxd.h:2656

FvCartesianSolverXD< nDim, SysEqn >::m_noWMImgPointsRecv
MInt * m_noWMImgPointsRecv
Definition: fvcartesiansolverxd.h:1889

FvCartesianSolverXD< nDim, SysEqn >::a_isHalo
MBool a_isHalo(const MInt cellId) const
Returns IsHalo of the cell cellId.
Definition: fvcartesiansolverxd.h:362

FvCartesianSolverXD< nDim, SysEqn >::m_static_constructGFieldPredictor_adaptiveGravity
MBool m_static_constructGFieldPredictor_adaptiveGravity
Definition: fvcartesiansolverxd.h:2611

FvCartesianSolverXD< nDim, SysEqn >::m_noSets
MInt m_noSets
Definition: fvcartesiansolverxd.h:1632

FvCartesianSolverXD< nDim, SysEqn >::m_vtuWriteGeometryFile
MBool m_vtuWriteGeometryFile
Definition: fvcartesiansolverxd.h:1672

FvCartesianSolverXD< nDim, SysEqn >::m_weightBndryCell
MFloat m_weightBndryCell
Definition: fvcartesiansolverxd.h:2433

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_EVelL1
MFloat m_static_applyBoundaryCondition_EVelL1
Definition: fvcartesiansolverxd.h:2628

FvCartesianSolverXD< nDim, SysEqn >::a_properties
maia::fv::cell::BitsetType & a_properties(const MInt cellId)
Returns properties of the cell cellId.
Definition: fvcartesiansolverxd.h:416

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_firstRun4
MBool m_static_logData_firstRun4
Definition: fvcartesiansolverxd.h:2638

FvCartesianSolverXD< nDim, SysEqn >::m_noPeriodicGhostBodies
MInt m_noPeriodicGhostBodies
Definition: fvcartesiansolverxd.h:2261

FvCartesianSolverXD< nDim, SysEqn >::m_static_logCellxd_firstRun
MBool m_static_logCellxd_firstRun
Definition: fvcartesiansolverxd.h:2706

FvCartesianSolverXD< nDim, SysEqn >::setUpwindCoefficient
void setUpwindCoefficient()
Definition: fvcartesiansolverxd.cpp:7290

FvCartesianSolverXD< nDim, SysEqn >::m_vtuGeometryOutput
std::set< MInt > m_vtuGeometryOutput
Definition: fvcartesiansolverxd.h:1675

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_oldMass
MFloat m_static_applyBoundaryCondition_oldMass
Definition: fvcartesiansolverxd.h:2632

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceArea
MFloat & a_surfaceArea(const MInt srfcId)
Returns the area of surface srfcId.
Definition: fvcartesiansolverxd.h:806

FvCartesianSolverXD< nDim, SysEqn >::m_masterCellIds
MInt * m_masterCellIds
Definition: fvcartesiansolverxd.h:1449

FvCartesianSolverXD< nDim, SysEqn >::m_LESValues
std::vector< MFloat > * m_LESValues
Definition: fvcartesiansolverxd.h:1801

FvCartesianSolverXD< nDim, SysEqn >::m_sutherlandPlusOne
MFloat m_sutherlandPlusOne
Definition: fvcartesiansolverxd.h:2310

FvCartesianSolverXD< nDim, SysEqn >::buildLeastSquaresStencilSimple
void buildLeastSquaresStencilSimple()
Determine the least squares stencil.
Definition: fvcartesiansolverxd.cpp:14033

FvCartesianSolverXD< nDim, SysEqn >::m_noLESVariables
MInt m_noLESVariables
Definition: fvcartesiansolverxd.h:1799

FvCartesianSolverXD< nDim, SysEqn >::m_chi
MFloat m_chi
Definition: fvcartesiansolverxd.h:1974

FvCartesianSolverXD< nDim, SysEqn >::computeCellSurfaceDistanceVectors
void computeCellSurfaceDistanceVectors()
Definition: fvcartesiansolverxd.cpp:14301

FvCartesianSolverXD< nDim, SysEqn >::a_cutCellLevel
MInt a_cutCellLevel(const MInt cellId) const
Returns the level for cutCells, this can either be the maxRefinementLevel or the level of the current...
Definition: fvcartesiansolverxd.h:450

FvCartesianSolverXD< nDim, SysEqn >::FV
SysEqn::FluxVariables * FV
Definition: fvcartesiansolverxd.h:2080

FvCartesianSolverXD< nDim, SysEqn >::m_multipleFvSolver
MBool m_multipleFvSolver
Definition: fvcartesiansolverxd.h:1664

FvCartesianSolverXD< nDim, SysEqn >::m_VInfinity
MFloat m_VInfinity
Definition: fvcartesiansolverxd.h:2459

FvCartesianSolverXD< nDim, SysEqn >::m_saveVorticityToRestart
MBool m_saveVorticityToRestart
Definition: fvcartesiansolverxd.h:1667

FvCartesianSolverXD< nDim, SysEqn >::m_static_getDistanceSplitSphere_first
MBool m_static_getDistanceSplitSphere_first
Definition: fvcartesiansolverxd.h:2608

FvCartesianSolverXD< nDim, SysEqn >::m_writeOutData
MInt m_writeOutData
Definition: fvcartesiansolverxd.h:1656

FvCartesianSolverXD< nDim, SysEqn >::a_variable
MFloat & a_variable(const MInt cellId, const MInt varId)
Returns conservative variable v of the cell cellId for variables varId.
Definition: fvcartesiansolverxd.h:610

FvCartesianSolverXD< nDim, SysEqn >::setRestartFileOutputTimeStep
void setRestartFileOutputTimeStep()
Definition: fvcartesiansolverxd.cpp:9760

FvCartesianSolverXD< nDim, SysEqn >::isMultilevelLowestSecondary
constexpr MBool isMultilevelLowestSecondary() const
Definition: fvcartesiansolverxd.h:2100

FvCartesianSolverXD< nDim, SysEqn >::a_resetPropertiesSolver
void a_resetPropertiesSolver(const MInt cellId)
Returns property p of the cell cellId.
Definition: fvcartesiansolverxd.h:636

FvCartesianSolverXD< nDim, SysEqn >::m_gapCells
std::vector< FvGapCell > m_gapCells
Definition: fvcartesiansolverxd.h:2287

FvCartesianSolverXD< nDim, SysEqn >::assertValidGridCellId
void assertValidGridCellId(const MInt cellId) const
Cecks wether the cell cellId is an actual grid-cell.
Definition: fvcartesiansolverxd.h:472

FvCartesianSolverXD< nDim, SysEqn >::noInternalCells
MInt noInternalCells() const override
Definition: fvcartesiansolverxd.h:349

FvCartesianSolverXD< nDim, SysEqn >::c_parentId
MLong c_parentId(const MInt cellId) const
Returns the grid parent id of the cell cellId.
Definition: fvcartesiansolverxd.h:546

FvCartesianSolverXD< nDim, SysEqn >::m_gamma
MFloat m_gamma
Definition: fvcartesiansolverxd.h:1985

FvCartesianSolverXD< nDim, SysEqn >::m_noTimeStepsBetweenSamples
MInt m_noTimeStepsBetweenSamples
Definition: fvcartesiansolverxd.h:1719

FvCartesianSolverXD< nDim, SysEqn >::m_gridPoints
Collector< CartesianGridPoint< nDim > > * m_gridPoints
Definition: fvcartesiansolverxd.h:1395

FvCartesianSolverXD< nDim, SysEqn >::m_wmImgWMSrfcIds
std::vector< std::vector< MInt > > m_wmImgWMSrfcIds
Definition: fvcartesiansolverxd.h:1900

FvCartesianSolverXD< nDim, SysEqn >::m_omegaInfinityFactor
MFloat m_omegaInfinityFactor
Definition: fvcartesiansolverxd.h:1866

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45299_freqFactor
MFloat m_static_logData_ic45299_freqFactor[s_logData_ic45299_maxNoEmbeddedBodies]
Definition: fvcartesiansolverxd.h:2643

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalMaxLevelHaloCells
std::vector< std::vector< MInt > > m_azimuthalMaxLevelHaloCells
Definition: fvcartesiansolverxd.h:1472

FvCartesianSolverXD< nDim, SysEqn >::m_noLevelSetsUsedForMb
MInt m_noLevelSetsUsedForMb
Definition: fvcartesiansolverxd.h:1628

FvCartesianSolverXD< nDim, SysEqn >::a_levelSetValuesMb
MFloat & a_levelSetValuesMb(const MInt cellId, const MInt set)
Returns the levelSetMb-value for fv-CellId cellId and set.
Definition: fvcartesiansolverxd.h:1005

FvCartesianSolverXD< nDim, SysEqn >::m_LESAverageCells
std::vector< MInt > m_LESAverageCells
Definition: fvcartesiansolverxd.h:1806

FvCartesianSolverXD< nDim, SysEqn >::CV
SysEqn::ConservativeVariables * CV
Definition: fvcartesiansolverxd.h:2079

FvCartesianSolverXD< nDim, SysEqn >::m_hInfinity
MFloat m_hInfinity
Definition: fvcartesiansolverxd.h:1508

FvCartesianSolverXD< nDim, SysEqn >::m_TInfinity
MFloat m_TInfinity
Definition: fvcartesiansolverxd.h:2462

FvCartesianSolverXD< nDim, SysEqn >::m_computeViscousFlux
void(FvCartesianSolverXD::* m_computeViscousFlux)()
Definition: fvcartesiansolverxd.h:2939

FvCartesianSolverXD< nDim, SysEqn >::m_rhoVInfinity
MFloat m_rhoVInfinity
Definition: fvcartesiansolverxd.h:2471

FvCartesianSolverXD< nDim, SysEqn >::m_movingAvgInterval
MInt m_movingAvgInterval
Definition: fvcartesiansolverxd.h:2069

FvCartesianSolverXD< nDim, SysEqn >::m_noRANSVariables
MInt m_noRANSVariables
Definition: fvcartesiansolverxd.h:1798

FvCartesianSolverXD< nDim, SysEqn >::m_rhoUInfinity
MFloat m_rhoUInfinity
Definition: fvcartesiansolverxd.h:2470

FvCartesianSolverXD< nDim, SysEqn >::viscousFlux
virtual void viscousFlux()
Definition: fvcartesiansolverxd.cpp:19334

FvCartesianSolverXD< nDim, SysEqn >::m_bodyIdOutput
MBool m_bodyIdOutput
Definition: fvcartesiansolverxd.h:1660

FvCartesianSolverXD< nDim, SysEqn >::m_currentGridFileName
MString m_currentGridFileName
Definition: fvcartesiansolverxd.h:1636

FvCartesianSolverXD< nDim, SysEqn >::m_maxNearestBodies
MInt m_maxNearestBodies
Definition: fvcartesiansolverxd.h:2693

FvCartesianSolverXD< nDim, SysEqn >::m_static_advanceSolution_meanDrag
MFloat m_static_advanceSolution_meanDrag
Definition: fvcartesiansolverxd.h:2614

FvCartesianSolverXD< nDim, SysEqn >::m_constructGField
MBool m_constructGField
Definition: fvcartesiansolverxd.h:1366

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceCoordinate
MFloat & a_surfaceCoordinate(const MInt srfcId, const MInt dir)
Returns the coordinate of surface srfcId in direction dir.
Definition: fvcartesiansolverxd.h:816

FvCartesianSolverXD< nDim, SysEqn >::computeDomainAndSpongeDimensions
void computeDomainAndSpongeDimensions()
Extracts the minimum and maximum coordinates of all cells in the grid.
Definition: fvcartesiansolverxd.cpp:16194

FvCartesianSolverXD< nDim, SysEqn >::m_associatedBodyIds
MInt * m_associatedBodyIds
Definition: fvcartesiansolverxd.h:1627

FvCartesianSolverXD< nDim, SysEqn >::m_storeNghbrIds
MInt * m_storeNghbrIds
Definition: fvcartesiansolverxd.h:1784

FvCartesianSolverXD< nDim, SysEqn >::m_eps
MFloat m_eps
Definition: fvcartesiansolverxd.h:206

FvCartesianSolverXD< nDim, SysEqn >::a_isGapCell
MBool a_isGapCell(const MInt cellId) const
Returns isGapCell of the cell cellId.
Definition: fvcartesiansolverxd.h:352

FvCartesianSolverXD< nDim, SysEqn >::saveGridFlowVarsPar
void saveGridFlowVarsPar(const MChar *fileName, MInt noTotalCells, MLong noInternalCells, MFloatScratchSpace &variables, std::vector< MString > &dbVariablesName, MInt, MIntScratchSpace &idVariables, std::vector< MString > &idVariablesName, MInt, MFloatScratchSpace &dbParameters, std::vector< MString > &dbParametersName, MIntScratchSpace &idParameters, std::vector< MString > &idParametersName, const MInt *recalcIds)
This function stores the massivley parallel flow information of the cells.
Definition: fvcartesiansolverxd.cpp:8403

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45299_cutOffAngle
MFloat m_static_logData_ic45299_cutOffAngle
Definition: fvcartesiansolverxd.h:2645

FvCartesianSolverXD< nDim, SysEqn >::Ausm
virtual void Ausm()
Dispatches the AUSM flux computation for different number of species.
Definition: fvcartesiansolverxd.cpp:19244

FvCartesianSolverXD< nDim, SysEqn >::a_associatedBodyIds
MInt & a_associatedBodyIds(const MInt cellId, const MInt set)
Returns the associatedBodyIds for fv-CellId cellId and set.
Definition: fvcartesiansolverxd.h:1045

FvCartesianSolverXD< nDim, SysEqn >::m_forcing
MBool m_forcing
Definition: fvcartesiansolverxd.h:2356

FvCartesianSolverXD< nDim, SysEqn >::m_noActiveHaloCellOffset
MInt m_noActiveHaloCellOffset
Definition: fvcartesiansolverxd.h:1445

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceUpwindCoefficient
MFloat & a_surfaceUpwindCoefficient(const MInt srfcId)
Returns the upwind coefficient of surface srfcId.
Definition: fvcartesiansolverxd.h:840

FvCartesianSolverXD< nDim, SysEqn >::checkCells
void checkCells()
Definition: fvcartesiansolverxd.cpp:32367

FvCartesianSolverXD< nDim, SysEqn >::a_noCells
MInt a_noCells() const
Returns the number of cells.
Definition: fvcartesiansolverxd.h:336

FvCartesianSolverXD< nDim, SysEqn >::m_vorticitySize
MInt m_vorticitySize
Definition: fvcartesiansolverxd.h:1669

FvCartesianSolverXD< nDim, SysEqn >::m_multilevel
MBool m_multilevel
Stores whether this solver is part of a multilevel computation.
Definition: fvcartesiansolverxd.h:2056

FvCartesianSolverXD< nDim, SysEqn >::m_wmSurfaces
std::vector< FvWMSurface< nDim > > m_wmSurfaces
Definition: fvcartesiansolverxd.h:1871

FvCartesianSolverXD< nDim, SysEqn >::createBoundaryCells
void createBoundaryCells()
identifies bndry cells (Sets a_isInterface for the solver!)
Definition: fvcartesiansolverxd.cpp:22423

FvCartesianSolverXD< nDim, SysEqn >::m_wmDomainId
MInt m_wmDomainId
Definition: fvcartesiansolverxd.h:1875

FvCartesianSolverXD< nDim, SysEqn >::m_wmSrfcProbeRecvBuffer
MFloat * m_wmSrfcProbeRecvBuffer
Definition: fvcartesiansolverxd.h:1894

FvCartesianSolverXD< nDim, SysEqn >::m_externalSourceDt1
MFloat ** m_externalSourceDt1
Definition: fvcartesiansolverxd.h:2049

FvCartesianSolverXD< nDim, SysEqn >::m_RKalpha
MFloat * m_RKalpha
Definition: fvcartesiansolverxd.h:1726

FvCartesianSolverXD< nDim, SysEqn >::m_wmSurfaceProbeIds
std::vector< MInt > m_wmSurfaceProbeIds
Definition: fvcartesiansolverxd.h:1903

FvCartesianSolverXD< nDim, SysEqn >::writeCenterLineVel
void writeCenterLineVel()
Definition: fvcartesiansolverxd.cpp:26264

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceFlux
MFloat & a_surfaceFlux(const MInt srfcId, const MInt fVarId)
Returns the flux fVarId for surface srfcId.
Definition: fvcartesiansolverxd.h:854

FvCartesianSolverXD< nDim, SysEqn >::m_zonalAveragingTimeStep
MInt m_zonalAveragingTimeStep
Definition: fvcartesiansolverxd.h:1795

FvCartesianSolverXD< nDim, SysEqn >::m_dualTimeStepping
MBool m_dualTimeStepping
Definition: fvcartesiansolverxd.h:1702

FvCartesianSolverXD< nDim, SysEqn >::m_bodyAngularVelocity
MFloat * m_bodyAngularVelocity
Definition: fvcartesiansolverxd.h:2253

FvCartesianSolverXD< nDim, SysEqn >::m_bndryCellSurfacesOffset
MInt m_bndryCellSurfacesOffset
Definition: fvcartesiansolverxd.h:1693

FvCartesianSolverXD< nDim, SysEqn >::m_vtuLevelThreshold
MInt m_vtuLevelThreshold
Definition: fvcartesiansolverxd.h:1686

FvCartesianSolverXD< nDim, SysEqn >::m_adaptationSinceLastRestartBackup
MBool m_adaptationSinceLastRestartBackup
Definition: fvcartesiansolverxd.h:1638

FvCartesianSolverXD< nDim, SysEqn >::m_localTS
MBool m_localTS
Definition: fvcartesiansolverxd.h:1198

FvCartesianSolverXD< nDim, SysEqn >::m_weightActiveCell
MFloat m_weightActiveCell
Definition: fvcartesiansolverxd.h:2432

FvCartesianSolverXD< nDim, SysEqn >::a_isBndryGhostCell
MBool a_isBndryGhostCell(const MInt cellId) const
Returns isBndryGhostCell of the cell cellId.
Definition: fvcartesiansolverxd.h:392

FvCartesianSolverXD< nDim, SysEqn >::m_weightMulitSolverFactor
MFloat m_weightMulitSolverFactor
Definition: fvcartesiansolverxd.h:2435

FvCartesianSolverXD< nDim, SysEqn >::m_mpi_sendRequest
MPI_Request * m_mpi_sendRequest
Definition: fvcartesiansolverxd.h:2227

FvCartesianSolverXD< nDim, SysEqn >::initAzimuthalMaxLevelExchange
void initAzimuthalMaxLevelExchange()

FvCartesianSolverXD< nDim, SysEqn >::m_maxLevelWindowCells
MInt ** m_maxLevelWindowCells
Definition: fvcartesiansolverxd.h:1450

FvCartesianSolverXD< nDim, SysEqn >::m_maxNoAzimuthalRecConst
const MInt m_maxNoAzimuthalRecConst
Definition: fvcartesiansolverxd.h:1480

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceDeltaX
MFloat & a_surfaceDeltaX(const MInt srfcId, const MInt varId)
Returns the delta X of surface srfcId for variable varId.
Definition: fvcartesiansolverxd.h:821

FvCartesianSolverXD< nDim, SysEqn >::m_RKStep
MInt m_RKStep
Definition: fvcartesiansolverxd.h:1717

FvCartesianSolverXD< nDim, SysEqn >::getAdjacentLeafCells
MInt getAdjacentLeafCells(const MInt, const MInt, MIntScratchSpace &, MIntScratchSpace &)
retrieves the first 'noLayers' layers of direct and(or diagonal neighbors to the given cell
Definition: fvcartesiansolverxd.cpp:13761

FvCartesianSolverXD< nDim, SysEqn >::m_angle
MFloat * m_angle
Definition: fvcartesiansolverxd.h:1725

FvCartesianSolverXD< nDim, SysEqn >::a_dt1Variable
MFloat & a_dt1Variable(const MInt cellId, const MInt varId)
Returns dt1Variables of the cell CellId variables varId.
Definition: fvcartesiansolverxd.h:747

FvCartesianSolverXD< nDim, SysEqn >::m_weightBaseCell
MFloat m_weightBaseCell
Definition: fvcartesiansolverxd.h:2430

FvCartesianSolverXD< nDim, SysEqn >::m_initialCondition
MInt m_initialCondition
Definition: fvcartesiansolverxd.h:1705

FvCartesianSolverXD< nDim, SysEqn >::m_static_writeVtkXmlFiles_firstCall
MBool m_static_writeVtkXmlFiles_firstCall
Definition: fvcartesiansolverxd.h:2703

FvCartesianSolverXD< nDim, SysEqn >::m_reconstructionDataSize
MUint m_reconstructionDataSize
Definition: fvcartesiansolverxd.h:1466

FvCartesianSolverXD< nDim, SysEqn >::m_bodyHeatFlux
MFloat * m_bodyHeatFlux
Definition: fvcartesiansolverxd.h:2257

FvCartesianSolverXD< nDim, SysEqn >::m_bodyCenter
MFloat * m_bodyCenter
Definition: fvcartesiansolverxd.h:2248

FvCartesianSolverXD< nDim, SysEqn >::m_levelSetValuesMb
MFloat * m_levelSetValuesMb
Definition: fvcartesiansolverxd.h:1626

FvCartesianSolverXD< nDim, SysEqn >::nDim
static constexpr MInt nDim
Definition: fvcartesiansolverxd.h:199

FvCartesianSolverXD< nDim, SysEqn >::calcSlopesAfterStep
MBool calcSlopesAfterStep()
Return if slopes should be calculated at after each step (not before)
Definition: fvcartesiansolverxd.h:2161

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_first
MBool m_static_logData_ic45301_first
Definition: fvcartesiansolverxd.h:2648

FvCartesianSolverXD< nDim, SysEqn >::a_hasProperty
MBool a_hasProperty(const MInt cellId, const Cell p) const
Returns grid cell property p of the cell cellId.
Definition: fvcartesiansolverxd.h:588

FvCartesianSolverXD< nDim, SysEqn >::m_splitSurfaces
std::set< MInt > m_splitSurfaces
Definition: fvcartesiansolverxd.h:1456

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceFactor
MFloat & a_surfaceFactor(const MInt srfcId, const MInt varId)
Returns the factor of surface srfcId for variable varId.
Definition: fvcartesiansolverxd.h:811

FvCartesianSolverXD< nDim, SysEqn >::m_static_updateBodyProperties_firstTime
MBool m_static_updateBodyProperties_firstTime
Definition: fvcartesiansolverxd.h:2620

FvCartesianSolverXD< nDim, SysEqn >::m_bndryLevelJumps
MBool m_bndryLevelJumps
Definition: fvcartesiansolverxd.h:1373

FvCartesianSolverXD< nDim, SysEqn >::m_levelSetOutput
MBool m_levelSetOutput
Definition: fvcartesiansolverxd.h:1661

FvCartesianSolverXD< nDim, SysEqn >::a_dt2Variable
MFloat & a_dt2Variable(const MInt cellId, const MInt varId)
Returns dt2Variables of the cell CellId variables varId.
Definition: fvcartesiansolverxd.h:753

FvCartesianSolverXD< nDim, SysEqn >::m_volumeThreshold
static constexpr MFloat m_volumeThreshold
Definition: fvcartesiansolverxd.h:203

FvCartesianSolverXD< nDim, SysEqn >::m_wasAdapted
MBool m_wasAdapted
Definition: fvcartesiansolverxd.h:2982

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_noPressurePoints
MInt m_static_logData_ic45301_noPressurePoints
Definition: fvcartesiansolverxd.h:2655

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalMaxLevelWindowMap
std::vector< std::vector< MInt > > m_azimuthalMaxLevelWindowMap
Definition: fvcartesiansolverxd.h:1487

FvCartesianSolverXD< nDim, SysEqn >::m_recordBodyData
MBool m_recordBodyData
Definition: fvcartesiansolverxd.h:1647

FvCartesianSolverXD< nDim, SysEqn >::sysEqn
SysEqn sysEqn() const
Definition: fvcartesiansolverxd.h:331

FvCartesianSolverXD< nDim, SysEqn >::m_sweptVolume
MFloat * m_sweptVolume
Definition: fvcartesiansolverxd.h:1381

FvCartesianSolverXD< nDim, SysEqn >::m_activeCellIds
MInt * m_activeCellIds
Definition: fvcartesiansolverxd.h:1443

FvCartesianSolverXD< nDim, SysEqn >::m_sweptVolumeBal
MFloat * m_sweptVolumeBal
Definition: fvcartesiansolverxd.h:1382

FvCartesianSolverXD< nDim, SysEqn >::c_isToDelete
MBool c_isToDelete(const MInt cellId) const
Returns the delete of the cell cellId.
Definition: fvcartesiansolverxd.h:595

FvCartesianSolverXD< nDim, SysEqn >::a_localTimeStep
MFloat & a_localTimeStep(const MInt cellId)
Returns the local time-step of the cell cellId.
Definition: fvcartesiansolverxd.h:986

FvCartesianSolverXD< nDim, SysEqn >::m_UInfinity
MFloat m_UInfinity
Definition: fvcartesiansolverxd.h:2458

FvCartesianSolverXD< nDim, SysEqn >::m_pipeRadius
MFloat m_pipeRadius
Definition: fvcartesiansolverxd.h:2259

FvCartesianSolverXD< nDim, SysEqn >::azimuthalNearBoundaryExchange
void azimuthalNearBoundaryExchange()

FvCartesianSolverXD< nDim, SysEqn >::m_euler
MBool m_euler
Definition: fvcartesiansolverxd.h:1703

FvCartesianSolverXD< nDim, SysEqn >::m_vtuLevelSetOutput
MBool m_vtuLevelSetOutput
Definition: fvcartesiansolverxd.h:1679

FvCartesianSolverXD< nDim, SysEqn >::m_globalUpwindCoefficient
MFloat m_globalUpwindCoefficient
Definition: fvcartesiansolverxd.h:1986

FvCartesianSolverXD< nDim, SysEqn >::m_noGapRegions
MInt m_noGapRegions
Definition: fvcartesiansolverxd.h:2285

FvCartesianSolverXD< nDim, SysEqn >::m_noDirs
static constexpr const MInt m_noDirs
Definition: fvcartesiansolverxd.h:200

FvCartesianSolverXD< nDim, SysEqn >::computePV
virtual void computePV()
Definition: fvcartesiansolverxd.cpp:6141

FvCartesianSolverXD< nDim, SysEqn >::m_bodyAngularAcceleration
MFloat * m_bodyAngularAcceleration
Definition: fvcartesiansolverxd.h:2254

FvCartesianSolverXD< nDim, SysEqn >::m_mpi_wmSendReq
MPI_Request * m_mpi_wmSendReq
Definition: fvcartesiansolverxd.h:1896

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_EVelLoo
MFloat m_static_applyBoundaryCondition_EVelLoo
Definition: fvcartesiansolverxd.h:2630

FvCartesianSolverXD< nDim, SysEqn >::m_physicalTimeStep
MFloat m_physicalTimeStep
Definition: fvcartesiansolverxd.h:1994

FvCartesianSolverXD< nDim, SysEqn >::m_wmUseInterpolation
MBool m_wmUseInterpolation
Definition: fvcartesiansolverxd.h:1880

FvCartesianSolverXD< nDim, SysEqn >::m_bodyTemperature
MFloat * m_bodyTemperature
Definition: fvcartesiansolverxd.h:2255

FvCartesianSolverXD< nDim, SysEqn >::exchangeGapInfo
void exchangeGapInfo()
exchanges the Gap-Information with the solver-own communicators!
Definition: fvcartesiansolverxd.cpp:25010

FvCartesianSolverXD< nDim, SysEqn >::m_physicalTime
MFloat m_physicalTime
Definition: fvcartesiansolverxd.h:1993

FvCartesianSolverXD< nDim, SysEqn >::m_sutherlandConstant
MFloat m_sutherlandConstant
Definition: fvcartesiansolverxd.h:2308

FvCartesianSolverXD< nDim, SysEqn >::determineStructuredCells
void determineStructuredCells()
Definition: fvcartesiansolverxd.cpp:7993

FvCartesianSolverXD< nDim, SysEqn >::m_bndryGhostCellsOffset
MInt m_bndryGhostCellsOffset
Definition: fvcartesiansolverxd.h:1704

FvCartesianSolverXD< nDim, SysEqn >::m_noSpecies
MInt m_noSpecies
Definition: fvcartesiansolverxd.h:207

FvCartesianSolverXD< nDim, SysEqn >::m_wmIterator
MInt m_wmIterator
Definition: fvcartesiansolverxd.h:1883

FvCartesianSolverXD< nDim, SysEqn >::m_static_writeVtkXmlFiles_firstCall2
MBool m_static_writeVtkXmlFiles_firstCall2
Definition: fvcartesiansolverxd.h:2704

FvCartesianSolverXD< nDim, SysEqn >::m_smallCellIds
MInt * m_smallCellIds
Definition: fvcartesiansolverxd.h:1448

FvCartesianSolverXD< nDim, SysEqn >::m_referenceLength
MFloat m_referenceLength
Definition: fvcartesiansolverxd.h:1998

FvCartesianSolverXD< nDim, SysEqn >::c_noChildren
MInt c_noChildren(const MInt cellId) const
Returns the number of children of the cell cellId.
Definition: fvcartesiansolverxd.h:540

FvCartesianSolverXD< nDim, SysEqn >::m_resetInitialCondition
MBool m_resetInitialCondition
Definition: fvcartesiansolverxd.h:1790

FvCartesianSolverXD< nDim, SysEqn >::m_LESNoVarAverage
MInt m_LESNoVarAverage
Definition: fvcartesiansolverxd.h:1807

FvCartesianSolverXD< nDim, SysEqn >::initCutOffBoundaryCondition
void initCutOffBoundaryCondition()
Definition: fvcartesiansolverxd.cpp:14270

FvCartesianSolverXD< nDim, SysEqn >::m_bodyAcceleration
MFloat * m_bodyAcceleration
Definition: fvcartesiansolverxd.h:2252

FvCartesianSolverXD< nDim, SysEqn >::m_static_updateSpongeLayer_mbSpongeLayer
MBool m_static_updateSpongeLayer_mbSpongeLayer
Definition: fvcartesiansolverxd.h:2635

FvCartesianSolverXD< nDim, SysEqn >::initAzimuthalCartesianHaloInterpolation
void initAzimuthalCartesianHaloInterpolation()

FvCartesianSolverXD< nDim, SysEqn >::c_coordinate
MFloat c_coordinate(const MInt cellId, const MInt dir) const
Returns the coordinate of the cell from the grid().tree() cellId for dimension dir.
Definition: fvcartesiansolverxd.h:520

FvCartesianSolverXD< nDim, SysEqn >::m_internalBodyId
MInt * m_internalBodyId
Definition: fvcartesiansolverxd.h:2262

FvCartesianSolverXD< nDim, SysEqn >::m_engineSetup
MBool m_engineSetup
Definition: fvcartesiansolverxd.h:1384

FvCartesianSolverXD< nDim, SysEqn >::m_geometry
Geometry< nDim > * m_geometry
Definition: fvcartesiansolverxd.h:205

FvCartesianSolverXD< nDim, SysEqn >::forceTimeStep
void forceTimeStep(const MFloat dt)
Force time step externally.
Definition: fvcartesiansolverxd.h:2547

FvCartesianSolverXD< nDim, SysEqn >::a_reconstructionData
MInt & a_reconstructionData(const MInt cellId)
Returns reconstruction data offset i of the cell cellId.
Definition: fvcartesiansolverxd.h:654

FvCartesianSolverXD< nDim, SysEqn >::m_rotIndVarsPV
std::vector< MInt > m_rotIndVarsPV
Definition: fvcartesiansolverxd.h:1492

FvCartesianSolverXD< nDim, SysEqn >::m_LsRotate
MBool m_LsRotate
Definition: fvcartesiansolverxd.h:1617

FvCartesianSolverXD< nDim, SysEqn >::m_totalnosplitchilds
MInt m_totalnosplitchilds
Definition: fvcartesiansolverxd.h:1364

FvCartesianSolverXD< nDim, SysEqn >::a_coordinate
MFloat & a_coordinate(const MInt cellId, const MInt dir)
Returns the coordinate of the cell from the fvcellcollector cellId for dimension dir.
Definition: fvcartesiansolverxd.h:425

FvCartesianSolverXD< nDim, SysEqn >::m_noAzimuthalReconstNghbrs
std::vector< MInt > m_noAzimuthalReconstNghbrs
Definition: fvcartesiansolverxd.h:1482

FvCartesianSolverXD< nDim, SysEqn >::initViscousFluxComputation
void initViscousFluxComputation()
Definition: fvcartesiansolverxd.cpp:22455

FvCartesianSolverXD< nDim, SysEqn >::m_wmOutput
MBool m_wmOutput
Definition: fvcartesiansolverxd.h:1878

FvCartesianSolverXD< nDim, SysEqn >::m_vtuGlobalIdOutput
MBool m_vtuGlobalIdOutput
Definition: fvcartesiansolverxd.h:1676

FvCartesianSolverXD< nDim, SysEqn >::m_wmSurfaceProbeSrfcs
std::vector< MInt > m_wmSurfaceProbeSrfcs
Definition: fvcartesiansolverxd.h:1904

FvCartesianSolverXD< nDim, SysEqn >::m_wmLocalNoSrfcProbeIds
MInt * m_wmLocalNoSrfcProbeIds
Definition: fvcartesiansolverxd.h:1887

FvCartesianSolverXD< nDim, SysEqn >::getVorticity
virtual void getVorticity(MFloat *const vorticity)
wrapper for vorticity computation
Definition: fvcartesiansolverxd.cpp:8907

FvCartesianSolverXD< nDim, SysEqn >::const
MFloat * const
Definition: fvcartesiansolverxd.h:2886

FvCartesianSolverXD< nDim, SysEqn >::m_bodyVelocity
MFloat * m_bodyVelocity
Definition: fvcartesiansolverxd.h:2249

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalBndrySide
std::vector< MInt > m_azimuthalBndrySide
Definition: fvcartesiansolverxd.h:1485

FvCartesianSolverXD< nDim, SysEqn >::m_LESVarAverage
std::vector< MFloat > * m_LESVarAverage
Definition: fvcartesiansolverxd.h:1804

FvCartesianSolverXD< nDim, SysEqn >::applyInitialCondition
virtual void applyInitialCondition()
Initializes the entire flow field.

FvCartesianSolverXD< nDim, SysEqn >::c_globalId
MLong c_globalId(const MInt cellId) const
Returns the global grid id of the grid cell cellId.
Definition: fvcartesiansolverxd.h:552

FvCartesianSolverXD< nDim, SysEqn >::m_maxLevelBeforeAdaptation
MInt m_maxLevelBeforeAdaptation
Definition: fvcartesiansolverxd.h:2064

FvCartesianSolverXD< nDim, SysEqn >::m_restartOldVariables
MBool m_restartOldVariables
Definition: fvcartesiansolverxd.h:1658

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceNghbrCellId
MInt & a_surfaceNghbrCellId(const MInt srfcId, const MInt dir)
Returns the neighbor cell id of surface srfcId in direction dir.
Definition: fvcartesiansolverxd.h:826

FvCartesianSolverXD< nDim, SysEqn >::exchange
virtual void exchange()
Definition: fvcartesiansolverxd.cpp:6368

FvCartesianSolverXD< nDim, SysEqn >::computeTimeStepEulerDirectional
MFloat computeTimeStepEulerDirectional(MInt cellId) const noexcept
Definition: fvcartesiansolverxd.cpp:21411

FvCartesianSolverXD< nDim, SysEqn >::m_linerLvlJump
MBool m_linerLvlJump
Definition: fvcartesiansolverxd.h:3008

FvCartesianSolverXD< nDim, SysEqn >::computePrimitiveVariables
virtual void computePrimitiveVariables()
Dispatches the computation of the primitive variables for different number of species.
Definition: fvcartesiansolverxd.cpp:19976

FvCartesianSolverXD< nDim, SysEqn >::m_static_advanceSolution_meanDragCoeff
MFloat m_static_advanceSolution_meanDragCoeff
Definition: fvcartesiansolverxd.h:2613

FvCartesianSolverXD< nDim, SysEqn >::m_vtuCoordinatesThreshold
MFloat * m_vtuCoordinatesThreshold
Definition: fvcartesiansolverxd.h:1687

FvCartesianSolverXD< nDim, SysEqn >::m_nuTildeInfinity
MFloat m_nuTildeInfinity
Definition: fvcartesiansolverxd.h:2464

FvCartesianSolverXD< nDim, SysEqn >::m_comm_wm
MPI_Comm m_comm_wm
Definition: fvcartesiansolverxd.h:1885

FvCartesianSolverXD< nDim, SysEqn >::m_static_getDistanceSplitSphere_h
MFloat m_static_getDistanceSplitSphere_h
Definition: fvcartesiansolverxd.h:2607

FvCartesianSolverXD< nDim, SysEqn >::m_orderOfReconstruction
MInt m_orderOfReconstruction
Definition: fvcartesiansolverxd.h:1713

FvCartesianSolverXD< nDim, SysEqn >::m_rhoEInfinity
MFloat m_rhoEInfinity
Definition: fvcartesiansolverxd.h:2473

FvCartesianSolverXD< nDim, SysEqn >::m_static_updateBodyProperties_c455_firstRun
MBool m_static_updateBodyProperties_c455_firstRun
Definition: fvcartesiansolverxd.h:2619

FvCartesianSolverXD< nDim, SysEqn >::m_sutherlandPlusOneThermal
MFloat m_sutherlandPlusOneThermal
Definition: fvcartesiansolverxd.h:2311

FvCartesianSolverXD< nDim, SysEqn >::m_sysEqn
SysEqn m_sysEqn
Definition: fvcartesiansolverxd.h:209

FvCartesianSolverXD< nDim, SysEqn >::m_levelSet
MBool m_levelSet
Definition: fvcartesiansolverxd.h:1615

FvCartesianSolverXD< nDim, SysEqn >::distributeFluxToCells
virtual void distributeFluxToCells()
Distributes the surface fluxes to the cell RHS.
Definition: fvcartesiansolverxd.cpp:19938

FvCartesianSolverXD< nDim, SysEqn >::a_spongeFactor
MFloat & a_spongeFactor(const MInt cellId)
Returns the spongeFactor of the cell cellId.
Definition: fvcartesiansolverxd.h:419

FvCartesianSolverXD< nDim, SysEqn >::m_noRansEquations
MInt m_noRansEquations
Definition: fvcartesiansolverxd.h:1792

FvCartesianSolverXD< nDim, SysEqn >::m_dataBlockSize
MInt m_dataBlockSize
Definition: fvcartesiansolverxd.h:2221

FvCartesianSolverXD< nDim, SysEqn >::m_levelSetRans
MBool m_levelSetRans
Definition: fvcartesiansolverxd.h:1618

FvCartesianSolverXD< nDim, SysEqn >::isMultilevel
constexpr MBool isMultilevel() const
Return true if solver is part of a multilevel computation.
Definition: fvcartesiansolverxd.h:2095

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalReconstNghbrIds
std::vector< MInt > m_azimuthalReconstNghbrIds
Definition: fvcartesiansolverxd.h:1484

FvCartesianSolverXD< nDim, SysEqn >::m_slopeMemory
MInt m_slopeMemory
Definition: fvcartesiansolverxd.h:1454

FvCartesianSolverXD< nDim, SysEqn >::noVariables
MInt noVariables() const override
Return the number of primitive variables.
Definition: fvcartesiansolverxd.h:2090

FvCartesianSolverXD< nDim, SysEqn >::a_wasGapCell
maia::fv::cell::BitsetType::reference a_wasGapCell(const MInt cellId)
Returns wasGapCell of the cell cellId.
Definition: fvcartesiansolverxd.h:358

FvCartesianSolverXD< nDim, SysEqn >::a_surfaceBndryCndId
MInt & a_surfaceBndryCndId(const MInt srfcId)
Returns the boundary condition of surface srfcId.
Definition: fvcartesiansolverxd.h:796

FvCartesianSolverXD< nDim, SysEqn >::m_VVInfinity
MFloat m_VVInfinity[3]
Definition: fvcartesiansolverxd.h:2469

FvCartesianSolverXD< nDim, SysEqn >::resetZonalLESAverage
virtual void resetZonalLESAverage()
Initializes zonal exchange arrays.
Definition: fvcartesiansolverxd.cpp:38256

FvCartesianSolverXD< nDim, SysEqn >::c_isLeafCell
MBool c_isLeafCell(const MInt cellId) const
Definition: fvcartesiansolverxd.h:525

FvCartesianSolverXD< nDim, SysEqn >::m_forceRestartGrid
MBool m_forceRestartGrid
Definition: fvcartesiansolverxd.h:1639

FvCartesianSolverXD< nDim, SysEqn >::setInfinityState
void setInfinityState()
Computes/defines the infinity values/state once and for all Ideally the infinity variables should not...

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45299_maxA
MFloat m_static_logData_ic45299_maxA
Definition: fvcartesiansolverxd.h:2644

FvCartesianSolverXD< nDim, SysEqn >::m_restartFileOutputTimeStep
MFloat m_restartFileOutputTimeStep
Definition: fvcartesiansolverxd.h:2539

FvCartesianSolverXD< nDim, SysEqn >::a_cellVolume
MFloat & a_cellVolume(const MInt cellId)
Returns the cell volume of the cell from the fvcellcollector cellId.
Definition: fvcartesiansolverxd.h:437

FvCartesianSolverXD< nDim, SysEqn >::m_noSamples
MInt m_noSamples
Definition: fvcartesiansolverxd.h:1711

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_ERhoLoo
MFloat m_static_applyBoundaryCondition_ERhoLoo
Definition: fvcartesiansolverxd.h:2627

FvCartesianSolverXD< nDim, SysEqn >::setPrimitiveVariables
void setPrimitiveVariables(MInt cellId)
computes primitive from primitive variables for given cell id. This is the version for all SysEqn.
Definition: fvcartesiansolverxd.cpp:20043

FvCartesianSolverXD< nDim, SysEqn >::m_cellSurfaceMapping
MInt ** m_cellSurfaceMapping
Definition: fvcartesiansolverxd.h:2032

FvCartesianSolverXD< nDim, SysEqn >::entropy
virtual MFloat entropy(MInt cellId)
Definition: fvcartesiansolverxd.h:2214

FvCartesianSolverXD< nDim, SysEqn >::m_noActiveCells
MInt m_noActiveCells
Definition: fvcartesiansolverxd.h:1444

FvCartesianSolverXD< nDim, SysEqn >::m_outputOffset
MInt m_outputOffset
Definition: fvcartesiansolverxd.h:2361

FvCartesianSolverXD< nDim, SysEqn >::m_adaptationLevel
MInt m_adaptationLevel
Definition: fvcartesiansolverxd.h:2981

FvCartesianSolverXD< nDim, SysEqn >::computeCellVolumes
void computeCellVolumes()
Definition: fvcartesiansolverxd.cpp:14386

FvCartesianSolverXD< nDim, SysEqn >::m_noEdges
static constexpr const MInt m_noEdges
Definition: fvcartesiansolverxd.h:201

FvCartesianSolverXD< nDim, SysEqn >::a_reconstructionNeighborId
MInt & a_reconstructionNeighborId(const MInt cellId, const MInt nghbrNo)
Returns reconstruction neighbor n of the cell cellId.
Definition: fvcartesiansolverxd.h:644

FvCartesianSolverXD< nDim, SysEqn >::m_extractedCells
Collector< PointBasedCell< nDim > > * m_extractedCells
Definition: fvcartesiansolverxd.h:1394

FvCartesianSolverXD< nDim, SysEqn >::exchangeDataFV
void exchangeDataFV(T *data, const MInt blockSize=1, MBool cartesian=true, const std::vector< MInt > &rotIndex=std::vector< MInt >())

FvCartesianSolverXD< nDim, SysEqn >::m_wmImgCoords
std::vector< std::vector< MFloat > > m_wmImgCoords
Definition: fvcartesiansolverxd.h:1901

FvCartesianSolverXD< nDim, SysEqn >::m_wmNoDomains
MInt m_wmNoDomains
Definition: fvcartesiansolverxd.h:1876

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45299_maxF
MFloat m_static_logData_ic45299_maxF
Definition: fvcartesiansolverxd.h:2644

FvCartesianSolverXD< nDim, SysEqn >::m_A
MFloat ** m_A
Definition: fvcartesiansolverxd.h:1462

FvCartesianSolverXD< nDim, SysEqn >::m_rhs0
MFloat ** m_rhs0
Definition: fvcartesiansolverxd.h:1499

FvCartesianSolverXD< nDim, SysEqn >::m_levelSetMb
MBool m_levelSetMb
Definition: fvcartesiansolverxd.h:1616

FvCartesianSolverXD< nDim, SysEqn >::a_isWindow
MBool a_isWindow(const MInt cellId) const
Returns IsWindow of the cell cellId.
Definition: fvcartesiansolverxd.h:368

FvCartesianSolverXD< nDim, SysEqn >::m_closeGaps
MBool m_closeGaps
Definition: fvcartesiansolverxd.h:2283

FvCartesianSolverXD< nDim, SysEqn >::m_restartTimeBc2800
MFloat m_restartTimeBc2800
Definition: fvcartesiansolverxd.h:1716

FvCartesianSolverXD< nDim, SysEqn >::setActiveFlag
void setActiveFlag(MIntScratchSpace &, const MInt mode, const MInt offset)
Set the flag for the cells needed for near bndry exchange.
Definition: fvcartesiansolverxd.cpp:12848

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalNearBoundaryBackupMaxCount
const MInt m_azimuthalNearBoundaryBackupMaxCount
Definition: fvcartesiansolverxd.h:1489

FvCartesianSolverXD< nDim, SysEqn >::allocateCommunicationMemory
void allocateCommunicationMemory()
Allocates and initializes send/receive buffers for multiSolver computations.
Definition: fvcartesiansolverxd.cpp:914

FvCartesianSolverXD< nDim, SysEqn >::m_reComputedBndry
MBool m_reComputedBndry
Definition: fvcartesiansolverxd.h:1633

FvCartesianSolverXD< nDim, SysEqn >::m_volumeAcceleration
MFloat * m_volumeAcceleration
Definition: fvcartesiansolverxd.h:1500

FvCartesianSolverXD< nDim, SysEqn >::m_createSpongeBoundary
MBool m_createSpongeBoundary
Definition: fvcartesiansolverxd.h:2012

FvCartesianSolverXD< nDim, SysEqn >::m_gapInitMethod
MInt m_gapInitMethod
Definition: fvcartesiansolverxd.h:2284

FvCartesianSolverXD< nDim, SysEqn >::a_level
MInt & a_level(const MInt cellId)
Returns the level of the cell from the fvcellcollector cellId.
Definition: fvcartesiansolverxd.h:431

FvCartesianSolverXD< nDim, SysEqn >::m_rhoWInfinity
MFloat m_rhoWInfinity
Definition: fvcartesiansolverxd.h:2472

FvCartesianSolverXD< nDim, SysEqn >::initAzimuthalNearBoundaryExchange
void initAzimuthalNearBoundaryExchange(MIntScratchSpace &activeFlag)

FvCartesianSolverXD< nDim, SysEqn >::a_hasNeighbor
MInt a_hasNeighbor(const MInt cellId, const MInt dir, const MBool assertNeighborState=true) const
Returns noNeighborIds of the cell CellId for direction dir.
Definition: fvcartesiansolverxd.h:601

FvCartesianSolverXD< nDim, SysEqn >::resetCutOffCells
void resetCutOffCells()
resets all Cut-Off Information should only be called before the adaptation and balance!
Definition: fvcartesiansolverxd.cpp:25062

FvCartesianSolverXD< nDim, SysEqn >::m_reconstructionConstants
std::vector< MFloat > m_reconstructionConstants
Definition: fvcartesiansolverxd.h:1467

FvCartesianSolverXD< nDim, SysEqn >::m_adaptationSinceLastRestart
MBool m_adaptationSinceLastRestart
Definition: fvcartesiansolverxd.h:1637

FvCartesianSolverXD< nDim, SysEqn >::m_static_constructGFieldPredictor_firstRun
MBool m_static_constructGFieldPredictor_firstRun
Definition: fvcartesiansolverxd.h:2610

FvCartesianSolverXD< nDim, SysEqn >::m_surfaceVarMemory
MInt m_surfaceVarMemory
Definition: fvcartesiansolverxd.h:1455

FvCartesianSolverXD< nDim, SysEqn >::m_Pr
MFloat m_Pr
Definition: fvcartesiansolverxd.h:1995

FvCartesianSolverXD< nDim, SysEqn >::resetZonalSolverData
virtual void resetZonalSolverData()
Definition: fvcartesiansolverxd.cpp:38337

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_Strouhal
MFloat m_static_logData_ic45301_Strouhal
Definition: fvcartesiansolverxd.h:2651

FvCartesianSolverXD< nDim, SysEqn >::timeStep
MFloat timeStep(MBool canSolver=false) noexcept
Definition: fvcartesiansolverxd.h:2503

FvCartesianSolverXD< nDim, SysEqn >::m_receiveBuffers
MFloat ** m_receiveBuffers
Definition: fvcartesiansolverxd.h:2220

FvCartesianSolverXD< nDim, SysEqn >::m_weightNearBndryCell
MFloat m_weightNearBndryCell
Definition: fvcartesiansolverxd.h:2434

FvCartesianSolverXD< nDim, SysEqn >::m_lsCutCellBaseLevel
MInt m_lsCutCellBaseLevel
Definition: fvcartesiansolverxd.h:1374

FvCartesianSolverXD< nDim, SysEqn >::computeVolumeForces
void computeVolumeForces()
Definition: fvcartesiansolverxd.cpp:6205

FvCartesianSolverXD< nDim, SysEqn >::a_bndryId
MInt & a_bndryId(const MInt cellId)
Returns the bndryId of the cell cellId.
Definition: fvcartesiansolverxd.h:672

FvCartesianSolverXD< nDim, SysEqn >::m_bodyTemperatureDt1
MFloat * m_bodyTemperatureDt1
Definition: fvcartesiansolverxd.h:2256

FvCartesianSolverXD< nDim, SysEqn >::m_splitCells
std::vector< MInt > m_splitCells
Definition: fvcartesiansolverxd.h:1457

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_ERhoL2
MFloat m_static_applyBoundaryCondition_ERhoL2
Definition: fvcartesiansolverxd.h:2626

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalHaloActive
std::vector< MInt > m_azimuthalHaloActive
Definition: fvcartesiansolverxd.h:1488

FvCartesianSolverXD< nDim, SysEqn >::m_refineDiagonals
MBool m_refineDiagonals
Definition: fvcartesiansolverxd.h:1377

FvCartesianSolverXD< nDim, SysEqn >::rebuildAzimuthalReconstructionConstants
void rebuildAzimuthalReconstructionConstants(MInt cellId, MInt offset, MFloat *recCoord, MInt mode=0)

FvCartesianSolverXD< nDim, SysEqn >::isMultilevelPrimary
constexpr MBool isMultilevelPrimary() const
Return true if solver is primary solver in multilevel computation.
Definition: fvcartesiansolverxd.h:2098

FvCartesianSolverXD< nDim, SysEqn >::reduceVariables
void reduceVariables()
Check whether any of the extracted cells lie below the halo cell level and interpolate their variable...
Definition: fvcartesiansolverxd.cpp:17590

FvCartesianSolverXD< nDim, SysEqn >::computeDomainLength
MFloat computeDomainLength(MInt direction)

FvCartesianSolverXD< nDim, SysEqn >::m_static_saveSolverSolutionxd_firstRun
MBool m_static_saveSolverSolutionxd_firstRun
Definition: fvcartesiansolverxd.h:2658

FvCartesianSolverXD< nDim, SysEqn >::m_timers
std::array< MInt, Timers::_count > m_timers
Definition: fvcartesiansolverxd.h:2443

FvCartesianSolverXD< nDim, SysEqn >::m_dragOutputInterval
MInt m_dragOutputInterval
Definition: fvcartesiansolverxd.h:1697

FvCartesianSolverXD< nDim, SysEqn >::m_static_logData_ic45301_maxF
MFloat m_static_logData_ic45301_maxF
Definition: fvcartesiansolverxd.h:2653

FvCartesianSolverXD< nDim, SysEqn >::a_noReconstructionNeighbors
MInt & a_noReconstructionNeighbors(const MInt cellId)
Returns the noRcnstrctnNghbrIds of the cell cellId.
Definition: fvcartesiansolverxd.h:678

FvCartesianSolverXD< nDim, SysEqn >::m_azimuthalRemappedNeighborDomains
std::vector< MInt > m_azimuthalRemappedNeighborDomains
Definition: fvcartesiansolverxd.h:1476

FvCartesianSolverXD< nDim, SysEqn >::tagCellsNeededForSurfaceFlux
void tagCellsNeededForSurfaceFlux()
Definition: fvcartesiansolverxd.cpp:8091

FvCartesianSolverXD< nDim, SysEqn >::m_sendBuffersNoBlocking
MFloat ** m_sendBuffersNoBlocking
Definition: fvcartesiansolverxd.h:2223

FvCartesianSolverXD< nDim, SysEqn >::m_noRKSteps
MInt m_noRKSteps
Definition: fvcartesiansolverxd.h:1710

FvCartesianSolverXD< nDim, SysEqn >::m_vtuDomainIdOutput
MBool m_vtuDomainIdOutput
Definition: fvcartesiansolverxd.h:1677

FvCartesianSolverXD< nDim, SysEqn >::a_pvariable
MFloat & a_pvariable(const MInt cellId, const MInt varId)
Returns primitive variable v of the cell cellId for variables varId.
Definition: fvcartesiansolverxd.h:616

FvCartesianSolverXD< nDim, SysEqn >::computeRecConstSVD
MFloat computeRecConstSVD(const MInt cellId, const MInt offset, MFloatScratchSpace &tmpA, MFloatScratchSpace &tmpC, MFloatScratchSpace &weights, const MInt recDim, const MInt, const MInt, const std::array< MBool, nDim > dirs={}, const MBool relocateCenter=false)
compute the reconstruction constants of the given cell by a weighted least-squares approach via singu...
Definition: fvcartesiansolverxd.cpp:9018

FvCartesianSolverXD< nDim, SysEqn >::m_noCellsInsideSpongeLayer
MInt m_noCellsInsideSpongeLayer
Definition: fvcartesiansolverxd.h:1447

FvCartesianSolverXD< nDim, SysEqn >::m_noMaxLevelHaloCells
MInt * m_noMaxLevelHaloCells
Definition: fvcartesiansolverxd.h:1453

FvCartesianSolverXD< nDim, SysEqn >::m_identNghbrIds
MInt * m_identNghbrIds
Definition: fvcartesiansolverxd.h:1785

FvCartesianSolverXD< nDim, SysEqn >::m_static_applyBoundaryCondition_firstRun
MBool m_static_applyBoundaryCondition_firstRun
Definition: fvcartesiansolverxd.h:2624

FvCartesianSolverXD< nDim, SysEqn >::m_spongeLayerThickness
MFloat m_spongeLayerThickness
Definition: fvcartesiansolverxd.h:2010

FvCartesianSolverXD< nDim, SysEqn >::checkNeighborActive
MBool checkNeighborActive(const MInt cellId, const MInt dir) const
Cecks wether the cell cellId has a valid neighbor in direction dir.
Definition: fvcartesiansolverxd.h:509

FvCartesianSolverXD< nDim, SysEqn >::m_maxIterations
MInt m_maxIterations
Definition: fvcartesiansolverxd.h:1712

FvCartesianSolverXD< nDim, SysEqn >::m_averageVorticity
MBool m_averageVorticity
Definition: fvcartesiansolverxd.h:2068

FvCartesianSolverXD< nDim, SysEqn >::a_FcellVolume
MFloat & a_FcellVolume(const MInt cellId) override
Returns the inverse cell volume of the cell from the fvcellcollector cellId.
Definition: fvcartesiansolverxd.h:443

FvCartesianSolverXD< nDim, SysEqn >::getAssociatedInternalCell
const MInt & getAssociatedInternalCell(const MInt &cellId) const
Returns the Id of the split cell, if cellId is a split child.
Definition: fvcartesiansolverxd.h:1081

FvMbCartesianSolverXD::Csg
Definition: fvmbcartesiansolverxd.h:1741

FvMbCartesianSolverXD::Csg::~Csg
~Csg()=default

FvMbCartesianSolverXD::Csg::polygons
std::vector< CsgPolygon > polygons
Definition: fvmbcartesiansolverxd.h:1743

FvMbCartesianSolverXD::Csg::Csg
Csg(std::vector< CsgPolygon > _polygons)
Definition: fvmbcartesiansolverxd.h:1747

FvMbCartesianSolverXD::Csg::Csg
Csg()
Definition: fvmbcartesiansolverxd.h:1745

FvMbCartesianSolverXD::Csg::inverse
void inverse()
Definition: fvmbcartesiansolverxd.h:1769

FvMbCartesianSolverXD::Csg::intersect
std::vector< CsgPolygon > intersect(const Csg &csg) const
Definition: fvmbcartesiansolverxd.h:1755

FvMbCartesianSolverXD::CsgNode
Definition: fvmbcartesiansolverxd.h:1617

FvMbCartesianSolverXD::CsgNode::CsgNode
CsgNode(std::vector< CsgPolygon > _polygons)
Definition: fvmbcartesiansolverxd.h:1625

FvMbCartesianSolverXD::CsgNode::planeValid
MBool planeValid
Definition: fvmbcartesiansolverxd.h:1620

FvMbCartesianSolverXD::CsgNode::plot
void plot(MInt tabCounter, const MChar *fileName)
Definition: fvmbcartesiansolverxd.h:1701

FvMbCartesianSolverXD::CsgNode::CsgNode
CsgNode()
Definition: fvmbcartesiansolverxd.h:1633

FvMbCartesianSolverXD::CsgNode::clipPolygons
std::vector< CsgPolygon > clipPolygons(std::vector< CsgPolygon > _polygons)
Definition: fvmbcartesiansolverxd.h:1658

FvMbCartesianSolverXD::CsgNode::invert
void invert()
Definition: fvmbcartesiansolverxd.h:1646

FvMbCartesianSolverXD::CsgNode::clipTo
void clipTo(CsgNode &bsp)
Definition: fvmbcartesiansolverxd.h:1677

FvMbCartesianSolverXD::CsgNode::build
void build(std::vector< CsgPolygon > _polygons)
Definition: fvmbcartesiansolverxd.cpp:31470

FvMbCartesianSolverXD::CsgNode::back
CsgNode * back
Definition: fvmbcartesiansolverxd.h:1622

FvMbCartesianSolverXD::CsgNode::allPolygons
std::vector< CsgPolygon > allPolygons()
Definition: fvmbcartesiansolverxd.h:1683

FvMbCartesianSolverXD::CsgNode::plane
CsgPlane plane
Definition: fvmbcartesiansolverxd.h:1619

FvMbCartesianSolverXD::CsgNode::polygons
std::vector< CsgPolygon > polygons
Definition: fvmbcartesiansolverxd.h:1623

FvMbCartesianSolverXD::CsgNode::front
CsgNode * front
Definition: fvmbcartesiansolverxd.h:1621

FvMbCartesianSolverXD::CsgNode::~CsgNode
~CsgNode()
Definition: fvmbcartesiansolverxd.h:1640

FvMbCartesianSolverXD::CsgPlane
Definition: fvmbcartesiansolverxd.h:1517

FvMbCartesianSolverXD::CsgPlane::CsgPlane
CsgPlane(CsgVector abc[nDim])
Definition: fvmbcartesiansolverxd.h:1528

FvMbCartesianSolverXD::CsgPlane::CsgPlane
CsgPlane(CsgVector *_normal, MFloat _w)
Definition: fvmbcartesiansolverxd.h:1524

FvMbCartesianSolverXD::CsgPlane::splitPolygon
void splitPolygon(CsgPolygon *polygon, std::vector< CsgPolygon > *coplanarFront, std::vector< CsgPolygon > *coplanarBack, std::vector< CsgPolygon > *front, std::vector< CsgPolygon > *back) const
Definition: fvmbcartesiansolverxd.cpp:31368

FvMbCartesianSolverXD::CsgPlane::CsgPlane
CsgPlane()=default

FvMbCartesianSolverXD::CsgPlane::w
MFloat w
Definition: fvmbcartesiansolverxd.h:1521

FvMbCartesianSolverXD::CsgPlane::clone
CsgPlane clone()
Definition: fvmbcartesiansolverxd.h:1542

FvMbCartesianSolverXD::CsgPlane::~CsgPlane
~CsgPlane()=default

FvMbCartesianSolverXD::CsgPlane::insertCoplanarPolygon
void insertCoplanarPolygon(CsgPolygon *polygon, std::vector< CsgPolygon > *coplanarFront, std::vector< CsgPolygon > *coplanarBack) const
Definition: fvmbcartesiansolverxd.cpp:31353

FvMbCartesianSolverXD::CsgPlane::eps
static constexpr MFloat eps
Definition: fvmbcartesiansolverxd.h:1519

FvMbCartesianSolverXD::CsgPlane::normal
CsgVector normal
Definition: fvmbcartesiansolverxd.h:1520

FvMbCartesianSolverXD::CsgPlane::flip
void flip()
Definition: fvmbcartesiansolverxd.h:1546

FvMbCartesianSolverXD::CsgPolygon
Definition: fvmbcartesiansolverxd.h:1560

FvMbCartesianSolverXD::CsgPolygon::CsgPolygon
CsgPolygon(std::vector< CsgVertex > _vertices, MInt _setIndex, MInt _faceId, MInt _faceType, MInt _bodyId, CsgPlane _plane)
Definition: fvmbcartesiansolverxd.h:1585

FvMbCartesianSolverXD::CsgPolygon::~CsgPolygon
~CsgPolygon()=default

FvMbCartesianSolverXD::CsgPolygon::flip
void flip()
Definition: fvmbcartesiansolverxd.h:1604

FvMbCartesianSolverXD::CsgPolygon::faceType
MInt faceType
Definition: fvmbcartesiansolverxd.h:1568

FvMbCartesianSolverXD::CsgPolygon::CsgPolygon
CsgPolygon()=default

FvMbCartesianSolverXD::CsgPolygon::faceId
MInt faceId
Definition: fvmbcartesiansolverxd.h:1567

FvMbCartesianSolverXD::CsgPolygon::setIndex
MInt setIndex
Definition: fvmbcartesiansolverxd.h:1565

FvMbCartesianSolverXD::CsgPolygon::CsgPolygon
CsgPolygon(std::vector< CsgVertex > _vertices, MInt _setIndex, MInt _faceId, MInt _faceType, MInt _bodyId)
Definition: fvmbcartesiansolverxd.h:1570

FvMbCartesianSolverXD::CsgPolygon::bodyId
MInt bodyId
Definition: fvmbcartesiansolverxd.h:1566

FvMbCartesianSolverXD::CsgPolygon::plane
CsgPlane plane
Definition: fvmbcartesiansolverxd.h:1564

FvMbCartesianSolverXD::CsgPolygon::clone
CsgPolygon clone() const
Definition: fvmbcartesiansolverxd.h:1599

FvMbCartesianSolverXD::CsgPolygon::vertices
std::vector< CsgVertex > vertices
Definition: fvmbcartesiansolverxd.h:1562

FvMbCartesianSolverXD::CsgVector
Definition: fvmbcartesiansolverxd.h:1432

FvMbCartesianSolverXD::CsgVector::cross
CsgVector cross(const CsgVector &a) const
Definition: fvmbcartesiansolverxd.h:1481

FvMbCartesianSolverXD::CsgVector::times
CsgVector times(const MFloat a) const
Definition: fvmbcartesiansolverxd.h:1459

FvMbCartesianSolverXD::CsgVector::minus
CsgVector minus(const CsgVector &a) const
Definition: fvmbcartesiansolverxd.h:1453

FvMbCartesianSolverXD::CsgVector::lerp
CsgVector lerp(const CsgVector &a, const MFloat t) const
Definition: fvmbcartesiansolverxd.h:1477

FvMbCartesianSolverXD::CsgVector::negate
void negate()
Definition: fvmbcartesiansolverxd.h:1492

FvMbCartesianSolverXD::CsgVector::clone
CsgVector clone() const
Definition: fvmbcartesiansolverxd.h:1442

FvMbCartesianSolverXD::CsgVector::length
MFloat length() const
Definition: fvmbcartesiansolverxd.h:1478

FvMbCartesianSolverXD::CsgVector::CsgVector
CsgVector(CsgVector &&) noexcept=default

FvMbCartesianSolverXD::CsgVector::dot
MFloat dot(const CsgVector &a) const
Definition: fvmbcartesiansolverxd.h:1471

FvMbCartesianSolverXD::CsgVector::unit
CsgVector unit() const
Definition: fvmbcartesiansolverxd.h:1479

FvMbCartesianSolverXD::CsgVector::dividedBy
CsgVector dividedBy(const MFloat a) const
Definition: fvmbcartesiansolverxd.h:1465

FvMbCartesianSolverXD::CsgVector::cross
CsgVector cross(const CsgVector &) const
Definition: fvmbcartesiansolverxd.h:1489

FvMbCartesianSolverXD::CsgVector::CsgVector
CsgVector(const MFloat *X)
Definition: fvmbcartesiansolverxd.h:1436

FvMbCartesianSolverXD::CsgVector::CsgVector
CsgVector()
Definition: fvmbcartesiansolverxd.h:1435

FvMbCartesianSolverXD::CsgVector::plus
CsgVector plus(const CsgVector &a) const
Definition: fvmbcartesiansolverxd.h:1447

FvMbCartesianSolverXD::CsgVector::xx
MFloat xx[3]
Definition: fvmbcartesiansolverxd.h:1434

FvMbCartesianSolverXD::CsgVector::CsgVector
CsgVector(const CsgVector &Y)
Definition: fvmbcartesiansolverxd.h:1437

FvMbCartesianSolverXD::CsgVertex
Definition: fvmbcartesiansolverxd.h:1499

FvMbCartesianSolverXD::CsgVertex::setIndex
MInt setIndex
Definition: fvmbcartesiansolverxd.h:1503

FvMbCartesianSolverXD::CsgVertex::clone
CsgVertex clone() const
Definition: fvmbcartesiansolverxd.h:1508

FvMbCartesianSolverXD::CsgVertex::interpolate
CsgVertex interpolate(CsgVertex *other, MFloat t) const
Definition: fvmbcartesiansolverxd.h:1512

FvMbCartesianSolverXD::CsgVertex::CsgVertex
CsgVertex(const CsgVector &_pos, MInt _vertexId, MInt _setIndex)
Definition: fvmbcartesiansolverxd.h:1504

FvMbCartesianSolverXD::CsgVertex::pos
CsgVector pos
Definition: fvmbcartesiansolverxd.h:1501

FvMbCartesianSolverXD::CsgVertex::vertexId
MInt vertexId
Definition: fvmbcartesiansolverxd.h:1502

FvMbCartesianSolverXD::cellWithSplitFace
Definition: fvmbcartesiansolverxd.h:1363

FvMbCartesianSolverXD::cellWithSplitFace::cellWithSplitFace
cellWithSplitFace(MInt id)
Definition: fvmbcartesiansolverxd.h:1367

FvMbCartesianSolverXD::cellWithSplitFace::splitFaces
std::vector< splitCartesianFace > splitFaces
Definition: fvmbcartesiansolverxd.h:1366

FvMbCartesianSolverXD::cellWithSplitFace::cellId
MInt cellId
Definition: fvmbcartesiansolverxd.h:1365

FvMbCartesianSolverXD::polyCutCellBase
Definition: fvmbcartesiansolverxd.h:1337

FvMbCartesianSolverXD::polyCutCellBase::volume
MFloat volume
Definition: fvmbcartesiansolverxd.h:1340

FvMbCartesianSolverXD::polyCutCellBase::center
MFloat center[nDim]
Definition: fvmbcartesiansolverxd.h:1341

FvMbCartesianSolverXD::polyCutCellBase::cartesianCell
MInt cartesianCell
Definition: fvmbcartesiansolverxd.h:1339

FvMbCartesianSolverXD::polyCutCellBase::polyCutCellBase
polyCutCellBase(MInt cartCell, MFloat *_center)
Definition: fvmbcartesiansolverxd.h:1342

FvMbCartesianSolverXD::polyCutCell
Definition: fvmbcartesiansolverxd.h:1347

FvMbCartesianSolverXD::polyCutCell::faces_edges
std::vector< MInt > faces_edges
Definition: fvmbcartesiansolverxd.h:1350

FvMbCartesianSolverXD::polyCutCell::polyCutCell
polyCutCell(MInt cartCell, MFloat *_center)
Definition: fvmbcartesiansolverxd.h:1351

FvMbCartesianSolverXD::polyEdge2D
Definition: fvmbcartesiansolverxd.h:1298

FvMbCartesianSolverXD::polyEdge2D::cutCell
MInt cutCell
Definition: fvmbcartesiansolverxd.h:1300

FvMbCartesianSolverXD::polyEdge2D::polyEdge2D
polyEdge2D(MInt v0, MInt v1, MInt eId, MInt eType, MInt _bodyId)
Definition: fvmbcartesiansolverxd.h:1302

FvMbCartesianSolverXD::polyEdge2D::w
MFloat w
Definition: fvmbcartesiansolverxd.h:1301

FvMbCartesianSolverXD::polyEdge3D
Definition: fvmbcartesiansolverxd.h:1306

FvMbCartesianSolverXD::polyEdge3D::polyEdge3D
polyEdge3D(MInt v0, MInt v1, MInt eId, MInt eType)
Definition: fvmbcartesiansolverxd.h:1309

FvMbCartesianSolverXD::polyEdge3D::face
MInt face[2]
Definition: fvmbcartesiansolverxd.h:1308

FvMbCartesianSolverXD::polyEdgeBase
Definition: fvmbcartesiansolverxd.h:1289

FvMbCartesianSolverXD::polyEdgeBase::vertices
MInt vertices[2]
Definition: fvmbcartesiansolverxd.h:1291

FvMbCartesianSolverXD::polyEdgeBase::polyEdgeBase
polyEdgeBase(MInt v0, MInt v1, MInt eId, MInt eType)
Definition: fvmbcartesiansolverxd.h:1295

FvMbCartesianSolverXD::polyEdgeBase::edgeId
MInt edgeId
Definition: fvmbcartesiansolverxd.h:1293

FvMbCartesianSolverXD::polyEdgeBase::edgeType
MInt edgeType
Definition: fvmbcartesiansolverxd.h:1292

FvMbCartesianSolverXD::polyFace
Definition: fvmbcartesiansolverxd.h:1312

FvMbCartesianSolverXD::polyFace::cutCell
MInt cutCell
Definition: fvmbcartesiansolverxd.h:1316

FvMbCartesianSolverXD::polyFace::faceId
MInt faceId
Definition: fvmbcartesiansolverxd.h:1317

FvMbCartesianSolverXD::polyFace::isLine
MInt isLine
Definition: fvmbcartesiansolverxd.h:1321

FvMbCartesianSolverXD::polyFace::tmpSetIndex
MInt tmpSetIndex
Definition: fvmbcartesiansolverxd.h:1320

FvMbCartesianSolverXD::polyFace::w
MFloat w
Definition: fvmbcartesiansolverxd.h:1319

FvMbCartesianSolverXD::polyFace::edges
std::vector< std::pair< MInt, MInt > > edges
Definition: fvmbcartesiansolverxd.h:1315

FvMbCartesianSolverXD::polyFace::polyFace
polyFace()
Definition: fvmbcartesiansolverxd.h:1326

FvMbCartesianSolverXD::polyFace::polyFace
polyFace(MInt fId, MInt fType, MInt _bodyId)
Definition: fvmbcartesiansolverxd.h:1322

FvMbCartesianSolverXD::polyFace::faceType
MInt faceType
Definition: fvmbcartesiansolverxd.h:1318

FvMbCartesianSolverXD::polyMultiFace
Definition: fvmbcartesiansolverxd.h:1330

FvMbCartesianSolverXD::polyMultiFace::edges
std::list< std::pair< MInt, MInt > > edges
Definition: fvmbcartesiansolverxd.h:1334

FvMbCartesianSolverXD::polyMultiFace::faces
std::vector< MInt > faces
Definition: fvmbcartesiansolverxd.h:1332

FvMbCartesianSolverXD::polyVertex
Definition: fvmbcartesiansolverxd.h:1274

FvMbCartesianSolverXD::polyVertex::cartSrfcId
MInt cartSrfcId
Definition: fvmbcartesiansolverxd.h:1280

FvMbCartesianSolverXD::polyVertex::polyVertex
polyVertex(MFloat *coords, MInt pId, MInt pType)
Definition: fvmbcartesiansolverxd.h:1284

FvMbCartesianSolverXD::polyVertex::surfaceIdentificators
std::set< MInt > surfaceIdentificators
Definition: fvmbcartesiansolverxd.h:1282

FvMbCartesianSolverXD::polyVertex::edges
std::vector< MInt > edges
Definition: fvmbcartesiansolverxd.h:1281

FvMbCartesianSolverXD::polyVertex::pointId
MInt pointId
Definition: fvmbcartesiansolverxd.h:1277

FvMbCartesianSolverXD::polyVertex::coordinates
MFloat coordinates[nDim]
Definition: fvmbcartesiansolverxd.h:1276

FvMbCartesianSolverXD::polyVertex::polyVertex
polyVertex(MInt pId, MInt pType)
Definition: fvmbcartesiansolverxd.h:1283

FvMbCartesianSolverXD::splitCartesianFace
Definition: fvmbcartesiansolverxd.h:1355

FvMbCartesianSolverXD::splitCartesianFace::srfcIds
std::vector< MInt > srfcIds
Definition: fvmbcartesiansolverxd.h:1358

FvMbCartesianSolverXD::splitCartesianFace::direction
MInt direction
Definition: fvmbcartesiansolverxd.h:1357

FvMbCartesianSolverXD::splitCartesianFace::splitCartesianFace
splitCartesianFace(MInt dir)
Definition: fvmbcartesiansolverxd.h:1359

FvMbCartesianSolverXD::surfBase
Definition: fvmbcartesiansolverxd.h:1264

FvMbCartesianSolverXD::surfBase::normal
MFloat normal[nDim]
Definition: fvmbcartesiansolverxd.h:1268

FvMbCartesianSolverXD::surfBase::surfBase
surfBase(MInt _bodyId)
Definition: fvmbcartesiansolverxd.h:1271

FvMbCartesianSolverXD::surfBase::center
MFloat center[nDim]
Definition: fvmbcartesiansolverxd.h:1269

FvMbCartesianSolverXD::surfBase::surfBase
surfBase()=default

FvMbCartesianSolverXD::surfBase::area
MFloat area
Definition: fvmbcartesiansolverxd.h:1267

FvMbCartesianSolverXD::surfBase::bodyId
MInt bodyId
Definition: fvmbcartesiansolverxd.h:1266

FvMbCartesianSolverXD
Definition: fvmbcartesiansolverxd.h:53

FvMbCartesianSolverXD::m_gravity
MFloat * m_gravity
Definition: fvmbcartesiansolverxd.h:689

FvMbCartesianSolverXD::logBoundaryData
void logBoundaryData(const MChar *fileName, MBool forceOutput)
logs several boundary values to the given output file
Definition: fvmbcartesiansolverxd.cpp:12750

FvMbCartesianSolverXD::resetMbBoundaryCells
void resetMbBoundaryCells()
resets all moving boundary cells - STL boundary remains intact
Definition: fvmbcartesiansolverxd.cpp:20140

FvMbCartesianSolverXD::m_particleTerminalVelocity
MFloat * m_particleTerminalVelocity
Definition: fvmbcartesiansolverxd.h:745

FvMbCartesianSolverXD::m_noneGapRegions
MBool m_noneGapRegions
Definition: fvmbcartesiansolverxd.h:638

FvMbCartesianSolverXD::printDynamicCoefficients
void printDynamicCoefficients(MBool firstRun, MFloat *pressureForce)
Definition: fvmbcartesiansolverxd.cpp:21392

FvMbCartesianSolverXD::reInitSolutionStep
void reInitSolutionStep(const MInt mode)
Re-initializes the solver.
Definition: fvmbcartesiansolverxd.cpp:1597

FvMbCartesianSolverXD::m_lsCutCellLevel
MInt * m_lsCutCellLevel
Definition: fvmbcartesiansolverxd.h:627

FvMbCartesianSolverXD::execRungeKuttaStep
MBool(FvMbCartesianSolverXD::* execRungeKuttaStep)()
Definition: fvmbcartesiansolverxd.h:1105

FvMbCartesianSolverXD::m_massRedistributionIds
std::vector< MInt > m_massRedistributionIds
Definition: fvmbcartesiansolverxd.h:820

FvMbCartesianSolverXD::returnNoActiveCorners
MInt returnNoActiveCorners(MInt)
returns the numer of active Corners for an arbitrary cell (the cell is not a bndryCandidate yet and t...
Definition: fvmbcartesiansolverxd.cpp:21052

FvMbCartesianSolverXD::applyInitialCondition
void applyInitialCondition() override
Definition: fvmbcartesiansolverxd.cpp:1522

FvMbCartesianSolverXD::m_slipDataParticleTorque
MFloat * m_slipDataParticleTorque
Definition: fvmbcartesiansolverxd.h:869

FvMbCartesianSolverXD::copyVarsToSmallCells
void copyVarsToSmallCells() override
calls m_fvBndryCnd->copyVarsToSmallCells()
Definition: fvmbcartesiansolverxd.cpp:12674

FvMbCartesianSolverXD::m_particleQuaternions
std::vector< MFloat > m_particleQuaternions
Definition: fvmbcartesiansolverxd.h:758

FvMbCartesianSolverXD::m_sampleNormals
MFloat * m_sampleNormals
Definition: fvmbcartesiansolverxd.h:807

FvMbCartesianSolverXD::sensorPatch
void sensorPatch(std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt) override
Definition: fvmbcartesiansolverxd.cpp:34732

FvMbCartesianSolverXD::m_bodyDensity
MFloat * m_bodyDensity
Definition: fvmbcartesiansolverxd.h:710

FvMbCartesianSolverXD::m_maxBodyRadius
MFloat m_maxBodyRadius
Definition: fvmbcartesiansolverxd.h:694

FvMbCartesianSolverXD::getLevelSetValueNaca00XX
MFloat getLevelSetValueNaca00XX(const MFloat *const, const MFloat sign)

FvMbCartesianSolverXD::m_centralizeSurfaceVariables
MInt m_centralizeSurfaceVariables
Definition: fvmbcartesiansolverxd.h:616

FvMbCartesianSolverXD::m_stableCellVolume
MFloat * m_stableCellVolume
Definition: fvmbcartesiansolverxd.h:790

FvMbCartesianSolverXD::m_slipDataParticleFluidVelRnd
MFloat * m_slipDataParticleFluidVelRnd
Definition: fvmbcartesiansolverxd.h:873

FvMbCartesianSolverXD::initPointParticleProperties
void initPointParticleProperties()

FvMbCartesianSolverXD::m_firstStats
MBool m_firstStats
Definition: fvmbcartesiansolverxd.h:851

FvMbCartesianSolverXD::m_sweptVolumeDt1
MFloat * m_sweptVolumeDt1
Definition: fvmbcartesiansolverxd.h:792

FvMbCartesianSolverXD::initGField
void initGField()
initializes the level-set data at startup
Definition: fvmbcartesiansolverxd.cpp:1536

FvMbCartesianSolverXD::m_noBodiesInSet
MInt * m_noBodiesInSet
Definition: fvmbcartesiansolverxd.h:671

FvMbCartesianSolverXD::m_boundaryPressureDt1
MFloat * m_boundaryPressureDt1
Definition: fvmbcartesiansolverxd.h:799

FvMbCartesianSolverXD::m_oldGeomBndryCells
std::map< MInt, MFloat > m_oldGeomBndryCells
Definition: fvmbcartesiansolverxd.h:631

FvMbCartesianSolverXD::m_forceAdaptation
MBool m_forceAdaptation
Definition: fvmbcartesiansolverxd.h:740

FvMbCartesianSolverXD::computeNormal
static void computeNormal(const MFloat *p0, const MFloat *p1, MFloat *res, MFloat &w)
returns the normal corresponding to the triangle abc and returns the result in res
Definition: fvmbcartesiansolverxd.h:1397

FvMbCartesianSolverXD::m_particleVelocityDt1
std::vector< MFloat > m_particleVelocityDt1
Definition: fvmbcartesiansolverxd.h:753

FvMbCartesianSolverXD::m_motionEquation
MInt m_motionEquation
Definition: fvmbcartesiansolverxd.h:581

FvMbCartesianSolverXD::leastSquaresReconstruction
void leastSquaresReconstruction()
Least squares reconstruction.
Definition: fvmbcartesiansolverxd.cpp:17504

FvMbCartesianSolverXD::getAdjacentGridCells
MInt getAdjacentGridCells(MInt cellId, MInt *adjacentCells)
retrieves all direct and diagonal fluid cell neighbours of the given cell
Definition: fvmbcartesiansolverxd.cpp:11138

FvMbCartesianSolverXD::m_noBndryCandidates
MInt m_noBndryCandidates
Definition: fvmbcartesiansolverxd.h:654

FvMbCartesianSolverXD::m_distThresholdStat
static constexpr MFloat m_distThresholdStat[m_noMeanStatistics]
Definition: fvmbcartesiansolverxd.h:853

FvMbCartesianSolverXD::storeAzimuthalPeriodicData
void storeAzimuthalPeriodicData(MInt mode=0)
Stored azimuthal periodic data from halo rank on window rank.
Definition: fvmbcartesiansolverxd.cpp:36461

FvMbCartesianSolverXD::checkCellState
void checkCellState()
checks the cell state of the inactive cells based on the nodal ls values if a cell is inactive (level...
Definition: fvmbcartesiansolverxd.cpp:26061

FvMbCartesianSolverXD::m_slipDataParticleQuaternion
MFloat * m_slipDataParticleQuaternion
Definition: fvmbcartesiansolverxd.h:865

FvMbCartesianSolverXD::broadcastSignal
MInt broadcastSignal(const MInt sender, const MInt signal)
hijacked function to compute gradients in intial condition 122 for pressure poisson equation
Definition: fvmbcartesiansolverxd.cpp:21324

FvMbCartesianSolverXD::writeGeometryToVtkXmlFile
static MInt writeGeometryToVtkXmlFile(const MString &fileName)

FvMbCartesianSolverXD::m_movingBndryCndId
MInt m_movingBndryCndId
Definition: fvmbcartesiansolverxd.h:582

FvMbCartesianSolverXD::m_temporarilyLinkedCells
std::vector< std::tuple< MInt, MInt, MInt > > m_temporarilyLinkedCells
Definition: fvmbcartesiansolverxd.h:819

FvMbCartesianSolverXD::m_slipDataTimeSteps
std::vector< MFloat > m_slipDataTimeSteps
Definition: fvmbcartesiansolverxd.h:877

FvMbCartesianSolverXD::createCutFaceMb
MBool createCutFaceMb()

FvMbCartesianSolverXD::m_slipDataParticleVel
MFloat * m_slipDataParticleVel
Definition: fvmbcartesiansolverxd.h:866

FvMbCartesianSolverXD::m_particleAngularAcceleration
std::vector< MFloat > m_particleAngularAcceleration
Definition: fvmbcartesiansolverxd.h:763

FvMbCartesianSolverXD::logData
void logData()

FvMbCartesianSolverXD::matrixProduct
static void matrixProduct(MFloatScratchSpace &C, MFloatScratchSpace &A, MFloatScratchSpace &B)
C=A*B.
Definition: fvmbcartesiansolverxd.cpp:4152

FvMbCartesianSolverXD::m_FSIToleranceW
MFloat m_FSIToleranceW
Definition: fvmbcartesiansolverxd.h:595

FvMbCartesianSolverXD::writeGeometryToVtkXmlFile
MInt writeGeometryToVtkXmlFile(const MString &fileName)
Writes VTK file for the embedded geometry.
Definition: fvmbcartesiansolverxd.cpp:33694

FvMbCartesianSolverXD::loadRestartFile
void loadRestartFile() override
Loads the restart files.
Definition: fvmbcartesiansolverxd.cpp:24729

FvMbCartesianSolverXD::m_rhsViscous
MFloat ** m_rhsViscous
Definition: fvmbcartesiansolverxd.h:793

FvMbCartesianSolverXD::computeFlowStatistics
void computeFlowStatistics(MBool force)
Definition: fvmbcartesiansolverxd.cpp:21526

FvMbCartesianSolverXD::updateCellVolumeGCL
MFloat updateCellVolumeGCL(MInt bndryId)
Definition: fvmbcartesiansolverxd.cpp:10878

FvMbCartesianSolverXD::locatenear
static MInt locatenear(const Point< nDim > &, MFloat, MInt *, MInt, MBool returnCellId=true)
Definition: fvmbcartesiansolverxd.h:560

FvMbCartesianSolverXD::matrixProductTranspose
static void matrixProductTranspose(MFloatScratchSpace &C, MFloatScratchSpace &A, MFloatScratchSpace &B)
C=A*B^t.
Definition: fvmbcartesiansolverxd.cpp:4171

FvMbCartesianSolverXD::m_cutFacePointIds
MInt ** m_cutFacePointIds
Definition: fvmbcartesiansolverxd.h:804

FvMbCartesianSolverXD::m_trackMovingBndry
MBool m_trackMovingBndry
Definition: fvmbcartesiansolverxd.h:579

FvMbCartesianSolverXD::m_bodyDataAverage2
MFloat * m_bodyDataAverage2
Definition: fvmbcartesiansolverxd.h:735

FvMbCartesianSolverXD::m_azimuthalNearBoundaryBackupBalLong
MLong * m_azimuthalNearBoundaryBackupBalLong
Definition: fvmbcartesiansolverxd.h:833

FvMbCartesianSolverXD::m_nearBoundaryBackup
std::map< MInt, std::vector< MFloat > > m_nearBoundaryBackup
Definition: fvmbcartesiansolverxd.h:818

FvMbCartesianSolverXD::m_cellCoordinates
MFloat * m_cellCoordinates
Definition: fvmbcartesiansolverxd.h:844

FvMbCartesianSolverXD::m_printHeaderSlip
MBool m_printHeaderSlip
Definition: fvmbcartesiansolverxd.h:856

FvMbCartesianSolverXD::m_printHeaderCorr
MBool m_printHeaderCorr
Definition: fvmbcartesiansolverxd.h:855

FvMbCartesianSolverXD::transferLevelSetFieldValues
void transferLevelSetFieldValues(MBool)

FvMbCartesianSolverXD::initAzimuthalLinkedHaloExc
void initAzimuthalLinkedHaloExc()
Create exchange for all window/halo cells which are used for the azimuthal periodic interpolation.
Definition: fvmbcartesiansolverxd.cpp:36805

FvMbCartesianSolverXD::m_saveSlipInterval
MInt m_saveSlipInterval
Definition: fvmbcartesiansolverxd.h:861

FvMbCartesianSolverXD::m_sampleCoordinates
MFloat * m_sampleCoordinates
Definition: fvmbcartesiansolverxd.h:806

FvMbCartesianSolverXD::m_linkedWindowCells
std::vector< MInt > * m_linkedWindowCells
Definition: fvmbcartesiansolverxd.h:794

FvMbCartesianSolverXD::m_bodyDataAverage
MFloat * m_bodyDataAverage
Definition: fvmbcartesiansolverxd.h:734

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void distributeFluxToCells() override

FvMbCartesianSolverXD::m_killSwitchCheckInterval
MInt m_killSwitchCheckInterval
Definition: fvmbcartesiansolverxd.h:598

FvMbCartesianSolverXD::computeRotationMatrix
static void computeRotationMatrix(MFloatScratchSpace &, MFloat *q)
rotation matrix co-rotating(~inertial) frame -> body-fixed frame
Definition: fvmbcartesiansolverxd.cpp:4133

FvMbCartesianSolverXD::s_cellDataTypeDlb
static const std::array< MInt, CellDataDlb::count > s_cellDataTypeDlb
Definition: fvmbcartesiansolverxd.h:1786

FvMbCartesianSolverXD::m_noSlipDataOutputs
MInt m_noSlipDataOutputs
Definition: fvmbcartesiansolverxd.h:862

FvMbCartesianSolverXD::m_bodyToSetTable
MInt * m_bodyToSetTable
Definition: fvmbcartesiansolverxd.h:672

FvMbCartesianSolverXD::createBodyTree
void createBodyTree()
Definition: fvmbcartesiansolverxd.cpp:7878

FvMbCartesianSolverXD::m_oldVars
MFloat * m_oldVars
Definition: fvmbcartesiansolverxd.h:848

FvMbCartesianSolverXD::m_noSlopes
const MInt m_noSlopes
Definition: fvmbcartesiansolverxd.h:681

FvMbCartesianSolverXD::computeSlipStatistics
void computeSlipStatistics(const MIntScratchSpace &nearestBodies, const MFloatScratchSpace &nearestDist, const MFloat maxDistConstructed)
Definition: fvmbcartesiansolverxd.cpp:26450

FvMbCartesianSolverXD::exchangeLevelSetData
void exchangeLevelSetData()
Definition: fvmbcartesiansolverxd.cpp:12059

FvMbCartesianSolverXD::gapCellExchange
void gapCellExchange(MInt)
exchanges variables and wasInactive for gapCells
Definition: fvmbcartesiansolverxd.cpp:29786

FvMbCartesianSolverXD::m_azimuthalLinkedWindowCells
std::vector< std::vector< MInt > > m_azimuthalLinkedWindowCells
Definition: fvmbcartesiansolverxd.h:829

FvMbCartesianSolverXD::setBoundaryVelocity
void setBoundaryVelocity()
Sets the boundry velocity at the moving cut-cells. sets: m_primVars[PV->VV[i]] to m_bodyVelocity[i] f...
Definition: fvmbcartesiansolverxd.cpp:17884

FvMbCartesianSolverXD::buildAdditionalAzimuthalReconstructionStencil
void buildAdditionalAzimuthalReconstructionStencil(MInt mode=0)
Rebuild azimuthal reconstruction constants for moving boundary cells.
Definition: fvmbcartesiansolverxd.cpp:36248

FvMbCartesianSolverXD::integrateBodyRotation
void integrateBodyRotation()
Definition: fvmbcartesiansolverxd.cpp:4240

FvMbCartesianSolverXD::m_refOldBndryCells
std::vector< MInt > m_refOldBndryCells
Definition: fvmbcartesiansolverxd.h:825

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void computeSurfaceValues(MInt timerId

FvMbCartesianSolverXD::m_boundaryDensityDt1
MFloat * m_boundaryDensityDt1
Definition: fvmbcartesiansolverxd.h:800

FvMbCartesianSolverXD::computeBodySurfaceData
void computeBodySurfaceData(MFloat *pressureForce=nullptr)
computes relevant variables at the moving boundary surface and determines the resulting body force
Definition: fvmbcartesiansolverxd.cpp:12983

FvMbCartesianSolverXD::finalizeAdaptation
void finalizeAdaptation() override
Definition: fvmbcartesiansolverxd.cpp:15542

FvMbCartesianSolverXD::recordBodyData
void recordBodyData(const MBool &firstRun)
Definition: fvmbcartesiansolverxd.cpp:21463

FvMbCartesianSolverXD::saveRestartFile
void saveRestartFile(const MBool) override
Saves the restart file.
Definition: fvmbcartesiansolverxd.cpp:24711

FvMbCartesianSolverXD::m_cellVolumesDt1
MFloat * m_cellVolumesDt1
Definition: fvmbcartesiansolverxd.h:797

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void computeSurfaceValuesLimited(MInt timerId

FvMbCartesianSolverXD::finalizeInitSolver
void finalizeInitSolver() override
Initializes the solver afer the initialRefinement!
Definition: fvmbcartesiansolverxd.cpp:11910

FvMbCartesianSolverXD::m_particleCoords
std::vector< MFloat > m_particleCoords
Definition: fvmbcartesiansolverxd.h:746

FvMbCartesianSolverXD::m_lsCutCellMinLevel
MInt m_lsCutCellMinLevel
Definition: fvmbcartesiansolverxd.h:626

FvMbCartesianSolverXD::m_slipDataParticleFluidVelRotRnd
MFloat * m_slipDataParticleFluidVelRotRnd
Definition: fvmbcartesiansolverxd.h:875

FvMbCartesianSolverXD::m_noMeanStatistics
static constexpr MInt m_noMeanStatistics
Definition: fvmbcartesiansolverxd.h:852

FvMbCartesianSolverXD::updateInfinityVariables
void updateInfinityVariables()
update infinity state for certain testcases with constructed level-set field!
Definition: fvmbcartesiansolverxd.cpp:14236

FvMbCartesianSolverXD::m_noGCells
MInt m_noGCells
Definition: fvmbcartesiansolverxd.h:645

FvMbCartesianSolverXD::writeVtkDebug
void writeVtkDebug(const MString suffix)
Definition: fvmbcartesiansolverxd.cpp:15829

FvMbCartesianSolverXD::getConservativeVarName
MString getConservativeVarName(MInt i)
returns the name of the conservative variable at the given index i
Definition: fvmbcartesiansolverxd.cpp:12686

FvMbCartesianSolverXD::filterFloat
MFloat filterFloat(MFloat number)
filter nan's
Definition: fvmbcartesiansolverxd.cpp:19365

FvMbCartesianSolverXD::m_bodyReducedMass
MFloat * m_bodyReducedMass
Definition: fvmbcartesiansolverxd.h:784

FvMbCartesianSolverXD::applyExternalOldSource
void applyExternalOldSource() override
remove external sources from tho old RHS for new-RungeKutta-scheme for moving boundaries
Definition: fvmbcartesiansolverxd.cpp:14208

FvMbCartesianSolverXD::m_bodyEquation
MInt * m_bodyEquation
Definition: fvmbcartesiansolverxd.h:731

FvMbCartesianSolverXD::m_bodyQuaternion
MFloat * m_bodyQuaternion
Definition: fvmbcartesiansolverxd.h:708

FvMbCartesianSolverXD::m_noFloatDataAdaptation
MInt m_noFloatDataAdaptation
Definition: fvmbcartesiansolverxd.h:835

FvMbCartesianSolverXD::m_slipDataParticleFluidVelGradRnd
MFloat * m_slipDataParticleFluidVelGradRnd
Definition: fvmbcartesiansolverxd.h:874

FvMbCartesianSolverXD::generateBndryCells
virtual void generateBndryCells()
Definition: fvmbcartesiansolverxd.cpp:20941

FvMbCartesianSolverXD::resetRHSCutOffCells
void resetRHSCutOffCells() override
Definition: fvmbcartesiansolverxd.cpp:19112

FvMbCartesianSolverXD::m_particleCoordsDt1
std::vector< MFloat > m_particleCoordsDt1
Definition: fvmbcartesiansolverxd.h:747

FvMbCartesianSolverXD::m_azimuthalNearBoundaryBackupBalFloat
MFloat * m_azimuthalNearBoundaryBackupBalFloat
Definition: fvmbcartesiansolverxd.h:832

FvMbCartesianSolverXD::advancePointParticles
void advancePointParticles()
Definition: fvmbcartesiansolverxd.cpp:7416

FvMbCartesianSolverXD::initSolutionStep
void initSolutionStep(MInt mode) override
Initializes the solver.
Definition: fvmbcartesiansolverxd.cpp:30548

FvMbCartesianSolverXD::getDistanceSplitSphere
MFloat getDistanceSplitSphere(const MInt, const MInt)
determines the level-set value for the given cell provided that the embedded body is spherical

FvMbCartesianSolverXD::correctRefinedBndryCell
void correctRefinedBndryCell()
correct old-BndryCells which are no-longer leaf-Cells after the adaptation NOTE: mas-conservative upd...
Definition: fvmbcartesiansolverxd.cpp:34785

FvMbCartesianSolverXD::updateViscousFluxComputation
void updateViscousFluxComputation()
corrects the cell-surface distances at the boundary needed for the viscous flux computation
Definition: fvmbcartesiansolverxd.cpp:18219

FvMbCartesianSolverXD::updateAzimuthalNearBoundaryExchange
void updateAzimuthalNearBoundaryExchange()
Reset former azimuthal nearBoundaryCells.
Definition: fvmbcartesiansolverxd.cpp:36300

FvMbCartesianSolverXD::Muscl
void Muscl(MInt timerId=-1) override
Reconstructs the flux on the surfaces.
Definition: fvmbcartesiansolverxd.cpp:2207

FvMbCartesianSolverXD::setupBoundaryCandidatesAnalytical
void setupBoundaryCandidatesAnalytical()
determine all possible fluid boundary cells for a spherical embedded body
Definition: fvmbcartesiansolverxd.cpp:5582

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) MBool rungeKuttaStepNew()

FvMbCartesianSolverXD::m_bodyAccelerationDt1
MFloat * m_bodyAccelerationDt1
Definition: fvmbcartesiansolverxd.h:712

FvMbCartesianSolverXD::swapCells
void swapCells(const MInt, const MInt) override
Definition: fvmbcartesiansolverxd.cpp:16838

FvMbCartesianSolverXD::m_reconstructionOffset
MInt m_reconstructionOffset
Definition: fvmbcartesiansolverxd.h:657

FvMbCartesianSolverXD::m_projectedArea
MFloat * m_projectedArea
Definition: fvmbcartesiansolverxd.h:699

FvMbCartesianSolverXD::getFacingNghbrs
MInt getFacingNghbrs(const MInt cellId, const MBool includeAllChilds)
determines the neighbors sharing a face with the given cell
Definition: fvmbcartesiansolverxd.cpp:16686

FvMbCartesianSolverXD::saveParticleSamples
void saveParticleSamples()
Definition: fvmbcartesiansolverxd.cpp:25892

FvMbCartesianSolverXD::updateGhostCellSlopesViscous
void updateGhostCellSlopesViscous()
Definition: fvmbcartesiansolverxd.cpp:18190

FvMbCartesianSolverXD::setCellDataDlb
void setCellDataDlb(const MInt dataId, const MFloat *const data) override
Set solver data for DLB.
Definition: fvmbcartesiansolverxd.h:1981

FvMbCartesianSolverXD::redistributeMass
void redistributeMass()
Definition: fvmbcartesiansolverxd.cpp:10110

FvMbCartesianSolverXD::computeGhostCellsMb
void computeGhostCellsMb()
creates a ghost cell for all cells near(!) the moving boundary
Definition: fvmbcartesiansolverxd.cpp:19602

FvMbCartesianSolverXD::saveSolverSolution
void saveSolverSolution(const MBool forceOutput=false, const MBool finalTimeStep=false) override
Manages solver-specific output.
Definition: fvmbcartesiansolverxd.cpp:21341

FvMbCartesianSolverXD::m_azimuthalNearBoundaryBackup
std::multimap< MLong, std::pair< std::vector< MFloat >, std::vector< MUlong > > > m_azimuthalNearBoundaryBackup
Definition: fvmbcartesiansolverxd.h:830

FvMbCartesianSolverXD::initSolver
void initSolver() override
Initializes the solution.
Definition: fvmbcartesiansolverxd.cpp:11834

FvMbCartesianSolverXD::getBodyRotationDt1
void getBodyRotationDt1(const MInt bodyId, MFloat *bodyRotation)
Definition: fvmbcartesiansolverxd.cpp:4468

FvMbCartesianSolverXD::setSensors
void setSensors(std::vector< std::vector< MFloat > > &sensors, std::vector< MFloat > &sensorWeight, std::vector< std::bitset< 64 > > &sensorCellFlag, std::vector< MInt > &sensorSolverId) override
Definition: fvmbcartesiansolverxd.cpp:15476

FvMbCartesianSolverXD::loadInitCorrData
MInt loadInitCorrData(const std::vector< MInt > &saveInitCorrDataTimeSteps, MFloatScratchSpace &bodyVelocityInit, MFloatScratchSpace &bodyAngularVelocityInit, MFloatScratchSpace &bodyQuaternionInit, MFloatScratchSpace &velMeanInit, MFloatScratchSpace &velGradMeanInit, MFloatScratchSpace &particleFluidRotationMeanInit, MIntScratchSpace &corrBodies, MFloatScratchSpace &bodyForceInit, MFloatScratchSpace &bodyTorqueInit, const MIntScratchSpace &bodyOffsets)

FvMbCartesianSolverXD::inverseGJ
MInt inverseGJ()
computes the Gauss Jordan matrix inversion of the first DxD-solver of m_A. The inverse A^-1 is stored...
Definition: fvmbcartesiansolverxd.cpp:11983

FvMbCartesianSolverXD::m_bndryCandidateIds
std::vector< MInt > m_bndryCandidateIds
Definition: fvmbcartesiansolverxd.h:776

FvMbCartesianSolverXD::m_particleAccelerationDt1
std::vector< MFloat > m_particleAccelerationDt1
Definition: fvmbcartesiansolverxd.h:757

FvMbCartesianSolverXD::m_noLongDataBalance
MInt m_noLongDataBalance
Definition: fvmbcartesiansolverxd.h:837

FvMbCartesianSolverXD::linkBndryCells
void linkBndryCells()
Links bndryCells.
Definition: fvmbcartesiansolverxd.cpp:29038

FvMbCartesianSolverXD::correctSrfcsMb
void correctSrfcsMb()
correct surfaces intersected by the moving boundary
Definition: fvmbcartesiansolverxd.cpp:31206

FvMbCartesianSolverXD::correctMasterSlaveSurfaces
void correctMasterSlaveSurfaces()
Removes surfaces between master-slave pairs and reassigns slave cell surfaces required in order to ma...
Definition: fvmbcartesiansolverxd.cpp:26022

FvMbCartesianSolverXD::m_bodyReducedVelocity
MFloat * m_bodyReducedVelocity
Definition: fvmbcartesiansolverxd.h:783

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) MBool rungeKuttaStepStandard()

FvMbCartesianSolverXD::m_bodyWasActuallyInCollision
std::set< MInt > m_bodyWasActuallyInCollision
Definition: fvmbcartesiansolverxd.h:771

FvMbCartesianSolverXD::m_bodyDampingCoefficient
MFloat * m_bodyDampingCoefficient
Definition: fvmbcartesiansolverxd.h:786

FvMbCartesianSolverXD::setParticleFluidVelocities
void setParticleFluidVelocities(MFloat *=nullptr)
Definition: fvmbcartesiansolverxd.cpp:7744

FvMbCartesianSolverXD::restoreNeighbourLinks
void restoreNeighbourLinks()
restores previously deleted neighbour information and reactivates cells
Definition: fvmbcartesiansolverxd.cpp:20237

FvMbCartesianSolverXD::applyDirichletCondition
void applyDirichletCondition()
Definition: fvmbcartesiansolverxd.cpp:17842

FvMbCartesianSolverXD::saveBodyRestartFile
void saveBodyRestartFile(const MBool backup)
save restart body file
Definition: fvmbcartesiansolverxd.cpp:24753

FvMbCartesianSolverXD::m_noLsMbBndryCells
MInt m_noLsMbBndryCells
Definition: fvmbcartesiansolverxd.h:651

FvMbCartesianSolverXD::m_bodyDataCollision
MBool * m_bodyDataCollision
Definition: fvmbcartesiansolverxd.h:738

FvMbCartesianSolverXD::initBodyVelocities
void initBodyVelocities()

FvMbCartesianSolverXD::m_slipDataParticleFluidVelGrad
MFloat * m_slipDataParticleFluidVelGrad
Definition: fvmbcartesiansolverxd.h:871

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void viscousFlux() override

FvMbCartesianSolverXD::m_sampleNghbrOffsets
MInt * m_sampleNghbrOffsets
Definition: fvmbcartesiansolverxd.h:665

FvMbCartesianSolverXD::m_outsideFactor
MFloat m_outsideFactor
Definition: fvmbcartesiansolverxd.h:597

FvMbCartesianSolverXD::updateGhostCellSlopesInviscid
void updateGhostCellSlopesInviscid()
Definition: fvmbcartesiansolverxd.cpp:18180

FvMbCartesianSolverXD::setAdditionalActiveFlag
void setAdditionalActiveFlag(MIntScratchSpace &) override
Definition: fvmbcartesiansolverxd.cpp:10673

FvMbCartesianSolverXD::computeBodyMomentOfInertia
void computeBodyMomentOfInertia()
Definition: fvmbcartesiansolverxd.cpp:8761

FvMbCartesianSolverXD::generateBndryCellsMb
void generateBndryCellsMb(const MInt mode)
call all routines necessary for the generation of boundary cells mode = -1: default argument,...

FvMbCartesianSolverXD::m_static_initSolutionStep_frstrn
MBool m_static_initSolutionStep_frstrn
Definition: fvmbcartesiansolverxd.h:1779

FvMbCartesianSolverXD::m_freeSurfaceIndices
std::set< MInt > m_freeSurfaceIndices
Definition: fvmbcartesiansolverxd.h:815

FvMbCartesianSolverXD::m_bodyReducedFrequency
MFloat * m_bodyReducedFrequency
Definition: fvmbcartesiansolverxd.h:785

FvMbCartesianSolverXD::m_azimuthalCornerEps
const MFloat m_azimuthalCornerEps
Definition: fvmbcartesiansolverxd.h:838

FvMbCartesianSolverXD::computeAzimuthalReconstructionConstants
void computeAzimuthalReconstructionConstants(MInt mode=0) override
Compute the reconstruction constants for azimuthal periodic exchange using a weighted least squares a...
Definition: fvmbcartesiansolverxd.cpp:36411

FvMbCartesianSolverXD::m_physicalTimeDt1
MFloat m_physicalTimeDt1
Definition: fvmbcartesiansolverxd.h:610

FvMbCartesianSolverXD::preSolutionStep
void preSolutionStep(const MInt=-1) override
step before the solver solution Step
Definition: fvmbcartesiansolverxd.cpp:26991

FvMbCartesianSolverXD::m_gapHaloCells
std::vector< MInt > * m_gapHaloCells
Definition: fvmbcartesiansolverxd.h:636

FvMbCartesianSolverXD::m_generateOuterBndryCells
MBool m_generateOuterBndryCells
Definition: fvmbcartesiansolverxd.h:617

FvMbCartesianSolverXD::transferBodyState
void transferBodyState(MInt k, MInt b)
Definition: fvmbcartesiansolverxd.cpp:8074

FvMbCartesianSolverXD::m_noPointParticles
MInt m_noPointParticles
Definition: fvmbcartesiansolverxd.h:662

FvMbCartesianSolverXD::adaptationTrigger
MBool adaptationTrigger() override
Definition: fvmbcartesiansolverxd.cpp:15387

FvMbCartesianSolverXD::checkNormalVectors
void checkNormalVectors()
Definition: fvmbcartesiansolverxd.cpp:31638

FvMbCartesianSolverXD::m_volumeFraction
MFloat * m_volumeFraction
Definition: fvmbcartesiansolverxd.h:788

FvMbCartesianSolverXD::sgn
static MFloat sgn(MFloat val)
Definition: fvmbcartesiansolverxd.h:1261

FvMbCartesianSolverXD::m_saveSlipData
MBool m_saveSlipData
Definition: fvmbcartesiansolverxd.h:859

FvMbCartesianSolverXD::commAzimuthalPeriodicData
void commAzimuthalPeriodicData(MInt mode=0)
Send stored azimuthal periodic data from window to halo.
Definition: fvmbcartesiansolverxd.cpp:36604

FvMbCartesianSolverXD::m_vars
MFloat * m_vars
Definition: fvmbcartesiansolverxd.h:847

FvMbCartesianSolverXD::removeSurfaces
void removeSurfaces(MInt cellId)
removes the surfaces of the given cell
Definition: fvmbcartesiansolverxd.cpp:16806

FvMbCartesianSolverXD::m_tCutGroup
MInt m_tCutGroup
Definition: fvmbcartesiansolverxd.h:575

FvMbCartesianSolverXD::applyALECorrection
void applyALECorrection()
Definition: fvmbcartesiansolverxd.cpp:13974

FvMbCartesianSolverXD::m_particleAngularVelocityDt1
std::vector< MFloat > m_particleAngularVelocityDt1
Definition: fvmbcartesiansolverxd.h:761

FvMbCartesianSolverXD::m_bodyCenterDt1
MFloat * m_bodyCenterDt1
Definition: fvmbcartesiansolverxd.h:724

FvMbCartesianSolverXD::g_mpiRequestMb
MPI_Request * g_mpiRequestMb
Definition: fvmbcartesiansolverxd.h:812

FvMbCartesianSolverXD::resetRHSNonInternalCells
void resetRHSNonInternalCells() override
Definition: fvmbcartesiansolverxd.cpp:5128

FvMbCartesianSolverXD::m_bodyTorque
MFloat * m_bodyTorque
Definition: fvmbcartesiansolverxd.h:717

FvMbCartesianSolverXD::m_cutCandidates
std::vector< CutCandidate< nDim > > m_cutCandidates
Definition: fvmbcartesiansolverxd.h:775

FvMbCartesianSolverXD::m_forceNoGaps
MInt m_forceNoGaps
Definition: fvmbcartesiansolverxd.h:883

FvMbCartesianSolverXD::initializeMb
void initializeMb()
called by the constructor 1) read additional fvmb properties 2) allocate fvmb specific memory 3) init...

FvMbCartesianSolverXD::m_slipDataParticleFluidVel
MFloat * m_slipDataParticleFluidVel
Definition: fvmbcartesiansolverxd.h:870

FvMbCartesianSolverXD::m_U2
MFloat m_U2
Definition: fvmbcartesiansolverxd.h:684

FvMbCartesianSolverXD::updateMultiSolverInformation
void updateMultiSolverInformation(MBool fullReset=false) override
Definition: fvmbcartesiansolverxd.cpp:11806

FvMbCartesianSolverXD::m_cellSlopes
MFloat * m_cellSlopes
Definition: fvmbcartesiansolverxd.h:846

FvMbCartesianSolverXD::m_noEmergedWindowCells
MInt m_noEmergedWindowCells
Definition: fvmbcartesiansolverxd.h:653

FvMbCartesianSolverXD::m_maxLevelDecrease
MBool m_maxLevelDecrease
Definition: fvmbcartesiansolverxd.h:601

FvMbCartesianSolverXD::m_dynamicStencil
MBool m_dynamicStencil
Definition: fvmbcartesiansolverxd.h:629

FvMbCartesianSolverXD::buildAdditionalReconstructionStencil
void buildAdditionalReconstructionStencil()
correct reconstruction stencil for all cells near moving boundaries
Definition: fvmbcartesiansolverxd.cpp:11641

FvMbCartesianSolverXD::m_gapState
MInt * m_gapState
Definition: fvmbcartesiansolverxd.h:640

FvMbCartesianSolverXD::m_bodyTorqueDt1
MFloat * m_bodyTorqueDt1
Definition: fvmbcartesiansolverxd.h:718

FvMbCartesianSolverXD::getDistance
MFloat getDistance(const MFloat *const, const MInt)
Definition: fvmbcartesiansolverxd.cpp:2716

FvMbCartesianSolverXD::m_standardRK
MBool m_standardRK
Definition: fvmbcartesiansolverxd.h:623

FvMbCartesianSolverXD::allocateBodyMemory
void allocateBodyMemory(MInt mode=0)
Definition: fvmbcartesiansolverxd.cpp:1186

FvMbCartesianSolverXD::exchangeAzimuthalOuterNodalValues
void exchangeAzimuthalOuterNodalValues(std::vector< CutCandidate< nDim > > &candidates, std::vector< MInt > &candidateIds)
Exchange of nodal values of azimuthal periodic halo cells.
Definition: fvmbcartesiansolverxd.cpp:5912

FvMbCartesianSolverXD::m_timeStepAdaptationEnd
MInt m_timeStepAdaptationEnd
Definition: fvmbcartesiansolverxd.h:612

FvMbCartesianSolverXD::m_noBndryCells
MInt m_noBndryCells
Definition: fvmbcartesiansolverxd.h:647

FvMbCartesianSolverXD::m_FSIStart
MInt m_FSIStart
Definition: fvmbcartesiansolverxd.h:590

FvMbCartesianSolverXD::correctCoarsenedBndryCellVolume
void correctCoarsenedBndryCellVolume()
correct BndryCells volume of bndryCells which were a bndryCell on a coarser level before
Definition: fvmbcartesiansolverxd.cpp:34932

FvMbCartesianSolverXD::m_slope
MFloat * m_slope
Definition: fvmbcartesiansolverxd.h:841

FvMbCartesianSolverXD::cellDataTypeDlb
MInt cellDataTypeDlb(const MInt dataId) const override
Definition: fvmbcartesiansolverxd.h:1019

FvMbCartesianSolverXD::saveInitCorrData
void saveInitCorrData(const std::vector< MInt > &saveInitCorrDataTimeSteps, const MFloatScratchSpace &bodyVelocityInit, const MFloatScratchSpace &bodyAngularVelocityInit, const MFloatScratchSpace &bodyQuaternionInit, const MFloatScratchSpace &velMeanInit, const MFloatScratchSpace &velGradMeanInit, const MFloatScratchSpace &particleFluidRotationMeanInit, const MIntScratchSpace &corrBodies, const MFloatScratchSpace &bodyForceInit, const MFloatScratchSpace &bodyTorqueInit, const MIntScratchSpace &bodyOffsets)

FvMbCartesianSolverXD::m_gapCellExchangeInit
MBool m_gapCellExchangeInit
Definition: fvmbcartesiansolverxd.h:637

FvMbCartesianSolverXD::deleteNeighbourLinks
void deleteNeighbourLinks()
deletes links to neighbours tagged inactive
Definition: fvmbcartesiansolverxd.cpp:20210

FvMbCartesianSolverXD::updateSpongeLayer
void updateSpongeLayer() override
computes the additional rhs of all cells lying inside the sponge layer to dissipate outgoing waves.

FvMbCartesianSolverXD::m_geometryChange
MBool * m_geometryChange
Definition: fvmbcartesiansolverxd.h:632

FvMbCartesianSolverXD::m_pointParticleTwoWayCoupling
MInt m_pointParticleTwoWayCoupling
Definition: fvmbcartesiansolverxd.h:743

FvMbCartesianSolverXD::initBndryLayer
void initBndryLayer()
initializes the bndryLayer data and is/was inactive at solver initialisation
Definition: fvmbcartesiansolverxd.cpp:1555

FvMbCartesianSolverXD::m_geometryIntersection
GeometryIntersection< nDim > * m_geometryIntersection
Definition: fvmbcartesiansolverxd.h:1256

FvMbCartesianSolverXD::m_sendBufferSize
MInt * m_sendBufferSize
Definition: fvmbcartesiansolverxd.h:813

FvMbCartesianSolverXD::hasSplitBalancing
MBool hasSplitBalancing() const override
Return if load balancing for solver is split into multiple methods or implemented in balance()
Definition: fvmbcartesiansolverxd.h:1009

FvMbCartesianSolverXD::createCutFaceMb_MGC
void createCutFaceMb_MGC()
determines the geometric cut-cell data
Definition: fvmbcartesiansolverxd.cpp:34048

FvMbCartesianSolverXD::getAdjacentCellsAllLevels
MInt getAdjacentCellsAllLevels(MInt cellId, MInt *adjacentCells)
retrieves all direct and diagonal fluid cell neighbours of the given cell
Definition: fvmbcartesiansolverxd.cpp:11333

FvMbCartesianSolverXD::moveSurface
void moveSurface(const MInt toSrfcId, const MInt fromSrfcId)
Definition: fvmbcartesiansolverxd.cpp:16369

FvMbCartesianSolverXD::createPeriodicGhostBodies
void createPeriodicGhostBodies()
Definition: fvmbcartesiansolverxd.cpp:7976

FvMbCartesianSolverXD::m_particleHeatFlux
std::vector< MFloat > m_particleHeatFlux
Definition: fvmbcartesiansolverxd.h:752

FvMbCartesianSolverXD::m_sampleNghbrs
MInt * m_sampleNghbrs
Definition: fvmbcartesiansolverxd.h:664

FvMbCartesianSolverXD::m_pointParticleType
MInt m_pointParticleType
Definition: fvmbcartesiansolverxd.h:744

FvMbCartesianSolverXD::updateBodyProperties
void updateBodyProperties()
update properties of the embedded body (mainly forced structural motion)

FvMbCartesianSolverXD::initializeRungeKutta
void initializeRungeKutta() override
This function loads all terms used by Runge Kutta.
Definition: fvmbcartesiansolverxd.cpp:13753

FvMbCartesianSolverXD::getCellDataDlb
void getCellDataDlb(const MInt dataId, const MInt oldNoCells, const MInt *const bufferIdToCellId, MFloat *const data) override
Return solver data for DLB.
Definition: fvmbcartesiansolverxd.h:1882

FvMbCartesianSolverXD::m_particleTemperature
std::vector< MFloat > m_particleTemperature
Definition: fvmbcartesiansolverxd.h:750

FvMbCartesianSolverXD::m_trackMbStart
MInt m_trackMbStart
Definition: fvmbcartesiansolverxd.h:589

FvMbCartesianSolverXD::m_maxBndryLayerLevel
MInt m_maxBndryLayerLevel
Definition: fvmbcartesiansolverxd.h:587

FvMbCartesianSolverXD::writeListOfActiveFlowCells
void writeListOfActiveFlowCells() override
stores all cells and surfaces needed for the flux computation
Definition: fvmbcartesiansolverxd.cpp:1446

FvMbCartesianSolverXD::writeVTKFileOfCell
void writeVTKFileOfCell(MInt, const std::vector< polyEdge2D > *, const std::vector< polyVertex > *, MInt)
Definition: fvmbcartesiansolverxd.cpp:33733

FvMbCartesianSolverXD::m_static_createCutFaceMb_MGC_first
MBool m_static_createCutFaceMb_MGC_first
Definition: fvmbcartesiansolverxd.h:1782

FvMbCartesianSolverXD::computeNearBodyFluidVelocity
void computeNearBodyFluidVelocity(const MIntScratchSpace &nearestBodies, const MFloatScratchSpace &nearestDist, MFloat *vel, MFloat *velGrad, MFloat *rotation, const std::vector< MFloat > &setup=std::vector< MFloat >(), MInt *skipBodies=nullptr, MFloat *meanBodyState=nullptr, MFloat *pressure=nullptr, MFloat *velDt=nullptr, MFloat *rotationDt=nullptr, MFloat *nearestFac=nullptr)
Mean parameters: near body data estimated by weighted filtering procedure All parameters after "setup...
Definition: fvmbcartesiansolverxd.cpp:23327

FvMbCartesianSolverXD::m_bodyNeutralCenter
MFloat * m_bodyNeutralCenter
Definition: fvmbcartesiansolverxd.h:730

FvMbCartesianSolverXD::setGapCellId
void setGapCellId()
set the gapCellId for gapInitMethod = 0, otherwise handeled in gapHandling!
Definition: fvmbcartesiansolverxd.cpp:28598

FvMbCartesianSolverXD::temperature
MFloat temperature(MInt cellId)
temperature
Definition: fvmbcartesiansolverxd.cpp:14345

FvMbCartesianSolverXD::m_bodyRadii
MFloat * m_bodyRadii
Definition: fvmbcartesiansolverxd.h:695

FvMbCartesianSolverXD::locatenear
MInt locatenear(const Point< nDim > &pt, MFloat r, MInt *list, MInt nmax, MBool returnCellId=true)
Definition: fvmbcartesiansolverxd.h:567

FvMbCartesianSolverXD::m_noNearBndryCells
MInt m_noNearBndryCells
Definition: fvmbcartesiansolverxd.h:656

FvMbCartesianSolverXD::m_noPVars
const MInt m_noPVars
Definition: fvmbcartesiansolverxd.h:680

FvMbCartesianSolverXD::cellDataSizeDlb
MInt cellDataSizeDlb(const MInt dataId, const MInt gridCellId) override
Return data size to be communicated during DLB for a grid cell and given data id.
Definition: fvmbcartesiansolverxd.h:1815

FvMbCartesianSolverXD::m_bodyVelocityDt2
MFloat * m_bodyVelocityDt2
Definition: fvmbcartesiansolverxd.h:716

FvMbCartesianSolverXD::initializeMaxLevelExchange
void initializeMaxLevelExchange() override
update window/halo cell collectors
Definition: fvmbcartesiansolverxd.cpp:16055

FvMbCartesianSolverXD::m_fvBndryCnd
FvBndryCndXD< nDim, SysEqn > * m_fvBndryCnd
Definition: fvmbcartesiansolverxd.h:1257

FvMbCartesianSolverXD::compVolumeIntegrals
void compVolumeIntegrals(std::vector< polyCutCell > *, std::vector< polyEdge2D > *, const std::vector< polyVertex > *)
Definition: fvmbcartesiansolverxd.cpp:31619

FvMbCartesianSolverXD::getBodyRotation
void getBodyRotation(const MInt bodyId, MFloat *bodyRotation)
Definition: fvmbcartesiansolverxd.cpp:4448

FvMbCartesianSolverXD::writeVtkXmlFiles
void writeVtkXmlFiles(const MString fileName, const MString GFileName, MBool regularOutput, MBool diverged) override
write flow variables as XML VTK files
Definition: fvmbcartesiansolverxd.cpp:23743

FvMbCartesianSolverXD::resetSolver
void resetSolver() override
Reset the solver prior to load balancing.
Definition: fvmbcartesiansolverxd.cpp:20060

FvMbCartesianSolverXD::m_stableVolumeFraction
MFloat m_stableVolumeFraction
Definition: fvmbcartesiansolverxd.h:789

FvMbCartesianSolverXD::writeVtkXmlOutput
void writeVtkXmlOutput(const MString &fileName, MBool debugOutput=false)
write flow variables as XML VTK
Definition: fvmbcartesiansolverxd.cpp:32665

FvMbCartesianSolverXD::determineNearBndryCells
void determineNearBndryCells()
determines cells at the boundary (i.e. boundary cells and their direct neighbors)
Definition: fvmbcartesiansolverxd.cpp:13670

FvMbCartesianSolverXD::m_bodyDistThreshold
MFloat m_bodyDistThreshold
Definition: fvmbcartesiansolverxd.h:686

FvMbCartesianSolverXD::rungeKuttaStep
MBool rungeKuttaStep() override
calls a Runge Kutta substep
Definition: fvmbcartesiansolverxd.cpp:19122

FvMbCartesianSolverXD::m_azimuthalBndryCandidates
std::vector< MInt > m_azimuthalBndryCandidates
Definition: fvmbcartesiansolverxd.h:778

FvMbCartesianSolverXD::updateCellSurfaceDistanceVectors
void updateCellSurfaceDistanceVectors()
correct the cell-surface distance vectors for cells near the moving boundary
Definition: fvmbcartesiansolverxd.cpp:21128

FvMbCartesianSolverXD::FD
static constexpr MFloat FD
Definition: fvmbcartesiansolverxd.h:676

FvMbCartesianSolverXD::balancePre
void balancePre() override
Reinitialize solver for DLB prior to setting solution data.
Definition: fvmbcartesiansolverxd.cpp:14353

FvMbCartesianSolverXD::m_slipDataParticlePosition
MFloat * m_slipDataParticlePosition
Definition: fvmbcartesiansolverxd.h:876

FvMbCartesianSolverXD::m_densityRatio
MFloat m_densityRatio
Definition: fvmbcartesiansolverxd.h:701

FvMbCartesianSolverXD::m_onlineRestart
MBool m_onlineRestart
Definition: fvmbcartesiansolverxd.h:609

FvMbCartesianSolverXD::readStlFile
void readStlFile(const MChar *fileName, MBool readNormals)
read specified STL file
Definition: fvmbcartesiansolverxd.cpp:24341

FvMbCartesianSolverXD::isNan
MBool isNan(T val)
Definition: fvmbcartesiansolverxd.cpp:13312

FvMbCartesianSolverXD::m_bodyRadius
MFloat * m_bodyRadius
Definition: fvmbcartesiansolverxd.h:692

FvMbCartesianSolverXD::m_FSIToleranceU
MFloat m_FSIToleranceU
Definition: fvmbcartesiansolverxd.h:593

FvMbCartesianSolverXD::balancePost
void balancePost() override
Reinitialize solver after setting solution data in DLB.
Definition: fvmbcartesiansolverxd.cpp:14394

FvMbCartesianSolverXD::computeBodyVolume
void computeBodyVolume(MFloatScratchSpace &partVol)
Definition: fvmbcartesiansolverxd.cpp:23285

FvMbCartesianSolverXD::loadBodyRestartFile
void loadBodyRestartFile(MInt)
load restart body file readMode = 0 : do not read the cellVolume from file (read only bodyData) readM...
Definition: fvmbcartesiansolverxd.cpp:25056

FvMbCartesianSolverXD::m_trackMbEnd
MInt m_trackMbEnd
Definition: fvmbcartesiansolverxd.h:591

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) MBool rungeKuttaStepNewLocalTimeStepping()

FvMbCartesianSolverXD::m_onlineRestartInterval
MInt m_onlineRestartInterval
Definition: fvmbcartesiansolverxd.h:586

FvMbCartesianSolverXD::adaptTimeStep
void adaptTimeStep()
computes the time step
Definition: fvmbcartesiansolverxd.cpp:8818

FvMbCartesianSolverXD::createSurfaceSplit
void createSurfaceSplit(MInt srfcId, MInt cellId, MInt splitChildId, MInt direction)
restores the surfaces of the given cell
Definition: fvmbcartesiansolverxd.cpp:16312

FvMbCartesianSolverXD::restoreSurfaces
void restoreSurfaces(const MInt cellId)
restores the surfaces of the given cell
Definition: fvmbcartesiansolverxd.cpp:16560

FvMbCartesianSolverXD::applyExternalSource
void applyExternalSource() override
Add external sources to the RHS for new-RungeKutta-scheme for moving boundaries differs from the base...
Definition: fvmbcartesiansolverxd.cpp:14162

FvMbCartesianSolverXD::checkBoundaryCells
void checkBoundaryCells()
performs an integrety check of the boundary cells
Definition: fvmbcartesiansolverxd.cpp:10689

FvMbCartesianSolverXD::test_face
MBool test_face(MInt, MInt, MInt)
Test a face (MarchingCubes helper routine) receives MAIA face if face>0 return true if the face conta...
Definition: fvmbcartesiansolverxd.cpp:31505

FvMbCartesianSolverXD::distancePointEllipseSpecial
static MFloat distancePointEllipseSpecial(const MFloat e[2], const MFloat y[2], MFloat x[2])
Definition: fvmbcartesiansolverxd.cpp:3989

FvMbCartesianSolverXD::getEqualLevelNeighbors
MInt getEqualLevelNeighbors(MInt cellId, MInt(&nghbrs)[27])
retrieves all direct and diagonal fluid cell neighbours of the given cell
Definition: fvmbcartesiansolverxd.cpp:11215

FvMbCartesianSolverXD::checkGapCells
void checkGapCells()
determines Gap-state, and organises GapCells
Definition: fvmbcartesiansolverxd.cpp:28349

FvMbCartesianSolverXD::m_particleGlobalId
std::vector< MInt > m_particleGlobalId
Definition: fvmbcartesiansolverxd.h:768

FvMbCartesianSolverXD::getNormalSphere
void getNormalSphere(const MInt, const MInt, MFloat[])
Definition: fvmbcartesiansolverxd.cpp:2639

FvMbCartesianSolverXD::m_nghbrList
MInt * m_nghbrList
Definition: fvmbcartesiansolverxd.h:810

FvMbCartesianSolverXD::constructGFieldCorrector
MBool constructGFieldCorrector()
determine the displacement of the embedded body – corrector step
Definition: fvmbcartesiansolverxd.cpp:4814

FvMbCartesianSolverXD::m_bodyWasInCollision
std::set< MInt > m_bodyWasInCollision
Definition: fvmbcartesiansolverxd.h:770

FvMbCartesianSolverXD::m_slipInterval
MInt m_slipInterval
Definition: fvmbcartesiansolverxd.h:860

FvMbCartesianSolverXD::m_maxBndryLayerDistances
MFloat ** m_maxBndryLayerDistances
Definition: fvmbcartesiansolverxd.h:787

FvMbCartesianSolverXD::m_noCutFacePoints
MInt ** m_noCutFacePoints
Definition: fvmbcartesiansolverxd.h:803

FvMbCartesianSolverXD::m_haloCellOutput
MBool m_haloCellOutput
Definition: fvmbcartesiansolverxd.h:604

FvMbCartesianSolverXD::m_maxStructureSteps
MInt m_maxStructureSteps
Definition: fvmbcartesiansolverxd.h:659

FvMbCartesianSolverXD::initGapCellExchange
void initGapCellExchange()
creates the gap-cell exchange communicators based on initializeMaxLevelExchange
Definition: fvmbcartesiansolverxd.cpp:29648

FvMbCartesianSolverXD::m_cellVolumesDt2
MFloat * m_cellVolumesDt2
Definition: fvmbcartesiansolverxd.h:798

FvMbCartesianSolverXD::computeBoundarySurfaceForces
void computeBoundarySurfaceForces()
Definition: fvmbcartesiansolverxd.cpp:13778

FvMbCartesianSolverXD::m_bodyForceDt1
MFloat * m_bodyForceDt1
Definition: fvmbcartesiansolverxd.h:720

FvMbCartesianSolverXD::setAdditionalCellProperties
static void setAdditionalCellProperties()
set the properties of cells and determines the state of halo cells
Definition: fvmbcartesiansolverxd.cpp:11973

FvMbCartesianSolverXD::initEmergingGapCells
void initEmergingGapCells()
initializes variables of cells which occur in a freshly opened gap (valve gap etc....
Definition: fvmbcartesiansolverxd.cpp:20433

FvMbCartesianSolverXD::updateSplitParentVariables
void updateSplitParentVariables() override
Definition: fvmbcartesiansolverxd.cpp:2154

FvMbCartesianSolverXD::m_slipDataParticleAngularVel
MFloat * m_slipDataParticleAngularVel
Definition: fvmbcartesiansolverxd.h:867

FvMbCartesianSolverXD::localToGlobalIds
void localToGlobalIds() override
Change local into global ids.
Definition: fvmbcartesiansolverxd.cpp:36743

FvMbCartesianSolverXD::advanceBodies
void advanceBodies()
advances the time and stores the flow variables
Definition: fvmbcartesiansolverxd.cpp:5229

FvMbCartesianSolverXD::m_gammaMinusOne
const MFloat m_gammaMinusOne
Definition: fvmbcartesiansolverxd.h:682

FvMbCartesianSolverXD::m_pointIsInside
MBool ** m_pointIsInside
Definition: fvmbcartesiansolverxd.h:801

FvMbCartesianSolverXD::applyNeumannCondition
void applyNeumannCondition()
Definition: fvmbcartesiansolverxd.cpp:17863

FvMbCartesianSolverXD::resetSolverFull
void resetSolverFull() override
resets the solver
Definition: fvmbcartesiansolverxd.cpp:20024

FvMbCartesianSolverXD::initializeEmergedCells
void initializeEmergedCells()
initializes variables of cells which recently became active and therefore have no up-to-date history ...
Definition: fvmbcartesiansolverxd.cpp:20254

FvMbCartesianSolverXD::m_maxNoSampleNghbrs
MInt m_maxNoSampleNghbrs
Definition: fvmbcartesiansolverxd.h:683

FvMbCartesianSolverXD::m_massRedistributionRhs
std::vector< MFloat > m_massRedistributionRhs
Definition: fvmbcartesiansolverxd.h:822

FvMbCartesianSolverXD::m_particleRadii
std::vector< MFloat > m_particleRadii
Definition: fvmbcartesiansolverxd.h:766

FvMbCartesianSolverXD::m_capacityConstantVolumeRatio
MFloat m_capacityConstantVolumeRatio
Definition: fvmbcartesiansolverxd.h:702

FvMbCartesianSolverXD::finalizeBalance
void finalizeBalance() override
Reinitialize solver after all data structures have been recreated.
Definition: fvmbcartesiansolverxd.cpp:15149

FvMbCartesianSolverXD::solutionStep
MBool solutionStep() override
Performs the solutionStep of the FVMB solver the loop over the different RK-steps is done in the exec...
Definition: fvmbcartesiansolverxd.cpp:30166

FvMbCartesianSolverXD::m_bodyCenterDt2
MFloat * m_bodyCenterDt2
Definition: fvmbcartesiansolverxd.h:725

FvMbCartesianSolverXD::m_tCutGroupTotal
MInt m_tCutGroupTotal
Definition: fvmbcartesiansolverxd.h:576

FvMbCartesianSolverXD::resetSolverMb
void resetSolverMb()
resets the solver to an empty domain without moving boundary
Definition: fvmbcartesiansolverxd.cpp:20073

FvMbCartesianSolverXD::checkAreaDiff
MFloat checkAreaDiff(MInt srfcId1, MInt srfcId2)
Definition: fvmbcartesiansolverxd.cpp:31343

FvMbCartesianSolverXD::m_gridCellArea
MFloat * m_gridCellArea
Definition: fvmbcartesiansolverxd.h:688

FvMbCartesianSolverXD::m_static_createCutFaceMb_MGC_bodyFaceJoinMode
MInt m_static_createCutFaceMb_MGC_bodyFaceJoinMode
Definition: fvmbcartesiansolverxd.h:1780

FvMbCartesianSolverXD::m_gapAngleOpen
MFloat * m_gapAngleOpen
Definition: fvmbcartesiansolverxd.h:881

FvMbCartesianSolverXD::m_massRedistributionSweptVol
std::vector< MFloat > m_massRedistributionSweptVol
Definition: fvmbcartesiansolverxd.h:824

FvMbCartesianSolverXD::m_massRedistributionVolume
std::vector< MFloat > m_massRedistributionVolume
Definition: fvmbcartesiansolverxd.h:823

FvMbCartesianSolverXD::setCellWeights
void setCellWeights(MFloat *) override
set static cell weights for solver cells, which are used for the domain decomposition
Definition: fvmbcartesiansolverxd.cpp:24670

FvMbCartesianSolverXD::getNormalEllipsoid
void getNormalEllipsoid(const MInt, const MInt, MFloat[])
Definition: fvmbcartesiansolverxd.cpp:2663

FvMbCartesianSolverXD::setOldGeomBndryCellVolume
void setOldGeomBndryCellVolume()
set bndryCell volume from m_oldGeomBndryCells which is read from bodyRestartFile at initSolver and th...
Definition: fvmbcartesiansolverxd.cpp:25681

FvMbCartesianSolverXD::m_LsMovement
MBool m_LsMovement
Definition: fvmbcartesiansolverxd.h:620

FvMbCartesianSolverXD::computeNormal
static MFloat computeNormal(const MFloat *p0, const MFloat *p1, const MFloat *p2, MFloat *res, MFloat &w)
returns the normal corresponding to the triangle abc and returns the result in res
Definition: fvmbcartesiansolverxd.h:1414

FvMbCartesianSolverXD::setGapOpened
void setGapOpened()
sets the global-Trigger m_gapOpened, to determine if Gap-Cells are opened! old and incorrect version!...
Definition: fvmbcartesiansolverxd.cpp:27161

FvMbCartesianSolverXD::m_particleTemperatureDt1
std::vector< MFloat > m_particleTemperatureDt1
Definition: fvmbcartesiansolverxd.h:751

FvMbCartesianSolverXD::m_loggingInterval
MInt m_loggingInterval
Definition: fvmbcartesiansolverxd.h:583

FvMbCartesianSolverXD::getAdjacentCellsExtended
MInt getAdjacentCellsExtended(MInt cellId, MInt *adjacentCells)
retrieves the first two layers of direct and diagonal fluid cell neighbours of the given cell
Definition: fvmbcartesiansolverxd.cpp:11415

FvMbCartesianSolverXD::computeLocalBoundingBox
void computeLocalBoundingBox()
Definition: fvmbcartesiansolverxd.cpp:2296

FvMbCartesianSolverXD::crossProduct
static void crossProduct(MFloat *c, MFloat *a, MFloat *b)
computes the cross product c <- (a x b) for a, b, c in R^3
Definition: fvmbcartesiansolverxd.cpp:8842

FvMbCartesianSolverXD::checkHaloBndryCells
void checkHaloBndryCells(MBool sweptVol)
Definition: fvmbcartesiansolverxd.cpp:9950

FvMbCartesianSolverXD::compFaceIntegrals
void compFaceIntegrals(polyCutCell *, std::vector< polyEdge2D > *, const std::vector< polyVertex > *, MInt, MInt)
Definition: fvmbcartesiansolverxd.cpp:31570

FvMbCartesianSolverXD::computeNodalLSValues
void computeNodalLSValues()
compute the level-set values at the mesh vertices
Definition: fvmbcartesiansolverxd.cpp:5762

FvMbCartesianSolverXD::constructGField
void constructGField(MBool updateBody=true)
manually constructs the level-set field after each time step
Definition: fvmbcartesiansolverxd.cpp:2376

FvMbCartesianSolverXD::m_bodyInCollision
MInt * m_bodyInCollision
Definition: fvmbcartesiansolverxd.h:732

FvMbCartesianSolverXD::getDistanceEllipsoid
MFloat getDistanceEllipsoid(const MFloat *const, const MInt)
Definition: fvmbcartesiansolverxd.cpp:3555

FvMbCartesianSolverXD::m_noLongData
MInt m_noLongData
Definition: fvmbcartesiansolverxd.h:836

FvMbCartesianSolverXD::m_t0
const clock_t m_t0
Definition: fvmbcartesiansolverxd.h:675

FvMbCartesianSolverXD::correctRefinedBndryCellVolume
void correctRefinedBndryCellVolume()
correct BndryCells volume of bndryCells which were a bndryCell on a coarser level before
Definition: fvmbcartesiansolverxd.cpp:34893

FvMbCartesianSolverXD::compProjectionIntegrals
void compProjectionIntegrals(polyCutCell *, std::vector< polyEdge2D > *, const std::vector< polyVertex > *, MInt, MInt, MFloat *)
compute various integrations over projection of face
Definition: fvmbcartesiansolverxd.cpp:31526

FvMbCartesianSolverXD::getDistancePiston
MFloat getDistancePiston(const MFloat *const, const MInt)
Definition: fvmbcartesiansolverxd.cpp:3514

FvMbCartesianSolverXD::setTimeStep
void setTimeStep() override
calls sets() and stores the time step for all cells
Definition: fvmbcartesiansolverxd.cpp:11071

FvMbCartesianSolverXD::advanceExternalSource
void advanceExternalSource() override
advance external sources
Definition: fvmbcartesiansolverxd.cpp:14224

FvMbCartesianSolverXD::m_noEmergedCells
MInt m_noEmergedCells
Definition: fvmbcartesiansolverxd.h:652

FvMbCartesianSolverXD::addBoundarySurfacesMb
void addBoundarySurfacesMb()
adds a surface for the ghost-boundary cell intersections
Definition: fvmbcartesiansolverxd.cpp:21198

FvMbCartesianSolverXD::m_bodyForce
MFloat * m_bodyForce
Definition: fvmbcartesiansolverxd.h:719

FvMbCartesianSolverXD::getPrimitiveVarName
MString getPrimitiveVarName(MInt i)
returns the name of the primitive variable at the given index i
Definition: fvmbcartesiansolverxd.cpp:12718

FvMbCartesianSolverXD::m_particleCellLink
std::vector< MInt > m_particleCellLink
Definition: fvmbcartesiansolverxd.h:767

FvMbCartesianSolverXD::updateGeometry
void updateGeometry()
Updates the member-variables in the geometry-intersection class.
Definition: fvmbcartesiansolverxd.cpp:30515

FvMbCartesianSolverXD::m_bodyQuaternionDt1
MFloat * m_bodyQuaternionDt1
Definition: fvmbcartesiansolverxd.h:709

FvMbCartesianSolverXD::computeTimeStep
void computeTimeStep()

FvMbCartesianSolverXD::createSplitCell
MInt createSplitCell(MInt cellId, MInt noSplitChilds)
Definition: fvmbcartesiansolverxd.cpp:19470

FvMbCartesianSolverXD::getNumberOfCells
MLong getNumberOfCells(MInt mode)
mode=0: total mode=1: min mode=2: max mode=3: average
Definition: fvmbcartesiansolverxd.cpp:19136

FvMbCartesianSolverXD::fileExists
MBool fileExists(const MChar *fileName)
Definition: fvmbcartesiansolverxd.cpp:26108

FvMbCartesianSolverXD::gridPointIsInside
MBool gridPointIsInside(MInt, MInt) override
Definition: fvmbcartesiansolverxd.cpp:21168

FvMbCartesianSolverXD::m_particleAngularAccelerationDt1
std::vector< MFloat > m_particleAngularAccelerationDt1
Definition: fvmbcartesiansolverxd.h:764

FvMbCartesianSolverXD::getBoundaryDistance
void getBoundaryDistance(MFloatScratchSpace &) override
Definition: fvmbcartesiansolverxd.cpp:15736

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void LSReconstructCellCenter() override

FvMbCartesianSolverXD::m_particleVelocityFluid
std::vector< MFloat > m_particleVelocityFluid
Definition: fvmbcartesiansolverxd.h:754

FvMbCartesianSolverXD::maxResidual
MBool maxResidual(MInt mode=0) override
Computes the maxResiduum for all cells.
Definition: fvmbcartesiansolverxd.cpp:19176

FvMbCartesianSolverXD::m_bodyAngularVelocityDt1
MFloat * m_bodyAngularVelocityDt1
Definition: fvmbcartesiansolverxd.h:721

FvMbCartesianSolverXD::Cell
typename maia::grid::tree::Tree< nDim >::Cell Cell
Definition: fvmbcartesiansolverxd.h:57

FvMbCartesianSolverXD::m_noCellNodes
static constexpr MInt m_noCellNodes
Definition: fvmbcartesiansolverxd.h:677

FvMbCartesianSolverXD::m_particleQuaternionsDt1
std::vector< MFloat > m_particleQuaternionsDt1
Definition: fvmbcartesiansolverxd.h:759

FvMbCartesianSolverXD::m_noSurfaces
MInt m_noSurfaces
Definition: fvmbcartesiansolverxd.h:646

FvMbCartesianSolverXD::m_minBodyRadius
MFloat m_minBodyRadius
Definition: fvmbcartesiansolverxd.h:693

FvMbCartesianSolverXD::writeVtkXmlOutput_MGC
void writeVtkXmlOutput_MGC(const MString &fileName)
write flow variables as XML VTK
Definition: fvmbcartesiansolverxd.cpp:32674

FvMbCartesianSolverXD::applyBoundaryCondition
void applyBoundaryCondition() override
dummy, since applyBoundaryCondition() it is placed wrong for moving boundary problems,...
Definition: fvmbcartesiansolverxd.cpp:13791

FvMbCartesianSolverXD::prepareAdaptation
void prepareAdaptation() override
Definition: fvmbcartesiansolverxd.cpp:15420

FvMbCartesianSolverXD::m_particleVelocity
std::vector< MFloat > m_particleVelocity
Definition: fvmbcartesiansolverxd.h:749

FvMbCartesianSolverXD::m_noAzimuthalBndryCandidates
MInt m_noAzimuthalBndryCandidates
Definition: fvmbcartesiansolverxd.h:655

FvMbCartesianSolverXD::m_particleAngularVelocity
std::vector< MFloat > m_particleAngularVelocity
Definition: fvmbcartesiansolverxd.h:760

FvMbCartesianSolverXD::m_noCutCellFaces
MInt * m_noCutCellFaces
Definition: fvmbcartesiansolverxd.h:802

FvMbCartesianSolverXD::m_massRedistributionVariables
std::vector< MFloat > m_massRedistributionVariables
Definition: fvmbcartesiansolverxd.h:821

FvMbCartesianSolverXD::createBndryCellMb
MInt createBndryCellMb(MInt cellId)
creates a moving boundary cell for the given cell
Definition: fvmbcartesiansolverxd.cpp:19377

FvMbCartesianSolverXD::m_bodyCenterInitial
MFloat * m_bodyCenterInitial
Definition: fvmbcartesiansolverxd.h:726

FvMbCartesianSolverXD::m_noCVars
const MInt m_noCVars
Definition: fvmbcartesiansolverxd.h:678

FvMbCartesianSolverXD::descendDistance
void descendDistance(const MInt cellId, const MInt *const bodyIds, const MInt bodyCnt, MIntScratchSpace &nearestBodies, MFloatScratchSpace &nearestDist)
Definition: fvmbcartesiansolverxd.cpp:1411

FvMbCartesianSolverXD::computeReconstructionConstants
void computeReconstructionConstants() override
computes the reconstruction constants using inverse distance weighted least squares
Definition: fvmbcartesiansolverxd.cpp:17256

FvMbCartesianSolverXD::m_movingPosDiff
std::vector< MFloat > m_movingPosDiff
Definition: fvmbcartesiansolverxd.h:573

FvMbCartesianSolverXD::m_rhoU2
MFloat m_rhoU2
Definition: fvmbcartesiansolverxd.h:685

FvMbCartesianSolverXD::m_FSIToleranceR
MFloat m_FSIToleranceR
Definition: fvmbcartesiansolverxd.h:596

FvMbCartesianSolverXD::CalculateLSV
MFloat CalculateLSV(MInt, MIntScratchSpace &)
Calculate LevelSetValue with an Approximation of the Neighbours for a grid in the NarrowBand.
Definition: fvmbcartesiansolverxd.cpp:3333

FvMbCartesianSolverXD::constructDistance
MInt constructDistance(const MFloat deltaMax, MIntScratchSpace &nearestBodies, MFloatScratchSpace &nearestDist)
Definition: fvmbcartesiansolverxd.cpp:2504

FvMbCartesianSolverXD::m_slipDataParticleCollision
MInt * m_slipDataParticleCollision
Definition: fvmbcartesiansolverxd.h:864

FvMbCartesianSolverXD::m_fixedBodyComponents
MInt * m_fixedBodyComponents
Definition: fvmbcartesiansolverxd.h:728

FvMbCartesianSolverXD::crankAngleSolutionOutput
void crankAngleSolutionOutput()
save a full solutionOutput at timeSteps closesed to a specified crankAngle Interval save a solution s...
Definition: fvmbcartesiansolverxd.cpp:15940

FvMbCartesianSolverXD::deleteSurface
void deleteSurface(MInt srfcId)
removes the surfaces of the given cell
Definition: fvmbcartesiansolverxd.cpp:16745

FvMbCartesianSolverXD::m_coarseOldBndryCells
std::set< MInt > m_coarseOldBndryCells
Definition: fvmbcartesiansolverxd.h:826

FvMbCartesianSolverXD::m_g
MFloat m_g
Definition: fvmbcartesiansolverxd.h:603

FvMbCartesianSolverXD::logOutput
void logOutput()
logs several collector sizes
Definition: fvmbcartesiansolverxd.cpp:1483

FvMbCartesianSolverXD::m_particleVelocityGradientFluid
std::vector< MFloat > m_particleVelocityGradientFluid
Definition: fvmbcartesiansolverxd.h:762

FvMbCartesianSolverXD::advanceSolution
void advanceSolution()
advances the time and stores the flow variables
Definition: fvmbcartesiansolverxd.cpp:5151

FvMbCartesianSolverXD::m_bodyAngularAccelerationDt1
MFloat * m_bodyAngularAccelerationDt1
Definition: fvmbcartesiansolverxd.h:722

FvMbCartesianSolverXD::interpolateLevelSet
MFloat interpolateLevelSet(MInt *, MFloat *, MInt)
interpolates levelset function to a given coordinate
Definition: fvmbcartesiansolverxd.cpp:18078

FvMbCartesianSolverXD::distancePointEllipsoidSpecial
MFloat distancePointEllipsoidSpecial(const MFloat e[3], const MFloat y[3], MFloat x[3])
Definition: fvmbcartesiansolverxd.cpp:3695

FvMbCartesianSolverXD::m_solutionDiverged
MInt m_solutionDiverged
Definition: fvmbcartesiansolverxd.h:599

FvMbCartesianSolverXD::checkNeighborActivity
MInt checkNeighborActivity(MInt)
ckecks that a new bndry-Cell has at least one neighbor which was active before if this is not the cas...
Definition: fvmbcartesiansolverxd.cpp:29512

FvMbCartesianSolverXD::setRungeKuttaFunctionPointer
void setRungeKuttaFunctionPointer()
This function sets the function pointers for rungeKutta (also used in splitBalance)

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void resetRHS() override

FvMbCartesianSolverXD::writeVTKFileOfCutCell
void writeVTKFileOfCutCell(MInt, std::vector< polyCutCell > *, const std::vector< polyEdge2D > *, const std::vector< polyVertex > *, MInt)
Definition: fvmbcartesiansolverxd.cpp:33794

FvMbCartesianSolverXD::m_linkedHaloCells
std::vector< MInt > * m_linkedHaloCells
Definition: fvmbcartesiansolverxd.h:795

FvMbCartesianSolverXD::m_bodyTerminalVelocity
MFloat * m_bodyTerminalVelocity
Definition: fvmbcartesiansolverxd.h:727

FvMbCartesianSolverXD::getNormal
void getNormal(const MInt, const MInt, MFloat[])
Definition: fvmbcartesiansolverxd.cpp:2563

FvMbCartesianSolverXD::m_couplingRateViscous
MFloat m_couplingRateViscous
Definition: fvmbcartesiansolverxd.h:707

FvMbCartesianSolverXD::CdLaw
static MFloat CdLaw(MFloat Re)
Definition: fvmbcartesiansolverxd.h:1220

FvMbCartesianSolverXD::refineCell
void refineCell(const MInt) override
Definition: fvmbcartesiansolverxd.cpp:15181

FvMbCartesianSolverXD::computeCutPointsMb_MGC
void computeCutPointsMb_MGC()
Computes cutpoints of zero level-set with grid edges and creates boundary cells for cut-cells.
Definition: fvmbcartesiansolverxd.cpp:18273

FvMbCartesianSolverXD::getDistanceTetrahedron
MFloat getDistanceTetrahedron(const MFloat *const, const MInt)
Definition: fvmbcartesiansolverxd.cpp:4058

FvMbCartesianSolverXD::checkDiv
void checkDiv() override
Check for divergence in case we use MB_DEBUG or debug.
Definition: fvmbcartesiansolverxd.cpp:26309

FvMbCartesianSolverXD::m_Fr
MFloat m_Fr
Definition: fvmbcartesiansolverxd.h:602

FvMbCartesianSolverXD::m_bodySumAverage
MFloat * m_bodySumAverage
Definition: fvmbcartesiansolverxd.h:737

FvMbCartesianSolverXD::prepareRestart
MBool prepareRestart(MBool, MBool &) override
Prepare the solvers for a grid-restart.
Definition: fvmbcartesiansolverxd.cpp:24540

FvMbCartesianSolverXD::m_initGapCell
MBool m_initGapCell
Definition: fvmbcartesiansolverxd.h:639

FvMbCartesianSolverXD::saveBodySamples
void saveBodySamples()
Definition: fvmbcartesiansolverxd.cpp:25754

FvMbCartesianSolverXD::m_slipDataParticleFluidVelRot
MFloat * m_slipDataParticleFluidVelRot
Definition: fvmbcartesiansolverxd.h:872

FvMbCartesianSolverXD::updateCellSurfaceDistanceVector
void updateCellSurfaceDistanceVector(MInt srfcId)
correct the cell-surface distance vectors for cells near the moving boundary
Definition: fvmbcartesiansolverxd.cpp:21147

FvMbCartesianSolverXD::m_bodyDataDevAverage
MFloat * m_bodyDataDevAverage
Definition: fvmbcartesiansolverxd.h:736

FvMbCartesianSolverXD::m_bodyMass
MFloat * m_bodyMass
Definition: fvmbcartesiansolverxd.h:698

FvMbCartesianSolverXD::m_oldBodyPosition
std::vector< MFloat > m_oldBodyPosition
Definition: fvmbcartesiansolverxd.h:571

FvMbCartesianSolverXD::m_FSIToleranceX
MFloat m_FSIToleranceX
Definition: fvmbcartesiansolverxd.h:594

FvMbCartesianSolverXD::updateLinkedCells
void updateLinkedCells()
update the temporarly-linked cells
Definition: fvmbcartesiansolverxd.cpp:12472

FvMbCartesianSolverXD::m_cflTarget
MFloat m_cflTarget
Definition: fvmbcartesiansolverxd.h:614

FvMbCartesianSolverXD::m_azimuthalLinkedHaloCells
std::vector< std::vector< MInt > > m_azimuthalLinkedHaloCells
Definition: fvmbcartesiansolverxd.h:828

FvMbCartesianSolverXD::saveParticleSlipData
void saveParticleSlipData()
Definition: fvmbcartesiansolverxd.cpp:26746

FvMbCartesianSolverXD::m_bodyMomentOfInertia
MFloat * m_bodyMomentOfInertia
Definition: fvmbcartesiansolverxd.h:711

FvMbCartesianSolverXD::m_solverType
SolverType m_solverType
Definition: fvmbcartesiansolverxd.h:600

FvMbCartesianSolverXD::matrixProductTranspose2
static void matrixProductTranspose2(MFloatScratchSpace &C, MFloatScratchSpace &A, MFloatScratchSpace &B)
C=A^t*B.
Definition: fvmbcartesiansolverxd.cpp:4190

FvMbCartesianSolverXD::constructGFieldPredictor
void constructGFieldPredictor()
determine the displacement of the embedded body – predictor step

FvMbCartesianSolverXD::m_gapAngleClose
MFloat * m_gapAngleClose
Definition: fvmbcartesiansolverxd.h:880

FvMbCartesianSolverXD::descendLevelSetValue
void descendLevelSetValue(const MInt cellId, const MInt *const bodyIds, const MInt bodyCnt)
Definition: fvmbcartesiansolverxd.cpp:1369

FvMbCartesianSolverXD::m_bodyTree
KDtree< nDim > * m_bodyTree
Definition: fvmbcartesiansolverxd.h:543

FvMbCartesianSolverXD::m_fixedBodyComponentsRotation
MInt * m_fixedBodyComponentsRotation
Definition: fvmbcartesiansolverxd.h:729

FvMbCartesianSolverXD::m_maxNoEmbeddedBodiesPeriodic
MInt m_maxNoEmbeddedBodiesPeriodic
Definition: fvmbcartesiansolverxd.h:648

FvMbCartesianSolverXD::getDistanceSphere
MFloat getDistanceSphere(const MFloat *const, const MInt)
Definition: fvmbcartesiansolverxd.cpp:2750

FvMbCartesianSolverXD::m_maxNoSurfacePointSamples
MInt m_maxNoSurfacePointSamples
Definition: fvmbcartesiansolverxd.h:661

FvMbCartesianSolverXD::m_oldMeanState
MFloat m_oldMeanState[m_noMeanStatistics][4]
Definition: fvmbcartesiansolverxd.h:854

FvMbCartesianSolverXD::m_buildCollectedLevelSetFunction
MBool m_buildCollectedLevelSetFunction
Definition: fvmbcartesiansolverxd.h:668

FvMbCartesianSolverXD::m_alwaysResetCutOff
MBool m_alwaysResetCutOff
Definition: fvmbcartesiansolverxd.h:621

FvMbCartesianSolverXD::computeAzimuthalHaloNodalValues
void computeAzimuthalHaloNodalValues()
init exchange of nodal values of azimuthal periodic halo cells
Definition: fvmbcartesiansolverxd.cpp:5838

FvMbCartesianSolverXD::m_bodyAccelerationDt3
MFloat * m_bodyAccelerationDt3
Definition: fvmbcartesiansolverxd.h:714

FvMbCartesianSolverXD::m_area
MFloat * m_area
Definition: fvmbcartesiansolverxd.h:842

FvMbCartesianSolverXD::m_bodyVelocityDt1
MFloat * m_bodyVelocityDt1
Definition: fvmbcartesiansolverxd.h:715

FvMbCartesianSolverXD::copyFile
MInt copyFile(const MChar *fromName, const MChar *toName)
Definition: fvmbcartesiansolverxd.cpp:26119

FvMbCartesianSolverXD::m_particleCoordsInitial
std::vector< MFloat > m_particleCoordsInitial
Definition: fvmbcartesiansolverxd.h:748

FvMbCartesianSolverXD::determineBndryCandidates
void determineBndryCandidates()
determine all possible fluid boundary cells for a generic embedded body
Definition: fvmbcartesiansolverxd.cpp:5714

FvMbCartesianSolverXD::setLevelSetMbCellProperties
void setLevelSetMbCellProperties()
determines relevant cell properties
Definition: fvmbcartesiansolverxd.cpp:1300

FvMbCartesianSolverXD::m_candidateNodeValues
std::vector< MFloat > m_candidateNodeValues
Definition: fvmbcartesiansolverxd.h:780

FvMbCartesianSolverXD::m_surfaceVariables
MFloat * m_surfaceVariables
Definition: fvmbcartesiansolverxd.h:843

FvMbCartesianSolverXD::m_bodyTypeMb
MInt m_bodyTypeMb
Definition: fvmbcartesiansolverxd.h:592

FvMbCartesianSolverXD::m_addedMassCoefficient
MFloat m_addedMassCoefficient
Definition: fvmbcartesiansolverxd.h:700

FvMbCartesianSolverXD::balance
void balance(const MInt *const noCellsToReceiveByDomain, const MInt *const noCellsToSendByDomain, const MInt *const targetDomainsByCell, const MInt oldNoCells) override
Balance the solver.
Definition: fvmbcartesiansolverxd.cpp:14693

FvMbCartesianSolverXD::m_oldBndryCells
std::map< MInt, MFloat > m_oldBndryCells
Definition: fvmbcartesiansolverxd.h:817

FvMbCartesianSolverXD::m_particleOffsets
std::vector< MInt > m_particleOffsets
Definition: fvmbcartesiansolverxd.h:863

FvMbCartesianSolverXD::m_bodyCentersLocal
std::vector< Point< nDim > > m_bodyCentersLocal
Definition: fvmbcartesiansolverxd.h:546

FvMbCartesianSolverXD::gapHandling
void gapHandling()
determines Gap-state, and organises GapCells
Definition: fvmbcartesiansolverxd.cpp:27224

FvMbCartesianSolverXD::printTime
MString printTime(const MFloat t)
Definition: fvmbcartesiansolverxd.cpp:25987

FvMbCartesianSolverXD::determineCoupling
MFloat determineCoupling(MFloatScratchSpace &coupling)
Definition: fvmbcartesiansolverxd.cpp:26381

FvMbCartesianSolverXD::m_previousTimeStep
MFloat m_previousTimeStep
Definition: fvmbcartesiansolverxd.h:615

FvMbCartesianSolverXD::m_maxBndryLayerWidth
MInt m_maxBndryLayerWidth
Definition: fvmbcartesiansolverxd.h:588

FvMbCartesianSolverXD::compactSurfaces
void compactSurfaces()
Definition: fvmbcartesiansolverxd.cpp:16472

FvMbCartesianSolverXD::reIntAfterRestart
void reIntAfterRestart(MBool) override
Definition: fvmbcartesiansolverxd.cpp:24651

FvMbCartesianSolverXD::setOuterBoundaryGhostCells
void setOuterBoundaryGhostCells()
Definition: fvmbcartesiansolverxd.cpp:19546

FvMbCartesianSolverXD::m_reConstSVDWeightMode
MInt m_reConstSVDWeightMode
Definition: fvmbcartesiansolverxd.h:624

FvMbCartesianSolverXD::updateGapBoundaryCells
void updateGapBoundaryCells()
set the velocity at gap-Boundary-Cells due to the irregular movement of the gap-surface during wideni...
Definition: fvmbcartesiansolverxd.cpp:28641

FvMbCartesianSolverXD::getDistanceNaca00XX
MFloat getDistanceNaca00XX(const MInt, const MInt)
Definition: fvmbcartesiansolverxd.cpp:3538

FvMbCartesianSolverXD::m_gclIntermediate
MBool m_gclIntermediate
Definition: fvmbcartesiansolverxd.h:608

FvMbCartesianSolverXD::matrixVectorProduct
static void matrixVectorProduct(MFloat *c, MFloatScratchSpace &A, MFloat *b)
c=A*b
Definition: fvmbcartesiansolverxd.cpp:4209

FvMbCartesianSolverXD::computeForceCoefficients
void computeForceCoefficients(MFloat *&)
dummy
Definition: fvmbcartesiansolverxd.cpp:21188

FvMbCartesianSolverXD::m_trackBodySurfaceData
MBool m_trackBodySurfaceData
Definition: fvmbcartesiansolverxd.h:667

FvMbCartesianSolverXD::m_azimuthalWasNearBndryIds
std::vector< MInt > m_azimuthalWasNearBndryIds
Definition: fvmbcartesiansolverxd.h:831

FvMbCartesianSolverXD::getAdjacentCells
MInt getAdjacentCells(MInt cellId, MInt *adjacentCells)
retrieves all direct and diagonal fluid cell neighbours of the given cell
Definition: fvmbcartesiansolverxd.cpp:11280

FvMbCartesianSolverXD::rebuildReconstructionConstants
void rebuildReconstructionConstants(MInt cellId)
computes the reconstruction constants using inverse distance weighted least squares
Definition: fvmbcartesiansolverxd.cpp:17396

FvMbCartesianSolverXD::m_azimuthalBndryCandidateIds
std::vector< MInt > m_azimuthalBndryCandidateIds
Definition: fvmbcartesiansolverxd.h:779

FvMbCartesianSolverXD::setOuterBoundarySurfaces
void setOuterBoundarySurfaces()
Definition: fvmbcartesiansolverxd.cpp:19574

FvMbCartesianSolverXD::m_particleSamplingInterval
MInt m_particleSamplingInterval
Definition: fvmbcartesiansolverxd.h:585

FvMbCartesianSolverXD::m_bodyCenters
std::vector< Point< nDim > > m_bodyCenters
Definition: fvmbcartesiansolverxd.h:545

FvMbCartesianSolverXD::distEllipsoidEllipsoid
MFloat distEllipsoidEllipsoid(const MInt k0, const MInt k1, MFloat *xc0, MFloat *xc1)
Compute the distance between two ellipsoids by iteratively searching the nearest point on the respect...
Definition: fvmbcartesiansolverxd.cpp:3605

FvMbCartesianSolverXD::m_bodyAccelerationDt2
MFloat * m_bodyAccelerationDt2
Definition: fvmbcartesiansolverxd.h:713

FvMbCartesianSolverXD::m_bodyNearDomain
MBool * m_bodyNearDomain
Definition: fvmbcartesiansolverxd.h:733

FvMbCartesianSolverXD::m_periodicGhostBodyDist
MFloat m_periodicGhostBodyDist
Definition: fvmbcartesiansolverxd.h:687

FvMbCartesianSolverXD::advanceTimeStep
void advanceTimeStep()
Definition: fvmbcartesiansolverxd.cpp:5565

FvMbCartesianSolverXD::m_particleFluidTemperature
std::vector< MFloat > m_particleFluidTemperature
Definition: fvmbcartesiansolverxd.h:755

FvMbCartesianSolverXD::setBodyQuaternions
void setBodyQuaternions(const MInt bodyId, MFloat *bodyRotation)
Definition: fvmbcartesiansolverxd.cpp:4488

FvMbCartesianSolverXD::m_receiveBufferSize
MInt * m_receiveBufferSize
Definition: fvmbcartesiansolverxd.h:814

FvMbCartesianSolverXD::getNewSurfaceId
MInt getNewSurfaceId()
returns a new surface id
Definition: fvmbcartesiansolverxd.cpp:17005

FvMbCartesianSolverXD::rebuildKDTreeLocal
void rebuildKDTreeLocal()
Definition: fvmbcartesiansolverxd.cpp:2348

FvMbCartesianSolverXD::m_particleShapeParams
std::vector< MFloat > m_particleShapeParams
Definition: fvmbcartesiansolverxd.h:765

FvMbCartesianSolverXD::m_periodicGhostBodies
std::vector< MInt > * m_periodicGhostBodies
Definition: fvmbcartesiansolverxd.h:769

FvMbCartesianSolverXD::initAnalyticalLevelSet
void initAnalyticalLevelSet()
This function creats the bodyTree for analytical LevelSets.
Definition: fvmbcartesiansolverxd.cpp:30380

FvMbCartesianSolverXD::m_cflInitial
MFloat m_cflInitial
Definition: fvmbcartesiansolverxd.h:613

FvMbCartesianSolverXD::interpolateGapBodyVelocity
void interpolateGapBodyVelocity()
sets the interpolated velocity for a bndryCell NOTE: all neighbors need to be available for levelset-...
Definition: fvmbcartesiansolverxd.cpp:17995

FvMbCartesianSolverXD::exchangeNodalLSValues
void exchangeNodalLSValues()

FvMbCartesianSolverXD::m_bndryLayerCells
std::vector< MInt > m_bndryLayerCells
Definition: fvmbcartesiansolverxd.h:782

FvMbCartesianSolverXD::initBodyProperties
void initBodyProperties()
initialize properties of the embedded body at startup

FvMbCartesianSolverXD::m_particleAcceleration
std::vector< MFloat > m_particleAcceleration
Definition: fvmbcartesiansolverxd.h:756

FvMbCartesianSolverXD::createSurface
void createSurface(MInt srfcId, MInt nghbrId0, MInt nghbrId1, MInt orientation)
restores the surfaces of the given cell
Definition: fvmbcartesiansolverxd.cpp:16223

FvMbCartesianSolverXD::m_bodyTreeLocal
KDtree< nDim > * m_bodyTreeLocal
Definition: fvmbcartesiansolverxd.h:544

FvMbCartesianSolverXD::m_conservationCheck
MBool m_conservationCheck
Definition: fvmbcartesiansolverxd.h:606

FvMbCartesianSolverXD::applyBoundaryConditionMb
void applyBoundaryConditionMb()
applies the boundary condition at all boundaries
Definition: fvmbcartesiansolverxd.cpp:18100

FvMbCartesianSolverXD::resetSurfaces
void resetSurfaces() override
Definition: fvmbcartesiansolverxd.cpp:20120

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void exchange() override

FvMbCartesianSolverXD::m_noAngleSetups
static constexpr MInt m_noAngleSetups
Definition: fvmbcartesiansolverxd.h:857

FvMbCartesianSolverXD::inside
MBool inside(MFloat x, MFloat a, MFloat b)
Definition: fvmbcartesiansolverxd.cpp:18209

FvMbCartesianSolverXD::m_hydroForce
MFloat * m_hydroForce
Definition: fvmbcartesiansolverxd.h:723

FvMbCartesianSolverXD::writeStencil
void writeStencil(const MInt bndryId)
Definition: fvmbcartesiansolverxd.cpp:26148

FvMbCartesianSolverXD::applyBoundaryConditionSlope
void applyBoundaryConditionSlope()
Definition: fvmbcartesiansolverxd.cpp:11468

FvMbCartesianSolverXD::m_noFVars
const MInt m_noFVars
Definition: fvmbcartesiansolverxd.h:679

FvMbCartesianSolverXD::updateLevelSetOutsideBand
void updateLevelSetOutsideBand()
computes an approximate level set value for cells outside the level-set computing band
Definition: fvmbcartesiansolverxd.cpp:3033

FvMbCartesianSolverXD::preTimeStep
void preTimeStep() override
Performs the preTimeStep of the FVMB solver.
Definition: fvmbcartesiansolverxd.cpp:30232

FvMbCartesianSolverXD::postSolutionStep
MBool postSolutionStep() override
step after the solver solution Step
Definition: fvmbcartesiansolverxd.cpp:27010

FvMbCartesianSolverXD::m_bbox
MFloat * m_bbox
Definition: fvmbcartesiansolverxd.h:808

FvMbCartesianSolverXD::m_gapWindowCells
std::vector< MInt > * m_gapWindowCells
Definition: fvmbcartesiansolverxd.h:635

FvMbCartesianSolverXD::m_forceFVMBStatistics
std::vector< MInt > m_forceFVMBStatistics
Definition: fvmbcartesiansolverxd.h:1167

FvMbCartesianSolverXD::m_bndryCandidates
std::vector< MInt > m_bndryCandidates
Definition: fvmbcartesiansolverxd.h:774

FvMbCartesianSolverXD::distancePointEllipsoid
MFloat distancePointEllipsoid(const MFloat e[3], const MFloat y[3], MFloat x[3])
Definition: fvmbcartesiansolverxd.cpp:3907

FvMbCartesianSolverXD::ATTRIBUTES1
ATTRIBUTES1(ATTRIBUTE_HOT) void Ausm() override

FvMbCartesianSolverXD::m_surfaceCoordinates
MFloat * m_surfaceCoordinates
Definition: fvmbcartesiansolverxd.h:845

FvMbCartesianSolverXD::m_noFlowCells
MInt m_noFlowCells
Definition: fvmbcartesiansolverxd.h:644

FvMbCartesianSolverXD::m_wasBalanced
MBool m_wasBalanced
Definition: fvmbcartesiansolverxd.h:777

FvMbCartesianSolverXD::m_applyCollisionModel
MBool m_applyCollisionModel
Definition: fvmbcartesiansolverxd.h:618

FvMbCartesianSolverXD::resetSlopes
void resetSlopes()
does what it says
Definition: fvmbcartesiansolverxd.cpp:21300

FvMbCartesianSolverXD::m_structureStep
MInt m_structureStep
Definition: fvmbcartesiansolverxd.h:658

FvMbCartesianSolverXD::prepareNextTimeStep
void prepareNextTimeStep() override
Updates the old Variables, the body positions and the increases the time.
Definition: fvmbcartesiansolverxd.cpp:30530

FvMbCartesianSolverXD::m_noSurfacePointSamples
MInt m_noSurfacePointSamples
Definition: fvmbcartesiansolverxd.h:660

FvMbCartesianSolverXD::m_static_initSolutionStep_firstRun
MBool m_static_initSolutionStep_firstRun
Definition: fvmbcartesiansolverxd.h:1778

FvMbCartesianSolverXD::m_logBoundaryData
MBool m_logBoundaryData
Definition: fvmbcartesiansolverxd.h:580

FvMbCartesianSolverXD::m_noOuterBoundarySurfaces
MInt m_noOuterBoundarySurfaces
Definition: fvmbcartesiansolverxd.h:650

FvMbCartesianSolverXD::m_bodyDiameter
MFloat * m_bodyDiameter
Definition: fvmbcartesiansolverxd.h:696

FvMbCartesianSolverXD::m_static_createCutFaceMb_MGC_maxA
MFloat m_static_createCutFaceMb_MGC_maxA
Definition: fvmbcartesiansolverxd.h:1781

FvMbCartesianSolverXD::checkHaloCells
void checkHaloCells(MInt mode=0)
Checks a couple of important properties and variables of halo-cells.
Definition: fvmbcartesiansolverxd.cpp:27054

FvMbCartesianSolverXD::checkCentroidDiff
MFloat checkCentroidDiff(MInt srfcId1, MInt srfcId2)
Definition: fvmbcartesiansolverxd.cpp:31326

FvMbCartesianSolverXD::m_gapOpened
MBool m_gapOpened
Definition: fvmbcartesiansolverxd.h:666

FvMbCartesianSolverXD::m_complexBoundary
MBool m_complexBoundary
Definition: fvmbcartesiansolverxd.h:605

FvMbCartesianSolverXD::writeVtkErrorFile
void writeVtkErrorFile()
write flow variables as XML VTK files
Definition: fvmbcartesiansolverxd.cpp:23733

FvMbCartesianSolverXD::m_initialSurfacesOffset
MInt m_initialSurfacesOffset
Definition: fvmbcartesiansolverxd.h:649

FvMbCartesianSolverXD::m_slipDataParticleForce
MFloat * m_slipDataParticleForce
Definition: fvmbcartesiansolverxd.h:868

FvMbCartesianSolverXD::m_bodySamplingInterval
MInt m_bodySamplingInterval
Definition: fvmbcartesiansolverxd.h:584

FvMbCartesianSolverXD::m_noPointParticlesLocal
MInt m_noPointParticlesLocal
Definition: fvmbcartesiansolverxd.h:663

FvMbCartesianSolverXD::~FvMbCartesianSolverXD
~FvMbCartesianSolverXD() override
Definition: fvmbcartesiansolverxd.cpp:68

FvMbCartesianSolverXD::createInitialSrfcs
void createInitialSrfcs()
computes initial set of internal grid surfaces
Definition: fvmbcartesiansolverxd.cpp:17032

FvMbCartesianSolverXD::m_startSet
MInt m_startSet
Definition: fvmbcartesiansolverxd.h:669

FvMbCartesianSolverXD::distancePointEllipsoidSpecial2
MFloat distancePointEllipsoidSpecial2(const MFloat e[3], const MFloat y[3], MFloat x[3])
Definition: fvmbcartesiansolverxd.cpp:3808

FvMbCartesianSolverXD::postAdaptation
void postAdaptation() override
Definition: fvmbcartesiansolverxd.cpp:15527

FvMbCartesianSolverXD::outputPolyData
void outputPolyData(const MInt, const std::vector< polyCutCell > *, const std::vector< polyEdge2D > *, const std::vector< polyVertex > *, MInt)
Definition: fvmbcartesiansolverxd.cpp:33888

FvMbCartesianSolverXD::postTimeStep
void postTimeStep() override
Performs the postTimeStep of the FVMB solver.
Definition: fvmbcartesiansolverxd.cpp:30341

FvMbCartesianSolverXD::setCellProperties
void setCellProperties() override
set the properties of cells and determines the state of halo cells
Definition: fvmbcartesiansolverxd.cpp:11962

FvMbCartesianSolverXD::m_coupling
MFloat ** m_coupling
Definition: fvmbcartesiansolverxd.h:704

FvMbCartesianSolverXD::removeChilds
void removeChilds(const MInt) override
Definition: fvmbcartesiansolverxd.cpp:15261

FvMbCartesianSolverXD::m_noDistSetups
static constexpr MInt m_noDistSetups
Definition: fvmbcartesiansolverxd.h:858

FvMbCartesianSolverXD::computeVolumeFraction
void computeVolumeFraction()
computes the volume fraction V/h^d and the level-set value in the volumetric center of all boundary c...
Definition: fvmbcartesiansolverxd.cpp:11051

FvMbCartesianSolverXD::m_timeStepAdaptationStart
MInt m_timeStepAdaptationStart
Definition: fvmbcartesiansolverxd.h:611

FvMbCartesianSolverXD::m_noFloatDataBalance
MInt m_noFloatDataBalance
Definition: fvmbcartesiansolverxd.h:834

FvMbCartesianSolverXD::m_maxLevelChange
MBool m_maxLevelChange
Definition: fvmbcartesiansolverxd.h:628

FvMbCartesianSolverXD::m_gapSign
MFloat * m_gapSign
Definition: fvmbcartesiansolverxd.h:882

FvMbCartesianSolverXD::m_bodyVolume
MFloat * m_bodyVolume
Definition: fvmbcartesiansolverxd.h:697

FvMbCartesianSolverXD::m_couplingRateLinear
MFloat m_couplingRateLinear
Definition: fvmbcartesiansolverxd.h:705

FvMbCartesianSolverXD::correctBoundarySurfaceVariablesMb
void correctBoundarySurfaceVariablesMb()
sets boundary surface variables to their correct values
Definition: fvmbcartesiansolverxd.cpp:18201

FvMbCartesianSolverXD::m_bboxLocal
MFloat * m_bboxLocal
Definition: fvmbcartesiansolverxd.h:809

FvMbCartesianSolverXD::m_candidateNodeSet
std::vector< MInt > m_candidateNodeSet
Definition: fvmbcartesiansolverxd.h:781

FvMbCartesianSolverXD::noCellDataDlb
MInt noCellDataDlb() const override
Methods to inquire solver data information.
Definition: fvmbcartesiansolverxd.h:1012

FvMbCartesianSolverXD::m_couplingRate
MFloat m_couplingRate
Definition: fvmbcartesiansolverxd.h:703

FvMbCartesianSolverXD::exchangeLinkedHaloCellsForAzimuthalReconstruction
void exchangeLinkedHaloCellsForAzimuthalReconstruction()
Create exchange for all window/halo cells which are used for the azimuthal periodic interpolation.
Definition: fvmbcartesiansolverxd.cpp:36884

FvMbCartesianSolverXD::updateAzimuthalMaxLevelRecCoords
void updateAzimuthalMaxLevelRecCoords()
Update reconstruction coordinate for azimuthal halo cells on max level This is done because of moving...
Definition: fvmbcartesiansolverxd.cpp:36341

FvMbCartesianSolverXD::m_couplingRatePressure
MFloat m_couplingRatePressure
Definition: fvmbcartesiansolverxd.h:706

FvMbCartesianSolverXD::rebuildKDTree
void rebuildKDTree()
Definition: fvmbcartesiansolverxd.cpp:2318

FvMbCartesianSolverXD::m_writeCenterLineData
MBool m_writeCenterLineData
Definition: fvmbcartesiansolverxd.h:607

FvMbCartesianSolverXD::m_applyRotationalCollisionModel
MBool m_applyRotationalCollisionModel
Definition: fvmbcartesiansolverxd.h:619

FvMbCartesianSolverXD::m_cutFaceArea
MFloat ** m_cutFaceArea
Definition: fvmbcartesiansolverxd.h:805

FvMbCartesianSolverXD::matrixVectorProductTranspose
static void matrixVectorProductTranspose(MFloat *c, MFloatScratchSpace &A, MFloat *b)
c=A^t*b
Definition: fvmbcartesiansolverxd.cpp:4224

Geometry
Definition: geometry.h:36

GeometryIntersection
Definition: geometryintersection.h:56

ScratchSpace
This class is a ScratchSpace.
Definition: scratch.h:758

Solver::m_restartTimeStep
MInt m_restartTimeStep
Definition: solver.h:80

Solver::outputDir
MString outputDir() const
Return the directory for output files.
Definition: solver.h:407

Solver::m_bandWidth
MInt * m_bandWidth
Definition: solver.h:94

Solver::m_restart
MBool m_restart
Definition: solver.h:97

Solver::m_solutionTimeSteps
std::set< MInt > m_solutionTimeSteps
Definition: solver.h:76

Solver::domainId
virtual MInt domainId() const
Return the domainId (rank)
Definition: solver.h:383

Solver::isActive
virtual MBool isActive() const
Definition: solver.h:391

Solver::mpiComm
MPI_Comm mpiComm() const
Return the MPI communicator used by this solver.
Definition: solver.h:380

Solver::m_outerBandWidth
MFloat * m_outerBandWidth
Definition: solver.h:92

Solver::solverId
MInt solverId() const
Return the solverId.
Definition: solver.h:425

Solver::m_useNonSpecifiedRestartFile
MBool m_useNonSpecifiedRestartFile
Definition: solver.h:83

Solver::m_solutionOutput
MString m_solutionOutput
Definition: solver.h:82

Solver::m_restartInterval
MInt m_restartInterval
The number of timesteps before writing the next restart file.
Definition: solver.h:79

Solver::getIdentifier
MString getIdentifier(const MBool useSolverId=false, const MString preString="", const MString postString="_")
Definition: solver.cpp:188

Solver::m_residualInterval
MInt m_residualInterval
The number of timesteps before writing the next residual.
Definition: solver.h:87

Solver::m_solutionOffset
MInt m_solutionOffset
Definition: solver.h:75

Solver::m_singleAdaptation
MBool m_singleAdaptation
Definition: solver.h:103

Solver::m_restartOffset
MInt m_restartOffset
Definition: solver.h:81

Solver::m_solverId
const MInt m_solverId
a unique solver identifier
Definition: solver.h:90

Solver::noDomains
virtual MInt noDomains() const
Definition: solver.h:387

Solver::m_restartFile
MBool m_restartFile
Definition: solver.h:98

Solver::m_solutionInterval
MInt m_solutionInterval
The number of timesteps before writing the next solution file.
Definition: solver.h:74

Solver::restartDir
MString restartDir() const
Return the directory for restart files.
Definition: solver.h:410

Solver::m_Re
MFloat m_Re
the Reynolds number
Definition: solver.h:68

Solver::m_Ma
MFloat m_Ma
the Mach number
Definition: solver.h:71

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::m_revDir
const MInt m_revDir[6]
Definition: cartesiansolver.h:291

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::noWindowCells
MInt noWindowCells(const MInt domainId) const
Definition: cartesiansolver.h:76

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::minLevel
MInt minLevel() const
Read-only accessors for grid data.
Definition: cartesiansolver.h:65

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::grid
constexpr GridProxy & grid() const
Definition: cartesiansolver.h:94

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::domainOffset
MLong domainOffset(const MInt id) const
Definition: cartesiansolver.h:72

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::collectVariables
void collectVariables(T *variablesIn, ScratchSpace< T > &variablesOut, const std::vector< MString > &variablesNameIn, std::vector< MString > &variablesNameOut, const MInt noVars, const MInt noCells, const MBool reverseOrder=false)
generalised helper function for writing restart files! This is necessary for example if the minLevel ...
Definition: cartesiansolver.h:2879

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::maxRefinementLevel
MInt maxRefinementLevel() const
Definition: cartesiansolver.h:68

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::extractPointIdsFromGrid
void extractPointIdsFromGrid(Collector< PointBasedCell< nDim > > *&, Collector< CartesianGridPoint< nDim > > *&, const MBool, const std::map< MInt, MInt > &, MInt levelThreshold=999999, MFloat *bBox=nullptr, MBool levelSetMb=false) const
Creates a list of unique corner points for all cells using a hash map levelThreshold optionally speci...
Definition: cartesiansolver.h:3524

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::collectParameters
void collectParameters(T, ScratchSpace< T > &, const MChar *, std::vector< MString > &)
This function collects a single parameters for the massivley parallel IO functions.
Definition: cartesiansolver.h:2930

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::noHaloCells
MInt noHaloCells(const MInt domainId) const
Definition: cartesiansolver.h:74

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::maxLevel
MInt maxLevel() const
Definition: cartesiansolver.h:66

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::c_noCells
MInt c_noCells() const
Definition: cartesiansolver.h:164

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::m_maxNoSets
MInt m_maxNoSets
Definition: cartesiansolver.h:285

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::isActive
MBool isActive() const override
Definition: cartesiansolver.h:91

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::windowCellId
MInt windowCellId(const MInt domainId, const MInt cellId) const
Definition: cartesiansolver.h:77

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::m_adaptation
MBool m_adaptation
Definition: cartesiansolver.h:266

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::noMinCells
MInt noMinCells() const
Definition: cartesiansolver.h:86

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::noNeighborDomains
MInt noNeighborDomains() const
Definition: cartesiansolver.h:70

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::haloCellId
MInt haloCellId(const MInt domainId, const MInt cellId) const
Definition: cartesiansolver.h:75

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::maxUniformRefinementLevel
MInt maxUniformRefinementLevel() const
Definition: cartesiansolver.h:69

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::neighborDomain
MInt neighborDomain(const MInt id) const
Definition: cartesiansolver.h:71

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::maxNoGridCells
MInt maxNoGridCells() const
Definition: cartesiansolver.h:67

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::m_recalcIds
MInt * m_recalcIds
Definition: cartesiansolver.h:277

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::exchangeData
void exchangeData(T *data, const MInt dataBlockSize=1)
Exchange memory in 'data' assuming a solver size of 'dataBlockSize' per cell.
Definition: cartesiansolver.h:3127

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::noHaloLayers
MInt noHaloLayers() const
Definition: cartesiansolver.h:73

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::minCell
MInt minCell(const MInt id) const
Definition: cartesiansolver.h:87

maia::CartesianSolver< nDim_, FvCartesianSolverXD< nDim_, SysEqn > >::m_adaptationInterval
MInt m_adaptationInterval
Definition: cartesiansolver.h:261

maia::grid::Proxy
Definition: cartesiangridproxy.h:36

SolverType
SolverType
Definition: enums.h:22

MFLOAT
@ MFLOAT
Definition: enums.h:269

MLONG
@ MLONG
Definition: enums.h:269

fvcartesiancellcollector.h

FvCell
FvCell
FV cell Property Labels.
Definition: fvcartesiancellproperties.h:14

fvcartesiansolverxd.h

m_revDir
const MInt m_revDir[6]
Definition: fvmbcartesiansolverxd.h:45

geometryintersection.h

kdtree.h

IPOW2
constexpr MLong IPOW2(MInt x)
Definition: maiaconstants.h:154

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

MLong
int64_t MLong
Definition: maiatypes.h:64

MBool
bool MBool
Definition: maiatypes.h:58

MChar
char MChar
Definition: maiatypes.h:56

id
MInt id
Definition: maiatypes.h:71

MUlong
uint64_t MUlong
Definition: maiatypes.h:65

maia::fv::cell::BitsetType
std::bitset< p(FvCell::NumProperties)> BitsetType
Definition: fvcartesiancellproperties.h:62

partition.h

pointbox.h

FvMbCartesianSolverXD::CellDataDlb
Definition: fvmbcartesiansolverxd.h:1792

FvMbCartesianSolverXD::CellDataDlb::count
static constexpr const MInt count
Definition: fvmbcartesiansolverxd.h:1793

KDtree
Definition: kdtree.h:73

KDtree::locatenear
MInt locatenear(Point< DIM > pt, MFloat r, MInt *list, MInt nmax, MBool returnCellId=true)
Definition: kdtree.h:320

Point
Definition: pointbox.h:20

a
Definition: contexttypes.h:19

b
Definition: geometrycontexttypes.h:23

maia::fv::Timers_
Definition: fvcartesiansolverxd.h:112

pointType
Definition: fvstructuredsolverwindowinfo.h:21

y
define array structures
Definition: geometrycontexttypes.h:14