Loading...
Searching...
No Matches
Public Types |
Public Member Functions |
Public Attributes |
Protected Attributes |
Static Protected Attributes |
Friends |
List of all members
FvStructuredSolver2D Class Reference
2D structured solver class More...
#include <fvstructuredsolver2d.h>
Inheritance diagram for FvStructuredSolver2D:
Collaboration diagram for FvStructuredSolver2D:
Public Types | |
| typedef void(FvStructuredSolver2D::* | fluxmethod) (MFloat *, MFloat *, MInt, MInt) |
 Public Types inherited from FvStructuredSolver< 2 > | |
| using | Timers = maia::structured::Timers_ |
Public Member Functions | |
| FvStructuredSolver2D (MInt, StructuredGrid< 2 > *, MBool *, const MPI_Comm comm) | |
| Constructor for the 2D structured solver. More... | |
| ~FvStructuredSolver2D () | |
| virtual void | initialCondition () |
| Computation of infinity values for the conservative and primitive variables Initialization ot the entire flow field. More... | |
| virtual void | initSolutionStep (MInt mode) |
| initalize the solution step More... | |
| void | computeCellCentreCoordinates () |
| void | addGhostPointCoordinateValues () |
| void | extrapolateGhostPointCoordinatesBC () |
| void | initMovingGrid () |
| void | moveGrid (const MBool isRestart, const MBool zeroPos) override |
| void | initFluxMethod () |
| void | assignBndryCells () |
| void | initBndryCnds () |
| void | allocateSingularities () |
| void | applyBoundaryCondition () |
| void | loadRestartBC2600 () |
| void | computePrimitiveVariables () override |
| template<MFloat(FvStructuredSolver::*)(MInt) const = &FvStructuredSolver::dummy> | |
| void | computePrimitiveVariables_ () |
| void | convertSA2KEPS () |
| void | gather (const MBool, std::vector< std::unique_ptr< StructuredComm< 2 > > > &) override |
| void | scatter (const MBool, std::vector< std::unique_ptr< StructuredComm< 2 > > > &) override |
| void | computeCellLength () |
| virtual void | computeTimeStep () |
| MBool | maxResidual () |
| MBool | rungeKuttaStep () |
| void | updateSpongeLayer () |
| void | viscousFlux () |
| void | viscousFluxRANS () |
| template<MBool twoEqRans = false> | |
| void | viscousFluxLES () |
| template<MBool twoEqRans = false> | |
| void | viscousFluxLESCompact () |
| virtual void | computeFrictionPressureCoef (MBool computePower) override |
| MInt | getPointIdFromCell (MInt i, MInt j) |
| MInt | cellIndex (MInt i, MInt j) |
| MInt | pointIndex (MInt i, MInt j) |
| MInt | getPointIdFromPoint (MInt origin, MInt incI, MInt incJ) |
| MInt | getCellIdFromCell (MInt origin, MInt incI, MInt incJ) |
| MFloat | crossProduct (MFloat vec1[2], MFloat vec2[2]) |
| MFloat | pressure (MInt cellId) |
| MFloat | getPSI (MInt, MInt) |
| void | Ausm () |
| void | AusmLES (MFloat *QLeft, MFloat *QRight, const MInt dim, const MInt cellId) |
| AUSM Central. More... | |
| void | AusmLES_PTHRC (MFloat *QLeft, MFloat *QRight, MInt dim, MInt cellId) |
| Same AUSM scheme as AusmLES with additional damping controlled by the 4th order pressure derivative. Pressure needs to computed beforehand. More... | |
| void | AusmDV (MFloat *QLeft, MFloat *QRight, const MInt dim, const MInt cellId) |
| void | AusmLES_MovingGrid (MFloatScratchSpace &QLeft, MFloatScratchSpace &QRight, MInt dim, MInt cellId) |
| template<fluxmethod ausm, MInt noVars> | |
| void | Muscl_ () |
| template<fluxmethod ausm, MInt noVars> | |
| void | MusclStretched_ () |
| void | MusclRANS () |
| void | Muscl (MInt timerId=-1) override |
| void | MusclAlbada () |
| void | MusclNoLimiter () |
| void | computeReconstructionConstantsSVD () |
| template<MBool twoEqRans = false> | |
| void | viscousFluxCorrection () |
| template<MBool twoEqRans = false> | |
| void | viscousFluxCompactCorrection () |
| virtual void | computePorousRHS (MBool) override |
| void | computePorousRHSCorrection () |
| void | exchange6002 () |
| Public Member Functions inherited from FvStructuredSolver< 2 > | |
| FvStructuredSolver (MInt solverId, StructuredGrid< nDim > *, MBool *propertiesGroups, const MPI_Comm comm) | |
| Constructor of the structured solver. More... | |
| MBool | isActive () const |
| void | initializeFQField () |
| Counts the number of necessary FQ fields, allocates them and corrects the indexes of the FQ variable pointers. More... | |
| MInt | timer (const MInt timerId) const |
| MInt | noSolverTimers (const MBool allTimings) override |
| virtual void | writeHeaderAttributes (ParallelIoHdf5 *pio, MString fileType) |
| Overloaded version of writeHeaderAttributes that receives ParallelIoHdf5 object pointer instead of 'fileId'. More... | |
| virtual void | writePropertiesAsAttributes (ParallelIoHdf5 *pio, MString path) |
| Overloaded version of writePropertiesAsAttributes that receives ParallelIoHdf5 object pointer instead of 'fileId'. More... | |
| void | saveSolverSolution (MBool=false, const MBool=false) override |
| void | saveSolution (MBool) |
| Saves the soution to hdf5 file. More... | |
| void | savePartitions () |
| Saves the partitioned grid into an HDF5 file. Not used in production use but useful for debugging. More... | |
| void | saveBoxes () |
| virtual void | savePointsToAsciiFile (MBool) |
| virtual void | initPointsToAsciiFile () |
| virtual void | saveInterpolatedPoints () |
| virtual void | saveNodalBoxes () |
| virtual void | reIntAfterRestart (MBool) |
| MBool | prepareRestart (MBool, MBool &) override |
| Prepare the solvers for a grid-restart. More... | |
| void | writeRestartFile (MBool) override |
| void | writeRestartFile (const MBool, const MBool, const MString, MInt *) override |
| void | shiftCellValuesRestart (MBool) |
| void | loadRestartFile () |
| Load Restart File (primitive and conservative output) general formulation. More... | |
| MBool | loadBoxFile (MString, MString, MInt, MInt) |
| Load Box file general formulation. More... | |
| virtual void | loadRestartBC2600 () |
| virtual void | loadRestartBC2601 () |
| virtual void | loadRestartSTG (MBool) |
| void | saveForcesToAsciiFile (MBool) |
| Function to save the force coefficients and power to an ASCII file. More... | |
| void | saveAveragedVariables (MString, MInt, MFloat **) |
| Saves the averaged (mean) variables from postprocessing to an HDF5 file. More... | |
| void | saveProductionTerms (MString, MFloat **) |
| Writes the production terms into a given file. More... | |
| void | saveDissipation (MString, MFloat *) |
| Writes the dissipation into a given file. More... | |
| void | saveGradients (MString, MFloat **, MString *) |
| Writes the gradients into a given file. More... | |
| void | saveAverageRestart (MString, MInt, MFloat **, MFloat **, MFloat **, MFloat **) |
| Writes an restart file for postprocessing. More... | |
| void | getSolverTimings (std::vector< std::pair< MString, MFloat > > &solverTimings, const MBool allTimings) override |
| Get solver timings. More... | |
| void | getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &domainInfo) override |
| Return decomposition information, i.e. number of local elements,... More... | |
| virtual MFloat | getCellLengthY (MInt, MInt, MInt) |
| virtual MFloat | getCellCoordinate (MInt, MInt) |
| MInt | noInternalCells () const override |
| Return the number of internal cells within this solver. More... | |
| void | saveAuxData () |
| void | saveForceCoefficient (ParallelIoHdf5 *parallelIoHdf5) |
| Saves force coefficients to an HDF5 file. More... | |
| void | computeAuxData () |
| void | computeAuxDataRoot () |
| virtual void | computeDomainWidth () |
| void | computeForceCoef () |
| Function to compute the force coefficient cl, split split into the viscous part cLv and the pressure part cLp. More... | |
| void | computeForceCoefRoot () |
| Function to compute the coefficient, split split into the viscous part cLv and the pressure part cLp The ROOT version is faster due to an MPI_Reduce instead of an MPI_Allreduce, but only root rank has data. More... | |
| virtual void | computeFrictionPressureCoef (MBool)=0 |
| virtual | ~FvStructuredSolver () |
| MFloat | computeRecConstSVD (const MInt ijk, const MInt noNghbrIds, MInt *nghbr, MInt ID, MInt sID, MFloatScratchSpace &tmpA, MFloatScratchSpace &tmpC, MFloatScratchSpace &weights, const MInt recDim) |
| AUX DATA ENDS /////////////////////////////////////////////////////////////. More... | |
| void | initializeFvStructuredSolver (MBool *propertiesGroups) |
| Structured Solver Constructor reads and allocate properties/variables. More... | |
| void | allocateAndInitBlockMemory () |
| void | allocateAuxDataMaps () |
| AUX DATA //////////////////////////////////////////////////////////////////. More... | |
| void | setRungeKuttaProperties () |
| This function reads the properties required for Runge Kutta time stepping. More... | |
| void | setSamplingProperties () |
| void | setNumericalProperties () |
| Reads and initializes properties associated with the numerical method. More... | |
| void | setInputOutputProperties () |
| Reads properties and initializes variables associated with input/output. More... | |
| void | setZonalProperties () |
| Set which zones are RANS and which are LES or if full LES or full RANS. More... | |
| void | allocateVariables () |
| void | setTestcaseProperties () |
| Reads and initializes properties associated with the Testcase. More... | |
| void | setMovingGridProperties () |
| Reads and initializes properties associated with the Moving Grid Methods. More... | |
| void | setBodyForceProperties () |
| Reads and initializes properties associated with the Moving Grid Methods. More... | |
| void | setPorousProperties () |
| Set properties for porous blocks. More... | |
| void | readAndSetSpongeLayerProperties () |
| void | setSTGProperties () |
| void | setProfileBCProperties () |
| void | createMPIGroups () |
| void | readAndSetAuxDataMap () |
| void | computePV () |
| MFloat | dummy (MInt) const |
| MFloat | pressure_twoEqRans (MInt cellId) const |
| MFloat | totalEnergy_twoEqRans (MInt cellId) const |
| void | partitionGrid () |
| virtual void | computePrimitiveVariables () |
| virtual void | computeConservativeVariables () |
| void | computeConservativeVariables_ () |
| void | saveVarToPrimitive (MInt, MInt, MFloat) |
| virtual void | gcFillGhostCells (std::vector< MFloat * > &) |
| void | computeSamplingInterval () |
| void | checkNans () |
| Checks whole domain for NaNs and adds the number of NaNs globally. More... | |
| void | setVolumeForce () |
| void | computeVolumeForces () |
| virtual void | computePorousRHS (MBool) |
| void | initPorous () |
| virtual void | applyBoundaryCondtition () |
| virtual void | moveGrid (MInt) |
| virtual void | moveGrid (MBool, MBool) |
| virtual void | initMovingGrid () |
| virtual void | initBodyForce () |
| virtual void | applyBodyForce (MBool, MBool) |
| virtual void | computeLambda2Criterion () |
| virtual void | computeVorticity () |
| void | exchange () |
| SVD STUFF ENDS /////////////////////////////////////////////////////////////. More... | |
| void | exchange (std::vector< std::unique_ptr< StructuredComm< nDim > > > &, std::vector< std::unique_ptr< StructuredComm< nDim > > > &) |
| Parallel exchange of primitive variables between partitions with MPI. More... | |
| void | send (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &, std::vector< MPI_Request > &) |
| void | receive (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &, std::vector< MPI_Request > &) |
| virtual void | gather (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &) |
| virtual void | scatter (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &) |
| MBool | isPeriodicComm (std::unique_ptr< StructuredComm< nDim > > &) |
| MBool | skipPeriodicDirection (std::unique_ptr< StructuredComm< nDim > > &) |
| virtual void | zonalExchange () |
| virtual void | spanwiseAvgZonal (std::vector< MFloat * > &) |
| virtual void | waveExchange () |
| virtual void | spanwiseWaveReorder () |
| void | setTimeStep () |
| void | setLimiterVisc () |
| void | fixTimeStepTravelingWave () |
| void | exchangeTimeStep () |
| void | initializeRungeKutta () |
| virtual void | computeTimeStep () |
| MBool | isInInterval (MInt) |
| MInt | getNoCells () |
| MInt | noVariables () const override |
| Return the number of variables. More... | |
| MInt | getNoActiveCells () |
| MInt * | getActiveCells () |
| MInt * | getOffsetCells () |
| MInt | getNoGhostLayers () |
| MInt | getWaveAvrgInterval () |
| MInt | getWaveStepOffset () |
| MInt * | getCellGrid () |
| MBool | isMovingGrid () |
| MInt | getGridMovingMethod () |
| MInt | getBodyForceMethod () |
| MBool | isStreamwiseTravelingWave () |
| MBool | isTravelingWave () |
| StructuredGrid< nDim > * | getGrid () |
| MFloat | getGamma () |
| MFloat | getSutherlandConstant () |
| MFloat | getRe0 () |
| MFloat | getMa () |
| MPI_Comm | getCommunicator () |
| virtual void | computeCumulativeAverage (MBool) |
| virtual void | loadSampleFile (MString) |
| virtual void | getSampleVariables (MInt, MFloat *) |
| MFloat | getPV (MInt var, MInt cellId) |
| void | setPV (MInt var, MInt cellId, MFloat value) |
| virtual MFloat | getSampleVorticity (MInt, MInt) |
| virtual MFloat | dvardxyz (MInt, MInt, MFloat *) |
| virtual MFloat | dvardx (MInt, MFloat *) |
| virtual void | loadAverageRestartFile (const char *, MFloat **, MFloat **, MFloat **, MFloat **) |
| virtual void | loadAveragedVariables (const char *) |
| void | convertRestartVariables (MFloat oldMa) |
| virtual void | convertRestartVariablesSTG (MFloat oldMa) |
| virtual bool | rungeKuttaStep ()=0 |
| virtual void | viscousFlux ()=0 |
| virtual void | Muscl (MInt=-1)=0 |
| virtual void | applyBoundaryCondition ()=0 |
| virtual void | initSolutionStep (MInt)=0 |
| virtual void | initialCondition ()=0 |
| void | tred2 (MFloatScratchSpace &A, MInt dim, MFloat *diag, MFloat *offdiag) |
| Householder Reduction according to Numercial Recipies in C: The Art of Scientific Computing. More... | |
| void | tqli2 (MFloat *diag, MFloat *offdiag, MInt dim) |
| Compute Eigenvalues with implicit shift according to Numercial Recipies in C: The Art of Scientific Computing. More... | |
| void | insertSort (MInt dim, MFloat *list) |
| Sorting function to sort list in ascending order. More... | |
| MFloat | pythag (MFloat a, MFloat b) |
| void | resetRHS () |
| Reset the right hand side to zero. More... | |
| void | rhs () |
| void | rhsBnd () |
| void | lhsBnd () |
| void | initSolver () override |
| virtual MBool | maxResidual () |
| MBool | solutionStep () override |
| void | preTimeStep () override |
| void | postTimeStep () override |
| : Performs the post time step More... | |
| void | finalizeInitSolver () override |
| void | cleanUp () override |
| virtual void | updateSpongeLayer ()=0 |
| MFloat | time () const override |
| Return the time. More... | |
| MInt | determineRestartTimeStep () const override |
| Load the restart time step from the restart file (useNonSpecifiedRestartFile enabled) More... | |
| MBool | hasRestartTimeStep () const override |
| void | init () |
| std::array< MInt, nDim > | beginP0 () |
| std::array< MInt, nDim > | beginP1 () |
| std::array< MInt, nDim > | beginP2 () |
| std::array< MInt, nDim > | endM2 () |
| std::array< MInt, nDim > | endM1 () |
| std::array< MInt, nDim > | endM0 () |
| Public Member Functions inherited from Solver | |
| MString | getIdentifier (const MBool useSolverId=false, const MString preString="", const MString postString="_") |
| virtual | ~Solver ()=default |
| virtual MInt | noInternalCells () const =0 |
| Return the number of internal cells within this solver. More... | |
| virtual MFloat | time () const =0 |
| Return the time. More... | |
| virtual MInt | noVariables () const |
| Return the number of variables. More... | |
| virtual void | getDimensionalizationParams (std::vector< std::pair< MFloat, MString > > &) const |
| Return the dimensionalization parameters of this solver. More... | |
| void | updateDomainInfo (const MInt domainId, const MInt noDomains, const MPI_Comm mpiComm, const MString &loc) |
| Set new domain information. More... | |
| virtual MFloat & | a_slope (const MInt, MInt const, const MInt) |
| virtual MBool | a_isBndryCell (const MInt) const |
| virtual MFloat & | a_FcellVolume (MInt) |
| virtual MInt | getCurrentTimeStep () const |
| virtual void | accessSampleVariables (MInt, MFloat *&) |
| virtual void | getSampleVariableNames (std::vector< MString > &NotUsed(varNames)) |
| virtual MBool | a_isBndryGhostCell (MInt) const |
| virtual void | saveCoarseSolution () |
| virtual void | getSolverSamplingProperties (std::vector< MInt > &NotUsed(samplingVarIds), std::vector< MInt > &NotUsed(noSamplingVars), std::vector< std::vector< MString > > &NotUsed(samplingVarNames), const MString NotUsed(featureName)="") |
| virtual void | initSolverSamplingVariables (const std::vector< MInt > &NotUsed(varIds), const std::vector< MInt > &NotUsed(noSamplingVars)) |
| virtual void | calcSamplingVariables (const std::vector< MInt > &NotUsed(varIds), const MBool NotUsed(exchange)) |
| virtual void | calcSamplingVarAtPoint (const MFloat *NotUsed(point), const MInt NotUsed(id), const MInt NotUsed(sampleVarId), MFloat *NotUsed(state), const MBool NotUsed(interpolate)=false) |
| virtual void | balance (const MInt *const NotUsed(noCellsToReceiveByDomain), const MInt *const NotUsed(noCellsToSendByDomain), const MInt *const NotUsed(targetDomainsByCell), const MInt NotUsed(oldNoCells)) |
| Perform load balancing. More... | |
| virtual MBool | hasSplitBalancing () const |
| Return if load balancing for solver is split into multiple methods or implemented in balance() More... | |
| virtual void | balancePre () |
| virtual void | balancePost () |
| virtual void | finalizeBalance () |
| virtual void | resetSolver () |
| Reset the solver/solver for load balancing. More... | |
| virtual void | cancelMpiRequests () |
| Cancel open mpi (receive) requests in the solver (e.g. due to interleaved execution) More... | |
| virtual void | setCellWeights (MFloat *) |
| Set cell weights. More... | |
| virtual MInt | noLoadTypes () const |
| virtual void | getDefaultWeights (MFloat *NotUsed(weights), std::vector< MString > &NotUsed(names)) const |
| virtual void | getLoadQuantities (MInt *const NotUsed(loadQuantities)) const |
| virtual MFloat | getCellLoad (const MInt NotUsed(cellId), const MFloat *const NotUsed(weights)) const |
| virtual void | limitWeights (MFloat *NotUsed(weights)) |
| virtual void | localToGlobalIds () |
| virtual void | globalToLocalIds () |
| virtual MInt | noCellDataDlb () const |
| Methods to inquire solver data information. More... | |
| virtual MInt | cellDataTypeDlb (const MInt NotUsed(dataId)) const |
| virtual MInt | cellDataSizeDlb (const MInt NotUsed(dataId), const MInt NotUsed(cellId)) |
| virtual void | getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt *const NotUsed(bufferIdToCellId), MInt *const NotUsed(data)) |
| virtual void | getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt *const NotUsed(bufferIdToCellId), MLong *const NotUsed(data)) |
| virtual void | getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt *const NotUsed(bufferIdToCellId), MFloat *const NotUsed(data)) |
| virtual void | setCellDataDlb (const MInt NotUsed(dataId), const MInt *const NotUsed(data)) |
| virtual void | setCellDataDlb (const MInt NotUsed(dataId), const MLong *const NotUsed(data)) |
| virtual void | setCellDataDlb (const MInt NotUsed(dataId), const MFloat *const NotUsed(data)) |
| virtual void | getGlobalSolverVars (std::vector< MFloat > &NotUsed(globalFloatVars), std::vector< MInt > &NotUsed(globalIntVars)) |
| virtual void | setGlobalSolverVars (std::vector< MFloat > &NotUsed(globalFloatVars), std::vector< MInt > &NotUsed(globalIdVars)) |
| void | enableDlbTimers () |
| void | reEnableDlbTimers () |
| void | disableDlbTimers () |
| MBool | dlbTimersEnabled () |
| void | startLoadTimer (const MString name) |
| void | stopLoadTimer (const MString &name) |
| void | stopIdleTimer (const MString &name) |
| void | startIdleTimer (const MString &name) |
| MBool | isLoadTimerRunning () |
| virtual MInt | noSolverTimers (const MBool NotUsed(allTimings)) |
| virtual void | getSolverTimings (std::vector< std::pair< MString, MFloat > > &NotUsed(solverTimings), const MBool NotUsed(allTimings)) |
| virtual void | getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &NotUsed(domainInfo)) |
| void | setDlbTimer (const MInt timerId) |
| virtual void | prepareAdaptation (std::vector< std::vector< MFloat > > &, std::vector< MFloat > &, std::vector< std::bitset< 64 > > &, std::vector< MInt > &) |
| virtual void | reinitAfterAdaptation () |
| virtual void | prepareAdaptation () |
| prepare adaptation for split adaptation before the adaptation loop More... | |
| virtual void | setSensors (std::vector< std::vector< MFloat > > &, std::vector< MFloat > &, std::vector< std::bitset< 64 > > &, std::vector< MInt > &) |
| set solver sensors for split adaptation within the adaptation loop More... | |
| virtual void | saveSensorData (const std::vector< std::vector< MFloat > > &, const MInt &, const MString &, const MInt *const) |
| virtual void | postAdaptation () |
| post adaptation for split adaptation within the adaptation loop More... | |
| virtual void | finalizeAdaptation () |
| finalize adaptation for split sadptation after the adaptation loop More... | |
| virtual void | refineCell (const MInt) |
| Refine the given cell. More... | |
| virtual void | removeChilds (const MInt) |
| Coarsen the given cell. More... | |
| virtual void | removeCell (const MInt) |
| Remove the given cell. More... | |
| virtual void | swapCells (const MInt, const MInt) |
| Swap the given cells. More... | |
| virtual void | swapProxy (const MInt, const MInt) |
| Swap the given cells. More... | |
| virtual MInt | cellOutside (const MFloat *, const MInt, const MInt) |
| Check whether cell is outside the fluid domain. More... | |
| virtual void | resizeGridMap () |
| Swap the given cells. More... | |
| virtual MBool | prepareRestart (MBool, MBool &) |
| Prepare the solvers for a grid-restart. More... | |
| virtual void | reIntAfterRestart (MBool) |
| MPI_Comm | mpiComm () const |
| Return the MPI communicator used by this solver. More... | |
| virtual MInt | domainId () const |
| Return the domainId (rank) More... | |
| virtual MInt | noDomains () const |
| virtual MBool | isActive () const |
| void | setSolverStatus (const MBool status) |
| MBool | getSolverStatus () |
| Get the solver status indicating if the solver is currently active in the execution recipe. More... | |
| MString | testcaseDir () const |
| Return the testcase directory. More... | |
| MString | outputDir () const |
| Return the directory for output files. More... | |
| MString | restartDir () const |
| Return the directory for restart files. More... | |
| MString | solverMethod () const |
| Return the solverMethod of this solver. More... | |
| MString | solverType () const |
| Return the solverType of this solver. More... | |
| MInt | restartInterval () const |
| Return the restart interval of this solver. More... | |
| MInt | restartTimeStep () const |
| Return the restart interval of this solver. More... | |
| MInt | solverId () const |
| Return the solverId. More... | |
| MBool | restartFile () |
| MInt | readSolverSamplingVarNames (std::vector< MString > &varNames, const MString featureName="") const |
| Read sampling variables names, store in vector and return the number of sampling variables. More... | |
| virtual MBool | hasRestartTimeStep () const |
| virtual MBool | forceAdaptation () |
| virtual void | preTimeStep ()=0 |
| virtual void | postTimeStep ()=0 |
| virtual void | initSolver ()=0 |
| virtual void | finalizeInitSolver ()=0 |
| virtual void | saveSolverSolution (const MBool NotUsed(forceOutput)=false, const MBool NotUsed(finalTimeStep)=false)=0 |
| virtual void | cleanUp ()=0 |
| virtual MBool | solutionStep () |
| virtual void | preSolutionStep (MInt) |
| virtual MBool | postSolutionStep () |
| virtual MBool | solverConverged () |
| virtual void | getInterpolatedVariables (MInt, const MFloat *, MFloat *) |
| virtual void | loadRestartFile () |
| virtual MInt | determineRestartTimeStep () const |
| virtual void | writeRestartFile (MBool) |
| virtual void | writeRestartFile (const MBool, const MBool, const MString, MInt *) |
| virtual void | setTimeStep () |
| virtual void | implicitTimeStep () |
| virtual void | prepareNextTimeStep () |
| Public Member Functions inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > > | |
| StructuredPostprocessing () | |
| Constructor for the postprocessing solver. More... | |
| ~StructuredPostprocessing () | |
| Destructor for the postprocessing solver. More... | |
| void | postprocessPreInit () |
| void | postprocessPreSolve () |
| void | postprocessPostSolve () |
| void | postprocessInSolve () |
Public Attributes | |
| void(FvStructuredSolver2D::* | viscFluxMethod )() |
| void(FvStructuredSolver2D::* | reconstructSurfaceData )() |
| FvStructuredSolver2DRans * | m_ransSolver |
| Public Attributes inherited from FvStructuredSolver< 2 > | |
| StructuredGrid< nDim > * | m_grid |
| MPI_Comm | m_StructuredComm |
| MInt | m_restartTimeStep |
| MString | m_outputFormat |
| MInt | m_lastOutputTimeStep |
| Public Attributes inherited from Solver | |
| std::set< MInt > | m_freeIndices |
| MBool | m_singleAdaptation = false |
| MBool | m_splitAdaptation = true |
| MBool | m_saveSensorData = false |
| Public Attributes inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > > | |
| MInt | m_restartTimeStep |
Static Protected Attributes | |
| static constexpr const MInt | nDim = 2 |
| Static Protected Attributes inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > > | |
| static const MInt | xsd |
| static const MInt | ysd |
| static const MInt | zsd |
Friends | |
| template<MBool isRans> | |
| class | StructuredBndryCnd2D |
| class | FvStructuredSolver2DRans |
Additional Inherited Members | |
| Protected Types inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > > | |
| typedef void(StructuredPostprocessing::* | tpost) () |
| typedef std::vector< tpost > | tvecpost |
| Protected Member Functions inherited from FvStructuredSolver< 2 > | |
| void | initTimers () |
| virtual void | initFsc () |
| Init for Falkner-Skan-Cooke flow. More... | |
| virtual MFloat | getFscPressure (MInt cellId) |
| virtual MFloat | getFscPressure (MFloat coordX) |
| virtual MFloat | getFscEta (MFloat coordX, MFloat coordY) |
| virtual void | getFscVelocity (MInt cellId, MFloat *const vel) |
| Load variables for the specified timeStep. More... | |
| virtual void | getFscVelocity (MFloat coordX, MFloat coordY, MFloat *const vel) |
| virtual void | initBlasius () |
| Init for Blasius boundary layer. More... | |
| virtual MFloat | getBlasiusEta (MFloat coordX, MFloat coordY) |
| virtual void | getBlasiusVelocity (MInt cellId, MFloat *const vel) |
| Load variables for the specified timeStep. More... | |
| virtual void | getBlasiusVelocity (MFloat coordX, MFloat coordY, MFloat *const vel) |
| Protected Member Functions inherited from Solver | |
| Solver (const MInt solverId, const MPI_Comm comm, const MBool isActive=true) | |
| MFloat | returnLoadRecord () const |
| MFloat | returnIdleRecord () const |
| Protected Member Functions inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > > | |
| void | initStructuredPostprocessing () |
| void | initAverageIn () |
| Initializes properties for averaging during solver run. More... | |
| void | initAverageVariables () |
| allocates memory for averageSolutions() and averageSolutionsInSolve() More... | |
| void | initTimeStepProperties () |
| Initializes timestep properties for postprocessing. More... | |
| void | initMovingAverage () |
| void | initProductionVariables () |
| void | initDissipationVariables () |
| void | averageSolutionsInSolve () |
| void | averageSolutions () |
| void | addAveragingSample () |
| Adds one sample to the summedVars. More... | |
| void | addTempWaveSample () |
| Adds for the travelling wave setups. More... | |
| void | saveAveragedSolution (MInt) |
| void | computeAveragedSolution () |
| Computes the mean variables from summed vars. More... | |
| void | computeAverageSkinFriction () |
| Computes skin friction of an averaged field. More... | |
| void | subtractPeriodicFluctuations () |
| void | subtractMean () |
| void | movingAverage () |
| void | movingAveragePost () |
| void | computeProductionTerms () |
| Computes the production terms from an averaged field. More... | |
| void | computeDissipationTerms () |
| Computes the production terms from an averaged field. More... | |
| void | decomposeCf () |
| void | decomposeCfDouble () |
| void | writeGradients () |
| void | loadAveragedSolution () |
| Loads an averaged file again. More... | |
| void | saveAverageRestart () |
| void | loadMeanFile (const MChar *fileName) |
| void | getSampleVariables (MInt cellId, const MFloat *&vars) |
| MInt | getNoPPVars () |
| Returns number of postprocessing variables. More... | |
| MInt | getNoVars () |
| MInt | getNoPPSquareVars () |
| Returns number of pp Square variables. More... | |
Detailed Description
Definition at line 21 of file fvstructuredsolver2d.h.
Member Typedef Documentation
◆ fluxmethod
| typedef void(FvStructuredSolver2D::* FvStructuredSolver2D::fluxmethod) (MFloat *, MFloat *, MInt, MInt) |
Definition at line 90 of file fvstructuredsolver2d.h.
Constructor & Destructor Documentation
◆ FvStructuredSolver2D()
| FvStructuredSolver2D::FvStructuredSolver2D | ( | MInt | solverId, |
| StructuredGrid< 2 > * | grid_, | ||
| MBool * | propertiesGroups, | ||
| const MPI_Comm | comm | ||
| ) |
Definition at line 19 of file fvstructuredsolver2d.cpp.
22 TRACE();
24
25 // count the no of necessary FQ fields and allocate
26 initializeFQField();
27
28 // compute the cell center coordinates from point coordinates
30
33 } else {
35 }
36
37 allocateSingularities();
38
39 // assign coordinates to all ghost points
41
42 // allocate memory for aux data maps (cf,cp)
43 allocateAuxDataMaps();
44
45 // if we are Rans we should allocate a new RANS solver
48 }
49
52 m_grid->computeMetrics();
55 m_grid->computeJacobian();
57
58 // TODO_SS labels:FV By now I am not sure if Code performs correctly for wrongly oriented meshes
64 }
65 }
66 }
67
68 initFluxMethod();
69
71
72 // Assign handlers to the correct boundary conditions
73 assignBndryCells();
74
75 // Computation of modified wall distance in porous computation requires to set the porosity,
76 // Da-number etc. first; on the other hand we need to wait for initializeFQField to be called
78 initPorous();
79 // exchange6002();
80 }
81
85 // m_structuredBndryCnd->computeLocalWallDistances();
86 else
88 }
89
90 // utau is required in RANS models for the computation of y+; In case the wall distance is very
91 // large, the utau computation is skipped; In such situations the default value of utau=0 would
92 // yield a y+=0 even very far away from walls
93 // TODO_SS labels:FV currently in UTAU we save the inverse of the turbulent length scale
97 }
98 }
99 }
100
103}
void addGhostPointCoordinateValues()
Definition: fvstructuredsolver2d.cpp:1630
void computeCellCentreCoordinates()
Definition: fvstructuredsolver2d.cpp:1461
void allocateSingularities()
Definition: fvstructuredsolver2d.cpp:4244
MInt cellIndex(MInt i, MInt j)
Definition: fvstructuredsolver2d.cpp:1624
StructuredBndryCnd< 2 > * m_structuredBndryCnd
Definition: fvstructuredsolver2d.h:120
FvStructuredSolver2DRans * m_ransSolver
Definition: fvstructuredsolver2d.h:117
friend class FvStructuredSolver2DRans
Definition: fvstructuredsolver2d.h:24
void assignBndryCells()
Definition: fvstructuredsolver2d.cpp:1445
std::unique_ptr< StructuredFQVariables > FQ
Definition: fvstructuredsolver.h:469
std::array< MInt, Timers::_count > m_timers
Definition: fvstructuredsolver.h:572
MBool m_setLocalWallDistance
Definition: fvstructuredsolver.h:491
MPI_Comm m_StructuredComm
Definition: fvstructuredsolver.h:324
void initializeFQField()
Counts the number of necessary FQ fields, allocates them and corrects the indexes of the FQ variable ...
Definition: fvstructuredsolver.cpp:277
void allocateAuxDataMaps()
AUX DATA //////////////////////////////////////////////////////////////////.
Definition: fvstructuredsolver.cpp:7804
Class for the 2D stuctured boundary conditions.
Definition: fvstructuredbndrycnd2d.h:21
virtual void computeLocalExtendedDistancesAndSetComm()
Definition: fvstructuredbndrycnd.h:178
virtual void computeWallDistances()
Definition: fvstructuredbndrycnd.h:176
void mTerm(const MInt errorCode, const MString &location, const MString &message)
Definition: functions.cpp:29
void printAllocatedMemory(const MLong oldAllocatedBytes, const MString &solverName, const MPI_Comm comm)
Prints currently allocated memory.
Definition: genericobject.cpp:26
◆ ~FvStructuredSolver2D()
| FvStructuredSolver2D::~FvStructuredSolver2D | ( | ) |
Definition at line 242 of file fvstructuredsolver2d.cpp.
242 {
243 TRACE();
244
248 }
249
252 }
253}
SingularInformation * m_singularity
Definition: fvstructuredsolver.h:835
Member Function Documentation
◆ addGhostPointCoordinateValues()
| void FvStructuredSolver2D::addGhostPointCoordinateValues | ( | ) |
Definition at line 1630 of file fvstructuredsolver2d.cpp.
1630 {
1631 TRACE();
1632
1639 }
1640 }
1641 }
1642
1643 // 1) extrapolate GhostPoints
1644 m_grid->extrapolateGhostPointCoordinates();
1645 // 2) communicate GhostPoints
1646
1649
1651
1652 computeCellCentreCoordinates();
1653
1654 // MUST be done after cell center computation!!!
1657
1660 }
1661
1662 // 3) write the totalGridFile with GhostPoints
1664 m_grid->writePartitionedGrid();
1665 }
1666}
void computeReconstructionConstantsSVD()
Definition: fvstructuredsolver2d.cpp:4341
void extrapolateGhostPointCoordinatesBC()
Definition: fvstructuredsolver2d.cpp:1669
MBool m_savePartitionOutput
Definition: fvstructuredsolver.h:669
std::vector< std::unique_ptr< StructuredComm< nDim > > > m_sndComm
Definition: fvstructuredsolver.h:728
std::vector< std::unique_ptr< StructuredComm< nDim > > > m_rcvComm
Definition: fvstructuredsolver.h:729
◆ allocateSingularities()
| void FvStructuredSolver2D::allocateSingularities | ( | ) |
Definition at line 4244 of file fvstructuredsolver2d.cpp.
4244 {
4249
4254 }
4255
4256 // 4 unknowns and Nstar cells
4257 mAlloc(m_singularity[i].ReconstructionConstants, nDim + 1, m_singularity[i].totalCells * m_singularity[i].Nstar,
4258 "ReconstructionConstants", 0.0, AT_);
4259 }
4260}
void mAlloc(T *&a, const MLong N, const MString &objectName, MString function)
allocates memory for one-dimensional array 'a' of size N
Definition: alloc.h:173
◆ applyBoundaryCondition()
|
virtual |
Implements FvStructuredSolver< 2 >.
Definition at line 1455 of file fvstructuredsolver2d.cpp.
1455 {
1456 TRACE();
1457 // treat Dirichlet and Neumann BC in one go!!!
1459}
void applyDirichletNeumannBC()
Definition: fvstructuredbndrycnd.cpp:47
◆ assignBndryCells()
| void FvStructuredSolver2D::assignBndryCells | ( | ) |
Definition at line 1445 of file fvstructuredsolver2d.cpp.
1445 {
1446 TRACE();
1448}
◆ Ausm()
| void FvStructuredSolver2D::Ausm | ( | ) |
Definition at line 2047 of file fvstructuredsolver2d.cpp.
2047 {
2048 // Ausm routines have been moved and are called from inside Muscl (better performance)
2049}
◆ AusmDV()
|
inline |
Definition at line 2215 of file fvstructuredsolver2d.cpp.
2215 {
2219
2222
2223 // left side
2229
2230 // right side
2236
2241
2242
2243 // compute lenght of metric vector for normalization
2246
2247 // scale by metric length to get velocity in the new basis (get normalized basis vectors)
2249
2250
2252
2253 MFloat AL = FRHOL * PL;
2254 MFloat AR = FRHOR * PR;
2255
2259
2260 AL = sqrt(gamma * AL);
2261 AR = sqrt(gamma * AR);
2262 AL = mMax(AL, AR);
2263 AR = AL;
2264
2267
2268 AL = AL * DGRAD;
2269 AR = AR * DGRAD;
2270
2273
2276
2280 MFloat SV = 2.0 * DGRAD / (m_cells->cellJac[I] + m_cells->cellJac[IP1]) * (FDV + (F1 - FDV) * getPSI(I, dim));
2283
2286
2287 MFloat FXMA = F1B2 * (XMAL1 + fabs(XMAL1));
2289 FXMA = F1B2 * (XMAR1 - fabs(XMAR1));
2290 const MFloat XMARM = ALPHAR * (-F1B4 * POW2(XMAR1 - F1) - FXMA) + FXMA + (mMin(-F1, XMAR) + F1);
2291
2295
2301
2304 UL = UL - UUL2;
2305 UR = UR - UUR2;
2308 VL = VL - UUL3;
2309 VR = VR - UUR3;
2310
2311
2313
2314 flux[CV->RHO_U][I] = RHOU2 * (UL + UR) + ARHOU2 * (UL - UR) + PLR * surf0 + RHOUL * UUL2 + RHOUR * UUR2;
2315 flux[CV->RHO_V][I] = RHOU2 * (VL + VR) + ARHOU2 * (VL - VR) + PLR * surf1 + RHOUL * UUL3 + RHOUR * UUR3;
2316 flux[CV->RHO_E][I] = RHOU2 * (e0 + e1) + ARHOU2 * (e0 - e1);
2317 flux[CV->RHO][I] = RHOU;
2318}
std::unique_ptr< MPrimitiveVariables< nDim > > PV
Definition: fvstructuredsolver.h:333
std::unique_ptr< MConservativeVariables< nDim > > CV
Definition: fvstructuredsolver.h:332
◆ AusmLES()
|
inline |
Can be used for moving grids, dxt term is included
Definition at line 2058 of file fvstructuredsolver2d.cpp.
2058 {
2062
2065
2067
2068 // calculate pressure
2073
2078
2079 // compute lenght of metric vector for normalization
2082
2083 // scale by metric length to get velocity in the new basis (get normalized basis vectors)
2085
2086
2088
2089
2090 // speed of sound
2093
2096
2099
2102
2105
2108
2109 const MFloat RHOU = F1B2 * (MALR * (RHO_AL + RHO_AR) + fabs(MALR) * (RHO_AL - RHO_AR)) * metricLength;
2111 // multiply by metric length to take surface area into account
2113
2115
2116 flux[CV->RHO_U][I] = RHOU2 * (UL + UR) + AbsRHO_U2 * (UL - UR) + PLR * surf0;
2117 flux[CV->RHO_V][I] = RHOU2 * (VL + VR) + AbsRHO_U2 * (VL - VR) + PLR * surf1;
2118 flux[CV->RHO_E][I] = RHOU2 * (e0 + e1) + AbsRHO_U2 * (e0 - e1) + PLR * dxdtau;
2119 flux[CV->RHO][I] = RHOU;
2120}
◆ AusmLES_MovingGrid()
|
inline |
◆ AusmLES_PTHRC()
|
inline |
Definition at line 2129 of file fvstructuredsolver2d.cpp.
2129 {
2133
2136
2138
2140
2141 // calculate pressure
2146
2151
2152 // compute lenght of metric vector for normalization
2155
2156 // scale by metric length to get velocity in the new basis (get normalized basis vectors)
2158
2159
2161
2162
2163 // speed of sound
2166
2169
2171
2172 // compute splitting pressure
2177
2182
2185
2188 MFloat fac = cfac * pfac;
2189 fac = min(1 / 64.0, fac * 5.0);
2190
2192
2195
2198
2201
2202 const MFloat RHOU = F1B2 * (MALR * (RHO_AL + RHO_AR) + fabs(MALR) * (RHO_AL - RHO_AR)) * metricLength;
2204 // multiply by metric length to take surface area into account
2206
2208
2209 flux[CV->RHO_U][I] = RHOU2 * (UL + UR) + AbsRHO_U2 * (UL - UR) + PLR * surf0;
2210 flux[CV->RHO_V][I] = RHOU2 * (VL + VR) + AbsRHO_U2 * (VL - VR) + PLR * surf1;
2211 flux[CV->RHO_E][I] = RHOU2 * (e0 + e1) + AbsRHO_U2 * (e0 - e1) + PLR * dxdtau;
2212 flux[CV->RHO][I] = RHOU;
2213}
MInt getCellIdFromCell(MInt origin, MInt incI, MInt incJ)
Definition: fvstructuredsolver2d.cpp:1620
constexpr std::underlying_type< FcCell >::type p(const FcCell property)
Converts property name to underlying integer value.
Definition: fccellproperties.h:32
◆ cellIndex()
Definition at line 1624 of file fvstructuredsolver2d.cpp.
◆ computeCellCentreCoordinates()
| void FvStructuredSolver2D::computeCellCentreCoordinates | ( | ) |
Definition at line 1461 of file fvstructuredsolver2d.cpp.
1461 {
1462 // function to compute the coordinates at cell centre
1463 // calculated over I, J loop but changed to one array
1471
1473 // average the coordinates for cell centre data
1477 }
1478 }
1479 }
1480}
MInt getPointIdFromPoint(MInt origin, MInt incI, MInt incJ)
Definition: fvstructuredsolver2d.cpp:1616
MInt getPointIdFromCell(MInt i, MInt j)
Definition: fvstructuredsolver2d.cpp:1614
◆ computeCellLength()
| void FvStructuredSolver2D::computeCellLength | ( | ) |
Definition at line 256 of file fvstructuredsolver2d.cpp.
256 {
257 // this function can be moved into the MusclSchemeStreched later but for testing it is easier
258 // REMEMBER: FOR MOVINg GRIDS THIS NEEDS TO BE CALLED EACH TIME
259
267 //----------Idirection
268 // face 1
271 // face 2
275 //----------Jdirection
276 // face 3
279 // face 4
283 }
284 }
285}
◆ computeFrictionPressureCoef()
|
inlineoverridevirtual |
Implements FvStructuredSolver< 2 >.
Definition at line 71 of file fvstructuredsolver2d.h.
71 {
73 }
virtual void computeFrictionPressureCoef(MBool)=0
◆ computePorousRHS()
|
overridevirtual |
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 3457 of file fvstructuredsolver2d.cpp.
3457 {
3458 TRACE();
3459
3461 1e-16; // std::min(std::numeric_limits<MFloat>::min(), 1.0/std::numeric_limits<MFloat>::max());
3463
3471
3472 if(isRans) {
3480
3486
3489 // get the adjacent cells;
3494
3495 // Compute Reynolds stresses at the corners
3498
3501
3505
3507 (m_rans2eq_mode == "production") ? -2 / 3 * F1B4 * (TKE[IJP] + TKE[IPJP] + TKE[IJ] + TKE[IPJ]) : 0.0;
3508
3511
3512 // compute tau1 = 2 du/dx - 2/3 ( du/dx + dv/dy + dw/dz )
3513
3514 // tau_xx = 4/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx )
3515 // - 2/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy)
3516 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
3517 MFloat tau1 = F4B3 * (dudxi * cornerMetrics[xsd * 2 + xsd] + dudet * cornerMetrics[ysd * 2 + xsd]) -
3518
3520
3521 // compute tau2 = du/dy + dv/dx
3522
3523 // tau_xy = du/dxi * dxi/dy + du/deta * deta/dy + du/dzeta * dzeta/dy
3524 // + dv/dxi * dxi/dx + dv/deta * deta/dx + dv/dzeta * dzeta/dx
3526
3528
3529 // compute tau4 = 2 dv/dy - 2/3 ( du/dx + dv/dy + dw/dz )
3530
3531 // tau_yy = 4/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy )
3532 // - 2/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx)
3533 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
3534 MFloat tau4 = F4B3 * (dvdxi * cornerMetrics[xsd * 2 + ysd] + dvdet * cornerMetrics[ysd * 2 + ysd]) -
3535
3537
3540 tau1 = mueOverRe * tau1 + TKEcorner;
3541 tau2 *= mueOverRe;
3542 tau4 = mueOverRe * tau4 + TKEcorner;
3543
3544 vflux[0][IJ] = -tau1;
3545 vflux[1][IJ] = -tau2;
3546 vflux[2][IJ] = -tau4;
3547
3548 // c_Dp-term
3551
3554
3555 // const MFloat TKEAvg = F1B4*(TKE[IJP]+TKE[IPJP]+TKE[IJ]+TKE[IPJ]);
3556 // const MFloat epsAvg = F1B4*(eps[IJP]+eps[IPJP]+eps[IJ]+eps[IPJ]);
3557 // const MFloat temp = POW2(TKEAvg)/std::max(epsAvg, minMFloat);
3558
3559 const MFloat dTKEdx = dTKEdxi * cornerMetrics[xsd * 2 + xsd] + dTKEdet * cornerMetrics[ysd * 2 + xsd];
3560
3561 const MFloat dTKEdy = dTKEdxi * cornerMetrics[xsd * 2 + ysd] + dTKEdet * cornerMetrics[ysd * 2 + ysd];
3562
3563 const MFloat depsdx = depsdxi * cornerMetrics[xsd * 2 + xsd] + depsdet * cornerMetrics[ysd * 2 + xsd];
3564
3565 const MFloat depsdy = depsdxi * cornerMetrics[xsd * 2 + ysd] + depsdet * cornerMetrics[ysd * 2 + ysd];
3566
3567 // Compute indicator function
3570
3571 const MFloat dpdx = dpdxi * cornerMetrics[xsd * 2 + xsd] + dpdet * cornerMetrics[ysd * 2 + xsd];
3572
3573 const MFloat dpdy = dpdxi * cornerMetrics[xsd * 2 + ysd] + dpdet * cornerMetrics[ysd * 2 + ysd];
3574
3580 // TODO_SS labels:FV,toenhance For now I take the Da and cf of the current cell and not at the corner;
3581 // To do it correctly we need to exchange Da and cf similar to porosity
3585 / std::max(POW2(velAbs)
3586 * (rRe0 * porAvg * muLamAvg * rDaAvg
3587 + rhoAvg * POW2(porAvg) * cfAvg * sqrt(rDaAvg) * velAbs),
3588 minMFloat);
3592 (-0.5 * tanh(indicator - 5.0) + 0.5); // it's not exactly the cell center indicator
3593
3594 // TODO_SS labels:FV evtl. das f_mu wieder loeschen, wenn der Code auch ohne laueft
3597 const MFloat wallDistAvg = F1B4 * (wallDist[IJP] + wallDist[IPJP] + wallDist[IJ] + wallDist[IPJ]);
3600
3601 MFloat limiterVisc1 = 1.0;
3602 MFloat limiterVisc2 = 1.0;
3604 // TODO_SS labels:FV limiter should preserve conservativity; auch in computePorousRHSCorrection einbauen
3608 // limiterVisc1 = std::min(1.0, mu_ref/std::abs( c_Dp_eff*temp ));
3609 // limiterVisc2 = std::min(1.0, mu_ref/std::abs( c_Dp_eps_eff*temp ));
3610 limiterVisc1 = std::min(1.0,
3611 mu_ref
3612 / std::abs(rRe0 * c_Dp_eff * RM_KEPS::rsigma_k
3613 * muTurbAvg)); // TODO_SS labels:FV scale with Re-number?
3614 limiterVisc2 = std::min(1.0, mu_ref / std::abs(rRe0 * c_Dp_eps_eff * RM_KEPS::rsigma_eps * muTurbAvg));
3615 }
3616
3618
3623
3628
3629 // const MFloat sax1 = fJac*c_Dp_eff*temp*
3630 // (dTKEdx * cornerMetrics[ xsd * 2 + xsd ]+
3631 // dTKEdy * cornerMetrics[ xsd * 2 + ysd ]);
3632 // const MFloat say1 = fJac*c_Dp_eff*temp*
3633 // (dTKEdx * cornerMetrics[ ysd * 2 + xsd ]+
3634 // dTKEdy * cornerMetrics[ ysd * 2 + ysd ]);
3635
3636 // TODO_SS labels:FV for now I assume that whenever rans-porous, then sa_1flux array is allocated
3637 sa_1flux[0][IJ] = sax1;
3638 sa_1flux[1][IJ] = say1;
3639 sa_2flux[0][IJ] = sax2;
3640 sa_2flux[1][IJ] = say2;
3641 }
3642 }
3643
3645
3650
3651 sa_1flux[0][IJM] = F1B2 * (sa_1flux[0][IJ] + sa_1flux[0][IJM]);
3652 sa_2flux[0][IJM] = F1B2 * (sa_2flux[0][IJ] + sa_2flux[0][IJM]);
3653 }
3654 }
3659
3660 sa_1flux[1][IMJ] = F1B2 * (sa_1flux[1][IJ] + sa_1flux[1][IMJ]);
3661 sa_2flux[1][IMJ] = F1B2 * (sa_2flux[1][IJ] + sa_2flux[1][IMJ]);
3662 }
3663 }
3664
3666 // intermediate saving of Reynolds stresses in the surface centers
3671
3672 eflux[var][IJ] = 0.5 * (vflux[var][IJ] + vflux[var][IJM]);
3673 }
3674 }
3679
3680 fflux[var][IJ] = 0.5 * (vflux[var][IJ] + vflux[var][IMJ]);
3681 }
3682 }
3683 }
3684
3685 // intermediate saving of velocity magnitude in the cell centers
3686 // TODO_SS labels:FV this intermediate could have done in the first for loop already
3690
3692 vflux[1][IJ] = 1.0 / std::max(vflux[0][IJ], minMFloat);
3693 }
3694 }
3695
3703
3707
3709
3710 // Average Reynolds stresses in the surface centers into cell center
3714
3721
3723 (dtau1dxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dtau1det * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3724 * invCellJac;
3726 (dtau1dxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dtau1det * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3727 * invCellJac;
3729 (dtau2dxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dtau2det * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3730 * invCellJac;
3732 (dtau2dxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dtau2det * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3733 * invCellJac;
3735 (dtau4dxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dtau4det * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3736 * invCellJac;
3738 (dtau4dxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dtau4det * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3739 * invCellJac;
3740
3741 // central discretization
3747 (dTKEdxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dTKEdet * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3748 * invCellJac;
3750 (dTKEdxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dTKEdet * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3751 * invCellJac;
3753 (depsdxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + depsdet * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3754 * invCellJac;
3756 (depsdxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + depsdet * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3757 * invCellJac;
3758
3759 // central discretization
3764 * invCellJac;
3767 * invCellJac;
3768
3769 // central discretization
3770 const MFloat dvel11dxi = 0.5 * (u_[IPJ] * u_[IPJ] * vflux[1][IPJ] - u_[IMJ] * u_[IMJ] * vflux[1][IMJ]);
3771 const MFloat dvel11det = 0.5 * (u_[IJP] * u_[IJP] * vflux[1][IJP] - u_[IJM] * u_[IJM] * vflux[1][IJM]);
3772 const MFloat dvel12dxi = 0.5 * (u_[IPJ] * v_[IPJ] * vflux[1][IPJ] - u_[IMJ] * v_[IMJ] * vflux[1][IMJ]);
3773 const MFloat dvel12det = 0.5 * (u_[IJP] * v_[IJP] * vflux[1][IJP] - u_[IJM] * v_[IJM] * vflux[1][IJM]);
3774 const MFloat dvel22dxi = 0.5 * (v_[IPJ] * v_[IPJ] * vflux[1][IPJ] - v_[IMJ] * v_[IMJ] * vflux[1][IMJ]);
3775 const MFloat dvel22det = 0.5 * (v_[IJP] * v_[IJP] * vflux[1][IJP] - v_[IJM] * v_[IJM] * vflux[1][IJM]);
3777 (dvel11dxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dvel11det * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3778 * invCellJac;
3780 (dvel11dxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dvel11det * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3781 * invCellJac;
3783 (dvel12dxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dvel12det * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3784 * invCellJac;
3786 (dvel12dxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dvel12det * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3787 * invCellJac;
3789 (dvel22dxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dvel22det * m_cells->cellMetrics[ysd * 2 + xsd][IJ])
3790 * invCellJac;
3792 (dvel22dxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dvel22det * m_cells->cellMetrics[ysd * 2 + ysd][IJ])
3793 * invCellJac;
3794
3797
3802 const MFloat tau112 = 2.0 * (tau1 * dtau2dx + tau2 * dtau2dy) + tau2 * dtau1dx + tau4 * dtau1dy;
3805
3806 // c_Dp-term
3808 /* MFloat limiterVisc = 1.0;
3809 if (m_limiterVisc) {
3810 //TODO_SS labels:FV limiter should preserve conservativity
3811 const MFloat mu_ref = m_cells->fq[FQ->LIMITERVISC][IJ];
3812 limiterVisc = std::min(1.0, mu_ref/std::abs( m_c_Dp*TKE[IJ]*kovereps ));
3813 }*/
3815 ((sa_1flux[0][IJM] - sa_1flux[0][IMJM]) + (sa_1flux[1][IMJ] - sa_1flux[1][IMJM])); // * limiterVisc;
3817 ((sa_2flux[0][IJM] - sa_2flux[0][IMJM]) + (sa_2flux[1][IMJ] - sa_2flux[1][IMJM])); // * limiterVisc;
3818
3819 /* m_cells->fq[FQ->VAR5][IJ] = diffusion_TKE;
3820 m_cells->fq[FQ->VAR6][IJ] = (- 2.0*rRe0*rDa*por[IJ]*muLam[IJ]*TKE[IJ]
3821 - 0.5*sqrt(rDa)*porPOW2*cf[IJ]*rho[IJ]*(
3822 4.0*TKE[IJ]*velAbs
3823 + 2.0*velAbsInv*temp))*m_cells->cellJac[IJ];*/
3824
3825 // RHS
3827 (-rRe0 * rDa * por[IJ] * muLam[IJ] * u
3828 - sqrt(rDa) * porPOW2 * cf[IJ] * rho[IJ]
3829 * ((velAbs + TKE[IJ] * velAbsInv - 0.5 * pow(velAbsInv, 3) * temp) * u
3830 + velAbsInv * (u * tau1 + v * tau2)))
3833 (-rRe0 * rDa * por[IJ] * muLam[IJ] * v
3834 - sqrt(rDa) * porPOW2 * cf[IJ] * rho[IJ]
3835 * ((velAbs + TKE[IJ] * velAbsInv - 0.5 * pow(velAbsInv, 3) * temp) * v
3836 + velAbsInv * (u * tau2 + v * tau4)))
3839 diffusion_TKE
3840 + (-2.0 * rRe0 * rDa * por[IJ] * muLam[IJ] * TKE[IJ]
3841 - 0.5 * sqrt(rDa) * porPOW2 * cf[IJ] * rho[IJ]
3842 * (4.0 * TKE[IJ] * velAbs + 2.0 * velAbsInv * temp
3843 + 3.0 * velAbsInv * m_c_t * kovereps * (u * tau111 + u * tau122 + v * tau112 + v * tau222)
3844 - pow(velAbsInv, 3) * m_c_t * kovereps
3845 * (u * u * u * tau111 + 3.0 * u * u * v * tau112 + 3.0 * u * v * v * tau122
3846 + v * v * v * tau222)))
3849 diffusion_eps
3850 + (-2.0 * rRe0 * rDa * por[IJ] * muLam[IJ] * eps[IJ]
3851 - sqrt(rDa) * porPOW2 * cf[IJ] * rho[IJ]
3852 * (F8B3 * velAbs * eps[IJ]
3853 + 2.0 * rRe0 * (muLam[IJ] / rho[IJ]) * (dvelAbsdx * dTKEdx + dvelAbsdy * dTKEdy)
3854 - 2.0 * m_c_eps * kovereps * velAbsInv
3855 * (u * tau1 * depsdx + v * tau2 * depsdx + u * tau2 * depsdy + v * tau4 * depsdy)
3856 + rRe0 * (muLam[IJ] / rho[IJ])
3857 * (dvel11dx * dtau1dx + dvel11dy * dtau1dy + 2.0 * dvel12dx * dtau2dx
3858 + 2.0 * dvel12dy * dtau2dy + dvel22dx * dtau4dx + dvel22dy * dtau4dy)))
3860
3861 // m_cells->fq[FQ->VAR3][IJ] = rho[IJ]*diffusion_TKE;
3862 // m_cells->fq[FQ->VAR4][IJ] = - 2.0*rRe0*rDa*por[IJ]*muLam[IJ]*TKE[IJ]*m_cells->cellJac[IJ];
3863 // m_cells->fq[FQ->VAR5][IJ] = -
3864 // 0.5*sqrt(rDa)*porPOW2*cf[IJ]*rho[IJ]*(4.0*TKE[IJ]*velAbs)*m_cells->cellJac[IJ];
3865 // m_cells->fq[FQ->VAR6][IJ] = -
3866 // 0.5*sqrt(rDa)*porPOW2*cf[IJ]*rho[IJ]*(2.0*velAbsInv*temp)*m_cells->cellJac[IJ];
3867
3868 // const MFloat dx0 = m_cells->coordinates[1][IJ] - m_cells->coordinates[1][IJM];
3869 // const MFloat dx1 = m_cells->coordinates[1][IJP] - m_cells->coordinates[1][IJ];
3870 // const MFloat ddTKE = 2.0*(TKE[IJP]*dx0 - TKE[IJ]*(dx0+dx1) +
3871 // TKE[IJM]*dx1)/(POW2(dx0)*dx1+POW2(dx1)*dx0); m_cells->fq[FQ->VAR7][IJ] =
3872 // m_c_Dp*POW2(TKE[IJ])/eps[IJ]*rho[IJ]*ddTKE;///(2.0*rRe0*rDa*por[IJ]*muLam[IJ]*TKE[IJ]);
3873 /* std::ignore = (rho[IJ]*diffusion_TKE
3874 - 2.0*rRe0*rDa*por[IJ]*muLam[IJ]*TKE[IJ]
3875 - 0.5*sqrt(rDa)*porPOW2*cf[IJ]*rho[IJ]*(
3876 4.0*TKE[IJ]*velAbs
3877 + 2.0*velAbsInv*temp
3878 + 3.0*velAbsInv*m_c_t*kovereps*(u*tau111+u*tau122+v*tau112+v*tau222)
3879 -
3880 pow(velAbsInv,3)*m_c_t*kovereps*(u*u*u*tau111+3.0*u*u*v*tau112+3.0*u*v*v*tau122+v*v*v*tau222)))*m_cells->cellJac[IJ];
3881 std::ignore = (-2.0*rRe0*rDa*por[IJ]*muLam[IJ]*eps[IJ]
3882 - sqrt(rDa)*porPOW2*cf[IJ]*rho[IJ]*(
3883 F8B3*velAbs*eps[IJ]
3884 + 2.0*rRe0*(muLam[IJ]/rho[IJ])*(dvelAbsdx*dTKEdx+dvelAbsdy*dTKEdy)
3885 - 2.0*m_c_eps*kovereps*velAbsInv*(u*tau1*depsdx+v*tau2*depsdx+u*tau2*depsdy+v*tau4*depsdy)
3886 +
3887 rRe0*(muLam[IJ]/rho[IJ])*(dvel11dx*dtau1dx+dvel11dy*dtau1dy+2.0*dvel12dx*dtau2dx+2.0*dvel12dy*dtau2dy+dvel22dx*dtau4dx+dvel22dy*dtau4dy)))*m_cells->cellJac[IJ];*/
3888 }
3889 }
3890 } else { // LES
3894 MFloat velAbs = F0;
3897 }
3898 velAbs = sqrt(velAbs);
3903 -(rRe0 * rDa * por[IJK] * muLam[IJK] + porPOW2 * sqrt(rDa) * cf[IJK] * velAbs * pvars[PV->RHO][IJK])
3905 }
3906 }
3907 }
3908 }
3909}
void computePorousRHSCorrection()
Definition: fvstructuredsolver2d.cpp:3912
static const MInt ysd
Definition: fvstructuredpostprocessing.h:149
static const MInt xsd
Definition: fvstructuredpostprocessing.h:148
static constexpr MFloat C3
Definition: fvransmodelconstants.h:95
static constexpr MFloat rsigma_eps
Definition: fvransmodelconstants.h:91
static constexpr MFloat rsigma_k
Definition: fvransmodelconstants.h:90
◆ computePorousRHSCorrection()
| void FvStructuredSolver2D::computePorousRHSCorrection | ( | ) |
Definition at line 3912 of file fvstructuredsolver2d.cpp.
3912 {
3914 1e-16; // std::min(std::numeric_limits<MFloat>::min(), 1.0/std::numeric_limits<MFloat>::max());
3916
3928
3929 // MFloat *const RESTRICT eflux= ALIGNED_MF(m_cells->eFlux);
3930 // MFloat *const RESTRICT fflux= ALIGNED_MF(m_cells->fFlux);
3934
3937
3939 // only correct for bc 6000 not for bc 4000-5000
3941 // totalCells=1;
3944 // if(len1[j]!=0) totalCells*=len1[j];
3945 }
3946
3950 // dim=n;
3951 // start[n]=m_singularity[i].start[n]+1;
3954 } else {
3957 }
3958 }
3959
3961 MFloat U, V, RHO, muTurb_corner, muLam_corner, TKEcorner, EPScorner, PORcorner, dudx, dudy, dvdx, dvdy, dTKEdx,
3962 dTKEdy, depsdx, depsdy, dpdx, dpdy;
3963 MFloat tau1, tau2, tau4;
3964 MFloat mueOverRe;
3967 MInt count = 0;
3968 // MInt temp[nDim]{};
3970
3971 // temp[dim]=1;
3973 nghbr[count++] = IJ;
3974 // nghbr[count++]=cellIndex(ii+temp[0],jj+temp[1],kk+temp[2]);
3975
3978
3980 m_cells->surfaceMetrics[0][IPMJ_], m_cells->surfaceMetrics[1][IPMJ_], m_cells->surfaceMetrics[2][IJPM_],
3982
3985 nghbr[count++] = cellIndex(ii + change[0], jj + change[1]);
3986 // nghbr[count++]=cellIndex(ii+temp[0]+change[0],jj+temp[1]+change[1],kk+temp[2]+change[2]);
3987 }
3988
3990 cout << "what the hell! it is wrong!!! count=" << count << " Nstar=" << m_singularity[i].Nstar << endl;
3991 }
3992
3994 u[m] = u_[nghbr[m]];
3995 v[m] = v_[nghbr[m]];
3996 muTurb[m] = muTurb_[nghbr[m]] / rho_[nghbr[m]]; // nuTurb
3997 muLam[m] = muLam_[nghbr[m]];
3998 TKE[m] = TKE_[nghbr[m]];
3999 EPS[m] = EPS_[nghbr[m]];
4000 p[m] = p_[nghbr[m]];
4001 rho[m] = rho_[nghbr[m]];
4002 POR[m] = por_[nghbr[m]];
4003 }
4004
4005 U = F0;
4006 V = F0;
4007 RHO = F0;
4008 muTurb_corner = F0;
4009 muLam_corner = F0;
4010 TKEcorner = F0, EPScorner = F0, PORcorner = F0;
4011 dudx = F0;
4012 dudy = F0;
4013 dvdx = F0;
4014 dvdy = F0;
4015 dTKEdx = F0;
4016 dTKEdy = F0;
4017 depsdx = F0;
4018 depsdy = F0;
4019 dpdx = F0;
4020 dpdy = F0;
4021
4022 MInt id2 = ii - start[0] + (jj - start[1]) * len1[0];
4023
4025 MInt ID = id2 * count + n;
4029
4033
4037
4040
4042
4046
4050 }
4051
4052 // cout << globalTimeStep << "(" << m_RKStep << ") dom=" << domainId() << " x|y=" <<
4053 // m_cells->coordinates[0][IJK] << "|" << m_cells->coordinates[1][IJK] << " U=" << U << " V=" << V
4054 // << " t=" << t << " cornerMetrics=" << cornerMetrics[0] << "|" << cornerMetrics[1] << "|" <<
4055 // cornerMetrics[2] << "|" << cornerMetrics[3] << endl;
4056
4057
4058 tau1 = 2 * dudx - 2 / 3 * (dudx + dvdy);
4059 tau2 = dudy + dvdx;
4060 tau4 = 2 * dvdy - 2 / 3 * (dudx + dvdy);
4061
4062 TKEcorner *= -2 / 3;
4063 mueOverRe = muTurb_corner * rRe0;
4064 tau1 = mueOverRe * tau1 + TKEcorner;
4065 tau2 *= mueOverRe;
4066 tau4 = mueOverRe * tau4 + TKEcorner;
4067
4068 vflux[0][IJ_] = -tau1;
4069 vflux[1][IJ_] = -tau2;
4070 vflux[2][IJ_] = -tau4;
4071
4072
4075 // TODO_SS labels:FV,toenhance For now I take the Da and cf of the current cell and not at the corner;
4076 // To do it correctly we need to exchange Da and cf similar to porosity
4080 / std::max(POW2(velAbs)
4081 * (rRe0 * PORcorner * muLam_corner * rDaAvg
4082 + RHO * POW2(PORcorner) * cfAvg * sqrt(rDaAvg) * velAbs),
4083 minMFloat);
4087 (-0.5 * tanh(indicator - 5.0) + 0.5); // it's not exactly the cell center indicator
4088
4089 // TODO_SS labels:FV f_mu & limiterVisc !!!!!!!!
4098
4099 // TODO_SS labels:FV for now I assume that whenever rans-porous, then sa_1flux array is allocated
4100 sa_1flux[0][IJ_] = sax1;
4101 sa_1flux[1][IJ_] = say1;
4102 sa_2flux[0][IJ_] = sax2;
4103 sa_2flux[1][IJ_] = say2;
4104 }
4105 }
4106 }
4107 }
4108}
MFloat ** ReconstructionConstants
Definition: structuredgrid.h:27
◆ computePrimitiveVariables()
|
overridevirtual |
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 4233 of file fvstructuredsolver2d.cpp.
4233 {
4236 computePrimitiveVariables_<&FvStructuredSolver::pressure_twoEqRans>();
4237 else
4238 computePrimitiveVariables_();
4239 } else
4240 computePrimitiveVariables_();
4241}
void computePrimitiveVariables_()
Definition: fvstructuredsolver2d.cpp:4202
◆ computePrimitiveVariables_()
| void FvStructuredSolver2D::computePrimitiveVariables_ |
Definition at line 4202 of file fvstructuredsolver2d.cpp.
4202 {
4204
4207
4212 MFloat velPOW2 = F0;
4215 velPOW2 += POW2(pvars[vel][cellId]);
4216 }
4217
4218 // density and pressure:
4221 gammaMinusOne
4222 * (cvars[CV->RHO_E][cellId] - F1B2 * pvars[PV->RHO][cellId] * velPOW2 + (this->*pressure_func)(cellId));
4223
4226 mMax(cvars[CV->RANS_VAR[ransVar]][cellId], 1e-16 /*F0*/); // TODO_SS labels:FV maybe activate this
4228 }
4229 }
4230 }
4231}
MInt m_noRansEquations
Definition: fvstructuredsolver.h:698
◆ computeReconstructionConstantsSVD()
| void FvStructuredSolver2D::computeReconstructionConstantsSVD | ( | ) |
Definition at line 4341 of file fvstructuredsolver2d.cpp.
4341 {
4344 m_orderOfReconstruction = 1;
4350 MFloat counter = F0;
4351 MFloat avg = F0;
4352 MFloat maxc = F0;
4353
4356 // MInt totalCells=1;
4358
4359 //(p)reset the reconstruction constants
4363 }
4364 }
4365
4368 // if(len1[j]!=0) totalCells*=len1[j];
4369 ASSERT(len1[j] == 1, "");
4370 }
4371
4373 // if(m_singularity[i].end[n]-m_singularity[i].start[n]>1) {
4374 // dim=n;
4375 // start[n]=m_singularity[i].start[n]+1;
4376 // end[n]=m_singularity[i].end[n]-1;
4377 // } else {
4380 // }
4381 }
4382
4383 // for( MInt kk = start[2]; kk <end[2]; ++kk ) {
4386 MInt count = 0;
4387 // MInt temp[nDim]{};
4388 // temp[dim]=1;
4389
4390 nghbr[count++] = cellIndex(ii, jj);
4391 // nghbr[count++]=cellIndex(ii+temp[0],jj+temp[1],kk+temp[2]);
4392
4393 // the coordinates of the corner where the viscousflux should be corrected.
4394 MInt ijk = getPointIdFromCell(ii + m_singularity[i].Viscous[0], jj + m_singularity[i].Viscous[1]);
4395 ijk = getPointIdFromPoint(ijk, 1, 1);
4396
4399 nghbr[count++] = cellIndex(ii + change[0], jj + change[1]);
4400 // nghbr[count++]=cellIndex(ii+temp[0]+change[0],jj+temp[1]+change[1],kk+temp[2]+change[2]);
4401 }
4402
4404 cerr << "Something wrong with the singularities in the LS coeffiecient computation" << endl;
4405 }
4406
4407 // weighted Least square
4408 weights.fill(F0);
4409
4410 // Compute weights with RBF (take mean distance as R0)
4412 MInt nghbrId = nghbr[n];
4413 MFloat dxdx = F0;
4416 }
4417
4418 weights[n] = 1 / dxdx; // RBF( dxdx, POW2( dist) );
4419 }
4420
4421 MInt id2 = ii - start[0] + (jj - start[1]) * len1[0];
4422 ASSERT(id2 == 0, "");
4424
4426 avg += condNum;
4427 maxc = mMax(maxc, condNum);
4428 counter += F1;
4429 if(condNum < F0 || condNum > 1e7 || std::isnan(condNum)) {
4431 << " with large condition number: " << condNum << " num of neighbor" << count << "x" << recDim << " "
4432 << " coords " << m_grid->m_coordinates[0][ijk] << ", " << m_grid->m_coordinates[1][ijk] << endl;
4433 }
4434 }
4435 }
4436 // }
4437 }
4438 }
4439}
MFloat computeRecConstSVD(const MInt ijk, const MInt noNghbrIds, MInt *nghbr, MInt ID, MInt sID, MFloatScratchSpace &tmpA, MFloatScratchSpace &tmpC, MFloatScratchSpace &weights, const MInt recDim)
AUX DATA ENDS /////////////////////////////////////////////////////////////.
Definition: fvstructuredsolver.cpp:8020
MInt m_orderOfReconstruction
Definition: fvstructuredsolver.h:435
◆ computeTimeStep()
|
virtual |
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 2320 of file fvstructuredsolver2d.cpp.
2320 {
2321 TRACE();
2322 m_timeStep = 1000.0;
2326
2331
2332 // compute the speed of sound
2334
2335 // no need for simplified metrics, since information is already contained
2336 // in cell metrics
2338
2340
2341 // contravariant velocities
2342 MFloat U_c = F0;
2343 MFloat V_c = F0;
2344
2348 }
2349
2350 // subtract grid velocity
2351 U_c -= dxtx[cellId];
2352 V_c -= dxty[cellId];
2353
2354 U_c = fabs(U_c);
2355 V_c = fabs(V_c);
2356
2357 // has area information in it due to metric terms
2359
2360 // divide volume information (jacobian) through area to get characteristic length for CFL
2364 m_timeStep = F1;
2365 m_timeRef = F1;
2366 } else {
2367 // TODO_SS labels:FV if jacobian is negative, then timeStep will be negative and the following mMin won't
2368 // work
2370 }
2371 }
2372 }
2373}
◆ convertSA2KEPS()
| void FvStructuredSolver2D::convertSA2KEPS | ( | ) |
Definition at line 343 of file fvstructuredsolver2d.cpp.
343 {
344 TRACE();
345
347 restartFromSA = Context::getSolverProperty<MBool>("restartFromSA", m_solverId, AT_, &restartFromSA);
348 if(!restartFromSA) return;
349
350 if(domainId() == 0) cout << "\033[1;31m !!!Converting SA turbulence quantities to k & epsilon!!!\033[0m\n" << endl;
351
355
358 // decode the kinematic turbulent viscosity from the turb dynamic visc arrays
365 }
366
367 // compute friction velocity at wall
369 // communicate wall properties to all cells
371
386
388
393
395 dudxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dudet * m_cells->cellMetrics[ysd * 2 + xsd][IJ];
397 dudxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dudet * m_cells->cellMetrics[ysd * 2 + ysd][IJ];
399 dvdxi * m_cells->cellMetrics[xsd * 2 + xsd][IJ] + dvdet * m_cells->cellMetrics[ysd * 2 + xsd][IJ];
401 dvdxi * m_cells->cellMetrics[xsd * 2 + ysd][IJ] + dvdet * m_cells->cellMetrics[ysd * 2 + ysd][IJ];
402
405 * invCellJac;
409
410 //
411 // const MFloat T = m_gamma*p[i]/rho[i];
412 // const MFloat nuLaminar = SUTHERLANDLAW(T)/rho[IJ];
413 // TODO_SS labels:FV
419 }
420 }
421
422 //
423 exchange();
424 applyBoundaryCondition();
425}
void applyBoundaryCondition()
Definition: fvstructuredsolver2d.cpp:1455
MBool m_keps_nonDimType
Definition: fvstructuredsolver.h:463
void exchange()
SVD STUFF ENDS /////////////////////////////////////////////////////////////.
Definition: fvstructuredsolver.cpp:8061
virtual void computeFrictionCoef()
Definition: fvstructuredbndrycnd.h:180
virtual void distributeWallAndFPProperties()
Definition: fvstructuredbndrycnd.h:182
static constexpr MFloat C_mu
Definition: fvransmodelconstants.h:92
static constexpr MFloat cv1to3
Definition: fvransmodelconstants.h:31
◆ crossProduct()
◆ exchange6002()
| void FvStructuredSolver2D::exchange6002 | ( | ) |
GATHER & SEND
RECEIVE
WAIT
SCATTER
Definition at line 4443 of file fvstructuredsolver2d.cpp.
4443 {
4444 if(m_rans && m_ransMethod != RANS_KEPSILON) mTerm(1, "Porous RANS computation is only supported by k-epsilon model!");
4445 // if (!m_porous)
4446 // mTerm(1, "bc6002 requires the property porous to be set to true!");
4447
4448 // 0) Check if initBc6002 is called for the first time
4449 // for(MInt bcId_=0; bcId_ < bcId; ++bcId_) {
4450 // if (m_physicalBCMap[bcId_]->BC==6002) return;
4451 // }
4452
4453 // Determine normal vectors and save for later use
4459
4462
4464
4466
4474
4478
4481
4482 // compute four surrounding points of surface centroid
4486 const MInt pp3 = getPointIdFromPoint(ij, n * (1 - normalDir), n * normalDir); // point lying outside domain
4487
4488 // compute the velocity of the surface centroid
4495 }
4496
4497 // compute normal vector of surface
4498 normalVec[0] = -firstVec[1];
4499 normalVec[1] = firstVec[0];
4501
4502 MFloat sgn = (std::inner_product(&normalVec[0], &normalVec[0] + nDim, &normalVec_[0], 0.0) < 0.0) ? -1 : 1;
4504
4506 normalVec[dim] /= normalLength;
4508 }
4509 }
4510 }
4511 }
4512
4513 // Determine normal vector at singularities
4516 // only correct for bc 6000 not for bc 4000-5000
4517 if(singularity.BC == -6000) {
4520 if(singularity.BCsingular[n] == -6002) takeIt = true;
4521 }
4522
4523 if(takeIt) {
4526 if(singularity.end[n] - singularity.start[n] > 1) {
4528 // dim=n;
4529 // start[n]=singularity.start[n]+1;
4530 start[n] = singularity.start[n] + 1;
4531 end[n] = singularity.end[n] - 1;
4532 } else {
4533 start[n] = singularity.start[n];
4534 end[n] = singularity.end[n];
4535 }
4536 }
4537
4547 }
4548 }
4549 }
4550 }
4551 }
4552 }
4553
4554 // TODO_SS labels:FV,toenhance The exchange of all the normals is an overhead, because it is only needed at
4555 // singularity points
4559 // MInt sendSizeTotal = 0;
4560 std::vector<MInt> receiveSizes;
4562 // TODO_SS labels:FV right now exchange at all 6000er not only 6002 because of singularities
4563 if(snd->bcId == -6000 || snd->bcId == -6002) {
4564 // Gather
4565
4566 MInt size = 1;
4568 size *= snd->endInfoCells[dim] - snd->startInfoCells[dim];
4569 // std::vector<MFloat> bufferSnd(size*(1+nDim));
4570 // sendSizeTotal += size;
4571
4572 MInt pos = 0;
4576 // TODO_SS labels:FV Latter only allocate FQ->POROSITY for m_blockType==porous
4577 // if (m_blockType=="fluid")
4578 // bufferSnd[pos++] = 1;
4579 // else
4583 }
4584 ++pos;
4585 }
4586 }
4587
4588 // Send
4590 MInt err = MPI_Isend((void*)&snd->cellBuffer[0], size * (nDim + 1), MPI_DOUBLE, snd->nghbrId, tag,
4593
4594
4595 // Determine size of receive buffer
4596 // TODO_SS labels:FV right now exchange at all 6000er not only 6002 because of singularities
4597 size = 1;
4599 size *= snd->endInfoCells[dim] - snd->startInfoCells[dim];
4600 receiveSizes.push_back(size);
4601 }
4602 }
4603
4607 std::vector<MFloat> bufferRcv(std::accumulate(receiveSizes.begin(), receiveSizes.end(), 0) * (nDim + 1));
4608 MInt offset = 0;
4609 MInt cnt = 0;
4611 // TODO_SS labels:FV right now exchange at all 6000er not only 6002 because of singularities
4612 if(rcv->bcId == -6002 || rcv->bcId == -6000) {
4615 MInt err = MPI_Irecv(&bufferRcv[offset], rcvSize * (1 + nDim), MPI_DOUBLE, rcv->nghbrId, tag, m_StructuredComm,
4616 &rcv->mpi_request, AT_, "(void*)&rcvSize");
4618
4619 offset += rcvSize * (1 + nDim);
4620 ++cnt;
4621 }
4622 }
4623
4628 if(snd->bcId == -6002 || snd->bcId == -6000) {
4629 MPI_Wait(&(snd->mpi_request), &(snd->mpi_status), AT_);
4630 }
4631 }
4632
4633
4635 if(rcv->bcId == -6002 || rcv->bcId == -6000) {
4636 MPI_Wait(&(rcv->mpi_request), &(rcv->mpi_status), AT_);
4637 }
4638 }
4639
4643 // TODO_SS labels:FV,toremove
4645 offset = 0;
4646 cnt = 0;
4648 if(rcv->bcId == -6002 || rcv->bcId == -6000) {
4649 // TODO_SS labels:FV right now exchange at all 6000er not only 6002 because of singularities
4650
4651 MInt j2, i2, id2;
4657 MInt totalCells = 1;
4659
4661 len1[j] = rcv->endInfoCells[j] - rcv->startInfoCells[j];
4662 if(len1[j] != 0) totalCells *= len1[j];
4663 // added check the step for RCV part !!!!!!!!important
4664 step2[rcv->orderInfo[j]] = rcv->stepInfo[j];
4665 }
4666
4667 // Sanity check
4668 ASSERT(totalCells == receiveSizes[cnt], "");
4669
4671 start2[j] = 0;
4672 end2[j] = len1[j] - 1;
4673 len2[rcv->orderInfo[j]] = len1[j];
4674 if(step2[j] < 0) {
4676 start2[j] = end2[j];
4677 end2[j] = dummy;
4678 }
4679 }
4680
4681 MInt pos = 0;
4682 j2 = start2[1];
4684 i2 = start2[0];
4686 start1[rcv->orderInfo[0]] = i2;
4687 start1[rcv->orderInfo[1]] = j2;
4688
4689 id2 = start1[0] + start1[1] * len2[0];
4693 normals_temp[m_noCells * d + cellId] = bufferRcv[offset * (nDim + 1) + (d + 1) * totalCells + id2];
4694 // m_cells->fq[FQ->NORMAL[d]][cellId] = bufferRcv[offset*(nDim+1)+(d+1)*totalCells+id2];
4695 }
4696
4697 i2 += step2[0];
4698 pos++;
4699 }
4700 j2 += step2[1];
4701 }
4702
4703 offset += totalCells;
4704 ++cnt;
4705 }
4706 }
4707
4708 // Determine normal vector at singularities
4711 // only correct for bc 6000 not for bc 4000-5000
4712 if(singularity.BC == -6000) {
4715 if(singularity.BCsingular[n] == -6002) takeIt = true;
4716 }
4717
4718 if(takeIt) {
4721 if(singularity.end[n] - singularity.start[n] > 1) {
4723 // dim=n;
4724 // start[n]=singularity.start[n]+1;
4725 start[n] = singularity.start[n] + 1;
4726 end[n] = singularity.end[n] - 1;
4727 } else {
4728 start[n] = singularity.start[n];
4729 end[n] = singularity.end[n];
4730 }
4731 }
4732
4734
4741 }
4746 temp[d] += normals_temp[m_noCells * d + nghbr];
4747 }
4748
4749 MFloat l = 0;
4753 }
4754 l = sqrt(l);
4757 }
4758
4764 }
4765 }
4766 }
4767 }
4768 }
4769 }
4770
4772#if 0
4773 // 1) Gather
4774 std::vector<MFloat> sendBuffer;
4775 std::vector<MInt> sendcounts;
4776 std::vector<MInt> snghbrs;
4777 std::vector<MInt> tags;
4779 if (snd->bcId==-6002) {
4780 snghbrs.push_back(snd->nghbrId);
4781 tags.push_back(domainId()+(snd->tagHelper)*m_solver->noDomains());
4782
4783 MInt size = 1;
4785 size *= snd->endInfoCells[dim] - snd->startInfoCells[dim];
4786 sendcounts.push_back(size);
4787
4788 sendBuffer.resize(pos+size);
4792 // TODO_SS labels:FV Latter only allocate FQ->POROSITY for m_blockType==porous
4793 // if (m_blockType=="fluid")
4794 // sendBuffer[pos++] = 1;
4795 // else
4797 }
4798 }
4799 }
4800 }
4801
4803
4804 // 2) Send & receive
4805 std::vector<MInt> recvcounts(noNeighborDomains);
4806 std::vector<MInt> rdispls(noNeighborDomains);
4807 std::vector<MFloat> recvBuffer = maia::mpi::mpiExchangePointToPoint(&sendBuffer[0],
4808 &snghbrs[0],
4809 noNeighborDomains,
4810 &sendcounts[0],
4811 &snghbrs[0],
4812 noNeighborDomains,
4813 m_StructuredComm,
4814 m_solver->domainId(),
4815 1,
4816 recvcounts.data(),
4817 rdispls.data());
4818 // 2.5) Send & receive the tags
4819 std::vector<MInt> sendcounts2(noNeighborDomains, 1);
4820 std::vector<MInt> recvTags = maia::mpi::mpiExchangePointToPoint(&tags[0],
4821 &snghbrs[0],
4822 noNeighborDomains,
4823 &sendcounts2[0],
4824 &snghbrs[0],
4825 noNeighborDomains,
4826 m_StructuredComm,
4827 m_solver->domainId(),
4828 1);
4829
4830 // 3) Scatter
4832 if (rcv->bcId==-6002) {
4834 MInt n;
4835 for (n = 0; n < noNeighborDomains; ++n) {
4836 if (tag==recvTags[n])
4837 break;
4838 }
4840
4843
4845 MInt j2, i2, id2;
4851 MInt totalCells=1;
4853
4855 len1[j]=rcv->endInfoCells[j] - rcv->startInfoCells[j];
4856 if(len1[j]!=0) totalCells*=len1[j];
4857 //added check the step for RCV part !!!!!!!!important
4858 step2[rcv->orderInfo[j]]=rcv->stepInfo[j];
4859 }
4860
4861 //TODO_SS labels:FV check if this assert makes sense
4862 ASSERT(noReceivedElements==totalCells, "noReceivedElements==totalCells");
4863
4865 start2[j]=0;
4866 end2[j]=len1[j]-1;
4867 len2[rcv->orderInfo[j]]=len1[j];
4868 if(step2[j]<0) {
4870 start2[j]=end2[j];
4871 end2[j]=dummy;
4872 }
4873 }
4874
4875 MInt* startInfo=rcv->startInfoCells;
4876 MInt* endInfo=rcv->endInfoCells;
4877
4878 MInt pos=0;
4879 j2=start2[1];
4881 i2=start2[0];
4883 start1[rcv->orderInfo[0]]=i2;
4884 start1[rcv->orderInfo[1]]=j2;
4885
4886 id2=start1[0]+start1[1]*len2[0];
4889
4890 i2+=step2[0];
4891 pos++;
4892 }
4893 j2+=step2[1];
4894 }
4895 }
4896 }
4897#endif
4899}
std::vector< std::unique_ptr< StructuredWindowMap< nDim > > > & m_physicalBCMap
Definition: fvstructuredbndrycnd.h:62
int MPI_Isend(const void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request, const MString &name, const MString &varname)
same as MPI_Isend
Definition: mpioverride.cpp:481
int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request, const MString &name, const MString &varname)
same as MPI_Irecv
Definition: mpioverride.cpp:606
int MPI_Wait(MPI_Request *request, MPI_Status *status, const MString &name)
same as MPI_Wait
Definition: mpioverride.cpp:732
std::vector< T > mpiExchangePointToPoint(const T *const sendBuffer, const MInt *const snghbrs, const MInt nosnghbrs, const MInt *const sendcounts, const MInt *const rnghbrs, const MInt nornghbrs, const MPI_Comm &mpi_comm, const MInt domainId, const MInt dataBlockSize, MInt *const recvcounts_=nullptr, MInt *const rdispls_=nullptr)
Definition: mpiexchange.h:1057
◆ extrapolateGhostPointCoordinatesBC()
| void FvStructuredSolver2D::extrapolateGhostPointCoordinatesBC | ( | ) |
Definition at line 1669 of file fvstructuredsolver2d.cpp.
1669 {
1671 // all the periodic BCs are NOT included.
1672 // also skip the channel bc
1677 continue;
1678 }
1679
1684 MInt pos[2], fix[2], mirror[2], ij[2], extendij[2];
1685 MInt pointId, FixPointId, MirrorPointId;
1686
1687 extendij[0] = 1;
1688 extendij[1] = 1;
1689 extendij[index] = 0;
1690
1691 for(ij[1] = start[1]; ij[1] < end[1] + extendij[1]; ++ij[1]) {
1692 for(ij[0] = start[0]; ij[0] < end[0] + extendij[0]; ++ij[0]) {
1694 if(index == m) {
1695 if(step == 1) {
1696 pos[m] = ij[m] + 1;
1697 fix[m] = start[m];
1698 mirror[m] = 2 * fix[m] - pos[m];
1699 } else {
1700 pos[m] = ij[m];
1701 fix[m] = end[m];
1702 mirror[m] = 2 * fix[m] - pos[m];
1703 }
1704 } else {
1705 pos[m] = ij[m];
1706 fix[m] = ij[m];
1707 mirror[m] = ij[m];
1708 }
1709 } // m
1710
1711 pointId = pointIndex(pos[0], pos[1]);
1712 FixPointId = pointIndex(fix[0], fix[1]);
1713 MirrorPointId = pointIndex(mirror[0], mirror[1]);
1714
1716 m_grid->m_coordinates[dim][pointId] =
1718 }
1719 } // ij
1720 }
1721
1722 } // bcid
1723}
MInt pointIndex(MInt i, MInt j)
Definition: fvstructuredsolver2d.cpp:1626
IdType index(const FloatType *const x, const IdType level)
Return Hilbert index for given location and level in 2D or 3D.
Definition: hilbert.h:165
◆ gather()
|
override |
Definition at line 4263 of file fvstructuredsolver2d.cpp.
4264 {
4265 for(auto& snd : sndComm) {
4268
4269 MInt pos = 0;
4274 snd->cellBuffer[pos] = snd->variables[var][cellId];
4275 pos++;
4276 }
4277 }
4278 }
4279 }
4280}
MBool isPeriodicComm(std::unique_ptr< StructuredComm< nDim > > &)
Definition: fvstructuredsolver.cpp:8197
MBool skipPeriodicDirection(std::unique_ptr< StructuredComm< nDim > > &)
Definition: fvstructuredsolver.cpp:8191
◆ getCellIdFromCell()
Definition at line 1620 of file fvstructuredsolver2d.cpp.
◆ getPointIdFromCell()
Definition at line 1614 of file fvstructuredsolver2d.cpp.
◆ getPointIdFromPoint()
Definition at line 1616 of file fvstructuredsolver2d.cpp.
◆ getPSI()
Definition at line 4902 of file fvstructuredsolver2d.cpp.
◆ initBndryCnds()
| void FvStructuredSolver2D::initBndryCnds | ( | ) |
Definition at line 1450 of file fvstructuredsolver2d.cpp.
1450 {
1451 TRACE();
1453}
virtual void correctBndryCndIndices()
Definition: fvstructuredbndrycnd.cpp:332
◆ initFluxMethod()
| void FvStructuredSolver2D::initFluxMethod | ( | ) |
Definition at line 105 of file fvstructuredsolver2d.cpp.
105 {
106 // set the MUSCL-scheme to the right function
110 } else {
112 viscFluxMethod = &FvStructuredSolver2D::viscousFluxLESCompact<>;
113 else
114 viscFluxMethod = &FvStructuredSolver2D::viscousFluxLES<>;
120 break;
121 }
122 default: {
123 stringstream errorMessage;
125 mTerm(1, AT_, errorMessage.str());
126 }
127 }
128 } else {
133 case 4: {
134 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmLES, 4>;
135 break;
136 }
137 case 5: {
138 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmLES, 5>;
139 break;
140 }
141 case 6: {
142 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmLES, 6>;
143 break;
144 }
145 default: {
146 stringstream errorMessage;
147 errorMessage << "Number of Variables " << CV->noVariables << " not implemented in template AUSM!" << endl;
148 mTerm(1, AT_);
149 }
150 }
153 case 4: {
154 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmLES_PTHRC, 4>;
155 break;
156 }
157 case 5: {
158 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmLES_PTHRC, 5>;
159 break;
160 }
161 case 6: {
162 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmLES_PTHRC, 6>;
163 break;
164 }
165 default: {
166 stringstream errorMessage;
167 errorMessage << "Number of Variables " << CV->noVariables << " not implemented in template AUSM!" << endl;
168 mTerm(1, AT_);
169 }
170 }
173 case 4: {
174 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmDV, 4>;
175 break;
176 }
177 case 5: {
178 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmDV, 5>;
179 break;
180 }
181 case 6: {
182 reconstructSurfaceData = &FvStructuredSolver2D::Muscl_<&FvStructuredSolver2D::AusmDV, 6>;
183 break;
184 }
185 default: {
186 stringstream errorMessage;
187 errorMessage << "Number of Variables " << CV->noVariables << " not implemented in template AUSM!" << endl;
188 mTerm(1, AT_);
189 }
190 }
191 }
195 computeCellLength();
198 case 4: {
199 reconstructSurfaceData = &FvStructuredSolver2D::MusclStretched_<&FvStructuredSolver2D::AusmLES, 4>;
200 break;
201 }
202 case 5: {
203 reconstructSurfaceData = &FvStructuredSolver2D::MusclStretched_<&FvStructuredSolver2D::AusmLES, 5>;
204 break;
205 }
206 case 6: {
207 reconstructSurfaceData = &FvStructuredSolver2D::MusclStretched_<&FvStructuredSolver2D::AusmLES, 6>;
208 break;
209 }
210 default: {
211 stringstream errorMessage;
212 errorMessage << "Number of Variables " << CV->noVariables << " not implemented in template AUSM!" << endl;
213 mTerm(1, AT_);
214 }
215 }
218 case 4: {
219 reconstructSurfaceData = &FvStructuredSolver2D::MusclStretched_<&FvStructuredSolver2D::AusmLES_PTHRC, 4>;
220 break;
221 }
222 case 5: {
223 reconstructSurfaceData = &FvStructuredSolver2D::MusclStretched_<&FvStructuredSolver2D::AusmLES_PTHRC, 5>;
224 break;
225 }
226 case 6: {
227 reconstructSurfaceData = &FvStructuredSolver2D::MusclStretched_<&FvStructuredSolver2D::AusmLES_PTHRC, 6>;
228 break;
229 }
230 default: {
231 stringstream errorMessage;
232 errorMessage << "Number of Variables " << CV->noVariables << " not implemented in template AUSM!" << endl;
233 mTerm(1, AT_);
234 }
235 }
236 }
237 }
238 }
239 }
240}
void viscousFluxRANS()
Definition: fvstructuredsolver2d.cpp:2501
void(FvStructuredSolver2D::* viscFluxMethod)()
Definition: fvstructuredsolver2d.h:68
void computeCellLength()
Definition: fvstructuredsolver2d.cpp:256
void(FvStructuredSolver2D::* reconstructSurfaceData)()
Definition: fvstructuredsolver2d.h:98
MInt string2enum(MString theString)
This global function translates strings in their corresponding enum values (integer values)....
Definition: enums.cpp:20
◆ initialCondition()
|
virtual |
Implements FvStructuredSolver< 2 >.
Definition at line 432 of file fvstructuredsolver2d.cpp.
432 {
433 TRACE();
434
436 MFloat UT;
437 // MFloat pressure=F0;
438 // MFloat Frho; switched off cause of compiler
439
447
448 // compute conservative variables
455
456 // internal Reynolds number Re0 = Re / ( rho8*M*sqrt(T8)/T8^F072)
458
459 // reference enthalpies (needed for combustion computations)
461
462 // reference time (convection time)
464
465 m_deltaP = F0;
466 // pressure loss per unit length dp = rho_00 u_tau^2 L / D ) here: D=1.0, L=1;
467 // channel: dp = rho_00 u_tau^2 L / D )
468 // m_deltaP = POW2( m_Ma * m_ReTau * sqrt(PV->TInfinity) / m_Re ) * CV->rhoInfinity / m_referenceLength;x
469 // result is obtained by making deltap dimensionless with a_0^2 and rho_0
470 // pipe: dp = lambda * L/D * rho/2 * u^2, lambda = 0.3164 Re^(-1/4) (Blasius)
471
477 PV->ransInfinity[0] = k8;
481 PV->ransInfinity[1] = m_keps_nonDimType ? RM_KEPS::C_mu * rho * POW2(k8) * m_Re0 / (lamVisc * m_epsScale)
483 } else {
485 }
488 } else {
489 MFloat chi = 0.1;
492 CV->ransInfinity[0] = chi * (lamVisc);
494 }
495 }
496
510 m_log << "Rans" << ransVarId << "Infinity = " << PV->ransInfinity[ransVarId] * 1e8 << "e-8" << endl;
512
514 cout << "**************************" << endl;
515 cout << "Initial Condition summary" << endl;
516 cout << "**************************" << endl;
527 cout << "Rans" << ransVarId << "Infinity = " << PV->ransInfinity[ransVarId] * 1e8 << "e-8" << endl;
529 }
530
531
533 // inflow condition
534 // ----------------
535
537 case 0:
538 case 465: // quiscient state
539 {
542 u_infty[0] = PV->VVInfinity[0];
543 u_infty[1] = PV->VVInfinity[1];
544 }
545 // parallel inflow field
547 // go through every cell
551 }
552
554
558 }
559 }
560 }
561 break;
562 }
563 case 43: {
564 // parallel inflow field
566 // go through every cell
570 }
571
573
574 MFloat radius =
575 sqrt(POW2(m_cells->coordinates[0][cellId] - 0.5) + POW2(m_cells->coordinates[1][cellId] - 0.5));
576 // impose pressure peak in the middle of the domain
577 if(radius <= 0.05) {
578 MFloat pAmp = 0.005;
581 }
582 }
583 break;
584 }
585 case 314: // stagnating flow field
586 {
591 }
592
594 }
595 cout << "I.C. stagnating flow field was applied! " << endl;
596 break;
597 }
598 case 333: {
599 // parallel inflow field
601 // go through every cell
605 }
606
608
609 // impose pressure peak in the middle of the domain
611 MFloat pAmp = 0.005;
615 }
616 }
617 break;
618 }
619 case 79091: // Turbulent plate
620 {
629
635 const MFloat yplus = m_cells->coordinates[1][cellId] * sqrt(cf / 2.) * CV->rhoUInfinity / mu * m_Re0;
637
638 // 1-7th profile
639 // log-law + wake
642 } else if(yplus < 10) {
644 } else {
646 utau * ((1. / K) * log(max(yplus, epss)) + C1 + 2 * PI1 / K * (3 * eta * eta - 2 * eta * eta * eta)),
647 PV->UInfinity);
648 }
649
653
657 }
658 }
659 }
660 }
661
662 break;
663 }
664 case 999: {
665 // blasius laminar bl
667 if(!m_useBlasius) mTerm(1, "property Blasius not set. Refer to the description of the property");
669 ofstream blasiusf;
670 // write velocity to file
671 blasiusf.open("velocity_x0.dat", ios::trunc);
672 if(blasiusf) {
673 blasiusf << "#y eta u v" << endl;
674 MFloat d0 = 0.0;
675 MFloat d1 = 0.0;
676 MFloat d2 = 0.0;
678
680 // coord
683 // velocity
688 blasiusf << endl;
689
691 d0 = y;
692 d0Set = true;
693 }
694
696 d1 += (1 - vel[0] / PV->UInfinity) * 0.05;
698 }
699 }
700 blasiusf.close();
701
703 cout << "d0: " << d0 << " d1: " << d1 << " d2: " << d2 << endl;
704 }
705 }
706
709 getBlasiusVelocity(cellid, vel);
712 }
715 }
716
717 break;
718 }
719
720 default: {
721 // put the parallel flow field input in here
722 // force output that no specific initial condition was chosen
723 m_log << "No (correct) initial Condition is given! Used initial Condtion of parallel inflow!!!!!" << endl;
724 break;
725 }
726 }
727 }
728}
virtual MFloat getBlasiusEta(MFloat coordX, MFloat coordY)
Definition: fvstructuredsolver.cpp:7726
MInt m_initialCondition
Definition: fvstructuredsolver.h:660
MFloat m_referenceLength
Definition: fvstructuredsolver.h:430
MInt m_blasius_noPoints
Definition: fvstructuredsolver.h:902
virtual void getBlasiusVelocity(MInt cellId, MFloat *const vel)
Load variables for the specified timeStep.
Definition: fvstructuredsolver.cpp:7721
◆ initMovingGrid()
|
virtual |
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 770 of file fvstructuredsolver2d.cpp.
◆ initSolutionStep()
|
virtual |
Implements FvStructuredSolver< 2 >.
Definition at line 295 of file fvstructuredsolver2d.cpp.
295 {
296 TRACE();
297
298 std::ignore = mode;
299
300 // Compute infinity values from property file
301 // and (if no restart) fill cells according
302 // to the initialCondition property
303 initialCondition();
304
306 loadRestartFile();
307 }
308
309 setTimeStep();
310
311 // initialize moving grid
312 // functions and move grid
313 // to correct position
317 initMovingGrid();
320 }
321
322 // Get the correct values
323 // in the exchange ghostcells
324 exchange();
325
326 // Call the init function of each BC
327 initBndryCnds();
328
329 // Apply boundary conditions
330 // and fill the non-exchange ghostcells
331 applyBoundaryCondition();
332
333 // Convert SA turb. quantities to k-epsilon when restarting from SA solution
335
336 // Check for NaNs
337 checkNans();
338
339 computeConservativeVariables();
340}
virtual void initialCondition()
Computation of infinity values for the conservative and primitive variables Initialization ot the ent...
Definition: fvstructuredsolver2d.cpp:432
void checkNans()
Checks whole domain for NaNs and adds the number of NaNs globally.
Definition: fvstructuredsolver.cpp:7029
void loadRestartFile()
Load Restart File (primitive and conservative output) general formulation.
Definition: fvstructuredsolver.cpp:5630
virtual void computeConservativeVariables()
Definition: fvstructuredsolver.cpp:4456
◆ loadRestartBC2600()
|
virtual |
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 4111 of file fvstructuredsolver2d.cpp.
4111 {
4114 cout << "Loading BC2600 values..." << endl;
4115 }
4116
4118 MInt noCellsBC = bcCells[0] * bcCells[1];
4119 ParallelIo::size_type bcOffset[2] = {0, 0};
4121
4123 stringstream restartFileName;
4124 MString restartFile = Context::getSolverProperty<MString>("restartVariablesFileName", m_solverId, AT_);
4126
4128 stringstream pathStr;
4130 std::string path = pathStr.str();
4131
4134 pio.readArray(&tmpRestartVars[var * noCellsBC], path, m_variableNames[var], nDim, bcOffset, bcCells);
4135 }
4136
4137 }
4138
4139 MPI_Bcast(&tmpRestartVars[0], noCellsBC * CV->noVariables, MPI_DOUBLE, 0, m_StructuredComm, AT_,
4140 "tmpRestartVars[0]");
4141
4143 cout << "Loading BC2600 values... SUCCESSFUL!" << endl;
4144 }
4145
4147 MInt startGC[2] = {0, 0};
4148 MInt endGC[2] = {0, 0};
4149
4151 startGC[0] = m_noGhostLayers;
4152 }
4154 endGC[0] = m_noGhostLayers;
4155 }
4156
4157 MInt startI = 0, endI = 0;
4159 startI = 0;
4160 endI = m_noGhostLayers;
4163 endI = m_nCells[2];
4164 }
4165
4169 MInt globalI = i;
4171 MInt cellIdBC = globalI + globalJ * bcCells[1];
4172
4173 // load values from restart field
4176 }
4177 }
4178 }
4179
4180
4181 // Fix diagonal cells at end of domain
4188 const MFloat distA1A2 = sqrt(POW2(m_cells->coordinates[0][cellIdA1] - m_cells->coordinates[0][cellIdA2])
4190 const MFloat slope = (m_cells->variables[var][cellIdA1] - m_cells->variables[var][cellIdA2]) / distA1A2;
4191 const MFloat distG1A1 = sqrt(POW2(m_cells->coordinates[0][cellIdG1] - m_cells->coordinates[0][cellIdA1])
4194 }
4195 }
4196 }
4197 }
4198 }
4199}
MInt * m_bc2600noOffsetCells
Definition: fvstructuredsolver.h:783
MInt * m_bc2600noActiveCells
Definition: fvstructuredsolver.h:782
MString * m_variableNames
Definition: fvstructuredsolver.h:410
MBool m_bc2600InitialStartup
Definition: fvstructuredsolver.h:778
Definition: parallelio_hdf5.h:19
int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm, const MString &name, const MString &varname)
same as MPI_Bcast
Definition: mpioverride.cpp:1114
◆ maxResidual()
|
virtual |
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 1482 of file fvstructuredsolver2d.cpp.
1482 {
1483 TRACE();
1484
1486 MFloat epsilon = pow(10.0, -10.0);
1487 m_avrgResidual = F0;
1489 MFloat tmpResidual = F0;
1490 MFloat maxResidual1 = F0;
1491 MInt maxResIndex[3];
1492 // MInt localCounter=F0;
1493 MFloat maxResidualOrg = F0;
1494 MFloat localMaxResidual = F0;
1495 MFloat localAvrgResidual = F0;
1496 MFloat accumAvrgResidual = F0;
1497 MFloat globalMaxResidual = F0;
1498 // MInt accumCounter=0;
1500 maxResIndex[dim] = F0;
1501 }
1502
1507 tmpResidual = m_timeStep / (m_cfl * m_cells->cellJac[cellId]) * fabs(m_cells->rightHandSide[CV->RHO][cellId]);
1508 m_avrgResidual += tmpResidual;
1509 if(tmpResidual > maxResidual1) {
1510 maxResIndex[0] = i - m_noGhostLayers;
1511 maxResIndex[1] = j - m_noGhostLayers;
1512 maxResidual1 = tmpResidual;
1513 }
1514 }
1515 }
1516 } else {
1522 m_avrgResidual += tmpResidual;
1523 if(tmpResidual > maxResidual1) {
1524 maxResIndex[0] = i - m_noGhostLayers;
1525 maxResIndex[1] = j - m_noGhostLayers;
1526 maxResidual1 = tmpResidual;
1527 }
1528 }
1529 }
1530 }
1531
1532 // localCounter = counter;
1533 localMaxResidual = maxResidual1;
1534 localAvrgResidual = m_avrgResidual;
1535 // reset average Residual
1536 m_avrgResidual = F0;
1537
1538 MPI_Allreduce(&localAvrgResidual, &accumAvrgResidual, 1, MPI_DOUBLE, MPI_SUM, m_StructuredComm, AT_,
1539 "localAvrgResidual", "accumAvrgResidual");
1540 MPI_Allreduce(&localMaxResidual, &globalMaxResidual, 1, MPI_DOUBLE, MPI_MAX, m_StructuredComm, AT_,
1541 "localMaxResidual", "globalMaxResidual");
1543 maxResidualOrg = globalMaxResidual;
1545
1546 // write first residuals;
1551 // write out values into residual file
1552 FILE* f_residual;
1553 f_residual = fopen("./Residual", "a+");
1556 fprintf(f_residual, "#iter, physTime, time, dT, wLoad, avrgRes, maxRes, blockId, i, j");
1557 fclose(f_residual);
1558 }
1559 }
1560
1561 // normalize residuals
1562 globalMaxResidual = globalMaxResidual / m_firstMaxResidual;
1564
1566 cerr << "Solution diverged, average residual is nan " << endl;
1571 savePartitions();
1573 }
1574
1575 // convergence Check
1579 }
1580
1581 // processor with the highest Residual writes out!!! saves communication;
1584 // write out values into residual file
1585 FILE* f_residual;
1586 f_residual = fopen("./Residual", "a+");
1593 fprintf(f_residual, " %1.10e", globalMaxResidual);
1597 fprintf(f_residual, "\n");
1598 fclose(f_residual);
1599 }
1600
1602 return true;
1603 } else {
1604 return false;
1605 }
1606}
MFloat m_firstAvrgResidual
Definition: fvstructuredsolver.h:647
MFloat m_convergenceCriterion
Definition: fvstructuredsolver.h:656
void saveSolverSolution(MBool=false, const MBool=false) override
Definition: fvstructuredsolver.cpp:5073
MFloat m_firstMaxResidual
Definition: fvstructuredsolver.h:646
void savePartitions()
Saves the partitioned grid into an HDF5 file. Not used in production use but useful for debugging.
Definition: fvstructuredsolver.cpp:5521
MInt m_residualInterval
The number of timesteps before writing the next residual.
Definition: solver.h:87
int MPI_Allreduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm, const MString &name, const MString &sndvarname, const MString &rcvvarname)
same as MPI_Allreduce
Definition: mpioverride.cpp:952
◆ moveGrid()
Reimplemented from FvStructuredSolver< 2 >.
Definition at line 1163 of file fvstructuredsolver2d.cpp.
1163 {
1164 TRACE();
1167
1169 case 4: // inner grid movement
1170 {
1175
1176 // for Square:
1181
1185
1189
1192
1193 MFloat g = F0;
1197 }
1198 m_grid->m_coordinates[0][pointId] = x * (F1 - h * g * (F1 - x));
1199 m_grid->m_velocity[0][pointId] = x * (-hvel * g * (F1 - x));
1200
1201 g = F0;
1203 g = ((x < x3) ? (1.0l + tanhl(beta * (x - (x2 + x3) / 2.0l) / y_max)) / 2.0l
1204 : ((x < x4) ? 1.0l : (1.0l - tanhl(beta * (x - (x4 + x5) / 2.0l) / y_max)) / 2.0l));
1205 }
1208 }
1209 }
1210
1211 break;
1212 }
1213 case 10: {
1214 // traveling wave case
1216 if(zeroPos) {
1217 t_offset = F0;
1218 }
1219
1221
1222 MFloat fadeInFactor = 0.0;
1223 MFloat fadeInFactorPrime = 0.0;
1224 MFloat fadeInFactorPrimePrime = 0.0;
1227 fadeInFactorPrime = (pi / m_waveTemporalTransition) * sin(t_offset / m_waveTemporalTransition * pi) * F1B2;
1228 fadeInFactorPrimePrime =
1230 } else {
1231 fadeInFactor = 1.0;
1232 fadeInFactorPrime = 0.0;
1233 fadeInFactorPrimePrime = 0.0;
1234 }
1235
1236 if(zeroPos) {
1237 fadeInFactor = F1;
1238 }
1239
1245
1246
1247 // To modify the activation function along the wall normal direction
1248 MFloat ytransitionFactor = F0;
1250 ytransitionFactor = F1;
1252 ytransitionFactor = (1 + cos((yInit - m_waveYBeginTransition) / ytransitionLength * pi)) * F1B2;
1253 } else {
1254 ytransitionFactor = F0;
1255 }
1256
1257 // Modified activation function
1259 ytransitionFactor * (m_waveAmplitude * cos((F2 * pi) / m_waveLength * (xInit - m_waveSpeed * t_offset)));
1260 const MFloat funcPrime = ytransitionFactor * (2 * PI * m_waveSpeed / m_waveLength) * m_waveAmplitude
1262 const MFloat funcPrimePrime = -ytransitionFactor * POW2(2 * PI * m_waveSpeed / m_waveLength) * m_waveAmplitude
1264
1265 // Base activation function
1266 /* const MFloat func = transitionFactor
1267 * (m_waveAmplitude * cos((F2 * pi) / m_waveLength * (zPrime - m_waveSpeed * t_offset)));
1268 const MFloat funcPrime = transitionFactor * (2 * PI * m_waveSpeed / m_waveLength) * m_waveAmplitude
1269 * sin((F2 * pi) / m_waveLength * (zPrime - m_waveSpeed * t_offset));
1270 const MFloat funcPrimePrime = -transitionFactor * POW2(2 * PI * m_waveSpeed / m_waveLength)
1271 * m_waveAmplitude
1272 * cos((F2 * pi) / m_waveLength * (zPrime - m_waveSpeed * t_offset));
1273 */
1274
1275 m_grid->m_coordinates[1][pointId] = func * fadeInFactor + yInit;
1276 m_grid->m_velocity[1][pointId] = func * fadeInFactorPrime + funcPrime * fadeInFactor;
1277 m_grid->m_acceleration[1][pointId] =
1278 funcPrimePrime * fadeInFactor + 2 * funcPrime * fadeInFactorPrime + func * fadeInFactorPrimePrime;
1279 }
1280 }
1281
1282 break;
1283 }
1284 case 12: {
1285 // streamwise traveling wave case
1287 if(zeroPos) {
1288 t_offset = F0;
1289 }
1293
1294 MFloat fadeInFactor = 0.0;
1295 MFloat fadeInFactorPrime = 0.0;
1296 MFloat fadeInFactorPrimePrime = 0.0;
1299 fadeInFactorPrime = (pi / m_waveTemporalTransition) * sin(t_offset / m_waveTemporalTransition * pi) * F1B2;
1300 fadeInFactorPrimePrime =
1302 } else {
1303 fadeInFactor = 1.0;
1304 fadeInFactorPrime = 0.0;
1305 fadeInFactorPrimePrime = 0.0;
1306 }
1307
1308 if(zeroPos) {
1309 fadeInFactor = F1;
1310 }
1311
1312
1318
1319 MFloat transitionFactor = F0;
1321 transitionFactor = F0;
1325 transitionFactor = F1;
1327 transitionFactor = (1 + cos((xInit - m_waveOutBeginTransition) / transitionOutLength * pi)) * F1B2;
1328 } else {
1329 transitionFactor = F0;
1330 }
1331
1332 MFloat yTransitionFactor = F1;
1334 yTransitionFactor = F1;
1336 yTransitionFactor = (1 + cos((yInit - m_waveYBeginTransition) / yTransitionLength * pi)) * F1B2;
1337 } else {
1338 yTransitionFactor = F0;
1339 }
1340
1343 const MFloat funcPrime = transitionFactor * yTransitionFactor * (2 * PI * m_waveSpeed / m_waveLength)
1348
1349 m_grid->m_coordinates[1][pointId] = func * fadeInFactor + yInit;
1350 m_grid->m_velocity[1][pointId] = func * fadeInFactorPrime + funcPrime * fadeInFactor;
1351 m_grid->m_acceleration[1][pointId] =
1352 funcPrimePrime * fadeInFactor + 2 * funcPrime * fadeInFactorPrime + func * fadeInFactorPrimePrime;
1353 }
1354 }
1355
1356 break;
1357 }
1358 case 14: {
1359 // oscillating cylinder
1361 if(zeroPos) {
1362 t_offset = F0;
1363 }
1364
1365 MFloat fadeInFactor = 0;
1367
1368 if(t_offset < timeRelaxation) {
1369 fadeInFactor = (1.0 - cos(t_offset / timeRelaxation * pi)) * F1B2;
1370 } else {
1371 fadeInFactor = 1.0;
1372 }
1373
1374 if(zeroPos) {
1375 fadeInFactor = F1;
1376 }
1377
1383
1385
1386 MFloat spaceTransition = F1;
1387
1388 if(r < 1.0) {
1389 spaceTransition = F0;
1390 } else if(r >= 1.0 && r <= 41.0) {
1391 spaceTransition = fabs(r - 1.0) / 40.0;
1392 } else {
1393 spaceTransition = F1;
1394 }
1395
1396 m_grid->m_coordinates[1][pIJ] =
1397 y * spaceTransition
1398 + (1.0 - spaceTransition) * (y + fadeInFactor * m_oscAmplitude * sin(2 * PI * m_oscFreq * t_offset));
1399 m_grid->m_velocity[1][pIJ] =
1400 (1.0 - spaceTransition)
1402 m_grid->m_acceleration[1][pIJ] =
1403 (1.0 - spaceTransition)
1404 * (-fadeInFactor * m_oscAmplitude * POW2(2 * PI * m_oscFreq) * sin(2 * PI * m_oscFreq * t_offset));
1405 }
1406 }
1407
1408 break;
1409 }
1410 default: {
1412 }
1413 }
1414
1416
1419 m_grid->extrapolateGhostPointCoordinates();
1420 }
1422 }
1423
1427 }
1428 }
1430
1432 m_grid->computeCellCenterCoordinates();
1434
1436 m_grid->computeMetrics();
1438
1440 m_grid->computeJacobian();
1441
1443}
MFloat m_waveEndTransition
Definition: fvstructuredsolver.h:367
MFloat m_waveYBeginTransition
Definition: fvstructuredsolver.h:374
MBool m_mgExchangeCoordinates
Definition: fvstructuredsolver.h:344
MFloat m_waveBeginTransition
Definition: fvstructuredsolver.h:366
MFloat m_waveTemporalTransition
Definition: fvstructuredsolver.h:377
MInt m_gridMovingMethod
Definition: fvstructuredsolver.h:345
MFloat m_waveOutEndTransition
Definition: fvstructuredsolver.h:369
MFloat m_movingGridTimeOffset
Definition: fvstructuredsolver.h:350
MFloat m_waveYEndTransition
Definition: fvstructuredsolver.h:375
MFloat m_waveOutBeginTransition
Definition: fvstructuredsolver.h:368
@ MGCellCenterCoordinates
Definition: fvstructuredtimers.h:40
◆ Muscl()
|
overridevirtual |
Implements FvStructuredSolver< 2 >.
Definition at line 1726 of file fvstructuredsolver2d.cpp.
1726 {
1727 TRACE();
1728
1733 m_grid->saveGrid();
1734 m_grid->saveCellJacobian();
1736 }
1737
1741
1742 // compute the volume fluxes
1747 }
1748
1750 (this->*reconstructSurfaceData)();
1752}
void moveGrid(const MBool isRestart, const MBool zeroPos) override
Definition: fvstructuredsolver2d.cpp:1163
◆ Muscl_()
template<FvStructuredSolver2D::fluxmethod ausm, MInt noVars>
| void FvStructuredSolver2D::Muscl_ |
Definition at line 1892 of file fvstructuredsolver2d.cpp.
1892 {
1893 TRACE();
1894 // stencil identifier
1897
1900
1906
1914
1915 // distances q_i+1 - q_i
1917 // distances q_i - q_i-1
1922
1929 qleft[v] = vars[I] + DSM * (DSM1 * DQ + DS * DQM1);
1930 qright[v] = vars[IP1] - DSP * (DS * DQP1 + DSP1 * DQ);
1931 }
1932
1934 }
1935 }
1936
1937 // FLUX BALANCE
1945 rhs[I] += flux[v][IM1] - flux[v][I];
1946 }
1947 }
1948 }
1949 }
1950}
◆ MusclAlbada()
| void FvStructuredSolver2D::MusclAlbada | ( | ) |
Definition at line 1756 of file fvstructuredsolver2d.cpp.
1756 {
1757 TRACE();
1758
1761 // grid stretching factors
1762 MFloat DS = F0, DSP1 = F0, DSM1 = F0, DSP = F0, DSM = F0;
1763 // stencil identifier
1765
1766 // flow variables differences
1767 // MFloat DQ=F0, DQP1=F0, DQM1=F0;
1771
1772 // left and right state
1774 MFloat smps = F0;
1776
1777 MFloat pIM2 = F0, pIM1 = F0, pIP1 = F0, pIP2 = F0;
1779 DQ[i] = F0;
1780 DQP1[i] = F0;
1781 DQM1[i] = F0;
1782 }
1783 // reduce to onedimensional arrays
1786
1787 MFloat phi = F0, psi = F0, vel = F0;
1788
1790 // MFloat epsi=F1;
1791 // MFloat kappa=F1B3;
1796 // cell ids
1798
1799 IP1 = cellId + IJ[dim];
1800 IM1 = cellId - IJ[dim];
1801 IP2 = cellId + 2 * IJ[dim];
1802
1803 // distances q_i+1 - q_i
1805 // distances q_i - q_i-1
1808 // account for grid stretching
1809 // like tfs comment
1810 // DSP=F2*DS/POW2(DSP1+DS);
1811 // DSM=F2*DS/POW2(DSM1+DS);
1812 // like tfs
1813 DSP = DS / POW2(DSP1 + DS);
1814 DSM = DS / POW2(DSM1 + DS);
1815
1816
1819
1821
1823 // limiter
1824 }
1825 vel = F0;
1828 }
1830 vel = F0;
1832 vel += POW2(m_cells->variables[CV->RHO_VV[dim1]][cellId] / m_cells->variables[CV->RHO][cellId]);
1833 }
1834 pIM1 = m_cells->variables[CV->RHO_E][cellId] - F1B2 * m_cells->variables[CV->RHO][cellId] * vel;
1835
1836 vel = F0;
1839 }
1841 vel = F0;
1844 }
1846
1847 smps = DS * DSP1;
1848
1849 dummy = fabs(pIM2 - F2 * pIM1 + pIP1) / (pIM2 + F2 * pIM1 + pIP1);
1850 dummy1 = fabs(pIM1 - F2 * pIP1 + pIP2) / (pIM1 + F2 * pIP1 + pIP2);
1851
1854
1855
1857 phi = F1B2
1858 - (F1B2
1859 - mMax(F0, (DQP1[var] * DQM1[var] * smps + F1B2 * epsLim)
1861 * psi;
1862
1863 m_QLeft[var] = m_cells->variables[var][cellId] + DSM * (DSM1 * DQ[var] + DS * DQM1[var]) * phi;
1865
1866 // PHI(IP,IM,ID)=F2-(F2-MAX(F0,(DQ(IP,ID)*DQ(IM,ID)*SMSP+EPSMP2)
1867 // & /((DQ(IP,ID)*SM)**2+(DQ(IM,ID)*SP)**2+EPSMP)))*PSI
1868 }
1869
1870
1872 }
1873 }
1874
1875
1876 // FLUX BALANCE
1881 IM1 = I - IJ[dim];
1883 }
1884 }
1885 }
1886 }
1887}
void AusmLES(MFloat *QLeft, MFloat *QRight, const MInt dim, const MInt cellId)
AUSM Central.
Definition: fvstructuredsolver2d.cpp:2058
◆ MusclNoLimiter()
| void FvStructuredSolver2D::MusclNoLimiter | ( | ) |
◆ MusclRANS()
| void FvStructuredSolver2D::MusclRANS | ( | ) |
Definition at line 1889 of file fvstructuredsolver2d.cpp.
void Muscl(MInt timerId=-1)
Definition: fvstructuredsolver2drans.cpp:170
◆ MusclStretched_()
template<FvStructuredSolver2D::fluxmethod ausm, MInt noVars>
| void FvStructuredSolver2D::MusclStretched_ |
Definition at line 1967 of file fvstructuredsolver2d.cpp.
1967 {
1968 TRACE();
1969
1970 // stencil identifier
1985
1992
1998
2004
2008 // left variables
2011 qleft[v] = vars[I] + f * (f1 * DQ + f2 * DQM1);
2012
2013 // right variables
2016 qright[v] = vars[IP1] - fa * (fb * DQP1 + fc * DQ1);
2017 }
2018
2020 }
2021 }
2022
2023 // FLUX BALANCE
2031 rhs[I] += flux[v][IM1] - flux[v][I];
2032 }
2033 }
2034 }
2035 }
2036}
◆ pointIndex()
Definition at line 1626 of file fvstructuredsolver2d.cpp.
◆ pressure()
Definition at line 1628 of file fvstructuredsolver2d.cpp.
◆ rungeKuttaStep()
|
virtual |
Implements FvStructuredSolver< 2 >.
Definition at line 2380 of file fvstructuredsolver2d.cpp.
2380 {
2381 TRACE();
2386
2387#ifdef MAIA_EXTRA_DEBUG
2389#endif
2390
2396
2397 // set old variables
2405 }
2406 }
2407 }
2408
2409
2411 case 2: {
2418
2423 cellVars[cellId] = oldCellVars[cellId] + factor * cellRhs[cellId];
2424 }
2425 }
2426 }
2433
2437 cellVars[cellId] =
2439 }
2440 }
2441 }
2442 } else {
2448
2453 cellVars[cellId] = oldCellVars[cellId] + factor * cellRhs[cellId];
2454 }
2455 }
2456 }
2457 }
2458 break;
2459 }
2460 case 3: {
2466
2471 cellVars[cellId] =
2473 }
2474 }
2475 }
2476 break;
2477 }
2478 default: {
2479 stringstream errorMessage;
2480 errorMessage << "Given RungeKutta Order " << m_rungeKuttaOrder << " not implemented! " << endl;
2481 mTerm(1, AT_, errorMessage.str());
2482 }
2483 }
2484
2485 ++m_RKStep;
2486
2490
2491 m_RKStep = 0;
2492
2493 return true;
2494 } else {
2495 return false;
2496 }
2497}
MInt m_rungeKuttaOrder
Definition: fvstructuredsolver.h:560
◆ scatter()
|
override |
Definition at line 4283 of file fvstructuredsolver2d.cpp.
4284 {
4285 // the ordering of the grid points can be different from
4286 // sending instance ==> reorder it and copy it to the
4287 // right place
4288
4289 for(auto& rcv : rcvComm) {
4292
4293 MInt step2[2];
4294 MInt start1[2];
4295 MInt start2[2];
4296 MInt end2[2];
4297 MInt len2[2];
4298 MInt totalCells = 1;
4299 MInt len1[2];
4300
4302 len1[j] = rcv->endInfoCells[j] - rcv->startInfoCells[j];
4303 if(len1[j] != 0) totalCells *= len1[j];
4304 step2[rcv->orderInfo[j]] = rcv->stepInfo[j];
4305 }
4306
4308 start2[j] = 0;
4309 end2[j] = len1[j] - 1;
4310 len2[rcv->orderInfo[j]] = len1[j];
4311 if(step2[j] < 0) {
4313 start2[j] = end2[j];
4314 end2[j] = dummy;
4315 }
4316 }
4317
4318 MInt pos = 0;
4320 MInt j2 = start2[1];
4322 MInt i2 = start2[0];
4324 start1[rcv->orderInfo[0]] = i2;
4325 start1[rcv->orderInfo[1]] = j2;
4326
4329 rcv->variables[var][cellId] = rcv->cellBuffer[id2];
4330
4331 i2 += step2[0];
4332 pos++;
4333 }
4334 j2 += step2[1];
4335 }
4336 }
4337 }
4338}
◆ updateSpongeLayer()
|
virtual |
Implements FvStructuredSolver< 2 >.
Definition at line 2375 of file fvstructuredsolver2d.cpp.
◆ viscousFlux()
|
virtual |
Implements FvStructuredSolver< 2 >.
Definition at line 2499 of file fvstructuredsolver2d.cpp.
2499{ (this->*viscFluxMethod)(); }
◆ viscousFluxCompactCorrection()
template<MBool twoEqRans>
| void FvStructuredSolver2D::viscousFluxCompactCorrection |
Definition at line 3332 of file fvstructuredsolver2d.cpp.
3332 {
3337
3341
3342 // MInt dim = 0;
3345 // MInt totalCells;
3346
3348 // only correct for bc 6000 not for bc 4000-5000
3350 // totalCells=1;
3353 // if(len1[j]!=0) totalCells*=len1[j];
3354 }
3355
3359 // dim=n;
3360 // start[n]=m_singularity[i].start[n]+1;
3363 } else {
3366 }
3367 }
3368
3369 MFloat u[10], v[10], T[10];
3370 MFloat U, V, t;
3373 MInt count = 0;
3374 // MInt temp[nDim]{};
3376
3377 // dxidx, dxidy, detadx, detady
3381
3382 // temp[dim]=1;
3384 nghbr[count++] = IJ;
3385 // nghbr[count++]=cellIndex(ii+temp[0],jj+temp[1],kk+temp[2]);
3386
3389 nghbr[count++] = cellIndex(ii + change[0], jj + change[1]);
3390 // nghbr[count++]=cellIndex(ii+temp[0]+change[0],jj+temp[1]+change[1],kk+temp[2]+change[2]);
3391 }
3392
3394 cout << "what the hell! it is wrong!!! count=" << count << " Nstar=" << m_singularity[i].Nstar << endl;
3395 }
3396
3398 u[m] = u_[nghbr[m]];
3399 v[m] = v_[nghbr[m]];
3400 // T[m]=(m_gamma*gammaMinusOne*(rhoE[nghbr[m]]-F1B2*rho[nghbr[m]]*(POW2(u[m])+POW2(v[m]))))/rho[nghbr[m]];
3401 T[m] = m_gamma * p_[nghbr[m]] / rho_[nghbr[m]];
3402 }
3403
3404 U = F0;
3405 V = F0;
3406 t = F0;
3407
3408 MInt id2 = ii - start[0] + (jj - start[1]) * len1[0];
3409
3411 MInt ID = id2 * count + n;
3415 }
3416
3417 // cout << globalTimeStep << "(" << m_RKStep << ") dom=" << domainId() << " x|y=" <<
3418 // m_cells->coordinates[0][IJK] << "|" << m_cells->coordinates[1][IJK] << " U=" << U << " V=" << V
3419 // << " t=" << t << " cornerMetrics=" << cornerMetrics[0] << "|" << cornerMetrics[1] << "|" <<
3420 // cornerMetrics[2] << "|" << cornerMetrics[3] << endl;
3421
3424
3427
3432
3437
3441
3445
3450 }
3451 }
3452 }
3453 }
3454}
MFloat ** surfaceMetricsSingularity
Definition: fvstructuredcell.h:45
◆ viscousFluxCorrection()
template<MBool twoEqRans>
| void FvStructuredSolver2D::viscousFluxCorrection |
Definition at line 3178 of file fvstructuredsolver2d.cpp.
3178 {
3179 mTerm(1, "I don't think that this correction is ok, becuase of the cornerMetrics at the singular point!");
3185
3191
3194
3195 // only relevant for 2-eq Rans model (Waiting for if constexpr)
3196 const MFloat* const RESTRICT TKE_ = (twoEqRans) ? ALIGNED_F(m_cells->pvariables[PV->RANS_VAR[0]]) : nullptr;
3197
3198 // MInt dim = 0;
3201 // MInt totalCells;
3202
3204 // only correct for bc 6000 not for bc 4000-5000
3206 // totalCells=1;
3209 // if(len1[j]!=0) totalCells*=len1[j];
3210 }
3211
3215 // dim=n;
3216 // start[n]=m_singularity[i].start[n]+1;
3219 } else {
3222 }
3223 }
3224
3225 MFloat u[10], v[10], T[10], muTurb[10], TKE[10];
3226 MFloat U, V, t, muTurb_corner, TKEcorner, dudx, dudy, dvdx, dvdy, dTdx, dTdy;
3227 MFloat tau1, tau2, tau4;
3228 MFloat mueOverRe, mue, mueH;
3231 MInt count = 0;
3232 // MInt temp[nDim]{};
3234
3235 const MFloat cornerMetrics[nDim * nDim] = {m_cells->cornerMetrics[0][IJK], m_cells->cornerMetrics[1][IJK],
3237
3238 // temp[dim]=1;
3239 nghbr[count++] = cellIndex(ii, jj);
3240 // nghbr[count++]=cellIndex(ii+temp[0],jj+temp[1],kk+temp[2]);
3241
3244 nghbr[count++] = cellIndex(ii + change[0], jj + change[1]);
3245 // nghbr[count++]=cellIndex(ii+temp[0]+change[0],jj+temp[1]+change[1],kk+temp[2]+change[2]);
3246 }
3247
3249 cout << "what the hell! it is wrong!!! count=" << count << " Nstar=" << m_singularity[i].Nstar << endl;
3250 }
3251
3253 u[m] = u_[nghbr[m]];
3254 v[m] = v_[nghbr[m]];
3255 // T[m]=(m_gamma*gammaMinusOne*(rhoE[nghbr[m]]-F1B2*rho[nghbr[m]]*(POW2(u[m])+POW2(v[m]))))/rho[nghbr[m]];
3256 T[m] = m_gamma * p_[nghbr[m]] / rho_[nghbr[m]];
3257 muTurb[m] = muTurb_[nghbr[m]];
3259 }
3260
3261 U = F0;
3262 V = F0;
3263 t = F0;
3264 muTurb_corner = F0;
3265 TKEcorner = F0;
3266 dudx = F0;
3267 dudy = F0;
3268 dvdx = F0;
3269 dvdy = F0;
3270 dTdx = F0;
3271 dTdy = F0;
3272
3273 MInt id2 = ii - start[0] + (jj - start[1]) * len1[0];
3274
3276 MInt ID = id2 * count + n;
3280
3284
3288
3290
3293 }
3294
3295 // cout << globalTimeStep << "(" << m_RKStep << ") dom=" << domainId() << " x|y=" <<
3296 // m_cells->coordinates[0][IJK] << "|" << m_cells->coordinates[1][IJK] << " U=" << U << " V=" << V
3297 // << " t=" << t << " cornerMetrics=" << cornerMetrics[0] << "|" << cornerMetrics[1] << "|" <<
3298 // cornerMetrics[2] << "|" << cornerMetrics[3] << endl;
3299
3300 tau1 = 2 * dudx - 2 / 3 * (dudx + dvdy);
3301 tau2 = dudy + dvdx;
3302 tau4 = 2 * dvdy - 2 / 3 * (dudx + dvdy);
3303
3304 mue = SUTHERLANDLAW(t);
3305 TKEcorner *= -2 / 3;
3306 mueOverRe = (mue + muTurb_corner) * rRe;
3307 tau1 = mueOverRe * tau1 + TKEcorner;
3308 tau2 *= mueOverRe;
3309 tau4 = mueOverRe * tau4 + TKEcorner;
3310 mueH = FgammaMinusOne * rRe * (rPr * mue + rPrTurb * muTurb_corner);
3311
3314
3315 // efluxes
3319
3320 // ffluxes
3324 }
3325 }
3326 }
3327 }
3328}
◆ viscousFluxLES()
template<MBool twoEqRans>
| template void FvStructuredSolver2D::viscousFluxLES< true > | ( | ) |
Definition at line 2505 of file fvstructuredsolver2d.cpp.
2505 {
2506 TRACE();
2512
2520
2524
2525 // only relevant for 2-eq Rans model (Waiting for if constexpr)
2526 const MFloat* const RESTRICT TKE = (twoEqRans) ? ALIGNED_F(m_cells->pvariables[PV->RANS_VAR[0]]) : nullptr;
2527 MFloat TKEcorner = 0;
2528
2533 muLam[I] = SUTHERLANDLAW(T[I]);
2534 }
2535 }
2536
2537 MFloat tau1, tau2, tau4;
2538 MFloat dTdx, dTdy;
2539
2542 // get the adjacent cells;
2547
2550
2553
2556
2559
2562
2563 if(twoEqRans) {
2565 TKEcorner =
2566 -2 / 3 * F1B4 * (rho[IJP] * TKE[IJP] + rho[IPJP] * TKE[IPJP] + rho[IJ] * TKE[IJ] + rho[IPJ] * TKE[IPJ]);
2567 }
2568
2571
2572 // compute tau1 = 2 du/dx - 2/3 ( du/dx + dv/dy + dw/dz )
2573
2574 // tau_xx = 4/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx )
2575 // - 2/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy)
2576 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
2578
2580
2581 // compute tau2 = du/dy + dv/dx
2582
2583 // tau_xy = du/dxi * dxi/dy + du/deta * deta/dy + du/dzeta * dzeta/dy
2584 // + dv/dxi * dxi/dx + dv/deta * deta/dx + dv/dzeta * dzeta/dx
2586
2588
2589 // compute tau4 = 2 dv/dy - 2/3 ( du/dx + dv/dy + dw/dz )
2590
2591 // tau_yy = 4/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy )
2592 // - 2/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx)
2593 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
2595
2597
2598
2600
2602
2605 tau1 = mueOverRe * tau1 + TKEcorner;
2606 tau2 *= mueOverRe;
2607 tau4 = mueOverRe * tau4 + TKEcorner;
2608
2609 const MFloat muCombined = FgammaMinusOne * rRe * fJac * (rPrLam * muLamAvg + rPrTurb * muTurbAvg);
2612
2613 // efluxes
2615
2617
2619
2620 // ffluxes
2622
2624
2626 }
2627 }
2628
2629
2630 // viscous flux correction for the singular points
2631 // m_hasSingularity=0 means no singular points in this block, otherwise do flux correction
2633 viscousFluxCorrection();
2634 }
2635
2641
2642 vflux[0][IJ] = F1B2 * (eflux[var][IJ] + eflux[var][IJM]);
2643 }
2644 }
2645
2650
2651 vflux[1][IJ] = F1B2 * (fflux[var][IJ] + fflux[var][IMJ]);
2652 }
2653 }
2654
2660 m_cells->rightHandSide[var][IJ] += (vflux[0][IJ] - vflux[0][IMJ] + vflux[1][IJ] - vflux[1][IJM]);
2661 }
2662 }
2663 }
2664}
void viscousFluxCorrection()
Definition: fvstructuredsolver2d.cpp:3178
◆ viscousFluxLESCompact()
template<MBool twoEqRans>
| template void FvStructuredSolver2D::viscousFluxLESCompact< true > | ( | ) |
Definition at line 2920 of file fvstructuredsolver2d.cpp.
2920 {
2921 TRACE();
2927
2935
2939
2940 // only relevant for 2-eq Rans model (Waiting for if constexpr)
2941 const MFloat* const RESTRICT TKE = (twoEqRans) ? ALIGNED_F(m_cells->pvariables[PV->RANS_VAR[0]]) : nullptr;
2942 MFloat TKEcorner = 0;
2943
2948 muLam[I] = SUTHERLANDLAW(T[I]);
2949 }
2950 }
2951
2952 // Save some aux. variables at the corners
2959
2964
2967
2970
2973
2977
2981
2986 }
2987 }
2988
2990 viscousFluxCompactCorrection();
2991 }
2992
2993 // xi-Flux
3001 // TODO_SS labels:FV here surface jac (m_cells->surfJac) verwenden!!!
3003 2.0 / (m_cells->cornerJac[IJ] + m_cells->cornerJac[IJM]); // TODO_SS labels:FV Is this the right way to go?
3004
3008
3011
3014
3015 // The underscores in the variable names should indicate, that these are just
3016 // one contribution to the full, e.g. dudx
3022
3023 if(twoEqRans) {
3024 if(m_rans2eq_mode == "production") TKEcorner = -2 / 3 * F1B2 * (rho[IJ] * TKE[IJ] + rho[IPJ] * TKE[IPJ]);
3025 }
3026
3027 // compute tau1 = 2 du/dx - 2/3 ( du/dx + dv/dy + dw/dz )
3028
3029 // tau_xx = 4/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx )
3030 // - 2/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy)
3031 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
3032 MFloat tau1 = F4B3 * (dudxi * surf0 + dudx_) - F2B3 * (dvdxi * surf1 + dvdy_);
3033
3034 // compute tau2 = du/dy + dv/dx
3035
3036 // tau_xy = du/dxi * dxi/dy + du/deta * deta/dy + du/dzeta * dzeta/dy
3037 // + dv/dxi * dxi/dx + dv/deta * deta/dx + dv/dzeta * dzeta/dx
3038 MFloat tau2 = dudxi * surf1 + dvdxi * surf0 + S12_;
3039
3040 // compute tau4 = 2 dv/dy - 2/3 ( du/dx + dv/dy + dw/dz )
3041
3042 // tau_yy = 4/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy )
3043 // - 2/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx)
3044 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
3045 MFloat tau4 = F4B3 * (dvdxi * surf1 + dvdy_) - F2B3 * (dudxi * surf0 + dudx_);
3046
3049
3051 tau1 = mueOverRe * tau1 + TKEcorner;
3052 tau2 *= mueOverRe;
3053 tau4 = mueOverRe * tau4 + TKEcorner;
3054
3058
3059 MFloat limiterVisc = 1.0;
3061 // TODO_SS labels:FV limiter should preserve conservativity
3062 const MFloat mu_ref = F1B2 * (m_cells->fq[FQ->LIMITERVISC][IJ] + m_cells->fq[FQ->LIMITERVISC][IPJ]);
3063 limiterVisc = std::min(1.0, mu_ref / std::abs(mueOverRe)); // TODO_SS labels:FV evtl: scale with Re
3064 }
3065
3066 // efluxes
3067 eflux[0][IJM] = (tau1 * surf0 + tau2 * surf1) * limiterVisc;
3068 eflux[1][IJM] = (tau2 * surf0 + tau4 * surf1) * limiterVisc;
3069 eflux[2][IJM] = (qx * surf0 + qy * surf1) * limiterVisc; // TODO_SS labels:FV aufpassen mit limiter
3070 }
3071 }
3072
3073 // eta-Flux
3081 // TODO_SS labels:FV here surface jac (m_cells->surfJac) verwenden!!!
3083 2.0 / (m_cells->cornerJac[IJ] + m_cells->cornerJac[IMJ]); // TODO_SS labels:FV Is this the right way to go?
3084
3088
3091
3094
3095 // The underscores in the variable names should indicate, that these are just
3096 // one contribution to the full, e.g. dudx
3102
3103 if(twoEqRans) {
3104 if(m_rans2eq_mode == "production") TKEcorner = -2 / 3 * F1B2 * (rho[IJ] * TKE[IJ] + rho[IJP] * TKE[IJP]);
3105 }
3106
3107 // compute tau1 = 2 du/dx - 2/3 ( du/dx + dv/dy + dw/dz )
3108
3109 // tau_xx = 4/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx )
3110 // - 2/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy)
3111 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
3112 MFloat tau1 = F4B3 * (dudx_ + dudet * surf0) - F2B3 * (dvdy_ + dvdet * surf1);
3113
3114 // compute tau2 = du/dy + dv/dx
3115
3116 // tau_xy = du/dxi * dxi/dy + du/deta * deta/dy + du/dzeta * dzeta/dy
3117 // + dv/dxi * dxi/dx + dv/deta * deta/dx + dv/dzeta * dzeta/dx
3118 MFloat tau2 = dudet * surf1 + dvdet * surf0 + S12_;
3119
3120 // compute tau4 = 2 dv/dy - 2/3 ( du/dx + dv/dy + dw/dz )
3121
3122 // tau_yy = 4/3*( dv/dxi * dxi/dy + dv/deta * deta/dy + dv/dzeta * dzeta/dy )
3123 // - 2/3*( du/dxi * dxi/dx + du/deta * deta/dx + du/dzeta * dzeta/dx)
3124 // - 2/3*( dw/dxi * dxi/dz + dw/deta * deta/dz + dw/dzeta * dzeta/dz )
3125 MFloat tau4 = F4B3 * (dvdy_ + dvdet * surf1) - F2B3 * (dudx_ + dudet * surf0);
3126
3129
3131 tau1 = mueOverRe * tau1 + TKEcorner;
3132 tau2 *= mueOverRe;
3133 tau4 = mueOverRe * tau4 + TKEcorner;
3134
3138
3139 MFloat limiterVisc = 1.0;
3141 // TODO_SS labels:FV limiter should preserve conservativity
3142 const MFloat mu_ref = F1B2 * (m_cells->fq[FQ->LIMITERVISC][IJ] + m_cells->fq[FQ->LIMITERVISC][IJP]);
3143 limiterVisc = std::min(1.0, mu_ref / std::abs(mueOverRe)); // TODO_SS labels:FV evtl: scale with Re
3144 }
3145
3146 // ffluxes
3147 fflux[0][IMJ] = (tau1 * surf0 + tau2 * surf1) * limiterVisc;
3148 fflux[1][IMJ] = (tau2 * surf0 + tau4 * surf1) * limiterVisc;
3149 fflux[2][IMJ] = (qx * surf0 + qy * surf1) * limiterVisc; // TODO_SS labels:FV aufpassen mit limiter
3150 }
3151 }
3152
3160
3161 MFloat limiterVisc = 1.0;
3162 /* if (m_limiterVisc) {
3163 // TODO_SS labels:FV limiter should preserve conservativity
3164 const MFloat mu_ref = m_cells->fq[FQ->LIMITERVISC][IJ];
3165 // TODO_SS labels:FV evtl: scale with Re
3166 limiterVisc = std::min(1.0, mu_ref/std::abs(rRe*(muLam[IJ]+muTurb[IJ])));
3167 }*/
3169 (eflux[var][IJM] - eflux[var][IMJM] + (fflux[var][IMJ] - fflux[var][IMJM])) * limiterVisc;
3170 }
3171 }
3172 }
3173}
void viscousFluxCompactCorrection()
Definition: fvstructuredsolver2d.cpp:3332
◆ viscousFluxRANS()
| void FvStructuredSolver2D::viscousFluxRANS | ( | ) |
Definition at line 2501 of file fvstructuredsolver2d.cpp.
void viscousFluxRANS()
Definition: fvstructuredsolver2drans.cpp:802
Friends And Related Function Documentation
◆ FvStructuredSolver2DRans
|
friend |
Definition at line 24 of file fvstructuredsolver2d.h.
◆ StructuredBndryCnd2D
template<MBool isRans>
|
friend |
Definition at line 23 of file fvstructuredsolver2d.h.
Member Data Documentation
◆ m_ransSolver
| FvStructuredSolver2DRans* FvStructuredSolver2D::m_ransSolver |
Definition at line 117 of file fvstructuredsolver2d.h.
◆ m_structuredBndryCnd
|
protected |
Definition at line 120 of file fvstructuredsolver2d.h.
◆ nDim
|
staticconstexprprotected |
Definition at line 121 of file fvstructuredsolver2d.h.
◆ reconstructSurfaceData
| void(FvStructuredSolver2D::* FvStructuredSolver2D::reconstructSurfaceData) () |
Definition at line 98 of file fvstructuredsolver2d.h.
◆ viscFluxMethod
| void(FvStructuredSolver2D::* FvStructuredSolver2D::viscFluxMethod) () |
Definition at line 68 of file fvstructuredsolver2d.h.
The documentation for this class was generated from the following files:
- /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstructuredsolver2d.h
- /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstructuredsolver2d.cpp
