#include <postprocessinglb.h>

Inheritance diagram for PostProcessingLb< nDim >:

Collaboration diagram for PostProcessingLb< nDim >:

Public Types
using	SolverType = LbSolver< nDim >

using	Base = PostProcessing< nDim, PostProcessingLb< nDim > >

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

using	Cell = typename PPGrid::Cell

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

using	Data = PostData< nDim >

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

virtual	~PostProcessingLb ()

SolverType &	solver () const

Public Member Functions inherited from PostProcessing< nDim, PostProcessingLb< nDim > >
	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	initPointSamplingData () override

void	savePointSamplingData () override

void	initSurfaceSamplingData () override

void	saveSurfaceSamplingData () override

void	initVolumeSamplingData () override

void	saveVolumeSamplingData () override

void	initIsoTurbulenceStatistics () override
	init function for Isotropic Turbulence Statistics More...

void	computeIsoTurbulenceStatistics () override
	write data for isotropic Turbulence (single phase and particle-laden) More...

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

Protected Member Functions inherited from PostProcessing< nDim, PostProcessingLb< nDim > >
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

MFloat	m_tau_eta

Protected Attributes inherited from PostProcessing< nDim, PostProcessingLb< nDim > >
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

std::vector< MString >	m_varNames

MBool	m_needVelocityGradient = false

Friends
template<MInt nDim_, class ppType >
class	PostProcessing

Additional Inherited Members
Public Attributes inherited from PostProcessing< nDim, PostProcessingLb< nDim > >
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, PostProcessingLb< nDim > >
typedef void(PostProcessing::*	tpost) ()

typedef std::vector< tpost >	tvecpost

Detailed Description

template<MInt nDim>
class PostProcessingLb< nDim >

Definition at line 21 of file postprocessinglb.h.

Member Typedef Documentation

◆ Base

template<MInt nDim>

using PostProcessingLb< nDim >::Base = PostProcessing<nDim, PostProcessingLb<nDim> >

Definition at line 28 of file postprocessinglb.h.

◆ SolverType

template<MInt nDim>

using PostProcessingLb< nDim >::SolverType = LbSolver<nDim>

Definition at line 27 of file postprocessinglb.h.

Constructor & Destructor Documentation

◆ PostProcessingLb()

template<MInt nDim>

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

Definition at line 15 of file postprocessinglb.cpp.

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

◆ ~PostProcessingLb()

template<MInt nDim>

PostProcessingLb< nDim >::~PostProcessingLb

virtual

Definition at line 21 of file postprocessinglb.cpp.

21{}

Member Function Documentation

◆ computeIsoTurbulenceStatistics()

template<MInt nDim>

void PostProcessingLb< nDim >::computeIsoTurbulenceStatistics

overrideprotectedvirtual

Author: Johannes Grafen

Date: 28.02.2022 writes the following parameters to std::cout: lambda ReLambda skewness eta (kolomogorovlength) tau_eta (kolomogorov time-scale)

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 97 of file postprocessinglb.cpp.

                                                            {
  TRACE();
 
  if((solver().m_fftInterval > 0 && globalTimeStep % solver().m_fftInterval == 0) || m_finalTimeStep) {
    const MInt fftLevel = solver().grid().maxUniformRefinementLevel();
    const MFloat DX = solver().c_cellLengthAtLevel(fftLevel);
 
    MFloat urms[6] = {F0, F0, F0, F0, F0, F0};
    MFloat dudx[3] = {F0, F0, F0};
    MFloat skew[4] = {F0, F0, F0, F0};
    MFloat lambda[3] = {F0, F0, F0};
    MFloat cnt = F0;
 
    MFloat lambdaAvg = F0;
    MFloat ReLambda = F0;
    MFloat skewness = F0;
    MFloat eta = F0;
 
    for(MInt cellId = 0; cellId < solver().a_noCells(); cellId++) {
      if(solver().a_isHalo(cellId)) continue;
      if(solver().a_isBndryGhostCell(cellId)) continue;
      if(solver().a_level(cellId) != fftLevel) continue;
      MFloat u = solver().a_variable(cellId, solver().PV->U);
      MFloat v = solver().a_variable(cellId, solver().PV->V);
      MFloat w = solver().a_variable(cellId, solver().PV->W);
      for(MInt i = 0; i < nDim; i++) {
        MInt n0 = (solver().a_hasNeighbor(cellId, 2 * i) > 0) ? solver().c_neighborId(cellId, 2 * i) : cellId;
        MInt n1 = (solver().a_hasNeighbor(cellId, 2 * i + 1) > 0) ? solver().c_neighborId(cellId, 2 * i + 1) : cellId;
        if(n0 == n1) continue;
        dudx[i] += POW2((solver().a_variable(n1, solver().PV->VV[i]) - solver().a_variable(n0, solver().PV->VV[i]))
                        / ((solver().a_coordinate(n1, i) - solver().a_coordinate(n0, i)) / DX));
        skew[i] += POW3((solver().a_variable(n1, solver().PV->VV[i]) - solver().a_variable(n0, solver().PV->VV[i]))
                        / ((solver().a_coordinate(n1, i) - solver().a_coordinate(n0, i)) / DX));
      }
      urms[0] += POW2(u);
      urms[1] += POW2(v);
      urms[2] += POW2(w);
      urms[3] += u * v;
      urms[4] += u * w;
      urms[5] += v * w;
      cnt++;
    }
 
    MPI_Allreduce(MPI_IN_PLACE, &cnt, 1, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "MPI_IN_PLACE", "cnt");
    MPI_Allreduce(MPI_IN_PLACE, &urms[0], 6, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "MPI_IN_PLACE", "urms[0]");
    MPI_Allreduce(MPI_IN_PLACE, &dudx[0], 3, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "MPI_IN_PLACE", "dudx[0]");
    MPI_Allreduce(MPI_IN_PLACE, &skew[0], 3, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "MPI_IN_PLACE", "skew[0]");
    skew[3] = ((skew[0] + skew[1] + skew[2]) / (F3 * cnt)) / pow((dudx[0] + dudx[1] + dudx[2]) / (F3 * cnt), 1.5);
    for(MInt i = 0; i < 3; i++)
      skew[i] = (skew[i] / cnt) / pow(dudx[i] / cnt, 1.5);
    for(MInt i = 0; i < 6; i++)
      urms[i] = sqrt(fabs(urms[i]) / cnt);
    for(MInt i = 0; i < 3; i++)
      dudx[i] /= cnt;
    for(MInt i = 0; i < 3; i++)
      lambda[i] = urms[i] / sqrt(dudx[i]); // Eq. 6.56 Turbulent Flows Pope two-point correlation
 
    lambdaAvg = F1B3 * (lambda[0] + lambda[1] + lambda[2]);
    ReLambda = F1B3 * (urms[0] + urms[1] + urms[2]) * lambdaAvg / solver().m_nu;
    skewness = skew[3];
 
    MFloat eps[3];
    for(MInt i = 0; i < 3; i++) {
      eps[i] = 15.0 * solver().m_nu * POW2(urms[i] / lambda[i]); // Eq. 6.58 Turbulent Flows Pope two-point correlation
    }
    eta = pow(solver().m_nu, 0.75)
          / pow(F1B3 * (eps[0] + eps[1] + eps[2]), 0.25); // Eq. 6.1 Turbulent Flows Pope two-point correlation
    m_tau_eta = pow(solver().m_nu / (F1B3 * (eps[0] + eps[1] + eps[2])), 0.5);
 
    if(solver().domainId() == 0) {
      std::ofstream ofl;
      ofl.open("IsoTurbulenceStatistics.log", ios::app);
      ofl << std::setw(5) << globalTimeStep << "\t" << std::setw(8) << ReLambda << "\t" << std::setw(8) << lambdaAvg
          << "\t" << std::setw(8) << eta << "\t" << std::setw(8) << m_tau_eta << "\t" << std::setw(8) << skewness
          << endl;
      ofl.close();
    }
  }
}

◆ getSampleVarsDerivatives()

template<MInt nDim>

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

inlineprotected

Definition at line 78 of file postprocessinglb.h.

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

◆ initIsoTurbulenceStatistics()

template<MInt nDim>

void PostProcessingLb< nDim >::initIsoTurbulenceStatistics

overrideprotectedvirtual

Author: Johannes Grafen

Date: Jul 2022

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 68 of file postprocessinglb.cpp.

                                                         {
  TRACE();
 
  if(solver().domainId() == 0) {
    std::ofstream ofl;
    ofl.open("IsoTurbulenceStatistics.log", ios::app);
    ofl << std::setw(5) << "t"
        << "\t" << std::setw(8) << "ReLambda"
        << "\t" << std::setw(8) << "lambda"
        << "\t" << std::setw(8) << "Eta"
        << "\t" << std::setw(8) << "tau_eta"
        << "\t" << std::setw(8) << "skewness" << endl;
    ofl.close();
  }
}

◆ initPointSamplingData()

template<MInt nDim>

void PostProcessingLb< nDim >::initPointSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 24 of file postprocessinglb.cpp.

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

◆ initSurfaceSamplingData()

template<MInt nDim>

void PostProcessingLb< nDim >::initSurfaceSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 38 of file postprocessinglb.cpp.

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

◆ initVolumeSamplingData()

template<MInt nDim>

void PostProcessingLb< nDim >::initVolumeSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 51 of file postprocessinglb.cpp.

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

◆ savePointSamplingData()

template<MInt nDim>

void PostProcessingLb< nDim >::savePointSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 33 of file postprocessinglb.cpp.

                                                   {
  m_pointData->save(m_finalTimeStep);
}

◆ saveSurfaceSamplingData()

template<MInt nDim>

void PostProcessingLb< nDim >::saveSurfaceSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 46 of file postprocessinglb.cpp.

                                                     {
  m_surfaceData->save(m_finalTimeStep);
}

◆ saveVolumeSamplingData()

template<MInt nDim>

void PostProcessingLb< nDim >::saveVolumeSamplingData

overrideprotectedvirtual

Reimplemented from PostProcessing< nDim, PostProcessingLb< nDim > >.

Definition at line 59 of file postprocessinglb.cpp.

                                                    {
  m_volumeData->save(m_finalTimeStep);
}

◆ solver()

template<MInt nDim>

SolverType & PostProcessingLb< nDim >::solver ( ) const

inline

Definition at line 35 of file postprocessinglb.h.

35{ return *m_ppSolver; }

Friends And Related Function Documentation

◆ PostProcessing

template<MInt nDim>

template<MInt nDim_, class ppType >

friend class PostProcessing

friend

Definition at line 24 of file postprocessinglb.h.

Member Data Documentation

◆ m_needVelocityGradient

template<MInt nDim>

MBool PostProcessingLb< nDim >::m_needVelocityGradient = false

private

Definition at line 57 of file postprocessinglb.h.

◆ m_pointData

template<MInt nDim>

std::unique_ptr<PointData<nDim, SolverType> > PostProcessingLb< nDim >::m_pointData

protected

Definition at line 72 of file postprocessinglb.h.

◆ m_ppSolver

template<MInt nDim>

SolverType* PostProcessingLb< nDim >::m_ppSolver

private

Definition at line 53 of file postprocessinglb.h.

◆ m_surfaceData

template<MInt nDim>

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

protected

Definition at line 73 of file postprocessinglb.h.

◆ m_tau_eta

template<MInt nDim>

MFloat PostProcessingLb< nDim >::m_tau_eta

protected

Definition at line 76 of file postprocessinglb.h.

◆ m_varNames

template<MInt nDim>

std::vector<MString> PostProcessingLb< nDim >::m_varNames

private

Definition at line 56 of file postprocessinglb.h.

◆ m_volumeData

template<MInt nDim>

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

protected

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

◆ PostProcessingLb()

◆ ~PostProcessingLb()

Member Function Documentation

◆ computeIsoTurbulenceStatistics()

◆ getSampleVarsDerivatives()

◆ initIsoTurbulenceStatistics()

◆ initPointSamplingData()

◆ initSurfaceSamplingData()

◆ initVolumeSamplingData()

◆ savePointSamplingData()

◆ saveSurfaceSamplingData()

◆ saveVolumeSamplingData()

◆ solver()

Friends And Related Function Documentation

◆ PostProcessing

Member Data Documentation

◆ m_needVelocityGradient

◆ m_pointData

◆ m_ppSolver

◆ m_surfaceData

◆ m_tau_eta

◆ m_varNames

◆ m_volumeData