#include <postprocessingfv.h>

Inheritance diagram for PostProcessingFv< nDim, SysEqn >:

Collaboration diagram for PostProcessingFv< nDim, SysEqn >:

Public Types
using	SolverType = FvCartesianSolverXD< nDim, SysEqn >

using	Base = PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >

Public Types inherited from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >
using	PPGrid = CartesianGrid< nDim >

using	Cell = typename PPGrid::Cell

using	GridProxy = typename maia::grid::Proxy< nDim >

using	Data = PostData< nDim >

Public Member Functions
	PostProcessingFv (MInt postprocessingId_, PostData< nDim > data, SolverType ppSolver_)

virtual	~PostProcessingFv ()

void	initPostProcessing () override

SolverType &	solver () const

Public Member Functions inherited from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >
	PostProcessing (MInt postprocessingId_, PostData< nDim > *data)

	~PostProcessing ()
	Destructor for the massive paralle postprocessing solver. More...

void	initPostProcessing () override
	Reads all required properties in and prepares for postprocessing. More...

void	postprocessPreSolve () override

void	postprocessPostSolve () override

void	postprocessInSolve (MBool finalTimeStep) override

void	postprocessSolution () override

Solver *	mSolver () const override

Data &	postData () const

Public Member Functions inherited from PostProcessingInterface
	PostProcessingInterface (const MInt postprocessingId_)

virtual	~PostProcessingInterface ()=default

	PostProcessingInterface (const PostProcessingInterface &)=delete

PostProcessingInterface &	operator= (const PostProcessingInterface &)=delete

virtual void	initPostProcessing ()=0

virtual void	postprocessPreSolve ()=0

virtual void	postprocessPostSolve ()=0

virtual void	postprocessInSolve (MBool finalTimeStep)=0

virtual void	postprocessSolution ()=0

virtual Solver *	mSolver () const =0

MInt	a_postprocessingId () const

Protected Member Functions
void	probeLinePeriodicPost () override

void	probeLinePeriodic () override

void	initMovingAverage () override
	Initializes properties and allocates memory for moving averaging. More...

void	initAveragingProperties () override
	Initialize properties relevant for temporal averaging. More...

void	initPointSamplingData () override

void	savePointSamplingData () override

void	initSurfaceSamplingData () override

void	saveSurfaceSamplingData () override

void	initVolumeSamplingData () override

void	saveVolumeSamplingData () override

void	initSprayData () override

void	calcVorticity (const MFloatTensor &deriv, MFloat vorticity[nDim *2 - 3]) override

void	getVorticity (MFloat *const vorticity) override

void	getVorticityT (MFloat *const vorticity) override

void	getSampleVarsDerivatives (MInt cellId, const MFloat *&vars)

MBool	getSampleVarsDerivatives (const MInt cellId, std::vector< MFloat > &vars)

MFloat &	vorticityAtCell (const MInt cellId, const MInt dir) override

void	getPrimitiveVariables (MInt cellId, MFloat Xp, MFloat vars, MInt order) override

void	computeAcousticSourceTermQe (MFloatScratchSpace &QeI, MFloatScratchSpace &QeIII, MFloatScratchSpace &cSquared, MFloatScratchSpace &drhodt) override

void	getPrimitiveVarNames (MString *names) const override

MFloat	getBoundaryHeatFlux (const MInt cellId) const override

void	vapourPenetration (MFloat spawnCoord[nDim])

void	vapourMass (const MInt)

void	advanceDataStep ()

void	resetDataStep ()

Protected Member Functions inherited from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >
MBool	isActive () const

void	transferSensorWeights ()

void	initReduceToLevelAvg ()
	Initializes properties for grid level reduction. More...

void	initTimeStepProperties ()
	Initializes timestep properties for postprocessing. More...

void	initTimeStepPropertiesSlice ()

void	initTimeStepPropertiesLine ()

virtual void	initAveragingProperties ()
	Initialize properties relevant for temporal averaging. More...

void	initProbePoint ()
	Initializes properties for point probing. More...

void	initProbeLine ()
	Initializes properties and memory for line probing. More...

void	initProbeSlice ()
	Initializes properties and memory for slice probing. More...

void	initSpatialAveraging ()

void	initProbeArbitraryLine ()
	initializes properties and data for arbitrary line probing More...

void	initProbeArbitrarySlice ()
	initializes properties and data for arbitrary slice probing More...

void	initProbeLinePeriodic ()

virtual void	probeLinePeriodic ()

virtual void	probeLinePeriodicPost ()

virtual void	initSprayData ()

virtual void	computeSprayData ()

virtual void	writeSprayData ()

virtual void	initLPTSolutionFile ()

virtual void	writeLPTSolutionFile ()

virtual void	initParticleStatistics ()

virtual void	computeParticleStatistics ()

virtual void	initPLIsoTurbulenceStatistics ()

virtual void	computePLIsoTurbulenceStatistics ()

virtual void	initAverageVariables ()
	allocates memory for averageSolutions() and averageSolutionsInSolve() More...

void	pp_saveCoarseSolution ()

void	averageSolutions ()
	Averages solutions. More...

virtual void	averageSolutionsInSolve ()

void	computeAndSaveDivergence ()

void	computeAndSaveMean ()

void	initAverageSolutionsSlice ()
	Initializes properties for slice averaging. More...

void	averageSolutionsSlice ()

void	probeLocation ()

void	findClosestProbePointsGridCells ()

virtual void	initPointSamplingData ()

virtual void	savePointSamplingData ()

virtual void	initSurfaceSamplingData ()

virtual void	saveSurfaceSamplingData ()

virtual void	initVolumeSamplingData ()

virtual void	saveVolumeSamplingData ()

virtual void	initIsoTurbulenceStatistics ()

virtual void	computeIsoTurbulenceStatistics ()

void	initWritePointData ()

void	writePointData ()

void	spatialAveraging ()

void	spatialAveragingPost ()

void	createCellToMap1D (std::map< MFloat, MInt, coord_comp_1d_ > &coordinates, std::map< MFloat, MFloat, coord_comp_1d_ > &cell_to_map)

void	createCellToMap2D (std::map< std::pair< MFloat, MFloat >, MInt, coord_comp_2d_ > &coordinates, std::map< std::pair< MFloat, MFloat >, std::pair< MFloat, MFloat >, coord_comp_2d_ > &cell_to_map)

void	probeLine ()

void	probeLinePre ()

void	probeLinePost ()

void	probeSlice ()

void	probeSliceIn ()

void	probeSlicePre ()

void	probeSlicePost ()

void	collectMinLvlCells ()

void	findContainingCell (const MFloat *coord, MInt &cellId)

void	probeArbitraryLine ()

void	probeArbitraryLinePost ()

void	probeArbitrarySlice ()

void	probeArbitrarySlicePost ()

virtual void	initMovingAverage ()
	Initializes properties and allocates memory for moving averaging. More...

void	movingAverage ()

void	movingAveragePost ()

void	initCorrelation ()

void	initPeriodicSliceAverage ()
	Initializes the periodic averaging on a slice. More...

void	periodicSliceAverage ()

MInt	findNearestGridCell (const MFloat *coord)

void	movePointsToGrid (MFloat *in_points, MInt in_noPoints, MInt in_moveType)

void	getSampleVariables (MInt cellId, const MFloat *&vars, MBool mode)

void	getSampleVariables (MInt const cellId, std::vector< MFloat > &vars)

void	calcSamplingVar (const MInt cellId, const MInt sampleVarId, MFloat *const vars)

void	saveSliceAiaFileFormat (const MInt step, const MInt noVars, MFloatScratchSpace &vars, const MInt sliceId)

MFloat	calcDivergence (const MInt cellIdSolver)

virtual void	calcVorticity (const MFloatTensor &deriv, MFloat vorticity[nDim *2 - 3])

virtual void	getVorticity (MFloat *const vorticity)

virtual void	getVorticityT (MFloat *const vorticity)

virtual void	getPrimitiveVariables (MInt, MFloat , MFloat , MInt)

virtual void	computeAcousticSourceTermQe (MFloatScratchSpace &, MFloatScratchSpace &, MFloatScratchSpace &, MFloatScratchSpace &)

void	getSampleVarsDerivatives (const MInt cellId, const MFloat *&vars)

MBool	getSampleVarsDerivatives (const MInt, std::vector< MFloat > &)

virtual MFloat &	vorticityAtCell (const MInt cellId, const MInt dir)

virtual MFloat	getBoundaryHeatFlux (const MInt cellId) const

virtual void	getPrimitiveVarNames (MString *names) const

void	neededMeanVarsForSourceTerm (const MInt sourceTerm, std::vector< MInt > &meanVars) const

MBool	isMeanFile ()

Protected Attributes
std::unique_ptr< PointData< nDim, SolverType > >	m_pointData

std::unique_ptr< SurfaceData< nDim, SolverType > >	m_surfaceData

std::unique_ptr< VolumeData< nDim, SolverType > >	m_volumeData

Protected Attributes inherited from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >
MInt	m_noPostprocessingOps

MString *	m_postprocessingOps

tvecpost	m_postprocessingSolution

std::vector< tvecpost >	m_postprocessingMethods

std::vector< std::vector< MString > >	m_postprocessingMethodsDesc

Data *	m_postData

MInt	m_noVariables

MBool	m_square

MBool	m_skewness

MBool	m_kurtosis

MBool	m_computeAndSaveMean

MBool	m_twoPass

MBool	m_useKahan

MBool	m_correlation

std::vector< MInt > *	m_cell2globalIndex

MInt *	m_noPeriodicSliceCells

MFloat **	m_sliceAverage

MInt	m_globalnoSlicePositions

std::multimap< MFloat, MFloat >	m_sliceGlobalPositions

MBool	m_averageVorticity

MBool	m_averageSpeedOfSound

MFloat	m_gamma

MInt	m_movingAverageStartTimestep

MInt	m_movingAverageStopTimestep

MInt	m_movingAverageInterval

MInt	m_movingAverageDataPoints

MInt	m_movingAverageCounter

MFloat **	m_movAvgVariables

MInt	m_movAvgNoVariables

MString *	m_movAvgVarNames

MInt	m_spatialDirection1

MInt	m_spatialDirection2

MFloat	m_spatialWeightSinglePoint

MFloat	m_spatialLvlWeight [20]

MInt *	m_spatialDispls

MInt *	m_spatialVarsDispls

MInt *	m_spatialRecvcnts

MInt *	m_spatialVarsRecvcnts

MInt	m_spatialCoordSum

std::map< MFloat, MInt, coord_comp_1d_ >	m_spatialLineCoordinates

std::map< MFloat, MFloat, coord_comp_1d_ >	m_spatialLineCellToMap

std::map< MFloat, MInt, coord_comp_1d_ >	m_spatialGlobalLineCoordinates

std::map< MFloat, MFloat, coord_comp_1d_ >	m_spatialGlobalLineCellToMap

MInt	m_spatialLineNoCells

MFloat *	m_spatialLineAllVars

MFloat *	m_spatialLineAllCoord

std::map< std::pair< MFloat, MFloat >, MInt, coord_comp_2d_ >	m_spatialPlaneCoordinates

std::map< std::pair< MFloat, MFloat >, std::pair< MFloat, MFloat >, coord_comp_2d_ >	m_spatialPlaneCellToMap

std::map< std::pair< MFloat, MFloat >, MInt, coord_comp_2d_ >	m_spatialGlobalPlaneCoordinates

std::map< std::pair< MFloat, MFloat >, std::pair< MFloat, MFloat >, coord_comp_2d_ >	m_spatialGlobalPlaneCellToMap

MInt	m_spatialPlaneNoCells

MFloat *	m_spatialPlaneAllVars

MFloat *	m_spatialPlaneAllCoord

MInt	m_noProbeLines

MInt *	m_probeLineDirection

MInt *	m_probeLinePeriodic

MFloat **	m_probeLineCoordinates

MInt **	m_probeLineIds

MInt *	m_noProbeLineIds

MFloat **	m_probeLinePositions

MInt *	m_globalNoProbeLineIds

MInt *	m_probeLineOffsets

MInt **	m_noGlobalProbeLineIds

MInt	m_probeLineInterval

MInt	m_probeLineStartTimestep

MInt	m_probeLineStopTimestep

MInt *	m_correlationDirection

MInt *	m_correlationVariableIndex

MFloat **	m_correlationCoordinates

MInt	m_noCorrelationLines

MInt *	m_noCorrelationIds

MInt **	m_correlationIds

MInt **	m_globalCorrelationIds

MFloat **	m_globalCorrelationPositions

MInt *	m_globalNoCorrelationIds

MFloat **	m_correlationPositions

MInt **	m_correlationIndexMapping

MFloat **	m_correlationExchangeVar

MFloat **	m_correlationExchangeVarMean

MFloat **	m_correlationExchangeVarRMS

MFloat **	m_globalCorrelationExchangeVar

MFloat **	m_globalCorrelationExchangeVarMean

MFloat **	m_globalCorrelationExchangeVarRMS

MInt *	m_probeLineAverageDirection

MFloat **	m_probeLineAverageCoordinates

MInt **	m_probeLineAverageCoordinatesSign

MInt **	m_noProbeLineAverageIds

MFloat ***	m_globalProbeLineAverageVars

MInt	m_noProbeLineAverageSteps

MInt **	m_globalNoProbeLineAverageIds

MInt ***	m_probeLineAverageIds

MFloat ***	m_probeLineAveragePositions

MInt	m_noProbeSlices

MInt *	m_probeSliceDir

MFloat *	m_probeSliceCoordinate

MInt **	m_probeSliceIds

MInt *	m_noProbeSliceIds

MFloat **	m_probeSlicePositions

MInt *	m_globalNoProbeSliceIds

MInt *	m_probeSliceOffsets

MInt **	m_noGlobalProbeSliceIds

MString *	m_probeSliceGridNames

MString *	m_sliceAxis

MFloat *	m_sliceIntercept

MBool	m_sliceAiaFileFormat

MBool	m_optimizedSliceIo

MInt *	m_noProbeSliceNoHilbertIds

MInt *	m_noProbeSliceMaxNoHilbertIds

MInt **	m_noProbeSliceHilbertInfo

MInt *	m_noProbeSliceNoContHilbertIds

MInt *	m_noProbeSliceMaxNoContHilbertIds

MInt **	m_noProbeSliceContHilbertInfo

MInt	m_probeSliceInterval

MInt	m_probeSliceStartTimestep

MInt	m_probeSliceStopTimestep

std::vector< MInt >	m_sliceVarIds
	List of slice variables. More...

std::vector< MInt >	m_noSliceVars
	Number of variables for each slice variable. More...

std::vector< std::vector< MString > >	m_sliceVarNames
	List of variable names for each slice variable. More...

MInt	m_noMinLvlIds

MInt *	m_minLvlIds

MInt	m_movePointsToGrid

MBool	m_spatialAveraging

MFloat *	m_arbLinePoints

MInt	m_noArbLines

MInt *	m_noArbLineIds

MFloat *	m_arbLinePointsDistribution

MInt *	m_arbLineHasNewDistribution

MInt *	m_arbLineFull

MInt *	m_moveLinePointsToGrid

MInt *	m_globalNoArbLineIds

MInt **	m_arbLineIds

MInt *	m_arbLineOffsets

MFloat **	m_arbLineCoordinates

MFloat *	m_arbSlicePoints

MInt	m_noArbSlices

MInt *	m_noArbSlicePoints

MFloat *	m_arbSlicePointsDistribution

MInt *	m_globalNoArbSlicePoints

MInt **	m_arbSliceIds

MInt *	m_arbSliceOffsets

MFloat **	m_arbSliceCoordinates

MString	m_postprocessFileName

MFloat **	m_localVars

MBool	m_averageRestart

MInt	m_averageInterval

MInt	m_averageStartTimestep

MInt	m_averageStopTimestep

MInt	m_noAveragedVorticities

MInt	m_noSpeedOfSoundVars

MInt	m_noSourceVars

MBool	m_needVorticity

MString	m_ReStressesAverageFileName

MFloat **	m_probeCoordinates

MString	m_probePath

MInt *	m_probeCellIds

std::ofstream *	m_probeFileStreams

MInt	m_noProbePoints

MInt	m_probeInterval

MInt	m_probeWriteInterval

MString	m_pdFileName

MInt	m_pdStartTimestep

MInt	m_pdStopTimestep

MInt	m_pdRestartInterval

std::vector< MFloat >	m_pdPoints

std::vector< MInt >	m_pdCells

std::vector< MFloat >	m_pdVars

MInt	m_pdNoPoints

MInt	m_sprayComputeInterval

MInt	m_sprayWriteInterval

MInt	m_sprayDataSize

MInt	m_sprayDataStep

MFloat **	m_particleCV

MFloat **	m_particlePen

MFloat **	m_sprayStat

MFloat **	m_sprayTimes

MFloat **	m_injectionData

MFloat **	m_vapourCV

MFloat **	m_vapourPen

MInt	m_LPTSolutionInterval

MBool	m_forceOutput

std::vector< MInt >	m_activeSourceTerms

std::array< MString, ST::totalNoSourceTerms >	s_sourceTermNames

std::set< MInt >	m_activeMeanVars

Protected Attributes inherited from PostProcessingInterface
MInt	m_postprocessingId

Private Attributes
SolverType *	m_ppSolver

Friends
template<MInt nDim_, class ppType >
class	PostProcessing

Additional Inherited Members
Public Attributes inherited from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >
MInt	m_noLocalVars

MInt	m_restartTimeStep

MBool	m_statisticCombustionAnalysis

MBool	m_acousticAnalysis

Public Attributes inherited from PostProcessingInterface
MBool	m_finalTimeStep = false

Protected Types inherited from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >
typedef void(PostProcessing::*	tpost) ()

typedef std::vector< tpost >	tvecpost

Detailed Description

template<MInt nDim, class SysEqn>
class PostProcessingFv< nDim, SysEqn >

Definition at line 26 of file postprocessingfv.h.

Member Typedef Documentation

◆ Base

template<MInt nDim, class SysEqn >

using PostProcessingFv< nDim, SysEqn >::Base = PostProcessing<nDim, PostProcessingFv<nDim, SysEqn> >

Definition at line 34 of file postprocessingfv.h.

◆ SolverType

template<MInt nDim, class SysEqn >

using PostProcessingFv< nDim, SysEqn >::SolverType = FvCartesianSolverXD<nDim, SysEqn>

Definition at line 32 of file postprocessingfv.h.

Constructor & Destructor Documentation

◆ PostProcessingFv()

template<MInt nDim, class SysEqn >

PostProcessingFv< nDim, SysEqn >::PostProcessingFv	(	MInt	postprocessingId_,
		PostData< nDim > *	data,
		SolverType *	ppSolver_
	)

Definition at line 14 of file postprocessingfv.cpp.

  : PostProcessingInterface(postprocessingId_),
    PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>(postprocessingId_, data) {
  m_ppSolver = ppSolver_;
}

◆ ~PostProcessingFv()

template<MInt nDim, class SysEqn >

PostProcessingFv< nDim, SysEqn >::~PostProcessingFv

virtual

Definition at line 24 of file postprocessingfv.cpp.

24{}

Member Function Documentation

◆ advanceDataStep()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::advanceDataStep ( )

inlineprotected

Definition at line 133 of file postprocessingfv.h.

133{ m_sprayDataStep++; };

PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >::m_sprayDataStep

MInt m_sprayDataStep

Definition: postprocessing.h:562

◆ calcVorticity()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::calcVorticity	(	const MFloatTensor &	deriv,
		MFloat	vorticity[nDim *2 - 3]
	)

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 103 of file postprocessingfv.h.

                                                                                         {
    if constexpr(nDim == 2) {
      vorticity[0] = 0.5 * (deriv(1, 0) - deriv(0, 1));
    } else { //(nDim ==3)
      vorticity[0] = 0.5 * (deriv(2, 1) - deriv(1, 2));
      vorticity[1] = 0.5 * (deriv(0, 2) - deriv(2, 0));
      vorticity[2] = 0.5 * (deriv(1, 0) - deriv(0, 1));
    }
  }

◆ computeAcousticSourceTermQe()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::computeAcousticSourceTermQe	(	MFloatScratchSpace &	QeI,
		MFloatScratchSpace &	QeIII,
		MFloatScratchSpace &	cSquared,
		MFloatScratchSpace &	drhodt
	)

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 123 of file postprocessingfv.h.

                                                                        {
    solver().computeAcousticSourceTermQe(QeI, QeIII, cSquared, drhodt);
  };

◆ getBoundaryHeatFlux()

template<MInt nDim, class SysEqn >

MFloat PostProcessingFv< nDim, SysEqn >::getBoundaryHeatFlux ( const MInt cellId ) const

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 129 of file postprocessingfv.h.

129{ return solver().getBoundaryHeatFlux(cellId); };

FvCartesianSolverXD::getBoundaryHeatFlux

virtual MFloat getBoundaryHeatFlux(const MInt cellId) const

calculates heat flux of boundary cells

Definition: fvcartesiansolverxd.cpp:8867

◆ getPrimitiveVariables()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::getPrimitiveVariables	(	MInt	cellId,
		MFloat *	Xp,
		MFloat *	vars,
		MInt	order
	)

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 119 of file postprocessingfv.h.

                                                                                         {
    solver().getPrimitiveVariables(cellId, Xp, vars, order);
  };

◆ getPrimitiveVarNames()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::getPrimitiveVarNames ( MString * names ) const

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 128 of file postprocessingfv.h.

128{ solver().sysEqn().PV->getPrimitiveVariableNames(names); }

FvCartesianSolverXD::sysEqn

SysEqn sysEqn() const

Definition: fvcartesiansolverxd.h:331

◆ getSampleVarsDerivatives() [1/2]

template<MInt nDim, class SysEqn >

MBool PostProcessingFv< nDim, SysEqn >::getSampleVarsDerivatives	(	const MInt	cellId,
		std::vector< MFloat > &	vars
	)

inlineprotected

Definition at line 115 of file postprocessingfv.h.

                                                                             {
    return solver().getSampleVarsDerivatives(cellId, vars);
  };

◆ getSampleVarsDerivatives() [2/2]

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::getSampleVarsDerivatives	(	MInt	cellId,
		const MFloat *&	vars
	)

inlineprotected

Definition at line 114 of file postprocessingfv.h.

114{ solver().getSampleVarsDerivatives(cellId, vars); };

◆ getVorticity()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::getVorticity ( MFloat *const vorticity )

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 112 of file postprocessingfv.h.

112{ solver().getVorticity(&vorticity[0]); };

FvCartesianSolverXD::getVorticity

virtual void getVorticity(MFloat *const vorticity)

wrapper for vorticity computation

Definition: fvcartesiansolverxd.cpp:8907

◆ getVorticityT()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::getVorticityT ( MFloat *const vorticity )

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 113 of file postprocessingfv.h.

113{ solver().getVorticityT(&vorticity[0]); };

FvCartesianSolverXD::getVorticityT

virtual void getVorticityT(MFloat *const vorticity)

wrapper for vorticity computation (transposed version)

Definition: fvcartesiansolverxd.cpp:8956

◆ initAveragingProperties()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initAveragingProperties

overrideprotectedvirtual

Author: Michael Schlottke-Lakemper (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: 2015-11-19

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 94 of file postprocessingfv.cpp.

                                                             {
  TRACE();
 
  PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>::initAveragingProperties();
 
  solver().m_averageVorticity = this->m_averageVorticity;
  solver().m_averageSpeedOfSound = this->m_averageSpeedOfSound;
}

◆ initMovingAverage()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initMovingAverage

overrideprotectedvirtual

Author: Ansgar Niemoeller

Date: 09.07.2014

reads properties pp_movingAvgInterval, pp_movingAvgDataPoints (pp_averageVorticity already read in initAveragingVariables)

Parameters

[in] grid pointer to the grid

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 85 of file postprocessingfv.cpp.

                                                       {
  TRACE();
 
  PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>::initMovingAverage();
 
  solver().m_movingAvgInterval = this->m_movingAverageInterval;
}

◆ initPointSamplingData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initPointSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 43 of file postprocessingfv.cpp.

                                                           {
  TRACE();
  m_pointData.reset(new PointData<nDim, SolverType>{*m_ppSolver});
  m_pointData->setInputOutputProperties();
  m_pointData->init();
}

◆ initPostProcessing()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initPostProcessing

overridevirtual

Implements PostProcessingInterface.

Reimplemented in PostProcessingFvLPT< nDim, SysEqn >.

Definition at line 27 of file postprocessingfv.cpp.

                                                        {
  TRACE();
 
  PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>::initPostProcessing();
 
  solver().m_skewness = this->m_skewness;
  solver().m_kurtosis = this->m_kurtosis;
  solver().m_activeMeanVars = this->m_activeMeanVars;
 
  // for(MInt i = 0; i < (signed)this->m_activeMeanVars.size(); i++){
  //   solver().m_activeMeanVars.insert(this->m_activeMeanVars[i]);
  // }
}

◆ initSprayData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initSprayData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Reimplemented in PostProcessingFvLPT< nDim, SysEqn >.

Definition at line 394 of file postprocessingfv.cpp.

                                                   {
  TRACE();
 
  PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>::initSprayData();
 
  if(solver().domainId() == 0) {
    cerr << "Allocating Post-processing Fv data!" << endl;
  }
 
  const MInt vapourPenSize = nDim == 3 ? 16 : 12;
  mAlloc(m_vapourPen, m_sprayDataSize, vapourPenSize, "m_vapourPen", F0, AT_);
  mAlloc(m_vapourCV, m_sprayDataSize, 5 + 2 * nDim, "m_vapourCV", F0, AT_);
}

◆ initSurfaceSamplingData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initSurfaceSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 57 of file postprocessingfv.cpp.

                                                             {
  TRACE();
  m_surfaceData.reset(new SurfaceData<nDim, SolverType>{*m_ppSolver});
  m_surfaceData->setInputOutputProperties();
  m_surfaceData->init();
}

◆ initVolumeSamplingData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::initVolumeSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 71 of file postprocessingfv.cpp.

                                                            {
  TRACE();
  m_volumeData.reset(new VolumeData<nDim, SolverType>{*m_ppSolver});
  m_volumeData->setInputOutputProperties();
  m_volumeData->init();
}

◆ probeLinePeriodic()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::probeLinePeriodic

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 124 of file postprocessingfv.cpp.

                                                       {
  TRACE();
 
  using namespace maia::parallel_io;
 
  // check for average timestep or postprocessFileName
  if((globalTimeStep >= m_averageStartTimestep && (globalTimeStep - m_averageStartTimestep) % m_averageInterval == 0
      && globalTimeStep <= m_averageStopTimestep)
     || globalTimeStep == 0) {
    MInt noVars = m_noVariables;
    if(m_postData->isMeanFile()) {
      noVars = m_postData->fileNoVars();
    }
 
    MInt step = (m_postData->isMeanFile()) ? 0 : globalTimeStep;
    stringstream fileName;
    fileName << solver().outputDir() << "probeLines_" << step << ParallelIo::fileExt();
    ParallelIo parallelIo(fileName.str(), maia::parallel_io::PIO_REPLACE, solver().mpiComm());
 
    // define all arrays in output file
    for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) {
      stringstream varNameBase;
      varNameBase << "line_" << probeLineId;
      string coordName = varNameBase.str() + "_coordinates";
 
      parallelIo.defineArray(PIO_FLOAT, coordName, m_globalNoProbeLineIds[probeLineId]);
      parallelIo.setAttribute(probeLineId, "lineId", coordName);
 
      varNameBase << "_var_";
      for(MInt varId = 0; varId < noVars; varId++) {
        stringstream varName;
        varName << varNameBase.str() << varId;
        parallelIo.defineArray(PIO_FLOAT, varName.str(), m_globalNoProbeLineIds[probeLineId]);
        parallelIo.setAttribute(probeLineId, "lineId", varName.str());
      }
    }
 
    for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) {
      if(m_probeLineDirection[probeLineId] < 0 || m_probeLineDirection[probeLineId] >= nDim) {
        continue;
      }
 
      m_log << "    ^        * probe line timestep " << globalTimeStep << " for line #" << probeLineId << endl;
 
      MInt noIds = m_noProbeLineIds[probeLineId];
      if(noIds == 0) {
        noIds = 1;
      } // avoid dereferencing array with length 0 in writeArray(...)
      ScratchSpace<MFloat> vars(noVars * noIds, "vars", FUN_);
 
      MInt probeId;
      const MFloat* cellVars = 0;
 
      // collect local variables
      for(MInt i = 0; i < m_noProbeLineIds[probeLineId]; i++) {
        probeId = m_probeLineIds[probeLineId][i];
        PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>::getSampleVariables(probeId, cellVars, false);
        for(MInt varId = 0; varId < noVars; varId++) {
          vars[i * noVars + varId] = cellVars[varId];
        }
      }
 
      parallelIo.setOffset(m_noProbeLineIds[probeLineId], m_probeLineOffsets[probeLineId]);
 
      // write to file
      stringstream varNameBase;
      varNameBase << "line_" << probeLineId;
      string coordName = varNameBase.str() + "_coordinates";
      parallelIo.writeArray(m_probeLinePositions[probeLineId], coordName);
 
      varNameBase << "_var_";
      for(MInt varId = 0; varId < noVars; varId++) { // write all variables to file
        stringstream varName;
        varName << varNameBase.str() << varId;
        parallelIo.writeArray(&(vars[varId]), varName.str(), noVars);
      }
    }
  } else {
    // PROBE_LINE_POST
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
 
    for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) {
      if(m_probeLineAverageDirection[probeLineId] < 0 || m_probeLineAverageDirection[probeLineId] >= nDim) {
        continue;
      }
 
      MInt probeId;
 
      if(m_probeLineDirection[probeLineId] == 1 || m_probeLineDirection[probeLineId] == 0) {
        MInt noVars;
        if(solver().m_rans) {
          noVars = m_noVariables + 1; // k
        } else {
          noVars = postData().noVariables();
        }
 
        MInt noIds = m_globalNoProbeLineIds[probeLineId];
        if(noIds == 0) {
          noIds = 1;
        }
 
        // ScratchSpace<MFloat> vars( noVars*ids, "vars", FUN_ );
        ScratchSpace<MFloat> avgVars(noVars * noIds, "avgVars", FUN_);
        ScratchSpace<MFloat> globalAvgVars(noVars * noIds, "globalAvgVars", FUN_);
        avgVars.fill(F0);
        globalAvgVars.fill(F0);
 
        if(solver().m_rans) {
          // RANS SOLVER
          for(MInt p = 0; p < m_globalNoProbeLineIds[probeLineId]; p++) {
            // collect local variables
            for(MInt i = 0; i < m_noProbeLineAverageIds[probeLineId][p]; i++) {
              probeId = m_probeLineAverageIds[probeLineId][p][i];
              const MFloat* cellVars = 0;
              PostProcessing<nDim, PostProcessingFv<nDim, SysEqn>>::getSampleVariables(probeId, cellVars, false);
 
              // RANS Variables
              for(MInt varId = 0; varId < m_noVariables; varId++) {
                avgVars[p * noVars + varId] += cellVars[varId];
              }
 
              // turbulent kinetic energy
              MFloat k = F0;
              const MFloat* cellVarsDeriv1;
              getSampleVarsDerivatives(probeId, cellVarsDeriv1);
              const MFloatTensor deriv1(const_cast<MFloat*>(cellVarsDeriv1), m_noVariables, nDim);
              MFloat SijSij = F0;
              for(MInt d1 = 0; d1 < nDim; d1++) {
                for(MInt d2 = 0; d2 < nDim; d2++) {
                  MFloat sij = 0.5 * (deriv1(d1, d2) + deriv1(d2, d1));
                  SijSij += sij * sij;
                }
              }
 
              k = sqrt(2.0 * SijSij / 0.09) * cellVars[5] / solver().sysEqn().m_Re0;
 
              avgVars[p * noVars + m_noVariables] += k;
            }
          }
        } else {
          // LES SOLVER
          for(MInt p = 0; p < m_globalNoProbeLineIds[probeLineId]; p++) {
            // collect local variables
            for(MInt i = 0; i < m_noProbeLineAverageIds[probeLineId][p]; i++) {
              // const MFloat* cellVars = 0;
              probeId = m_probeLineAverageIds[probeLineId][p][i];
              // PostProcessingBlock<nDim, Block>::getSampleVariables( probeId, cellVars );
              MInt dataId = convertIdParent(solver(), postData(), probeId);
              if(dataId != -1) {
                for(MInt varId = 0; varId < noVars; varId++) {
                  avgVars[p * noVars + varId] += postData().m_averagedVars[dataId][varId];
                }
 
                // SijSij
                // calculating strain rate tensor Sij = 0.5(dui/dxj + duj/dxi)
                std::vector<std::vector<MFloat>> du(nDim, std::vector<MFloat>(nDim, F0));
                const MInt recData = solver().a_reconstructionData(probeId);
                std::vector<MFloat> u{postData().m_averagedVars[dataId][0], postData().m_averagedVars[dataId][1],
                                      postData().m_averagedVars[dataId][2]};
 
                for(MInt nghbr = 0; nghbr < solver().a_noReconstructionNeighbors(probeId); nghbr++) {
                  const MInt recNghbrId = solver().a_reconstructionNeighborId(probeId, nghbr);
                  if(recNghbrId > -1 && recNghbrId < solver().noInternalCells()) {
                    MInt dataNgbhrId = convertIdParent(solver(), postData(), recNghbrId);
                    if(dataNgbhrId > -1) {
                      // std::ignore = recData;
                      // std::ignore = u;
                      const MFloat recConst_x = solver().m_reconstructionConstants[nDim * (recData + nghbr) + 0];
                      const MFloat recConst_y = solver().m_reconstructionConstants[nDim * (recData + nghbr) + 1];
                      const MFloat recConst_z = solver().m_reconstructionConstants[nDim * (recData + nghbr) + 2];
                      for(MInt dim = 0; dim < nDim; ++dim) {
                        MFloat delta_u = postData().m_averagedVars[dataNgbhrId][dim] - u[dim];
                        du[dim][0] += recConst_x * delta_u;
                        du[dim][1] += recConst_y * delta_u;
                        du[dim][2] += recConst_z * delta_u;
                      }
                    }
                  }
                }
                std::vector<std::vector<MFloat>> sij(nDim, std::vector<MFloat>(nDim, F0));
                MFloat SijSij = F0;
                for(MInt d1 = 0; d1 < nDim; d1++) {
                  for(MInt d2 = 0; d2 < nDim; d2++) {
                    sij[d1][d2] = 0.5 * (du[d1][d2] + du[d2][d1]);
                    SijSij += sij[d1][d2] * sij[d1][d2];
                  }
                }
                avgVars[p * noVars + (noVars - 1)] += SijSij;
              }
            }
          }
        }
 
        MPI_Allreduce(&avgVars[0], &globalAvgVars[0], noVars * noIds, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_,
                      "avgVars", "globalAvgVars");
 
 
        if(solver().domainId() == 0) {
          // Calculate spanwise average
          //--------------------------------------------------------------------
          MInt tempId = 0;
          for(MInt p = 0; p < m_globalNoProbeLineIds[probeLineId]; p++) {
            for(MInt varId = 0; varId < noVars; varId++) {
              m_globalProbeLineAverageVars[probeLineId][p][varId] =
                  globalAvgVars[tempId] / m_globalNoProbeLineAverageIds[probeLineId][p];
              tempId++;
            }
          }
 
          // vector<MInt> outputIds;
          // if(solver().m_rans) {
          //   outputIds = {0, 1, 2, 3, 4, 5, 6};
          // } else {
          //   outputIds = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
          // }
          //--------------------------------------------------------------------
 
 
          // OUTPUT
          //--------------------------------------------------------------------
          // Sorting
          ScratchSpace<MFloat> sorting(m_globalNoProbeLineIds[probeLineId], "sorting", FUN_);
          vector<int> sortingIndex(m_globalNoProbeLineIds[probeLineId]);
          for(MInt p = 0; p < m_globalNoProbeLineIds[probeLineId]; p++) {
            sorting[p] = m_probeLineAverageCoordinates[probeLineId][p];
          }
          int x = 0;
          iota(sortingIndex.begin(), sortingIndex.end(), x++); // Initializing
          sort(sortingIndex.begin(), sortingIndex.end(), [&](int i, int j) { return sorting[i] < sorting[j]; });
 
          // Write text file
          MString dir;
          if(solver().m_rans) {
            dir = "#y um vm wm rhom pm num ym k";
          } else {
            if(solver().m_solverId == 1) {
              dir = "#y um vm wm rhom pm num ym u'u' u'v' u'w' v'v' v'w' w'w' p'";
            } else {
              dir = "#y um vm wm rhom pm u'u' u'v' u'w' v'v' v'w' w'w' p' SijSij";
            }
          }
          ofstream lineprob;
          lineprob.precision(8);
          MString fname = "probeLine" + to_string(solver().m_solverId) + "_" + to_string(probeLineId) + "_"
                          + to_string(globalTimeStep) + ".txt";
          cerr << "Writing " << fname << endl;
          lineprob.open(fname);
          for(MInt p = 0; p < m_globalNoProbeLineIds[probeLineId]; p++) {
            MInt index = sortingIndex[p];
            MString line = "";
            line.append(to_string(m_probeLineAverageCoordinates[probeLineId][index]));
            if(p == 0) lineprob << dir << endl;
            for(MInt k = 0; k < noVars; k++) {
              MInt varId = k; // outputIds[k];
              line.append(" " + to_string(m_globalProbeLineAverageVars[probeLineId][index][varId]));
            }
            lineprob << line << endl;
          }
          lineprob.close();
          //--------------------------------------------------------------------
        }
      } else if(m_probeLineDirection[probeLineId] == 2) {
        //
      }
    }
  }
}

◆ probeLinePeriodicPost()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::probeLinePeriodicPost

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 105 of file postprocessingfv.cpp.

                                                           {
  TRACE();
 
  if(!solver().grid().isActive()) return;
 
  if(m_postprocessFileName != "") {
    m_log << "    ^        * probe line for file " << m_postprocessFileName << endl;
    // TERMM(1, "FIXME untested");
    IF_CONSTEXPR(SysEqn::m_noRansEquations == 0) postData().loadMeanFile(m_postprocessFileName);
    probeLinePeriodic();
  } else {
    for(MInt t = m_averageStartTimestep; t <= m_averageStopTimestep; t += m_averageInterval) {
      solver().loadSampleVariables(t);
      probeLinePeriodic();
    }
  }
}

◆ resetDataStep()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::resetDataStep ( )

inlineprotected

Definition at line 134 of file postprocessingfv.h.

134{ m_sprayDataStep = 0; };

◆ savePointSamplingData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::savePointSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 51 of file postprocessingfv.cpp.

                                                           {
  if(!isActive()) return;
  m_pointData->save(m_finalTimeStep);
}

◆ saveSurfaceSamplingData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::saveSurfaceSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 65 of file postprocessingfv.cpp.

                                                             {
  if(!isActive()) return;
  m_surfaceData->save(m_finalTimeStep);
}

◆ saveVolumeSamplingData()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::saveVolumeSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 79 of file postprocessingfv.cpp.

                                                            {
  if(!isActive()) return;
  m_volumeData->save(m_finalTimeStep);
}

◆ solver()

template<MInt nDim, class SysEqn >

SolverType & PostProcessingFv< nDim, SysEqn >::solver ( ) const

inline

Definition at line 79 of file postprocessingfv.h.

79{ return *m_ppSolver; }

◆ vapourMass()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::vapourMass ( const MInt speciesId )

protected

Definition at line 409 of file postprocessingfv.cpp.

                                                                    {
  TRACE();
 
  // calculate dimensionless vapour information from finite volume solver
  const MBool hasSpecies = solver().m_noSpecies > 0 ? true : false;
 
  // reset
  for(MInt i = 0; i < 5 + 2 * nDim; i++) {
    m_vapourCV[m_sprayDataStep][i] = 0;
  }
 
  if(solver().isActive()) {
    for(MInt cellId = 0; cellId < solver().noInternalCells(); cellId++) {
      if(!solver().c_isLeafCell(cellId)) continue;
      if(solver().a_isInactive(cellId)) continue;
      const MFloat cellV = 1 / solver().a_FcellVolume(cellId);
      const MFloat rho = solver().a_variable(cellId, solver().m_sysEqn.CV->RHO);
      const MFloat rhoY = hasSpecies ? solver().a_variable(cellId, solver().m_sysEqn.CV->RHO_Y[speciesId]) : 0;
 
      m_vapourCV[m_sprayDataStep][0] += cellV * rhoY;
      m_vapourCV[m_sprayDataStep][1] += cellV * (rho - rhoY);
      m_vapourCV[m_sprayDataStep][2] += cellV * solver().a_variable(cellId, solver().m_sysEqn.CV->RHO_E);
      m_vapourCV[m_sprayDataStep][3] += cellV * solver().a_variable(cellId, solver().m_sysEqn.CV->RHO_U);
      m_vapourCV[m_sprayDataStep][4] += cellV * solver().a_variable(cellId, solver().m_sysEqn.CV->RHO_V);
      IF_CONSTEXPR(nDim == 3) {
        m_vapourCV[m_sprayDataStep][5] += cellV * solver().a_variable(cellId, solver().m_sysEqn.CV->RHO_W);
      }
    }
    if(solver().m_hasExternalSource) {
      MInt numVars = 2 + nDim;
      for(MInt i = 0; i < numVars; i++) {
        MFloat source = (solver().m_vapourData.find(globalTimeStep)->second)[i];
        m_vapourCV[m_sprayDataStep][3 + nDim + i] = source;
      }
    }
  }
}

◆ vapourPenetration()

template<MInt nDim, class SysEqn >

void PostProcessingFv< nDim, SysEqn >::vapourPenetration ( MFloat spawnCoord[nDim] )

protected

Definition at line 448 of file postprocessingfv.cpp.

                                                                              {
  TRACE();
 
  const MInt noYLimits = 3;
  const MInt refLvl = 10;
  const MFloat yLimitRefLvl = 0.001;
 
  // concentration limits for differecent penetration lengths
  array<MFloat, noYLimits> yLimits{};
  yLimits[0] = 0.001;
  yLimits[1] = 0.01;
  yLimits[2] = 0.05;
 
  // x,y,z, axial penetration and distance
  array<array<MFloat, noYLimits>, nDim + 1> maxVapPen{};
  array<MFloat, nDim> maxVapPenRefLvl{};
  for(MInt n = 0; n < noYLimits; n++) {
    for(MInt i = 0; i < nDim + 1; i++) {
      maxVapPen[i][n] = 0.0;
    }
  }
  for(MInt i = 0; i < nDim; i++) {
    maxVapPenRefLvl[i] = 0.0;
  }
 
  auto assignLarger = [&](MFloat& A, MFloat b) {
    if(b > A) {
      A = b;
    }
  };
 
  const MBool hasSpecies = solver().m_noSpecies > 0 ? true : false;
 
  if(solver().isActive() && hasSpecies) {
    for(MInt cellId = 0; cellId < solver().noInternalCells(); cellId++) {
      if(solver().a_isInactive(cellId)) continue;
      if(solver().c_isLeafCell(cellId)) {
        const MFloat rho = solver().a_variable(cellId, nDim + 1);
        const MFloat Y = hasSpecies ? solver().a_variable(cellId, nDim + 2) / rho : 0;
        array<MFloat, nDim> centerCoords{};
 
        for(MInt n = 0; n < noYLimits; n++) {
          if(Y > yLimits[n]) {
            for(MInt i = 0; i < nDim; i++) {
              centerCoords[i] = solver().a_coordinate(cellId, i);
            }
            array<MFloat, nDim + 1> distance{};
            for(int i = 0; i < nDim; i++) {
              distance[i] = abs(centerCoords[i] - spawnCoord[i]);
            }
            distance[nDim] = maia::math::distance(centerCoords, spawnCoord);
 
            for(int i = 0; i < nDim + 1; i++) {
              assignLarger(maxVapPen[i][n], distance[i]);
            }
          } else {
            break;
          }
        }
      } else {
        if(solver().a_level(cellId) == refLvl) {
          solver().reduceData(cellId, &solver().a_variable(0, 0), solver().CV->noVariables);
          const MFloat rho = solver().a_variable(cellId, nDim + 1);
          const MFloat Y = hasSpecies ? solver().a_variable(cellId, nDim + 2) / rho : 0;
          if(Y > yLimitRefLvl) {
            for(MInt i = 0; i < nDim; i++) {
              assignLarger(maxVapPenRefLvl[i], solver().a_coordinate(cellId, i));
            }
          }
        }
      }
    }
  }
 
  // save data:
  MInt it = 0;
  for(MInt n = 0; n < noYLimits; n++) {
    // absolute distance
    m_vapourPen[m_sprayDataStep][it++] = maxVapPen[nDim][n];
    // x/y/z-distance
    for(MInt i = 0; i < nDim; i++) {
      m_vapourPen[m_sprayDataStep][it++] = maxVapPen[i][n];
    }
  }
  for(MInt i = 0; i < nDim; i++) {
    m_vapourPen[m_sprayDataStep][it++] = maxVapPenRefLvl[i];
  }
}

◆ vorticityAtCell()

template<MInt nDim, class SysEqn >

MFloat & PostProcessingFv< nDim, SysEqn >::vorticityAtCell	(	const MInt	cellId,
		const MInt	dir
	)

inlineoverrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingFv< nDim, SysEqn > >.

Definition at line 118 of file postprocessingfv.h.

118{ return solver().vorticityAtCell(cellId, dir); };

FvCartesianSolverXD::vorticityAtCell

virtual MFloat & vorticityAtCell(const MInt cellId, const MInt dir)

Definition: fvcartesiansolverxd.cpp:8967

Friends And Related Function Documentation

◆ PostProcessing

template<MInt nDim, class SysEqn >

template<MInt nDim_, class ppType >

friend class PostProcessing

friend

Definition at line 29 of file postprocessingfv.h.

Member Data Documentation

◆ m_pointData

template<MInt nDim, class SysEqn >

std::unique_ptr<PointData<nDim, SolverType> > PostProcessingFv< nDim, SysEqn >::m_pointData

protected

Definition at line 136 of file postprocessingfv.h.

◆ m_ppSolver

template<MInt nDim, class SysEqn >

SolverType* PostProcessingFv< nDim, SysEqn >::m_ppSolver

private

Definition at line 82 of file postprocessingfv.h.

◆ m_surfaceData

template<MInt nDim, class SysEqn >

std::unique_ptr<SurfaceData<nDim, SolverType> > PostProcessingFv< nDim, SysEqn >::m_surfaceData

protected

Definition at line 137 of file postprocessingfv.h.

◆ m_volumeData

template<MInt nDim, class SysEqn >

std::unique_ptr<VolumeData<nDim, SolverType> > PostProcessingFv< nDim, SysEqn >::m_volumeData

protected

Definition at line 138 of file postprocessingfv.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/fvcartesiansolverxd.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/POST/postprocessingfv.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/POST/postprocessingfv.cpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ SolverType

Constructor & Destructor Documentation

◆ PostProcessingFv()

◆ ~PostProcessingFv()

Member Function Documentation

◆ advanceDataStep()

◆ calcVorticity()

◆ computeAcousticSourceTermQe()

◆ getBoundaryHeatFlux()

◆ getPrimitiveVariables()

◆ getPrimitiveVarNames()

◆ getSampleVarsDerivatives() [1/2]

◆ getSampleVarsDerivatives() [2/2]

◆ getVorticity()

◆ getVorticityT()

◆ initAveragingProperties()

◆ initMovingAverage()

◆ initPointSamplingData()

◆ initPostProcessing()

◆ initSprayData()

◆ initSurfaceSamplingData()

◆ initVolumeSamplingData()

◆ probeLinePeriodic()

◆ probeLinePeriodicPost()

◆ resetDataStep()

◆ savePointSamplingData()

◆ saveSurfaceSamplingData()

◆ saveVolumeSamplingData()

◆ solver()

◆ vapourMass()

◆ vapourPenetration()

◆ vorticityAtCell()

Friends And Related Function Documentation

◆ PostProcessing

Member Data Documentation

◆ m_pointData

◆ m_ppSolver

◆ m_surfaceData

◆ m_volumeData