PostProcessing< nDim, ppType > Class Template Reference

#include <postprocessing.h>

Inheritance diagram for PostProcessing< nDim, ppType >:

Collaboration diagram for PostProcessing< nDim, ppType >:

Classes
struct	MV
struct	ST

Public Types
using	PPGrid = CartesianGrid< nDim >
using	Cell = typename PPGrid::Cell
using	GridProxy = typename maia::grid::Proxy< nDim >
using	Data = PostData< nDim >

Public Member Functions
	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

Public Attributes
MInt	m_noLocalVars {}
MInt	m_restartTimeStep {}
MBool	m_statisticCombustionAnalysis {}
MBool	m_acousticAnalysis {}
Public Attributes inherited from PostProcessingInterface
MBool	m_finalTimeStep = false

Protected Types
typedef void(PostProcessing::*	tpost) ()
typedef std::vector< tpost >	tvecpost

Protected Member Functions
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 ()
template<MBool inSolution = false>
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
MInt	m_noPostprocessingOps {}
MString *	m_postprocessingOps = nullptr
tvecpost	m_postprocessingSolution
std::vector< tvecpost >	m_postprocessingMethods
std::vector< std::vector< MString > >	m_postprocessingMethodsDesc
Data *	m_postData = nullptr
MInt	m_noVariables {}
MBool	m_square = false
MBool	m_skewness = false
MBool	m_kurtosis = false
MBool	m_computeAndSaveMean = false
MBool	m_twoPass = false
MBool	m_useKahan {}
MBool	m_correlation = false
std::vector< MInt > *	m_cell2globalIndex = nullptr
MInt *	m_noPeriodicSliceCells = nullptr
MFloat **	m_sliceAverage = nullptr
MInt	m_globalnoSlicePositions = 0
std::multimap< MFloat, MFloat >	m_sliceGlobalPositions
MBool	m_averageVorticity = false
MBool	m_averageSpeedOfSound = false
MFloat	m_gamma = -1.0
MInt	m_movingAverageStartTimestep = 0
MInt	m_movingAverageStopTimestep = 0
MInt	m_movingAverageInterval = 1
MInt	m_movingAverageDataPoints {}
MInt	m_movingAverageCounter {}
MFloat **	m_movAvgVariables = nullptr
MInt	m_movAvgNoVariables {}
MString *	m_movAvgVarNames = nullptr
MInt	m_spatialDirection1 {}
MInt	m_spatialDirection2 {}
MFloat	m_spatialWeightSinglePoint {}
MFloat	m_spatialLvlWeight [20] {}
MInt *	m_spatialDispls = nullptr
MInt *	m_spatialVarsDispls = nullptr
MInt *	m_spatialRecvcnts = nullptr
MInt *	m_spatialVarsRecvcnts = nullptr
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 = -1
MFloat *	m_spatialLineAllVars = nullptr
MFloat *	m_spatialLineAllCoord = nullptr
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 = -1
MFloat *	m_spatialPlaneAllVars = nullptr
MFloat *	m_spatialPlaneAllCoord = nullptr
MInt	m_noProbeLines = -1
MInt *	m_probeLineDirection = nullptr
MInt *	m_probeLinePeriodic = nullptr
MFloat **	m_probeLineCoordinates = nullptr
MInt **	m_probeLineIds = nullptr
MInt *	m_noProbeLineIds = nullptr
MFloat **	m_probeLinePositions = nullptr
MInt *	m_globalNoProbeLineIds = nullptr
MInt *	m_probeLineOffsets = nullptr
MInt **	m_noGlobalProbeLineIds = nullptr
MInt	m_probeLineInterval = -1
MInt	m_probeLineStartTimestep = 0
MInt	m_probeLineStopTimestep = -1
MInt *	m_correlationDirection = nullptr
MInt *	m_correlationVariableIndex = nullptr
MFloat **	m_correlationCoordinates = nullptr
MInt	m_noCorrelationLines = -1
MInt *	m_noCorrelationIds = nullptr
MInt **	m_correlationIds = nullptr
MInt **	m_globalCorrelationIds = nullptr
MFloat **	m_globalCorrelationPositions = nullptr
MInt *	m_globalNoCorrelationIds = nullptr
MFloat **	m_correlationPositions = nullptr
MInt **	m_correlationIndexMapping = nullptr
MFloat **	m_correlationExchangeVar = nullptr
MFloat **	m_correlationExchangeVarMean = nullptr
MFloat **	m_correlationExchangeVarRMS = nullptr
MFloat **	m_globalCorrelationExchangeVar = nullptr
MFloat **	m_globalCorrelationExchangeVarMean = nullptr
MFloat **	m_globalCorrelationExchangeVarRMS = nullptr
MInt *	m_probeLineAverageDirection = nullptr
MFloat **	m_probeLineAverageCoordinates = nullptr
MInt **	m_probeLineAverageCoordinatesSign = nullptr
MInt **	m_noProbeLineAverageIds = nullptr
MFloat ***	m_globalProbeLineAverageVars = nullptr
MInt	m_noProbeLineAverageSteps
MInt **	m_globalNoProbeLineAverageIds = nullptr
MInt ***	m_probeLineAverageIds = nullptr
MFloat ***	m_probeLineAveragePositions = nullptr
MInt	m_noProbeSlices = -1
MInt *	m_probeSliceDir = nullptr
MFloat *	m_probeSliceCoordinate = nullptr
MInt **	m_probeSliceIds = nullptr
MInt *	m_noProbeSliceIds = nullptr
MFloat **	m_probeSlicePositions = nullptr
MInt *	m_globalNoProbeSliceIds = nullptr
MInt *	m_probeSliceOffsets = nullptr
MInt **	m_noGlobalProbeSliceIds = nullptr
MString *	m_probeSliceGridNames = nullptr
MString *	m_sliceAxis = nullptr
MFloat *	m_sliceIntercept = nullptr
MBool	m_sliceAiaFileFormat = false
MBool	m_optimizedSliceIo = true
MInt *	m_noProbeSliceNoHilbertIds = nullptr
MInt *	m_noProbeSliceMaxNoHilbertIds = nullptr
MInt **	m_noProbeSliceHilbertInfo = nullptr
MInt *	m_noProbeSliceNoContHilbertIds = nullptr
MInt *	m_noProbeSliceMaxNoContHilbertIds = nullptr
MInt **	m_noProbeSliceContHilbertInfo = nullptr
MInt	m_probeSliceInterval = -1
MInt	m_probeSliceStartTimestep = 0
MInt	m_probeSliceStopTimestep = -1
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 = nullptr
MInt	m_movePointsToGrid {}
MBool	m_spatialAveraging {}
MFloat *	m_arbLinePoints = nullptr
MInt	m_noArbLines = 0
MInt *	m_noArbLineIds = nullptr
MFloat *	m_arbLinePointsDistribution = nullptr
MInt *	m_arbLineHasNewDistribution = nullptr
MInt *	m_arbLineFull = nullptr
MInt *	m_moveLinePointsToGrid = nullptr
MInt *	m_globalNoArbLineIds = nullptr
MInt **	m_arbLineIds = nullptr
MInt *	m_arbLineOffsets = nullptr
MFloat **	m_arbLineCoordinates = nullptr
MFloat *	m_arbSlicePoints = nullptr
MInt	m_noArbSlices {}
MInt *	m_noArbSlicePoints = nullptr
MFloat *	m_arbSlicePointsDistribution = nullptr
MInt *	m_globalNoArbSlicePoints = nullptr
MInt **	m_arbSliceIds = nullptr
MInt *	m_arbSliceOffsets = nullptr
MFloat **	m_arbSliceCoordinates = nullptr
MString	m_postprocessFileName = ""
MFloat **	m_localVars = nullptr
MBool	m_averageRestart {}
MInt	m_averageInterval {}
MInt	m_averageStartTimestep {}
MInt	m_averageStopTimestep {}
MInt	m_noAveragedVorticities {}
MInt	m_noSpeedOfSoundVars {}
MInt	m_noSourceVars {}
MBool	m_needVorticity = false
MString	m_ReStressesAverageFileName
MFloat **	m_probeCoordinates = nullptr
MString	m_probePath
MInt *	m_probeCellIds = nullptr
std::ofstream *	m_probeFileStreams = nullptr
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 = 50
MInt	m_sprayWriteInterval = 50
MInt	m_sprayDataSize = 50
MInt	m_sprayDataStep = 0
MFloat **	m_particleCV = nullptr
MFloat **	m_particlePen = nullptr
MFloat **	m_sprayStat = nullptr
MFloat **	m_sprayTimes = nullptr
MFloat **	m_injectionData = nullptr
MFloat **	m_vapourCV = nullptr
MFloat **	m_vapourPen = nullptr
MInt	m_LPTSolutionInterval = 50
MBool	m_forceOutput = false
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
MString	m_solverType
ppType *	pp = static_cast<ppType*>(this)
	CRTP. More...
GridProxy *	m_gridProxy

Detailed Description

template<MInt nDim, class ppType>
class PostProcessing< nDim, ppType >

Definition at line 85 of file postprocessing.h.

Member Typedef Documentation

Cell

template<MInt nDim, class ppType >

using PostProcessing< nDim, ppType >::Cell = typename PPGrid::Cell

Definition at line 88 of file postprocessing.h.

Data

template<MInt nDim, class ppType >

using PostProcessing< nDim, ppType >::Data = PostData<nDim>

Definition at line 90 of file postprocessing.h.

GridProxy

template<MInt nDim, class ppType >

using PostProcessing< nDim, ppType >::GridProxy = typename maia::grid::Proxy<nDim>

Definition at line 89 of file postprocessing.h.

PPGrid

template<MInt nDim, class ppType >

using PostProcessing< nDim, ppType >::PPGrid = CartesianGrid<nDim>

Definition at line 87 of file postprocessing.h.

tpost

template<MInt nDim, class ppType >

typedef void(PostProcessing::* PostProcessing< nDim, ppType >::tpost) ()

protected

Definition at line 280 of file postprocessing.h.

tvecpost

template<MInt nDim, class ppType >

typedef std::vector<tpost> PostProcessing< nDim, ppType >::tvecpost

protected

Definition at line 281 of file postprocessing.h.

Constructor & Destructor Documentation

PostProcessing()

template<MInt nDim, class ppType >

PostProcessing< nDim, ppType >::PostProcessing ( MInt  postprocessingId_, PostData< nDim > *  data  )

inline

Definition at line 93 of file postprocessing.h.

                                                               : PostProcessingInterface(postprocessingId_) {
    m_postData = data;
  }

~PostProcessing()

template<MInt nDim, class ppType >

PostProcessing< nDim, ppType >::~PostProcessing

Author

Andreas Lintermann

Date

26.08.2012

Template Parameters

in] T celltype

Definition at line 64 of file postprocessing.cpp.

                                              {
  TRACE();
 
  if(m_noPostprocessingOps > 0)
    for(MInt op = 0; op < m_noPostprocessingOps; op++) {
      switch(string2enum(m_postprocessingOps[op])) {
        case PP_PROBE_POINT_PRE:
        case PP_PROBE_POINT_POST:
        case PP_PROBE_POINT_IN: {
          for(MInt np = 0; np < m_noProbePoints; np++)
            m_probeFileStreams[np].close();
 
          delete[] m_probeFileStreams;
          break;
        }
        case PP_AVERAGE_PRE:
        case PP_AVERAGE_IN:
        case PP_AVERAGE_POST: {
          // mDeallocate(m_summedVars);
          // mDeallocate(m_square);
          if(m_useKahan) {
            // mDeallocate(m_cSum);
            // mDeallocate(m_ySum);
            // mDeallocate(m_tSum);
 
            // mDeallocate(m_cSquare);
            // mDeallocate(m_ySquare);
            // mDeallocate(m_tSquare);
 
            if(m_kurtosis) {
              // mDeallocate(m_cCube);
              // mDeallocate(m_yCube);
              // mDeallocate(m_tCube);
 
              // mDeallocate(m_cFourth);
              // mDeallocate(m_yFourth);
              // mDeallocate(m_tFourth);
            } else if(m_skewness) {
              // mDeallocate(m_cCube);
              // mDeallocate(m_yCube);
              // mDeallocate(m_tCube);
            }
          }
          if(m_kurtosis) {
            // mDeallocate(m_cube);
            // mDeallocate(m_fourth);
          } else if(m_skewness) {
            // mDeallocate(m_cube);
          }
          break;
        }
        case PP_MOVING_AVERAGE_IN:
        case PP_MOVING_AVERAGE_PRE:
        case PP_MOVING_AVERAGE_POST: {
          break;
        }
        case PP_SPATIAL_AVERAGE_PRE:
        case PP_SPATIAL_AVERAGE_POST:
        case PP_SPATIAL_AVERAGE_IN: {
          break;
        }
        case PP_PROBE_LINE_PRE:
        case PP_PROBE_LINE_POST:
        case PP_PROBE_LINE_IN: {
          break;
        }
        case PP_PROBE_ARB_LINE_PRE:
        case PP_PROBE_ARB_LINE_POST:
        case PP_PROBE_ARB_LINE_IN: {
          break;
        }
        case PP_PROBE_SLICE_PRE:
        case PP_PROBE_SLICE_POST:
        case PP_PROBE_SLICE_IN: {
          break;
        }
        case PP_PROBE_ARB_SLICE_PRE:
        case PP_PROBE_ARB_SLICE_POST:
        case PP_PROBE_ARB_SLICE_IN: {
          break;
        }
        case PP_WRITEPOINTS_IN: {
          break;
        }
        case PP_REDUCE_TO_LEVEL_PRE:
        case PP_REDUCE_TO_LEVEL_POST: {
          break;
        }
        case PP_AVERAGE_SLICE_PRE: {
          break;
        }
        case PP_SPRAY_STATS:
        case PP_PARTICLE_STATISTICS:
        case PP_PARTICLE_SOLUTION: {
          break;
        }
        case PP_PL_ISO_TURBULENCE_STATISTICS:
        case PP_ISO_TURBULENCE_STATISTICS: {
          break;
        }
        default: {
          mTerm(1, AT_, "Unknown postprocessing operation");
        }
      }
    }
  delete[] m_postprocessingOps;
  //}
}

Member Function Documentation

averageSolutions()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::averageSolutions

protected

Author

A. Niemoeller

Date

09.12.2013

loads variables for all averaging timesteps and performs averaging (mean values and reynolds stress components)
additionally computation of skewness and kurtosis of the velocity components is performed if activated (see properties "skewness"/"kurtosis")
summation of variables can be done alternatively using kahan summation or two pass in contrast to normal summation (see properties "useKahan"/"twoPass")
solution output filename will be "Mean_[averageStartTimestep]-[averageStopTimestep]"

Definition at line 3481 of file postprocessing.cpp.

                                                    {
  TRACE();
 
  if(!pp->solver().grid().isActive()) return;
 
  // Find out how many solutions are required and how the weighting will be
  const MFloat weight = 1.0 / (((m_averageStopTimestep - m_averageStartTimestep) / m_averageInterval) + 1);
 
  const MInt noCells = postData().grid().noInternalCells();
 
  const MFloat* cellVars = nullptr;
  MFloat* heatRelease = nullptr;
 
  if(m_twoPass) { // two pass activated, compute mean values first
    TERMM(1, "FIXME two-pass averaging is untested and probably broken");
    for(MInt t = m_averageStartTimestep; t <= m_averageStopTimestep; t += m_averageInterval) {
      m_log << "    ^        * Mean computation timestep " << t << " with weight " << weight << "\n";
 
      pp->solver().loadSampleVariables(t); // load variables for timestep t
 
      if(m_statisticCombustionAnalysis) pp->solver().getHeatRelease(heatRelease);
 
      for(MInt dataId = 0; dataId < noCells; dataId++) {
        MInt cellId = convertIdParent(postData(), pp->solver(), dataId);
        if(cellId != -1) {
          getSampleVariables(cellId, cellVars, true);
 
          if(cellVars == nullptr) {
            return;
          }
 
          for(MInt varId = 0; varId < m_noVariables; varId++) { // sum up all variables
            // m_summedVars[cellId][varId] += cellVars[varId];
            postData().a_variable(dataId, varId) += cellVars[varId];
          }
        }
      }
    }
    // weighting of summed primitive variables
    for(MInt dataId = 0; dataId < noCells; dataId++) {
      MInt cellId = convertIdParent(postData(), pp->solver(), dataId);
      if(cellId != -1) {
        for(MInt varId = 0; varId < m_noVariables; varId++) {
          // m_summedVars[cellId][varId] *= weight;
          postData().a_variable(dataId, varId) *= weight;
        }
      }
    }
  } // end of mean calculation for twoPass
 
  // Start averaging, timestep loop
  // PP_ToDo-Average:is this correct
  // MInt restartT = m_restartTimeStep;
  // if(m_averageRestart) {
  //   restartT += m_averageInterval;
  // } else {
  MInt restartT = m_averageStartTimestep;
  // }
  // TODO labels:PP move to separate method e.g. addAveragingSample() (see fv-structured PP)
  for(MInt t = restartT; t <= m_averageStopTimestep; t += m_averageInterval) {
    m_log << "    ^        * Averaging timestep " << t << " with weight " << weight << "\n";
    pp->solver().loadSampleVariables(t); // load variables for timestep t
 
    if(m_statisticCombustionAnalysis) pp->solver().getHeatRelease(heatRelease);
 
    for(MInt dataId = 0; dataId < noCells; dataId++) { // cell loop
      const MInt cellId = convertIdParent(postData(), pp->solver(), dataId);
      if(cellId != -1) {
        getSampleVariables(cellId, cellVars, true);
 
        if(cellVars == nullptr) {
          return;
        }
 
        if(m_twoPass) // two pass, second part
        {
          for(MInt varId = 0; varId < nDim; varId++) {
            // m_summedVars[cellId][varId + m_noVariables] +=
            //     (cellVars[varId] - m_summedVars[cellId][varId]) * (cellVars[varId] - m_summedVars[cellId][varId]);
            // postData().a_variable(dataId, varId) +=
            //   (cellVars[varId] - postData().a_variable(dataId, varId)) * (cellVars[varId] -
            //   m_summedVars[cellId][varId]);
          }
          for(MInt varId = 0; varId < 2 * nDim - 3; varId++) {
            // m_summedVars[cellId][m_noVariables + nDim + varId] +=
            //     (cellVars[varId % nDim] - m_summedVars[cellId][varId])
            //     * (cellVars[(varId + 1) % nDim] - m_summedVars[cellId][(varId + 1) % nDim]);
            // postData().a_variable(dataId, m_noVariables + nDim + varId) +=
            //   (cellVars[varId % nDim] - postData().a_variable(dataId, varId))
            //   * (cellVars[(varId + 1) % nDim] - m_summedVars[cellId][(varId + 1) % nDim]);
          }
          if(m_kurtosis) {
            for(MInt varId = 0; varId < nDim; varId++) {
              // m_summedVars[cellId][m_noVariables + 3 * (nDim - 1) + varId] +=
              //     pow(cellVars[varId] - m_summedVars[cellId][varId], 3);
              // m_summedVars[cellId][m_noVariables + 3 * (nDim - 1) + nDim + varId] +=
              //     pow(cellVars[varId] - m_summedVars[cellId][varId], 4);
              // postData().a_variable(dataId, m_noVariables + 3 * (nDim - 1) + varId) +=
              //   pow(cellVars[varId] - postData().a_variable(dataId,varId), 3);
              // postData().a_variable(dataId, m_noVariables + 3 * (nDim - 1) + nDim + varId) +=
              //   pow(cellVars[varId] - postData().a_variable(dataId, varId), 4);
            }
          } else if(m_skewness) {
            for(MInt varId = 0; varId < nDim; varId++) {
              // m_summedVars[cellId][m_noVariables + 3 * (nDim - 1) + varId] +=
              //     pow(cellVars[varId] - m_summedVars[cellId][varId], 3);
              // postData().a_variable(dataId, m_noVariables + 3 * (nDim - 1) + varId) +=
              //   pow(cellVars[varId] - postData().a_variable(dataId, varId), 3);
            }
          }
        }                   // two pass end
        else if(m_useKahan) // Kahan summation activated, reduced error in summation of variables
        {
          if(dataId == 0) m_log << "start kahan summation" << endl;
          /* Kahan summation pseudocode
 
             sum=0; c=0;
             for i=0 to input.length
             y = input[i] -c;
             t = sum + y;
             c = (t-sum) - y;
             sum = t;
 
          */
          for(MInt varId = 0; varId < m_noVariables; varId++) { // sum up all variables
            // m_ySum[cellId][varId] = cellVars[varId] - m_cSum[cellId][varId];
            // m_tSum[cellId][varId] = m_summedVars[cellId][varId] + m_ySum[cellId][varId];
            // m_cSum[cellId][varId] = (m_tSum[cellId][varId] - m_summedVars[cellId][varId]) - m_ySum[cellId][varId];
            // m_summedVars[cellId][varId] = m_tSum[cellId][varId];
          }
          for(MInt varId = 0; varId < nDim; varId++) { // squares of velocity components (u*u,v*v(,w*w))
            // m_ySquare[cellId][varId] = (cellVars[varId] * cellVars[varId]) - m_cSquare[cellId][varId];
            // m_tSquare[cellId][varId] = m_square[cellId][varId] + m_ySquare[cellId][varId];
            // m_cSquare[cellId][varId] = (m_tSquare[cellId][varId] - m_square[cellId][varId]) -
            // m_ySquare[cellId][varId]; m_square[cellId][varId] = m_tSquare[cellId][varId];
          }
          for(MInt varId = 0; varId < 2 * nDim - 3;
              varId++) { // products of different velocity components (u*v(,v*w,w*u))
            // m_ySquare[cellId][nDim + varId] =
            //(cellVars[varId]) * (cellVars[(varId + 1) % nDim]) - m_cSquare[cellId][nDim + varId];
            // m_tSquare[cellId][nDim + varId] = m_square[cellId][nDim + varId] + m_ySquare[cellId][nDim + varId];
            // m_cSquare[cellId][nDim + varId] =
            //(m_tSquare[cellId][nDim + varId] - m_square[cellId][nDim + varId]) - m_ySquare[cellId][nDim + varId];
            // m_square[cellId][nDim + varId] = m_tSquare[cellId][nDim + varId];
          }
          if(m_kurtosis) { // compute third and fourth power of velocity components for skewness and kurtosis
            for(MInt varId = 0; varId < nDim; varId++) {
              // m_yCube[cellId][varId] = pow(cellVars[varId], 3) - m_cCube[cellId][varId];
              // m_tCube[cellId][varId] = m_cube[cellId][varId] + m_yCube[cellId][varId];
              // m_cCube[cellId][varId] = (m_tCube[cellId][varId] - m_cube[cellId][varId]) - m_yCube[cellId][varId];
              // m_cube[cellId][varId] = m_tCube[cellId][varId];
 
              // m_yFourth[cellId][varId] = pow(cellVars[varId], 4) - m_cFourth[cellId][varId];
              // m_tFourth[cellId][varId] = m_fourth[cellId][varId] + m_yFourth[cellId][varId];
              // m_cFourth[cellId][varId] = (m_tFourth[cellId][varId] - m_fourth[cellId][varId]) -
              // m_yFourth[cellId][varId]; m_fourth[cellId][varId] = m_tFourth[cellId][varId];
            }
          } else if(m_skewness) { // compute only third power of velocity components for skewness
            for(MInt varId = 0; varId < nDim; varId++) {
              // m_yCube[cellId][varId] = pow(cellVars[varId], 3) - m_cCube[cellId][varId];
              // m_tCube[cellId][varId] = m_cube[cellId][varId] + m_yCube[cellId][varId];
              // m_cCube[cellId][varId] = (m_tCube[cellId][varId] - m_cube[cellId][varId]) - m_yCube[cellId][varId];
              // m_cube[cellId][varId] = m_tCube[cellId][varId];
            }
          }
        }    // kahan summation end
        else // normal summation
        {
          // Primitive variables
          MInt varIndex = postData().getPropertyVariableOffset("primitive").first;
          for(MInt varId = 0; varId < m_noVariables; varId++) {
            postData().a_variable(dataId, varIndex + varId) += cellVars[varId];
          }
 
          if(m_square) {
            MInt varSquare = postData().getPropertyVariableOffset("square").first;
            for(MInt varId = 0; varId < nDim; varId++) {
              // squares of velocity components (u*u,v*v(,w*w))
              postData().a_variable(dataId, varSquare + varId) += cellVars[varId] * cellVars[varId];
            }
            for(MInt varId = 0; varId < 2 * nDim - 3; varId++) {
              // products of different velocity components (u*v(,v*w,w*u))
              postData().a_variable(dataId, varSquare + nDim + varId) +=
                  (cellVars[varId % nDim]) * (cellVars[(varId + 1) % nDim]);
            }
            // squares of pressure  p*p
            postData().a_variable(dataId, varSquare + 3 * nDim - 3) += cellVars[nDim + 1] * cellVars[nDim + 1];
          }
 
          // third and fourth powers of velocity components (skewness and kurtosis)
          if(m_kurtosis) {
            ASSERT(m_square, "");
            ASSERT(m_skewness, "");
            MInt varSkew = postData().getPropertyVariableOffset("skewness").first;
            MInt varKurt = postData().getPropertyVariableOffset("kurtosis").first;
            for(MInt varId = 0; varId < nDim; varId++) {
              postData().a_variable(dataId, varSkew + varId) += pow(cellVars[varId], 3);
              postData().a_variable(dataId, varKurt + varId) += pow(cellVars[varId], 4);
            }
            // third powers of velocity components (skewness)
          } else if(m_skewness) {
            ASSERT(m_square, "");
            MInt varSkew = postData().getPropertyVariableOffset("skewness").first;
            for(MInt varId = 0; varId < nDim; varId++) {
              postData().a_variable(dataId, varSkew + varId) += pow(cellVars[varId], 3);
            }
          }
 
          // hm,c',h'
          if(m_statisticCombustionAnalysis) {
            MInt varComb = postData().getPropertyVariableOffset("statisticCombustionAnalysis").first;
            postData().a_variable(dataId, varComb) += heatRelease[cellId];
            postData().a_variable(dataId, varComb + 1) += cellVars[nDim + 2] * cellVars[nDim + 2];
            postData().a_variable(dataId, varComb + 2) += heatRelease[cellId] * heatRelease[cellId];
          }
 
          // Vorticities
          if(m_averageVorticity) {
            MInt varVort = postData().getPropertyVariableOffset("averageVorticity").first;
            for(MInt varId = 0; varId < m_noAveragedVorticities; varId++) {
              postData().a_variable(dataId, varVort + varId) += pp->vorticityAtCell(cellId, varId);
            }
          }
        }
      }
    } // normal summation end
  }   // cell loop end
 
  if(m_twoPass) {
    TERMM(1, "FIXME");
    // weighting for twoPass
    for(MInt dataId = 0; dataId < noCells; dataId++) {
      MInt cellId = convertIdParent(postData(), pp->solver(), dataId);
      if(cellId != -1) {
        for(MInt varId = 0; varId < 3 * nDim - 3 + nDim * (m_skewness + m_kurtosis); varId++) {
          // m_summedVars[cellId][m_noVariables + varId] *= weight;
        }
      }
    }
  } else {
    m_computeAndSaveMean = true;
    computeAndSaveMean();
  }
 
  m_log << "    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n" << endl;
}

averageSolutionsInSolve()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::averageSolutionsInSolve ( )

protectedvirtual

averageSolutionsSlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::averageSolutionsSlice ( )

protected

calcDivergence()

template<MInt nDim, class ppType >

MFloat PostProcessing< nDim, ppType >::calcDivergence ( const MInt  cellIdSolver )

inlineprotected

Definition at line 214 of file postprocessing.h.

                                                 {
    const MInt noVariables = pp->solver().noVariables();
    std::vector<MFloat> cellVarsDeriv(noVariables * nDim);
    MFloat divergence = 0.0;
    if(pp->getSampleVarsDerivatives(cellIdSolver, cellVarsDeriv)) {
      const MFloatTensor deriv(cellVarsDeriv.data(), noVariables, nDim);
      for(MInt d = 0; d < nDim; d++) {
        divergence += deriv(d, d);
      }
    }
    return divergence;
  }

calcSamplingVar()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::calcSamplingVar ( const MInt  cellId, const MInt  sampleVarId, MFloat *const  vars  )

protected

calcVorticity()

template<MInt nDim, class ppType >

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

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 227 of file postprocessing.h.

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

collectMinLvlCells()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::collectMinLvlCells ( )

protected

computeAcousticSourceTermQe()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::computeAcousticSourceTermQe ( MFloatScratchSpace &  , MFloatScratchSpace &  , MFloatScratchSpace &  , MFloatScratchSpace &    )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 248 of file postprocessing.h.

                                                                                                                  {
    TERMM(1, "Not implemented for this solverType");
  }

computeAndSaveDivergence()

template<MInt nDim, class ppType >

template<MBool inSolution = false>

void PostProcessing< nDim, ppType >::computeAndSaveDivergence ( )

protected

computeAndSaveMean()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::computeAndSaveMean ( )

protected

computeIsoTurbulenceStatistics()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::computeIsoTurbulenceStatistics ( )

inlineprotectedvirtual

Reimplemented in PostProcessingLb< nDim >.

Definition at line 168 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

computeParticleStatistics()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::computeParticleStatistics ( )

inlineprotectedvirtual

Reimplemented in PostProcessingLbLPT< nDim >, and PostProcessingLPT< nDim >.

Definition at line 140 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

computePLIsoTurbulenceStatistics()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::computePLIsoTurbulenceStatistics ( )

inlineprotectedvirtual

Reimplemented in PostProcessingLbLPT< nDim >.

Definition at line 144 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

computeSprayData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::computeSprayData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFvLPT< nDim, SysEqn >.

Definition at line 133 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

createCellToMap1D()

template<MInt nDim, class ppType >

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

protected

createCellToMap2D()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::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  )

protected

findClosestProbePointsGridCells()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::findClosestProbePointsGridCells ( )

protected

findContainingCell()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::findContainingCell ( const MFloat *  coord, MInt &  cellId  )

protected

findNearestGridCell()

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::findNearestGridCell ( const MFloat *  coord )

protected

getBoundaryHeatFlux()

template<MInt nDim, class ppType >

virtual MFloat PostProcessing< nDim, ppType >::getBoundaryHeatFlux ( const MInt  cellId ) const

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 266 of file postprocessing.h.

                                                              {
    std::ignore = cellId;
    TERMM(1, "Not implemented for this solver");
  };

getPrimitiveVariables()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::getPrimitiveVariables ( MInt  , MFloat *  , MFloat *  , MInt    )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 245 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

getPrimitiveVarNames()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::getPrimitiveVarNames ( MString *  names ) const

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 270 of file postprocessing.h.

                                                          {
    std::ignore = names;
    TERMM(1, "Not implemented for this solverType");
  };

getSampleVariables() [1/2]

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::getSampleVariables ( MInt  cellId, const MFloat *&  vars, MBool  mode  )

protected

getSampleVariables() [2/2]

template<MInt nDim, class ppType >

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

protected

getSampleVarsDerivatives() [1/2]

template<MInt nDim, class ppType >

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

inlineprotected

Definition at line 252 of file postprocessing.h.

                                                                        {
    std::ignore = cellId;
    vars = nullptr;
    // TERMM(1, "Not implemented for this solverType");
  };

getSampleVarsDerivatives() [2/2]

template<MInt nDim, class ppType >

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

inlineprotected

Definition at line 257 of file postprocessing.h.

                                                                     {
    return false; // = not implemented for this solver
    // TERMM(1, "Not implemented for this solverType");
  };

getVorticity()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::getVorticity ( MFloat *const  vorticity )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 237 of file postprocessing.h.

                                                     {
    std::ignore = vorticity;
    TERMM(1, "Not implemented for this solverType");
  };

getVorticityT()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::getVorticityT ( MFloat *const  vorticity )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 241 of file postprocessing.h.

                                                      {
    std::ignore = vorticity;
    TERMM(1, "Not implemented for this solverType");
  };

initAverageSolutionsSlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initAverageSolutionsSlice

protected

Author

D. Zilles

Date

07.09.2017

loads sliceAxes and sliceIntercepts.

Definition at line 2462 of file postprocessing.cpp.

                                                             {
  TRACE();
 
  m_noProbeSlices = Context::propertyLength("sliceAxis", m_postprocessingId);
 
  mAlloc(m_sliceAxis, m_noProbeSlices, "m_sliceAxis", AT_);
  mAlloc(m_sliceIntercept, m_noProbeSlices, "m_sliceIntercept", AT_);
 
  for(MInt sliceId = 0; sliceId < m_noProbeSlices; sliceId++) {
    m_sliceAxis[sliceId] = Context::getSolverProperty<MString>("sliceAxis", m_postprocessingId, AT_, sliceId);
  }
  for(MInt sliceId = 0; sliceId < m_noProbeSlices; sliceId++) {
    m_sliceIntercept[sliceId] = Context::getSolverProperty<MFloat>("sliceIntercept", m_postprocessingId, AT_, sliceId);
  }
}

initAverageVariables()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initAverageVariables

protectedvirtual

Author

A. Niemoeller

Date

09.12.2013

Definition at line 1013 of file postprocessing.cpp.

                                                        {
  // TODO:move to postData!
 
#if not defined(MAIA_DISABLE_LB)
  constexpr MBool isothermal = (std::is_same<ppType, PostProcessingLb<nDim>>::value);
  m_averageSpeedOfSound = (m_averageSpeedOfSound && !isothermal);
#else
  constexpr MBool isothermal = false;
#endif
 
  // Allocate memory for summed variables
  m_noAveragedVorticities = (m_averageVorticity) * (nDim * 2 - 3);
  m_noSpeedOfSoundVars = (m_averageSpeedOfSound) * (1 + nDim);
  m_needVorticity = (m_averageVorticity || (m_activeMeanVars.find(MV::LAMB0) != m_activeMeanVars.end()));
 
  const MInt noSummedVars =
      m_noVariables                                          // primitive variables
      + (3 * (nDim - 1) + 1) * m_square                      // Reynolds stresses +  pressure amplitude
      + nDim * m_skewness                                    // sknewness
      + nDim * m_kurtosis                                    // kurtosis
      + static_cast<MInt>(m_statisticCombustionAnalysis) * 3 // combustion variables (hm,c',h': cm in m_noVariables)
      + m_noAveragedVorticities                              // vorticities
      + m_noSpeedOfSoundVars                                 // speed of sound and derivatives
      + m_noSourceVars                                       // APE source terms
      + m_correlation * m_noCorrelationLines;
 
  if(noSummedVars > postData().noVariables()) {
    std::stringstream ss;
    ss << "PostData: noVariables in postprocessing not correct: postData().noVariables(): " << postData().noVariables()
       << " m_varNames.size(): " << noSummedVars << std::endl;
    TERMM(1, ss.str());
  }
 
  MInt count = 0;
  postData().setPropertyVariableOffset("primitive", count, m_noVariables);
  count += m_noVariables;
 
  if(m_square) {
    const MInt offset = 3 * (nDim - 1) + 1;
    postData().setPropertyVariableOffset("square", count, offset);
    count += offset;
  }
 
  if(m_kurtosis) {
    postData().setPropertyVariableOffset("skewness", count, nDim);
    count += nDim;
    postData().setPropertyVariableOffset("kurtosis", count, nDim);
    count += nDim;
    ASSERT(m_skewness, "required as well");
  } else if(m_skewness) {
    postData().setPropertyVariableOffset("skewness", count, nDim);
    count += nDim;
  }
 
  if(m_statisticCombustionAnalysis) {
    postData().setPropertyVariableOffset("statisticCombustionAnalysis", count, 3);
    count += 3;
  }
 
  if(m_averageVorticity) {
    postData().setPropertyVariableOffset("averageVorticity", count, m_noAveragedVorticities);
    count += m_noAveragedVorticities;
  }
 
  if(m_averageSpeedOfSound) {
    postData().setPropertyVariableOffset("averageSpeedOfSound", count, m_noSpeedOfSoundVars);
    count += m_noSpeedOfSoundVars;
  }
 
  if(m_noSourceVars > 0) {
    postData().m_sourceVarsIndex = count;
    if(m_activeMeanVars.find(MV::LAMB0) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("lamb0", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::GRADU) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("gradu", count, nDim * nDim);
      count += nDim * nDim;
    } else if(m_activeMeanVars.find(MV::DU) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("du", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::UGRADU) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("ugradu", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::DRHO) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("drho", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::DP) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("dp", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::RHODIVU) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("rhodivu", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::UGRADRHO) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("ugradrho", count, nDim);
      count += nDim;
    }
 
    if(m_activeMeanVars.find(MV::GRADPRHO) != m_activeMeanVars.end()) {
      postData().setPropertyVariableOffset("gradprho", count, nDim);
      count += nDim;
    }
  }
 
  if(m_correlation) {
    postData().setPropertyVariableOffset("correlation", count, m_noCorrelationLines);
    count += m_noCorrelationLines;
  }
 
  postData().setVariableNames();
 
  if(count > postData().noVariables()) {
    cerr << "Missmatching post data " << count << " " << postData().noVariables() << endl;
    mTerm(1, AT_, "Variables size not matching!");
  }
 
  // Allocate memory for squared variables
  // mAlloc(m_square, noInternalCells, 3 * (nDim - 1) + 1 + (MInt)(m_statisticCombustionAnalysis)*2, "m_square", F0,
  //           FUN_);
  // + 1 for pressure ampl + 2 ampl for combustion variables, c',h'
 
  // if(m_kurtosis != 0 /*&& !m_twoPass*/) {
  //   mAlloc(m_cube, noInternalCells, nDim, "m_cube", F0, FUN_);
  //   mAlloc(m_fourth, noInternalCells, nDim, "m_fourth", F0, FUN_);
  // } else if(m_skewness != 0 /*&& !m_twoPass*/) {
  //   mAlloc(m_cube, noInternalCells, nDim, "m_cube", F0, FUN_);
  // }
 
  if(m_useKahan) // allocate memory for kahan summation
  {
    m_log << "m_useKahan is activated" << endl;
    TERMM(1, "FIXME Kahan summation is untested and probably broken");
    // mAlloc(m_cSum, noInternalCells, m_noVariables + 3 * (nDim - 1), "m_cSum", F0, AT_);
    // mAlloc(m_tSum, noInternalCells, m_noVariables + 3 * (nDim - 1), "m_tSum", F0, AT_);
    // mAlloc(m_ySum, noInternalCells, m_noVariables + 3 * (nDim - 1), "m_ySum", F0, AT_);
    // mAlloc(m_cSquare, noInternalCells, 3 * (nDim - 1), "m_cSquare", F0, AT_);
    // mAlloc(m_tSquare, noInternalCells, 3 * (nDim - 1), "m_tSquare", F0, AT_);
    // mAlloc(m_ySquare, noInternalCells, 3 * (nDim - 1), "m_ySquare", F0, AT_);
    if(m_kurtosis) {
      // mAlloc(m_cCube, noInternalCells, nDim, "m_cCube", F0, AT_);
      // mAlloc(m_tCube, noInternalCells, nDim, "m_tCube", F0, AT_);
      // mAlloc(m_yCube, noInternalCells, nDim, "m_yCube", F0, AT_);
      // mAlloc(m_cFourth, noInternalCells, nDim, "m_cFourth", F0, AT_);
      // mAlloc(m_tFourth, noInternalCells, nDim, "m_tFourth", F0, AT_);
      // mAlloc(m_yFourth, noInternalCells, nDim, "m_yFourth", F0, AT_);
    } else if(m_skewness) {
      // mAlloc(m_cCube, noInternalCells, nDim, "m_cCube", F0, AT_);
      // mAlloc(m_tCube, noInternalCells, nDim, "m_tCube", F0, AT_);
      // mAlloc(m_yCube, noInternalCells, nDim, "m_yCube", F0, AT_);
    }
  }
}

initAveragingProperties()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initAveragingProperties ( )

protectedvirtual

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 in PostProcessingFv< nDim, SysEqn >.

initCorrelation()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initCorrelation

protected

Definition at line 1179 of file postprocessing.cpp.

                                                   {
  TRACE();
 
  if(!postData().grid().isActive()) return;
 
  GridProxy* gridProxy = &postData().grid();
 
  // Read properties
  m_noCorrelationLines = Context::propertyLength("pp_correlationDirection", m_postprocessingId);
  if(m_noCorrelationLines <= 0) {
    TERMM(1, "Error: line probing activated but number of probe line directions is "
                 + std::to_string(m_noCorrelationLines) + "!");
  }
 
  mAlloc(m_correlationDirection, m_noCorrelationLines, "m_correlationDirection", AT_);
  mAlloc(m_correlationVariableIndex, m_noCorrelationLines, "m_correlationVariableIndex", AT_);
 
  for(MInt correlationId = 0; correlationId < m_noCorrelationLines; correlationId++) {
    m_correlationDirection[correlationId] =
        Context::getSolverProperty<MInt>("pp_correlationDirection", m_postprocessingId, AT_, correlationId);
    if(m_correlationDirection[correlationId] < 0 || m_correlationDirection[correlationId] >= nDim) {
      m_log << "invalid value for property correlationDirection: " << m_correlationDirection << " at position "
            << correlationId << endl;
    }
    m_correlationVariableIndex[correlationId] =
        Context::getSolverProperty<MInt>("pp_correlationVariableIndex", m_postprocessingId, AT_, correlationId);
  }
 
  ScratchSpace<MInt> correlationDir(m_noCorrelationLines, (nDim - 1), AT_, "correlationDir");
  mAlloc(m_correlationCoordinates, m_noCorrelationLines, (nDim - 1), "m_correlationCoordinates", AT_);
 
  for(MInt correlationId = 0; correlationId < m_noCorrelationLines; correlationId++) {
    if(m_correlationDirection[correlationId] == 0) {
      correlationDir(correlationId, 0) = 1;
    } else {
      correlationDir(correlationId, 0) = 0;
    }
    m_correlationCoordinates[correlationId][0] = Context::getSolverProperty<MFloat>(
        "pp_correlationCoordinates", m_postprocessingId, AT_, (nDim - 1) * correlationId);
    IF_CONSTEXPR(nDim == 3) {
      if(m_correlationDirection[correlationId] == 2) {
        correlationDir(correlationId, 1) = 1;
      } else {
        correlationDir(correlationId, 1) = 2;
      }
      m_correlationCoordinates[correlationId][1] = Context::getSolverProperty<MFloat>(
          "pp_correlationCoordinates", m_postprocessingId, AT_, 2 * correlationId + 1);
    }
  }
 
  for(MInt correlationId = 0; correlationId < m_noCorrelationLines; correlationId++) {
    m_log << "correlation in correlation function direction " << m_correlationDirection[correlationId]
          << " with correlationCorrelationDirection "
          << "m_noCorrelationLines is " << m_noCorrelationLines;
    m_log << std::endl;
  }
  mAlloc(m_noCorrelationIds, m_noCorrelationLines, "m_noCorrelationIds", AT_);
  mAlloc(m_correlationIds, m_noCorrelationLines, "m_correlationIds", AT_);
  mAlloc(m_correlationExchangeVar, m_noCorrelationLines, "m_correlationExchangeVar", AT_);
  mAlloc(m_correlationExchangeVarMean, m_noCorrelationLines, "m_correlationExchangeVarMean", AT_);
  mAlloc(m_correlationExchangeVarRMS, m_noCorrelationLines, "m_correlationExchangeVarRMS", AT_);
  mAlloc(m_correlationPositions, m_noCorrelationLines, "m_correlationPositions", AT_);
  mAlloc(m_globalNoCorrelationIds, m_noCorrelationLines, "m_globalNoCorrelationIds", AT_);
 
  // suppress valgrind error
  for(MInt i = 0; i < m_noCorrelationLines; i++) {
    m_correlationIds[i] = nullptr;
    m_correlationPositions[i] = nullptr;
  }
 
  for(MInt correlationId = 0; correlationId < m_noCorrelationLines; correlationId++) {
    map<MFloat, MInt, coord_comp_1d_> coordinates;
    std::vector<MFloat> coord(nDim, std::numeric_limits<MFloat>::max());
    MFloat halfCellLength = NAN;
    MBool ok;
    MBool ok2;
    MBool nghbrFound;
    for(MInt cellId = 0; cellId < postData().grid().noInternalCells(); cellId++) {
      if(gridProxy->tree().noChildren(cellId) > 0) continue; // skip non leaf cells
      for(MInt dim = 0; dim < nDim; dim++) {
        coord[dim] = postData().c_coordinate(cellId, dim);
      }
      ok = true;
      ok2 = true;
      nghbrFound = false;
 
      halfCellLength = gridProxy->halfCellLength(cellId);
      for(MInt i = 0; i < nDim - 1; i++) {
        // check if distance is greater than half of the cell length (in direction i)
        if(abs(m_correlationCoordinates[correlationId][i] - coord[correlationDir(correlationId, i)])
           >= halfCellLength) {
          ok = false;
        }
 
        // check if distance is a bit more than half of the cell length (line between cells)
        if(abs(m_correlationCoordinates[correlationId][i] - coord[correlationDir(correlationId, i)])
           < (halfCellLength + MFloatEps)) {
          for(MInt dirId = 0; dirId < 2 * nDim; dirId++) {
            if(dirId == 2 * m_correlationDirection[correlationId]
               || dirId == 2 * m_correlationDirection[correlationId] + 1) {
              continue;
            }
            if(gridProxy->tree().hasNeighbor(cellId, dirId) != 1) {
              continue;
            }
            MInt nId = gridProxy->tree().neighbor(cellId, dirId);
            // check if neighbor cell is already in the probe line
            if(coordinates.find(postData().c_coordinate(nId, m_correlationDirection[correlationId]))
               != coordinates.end()) {
              nghbrFound = true;
            }
          }
        } else {
          ok2 = false;
        }
      }
      if(ok || (ok2 && !nghbrFound)) {
        if(postData().a_isBndryGhostCell(cellId)) continue;
        coordinates[coord[m_correlationDirection[correlationId]]] = cellId;
      }
    }
 
    m_noCorrelationIds[correlationId] = coordinates.size(); // local number of cells
 
    if(m_noCorrelationIds[correlationId] > 0) {
      mAlloc(m_correlationIds[correlationId], m_noCorrelationIds[correlationId], "m_correlationIds", AT_);
      mAlloc(m_correlationPositions[correlationId], m_noCorrelationIds[correlationId], "m_correlationPositions", AT_);
    } else {
      // Allocate dummy array to avoid errors when dereferencing during writing
      mAlloc(m_correlationIds[correlationId], 1, "m_correlationIds", AT_);
      mAlloc(m_correlationPositions[correlationId], 1, "m_correlationPositions", AT_);
    }
    auto it = coordinates.begin();
    for(MInt i = 0; it != coordinates.end(); it++, i++) {
      m_correlationIds[correlationId][i] = (*it).second;
      m_correlationPositions[correlationId][i] = (*it).first;
    }
  }
 
  // fill global arrays
  MPI_Allreduce(m_noCorrelationIds, m_globalNoCorrelationIds, m_noCorrelationLines, MPI_INT, MPI_SUM,
                postData().mpiComm(), AT_, "m_noCorrelationIds", "m_globalNoCorrelationIds");
 
  MInt maxGlobalNoCorrelationIds = 0;
  for(MInt correlationId = 0; correlationId < m_noCorrelationLines; correlationId++) {
    if(m_globalNoCorrelationIds[correlationId] >= maxGlobalNoCorrelationIds) {
      maxGlobalNoCorrelationIds = m_globalNoCorrelationIds[correlationId];
    }
  }
 
  mAlloc(m_globalCorrelationIds, m_noCorrelationLines, maxGlobalNoCorrelationIds, "m_globalCorrelationIds", 0, AT_);
  mAlloc(m_globalCorrelationPositions, m_noCorrelationLines, maxGlobalNoCorrelationIds, "m_globalCorrelationPositions",
         F0, AT_);
  mAlloc(m_globalCorrelationExchangeVar, m_noCorrelationLines, maxGlobalNoCorrelationIds,
         "m_globalCorrelationExchangeVar", F0, AT_);
  mAlloc(m_globalCorrelationExchangeVarMean, m_noCorrelationLines, maxGlobalNoCorrelationIds,
         "m_globalCorrelationExchangeVarMean", F0, AT_);
  mAlloc(m_globalCorrelationExchangeVarRMS, m_noCorrelationLines, maxGlobalNoCorrelationIds,
         "m_globalCorrelationExchangeVarRMS", F0, AT_);
 
  // create mapping for cells
  mAlloc(m_correlationIndexMapping, m_noCorrelationLines, postData().noInternalCells(), "m_correlationIndexMapping", -1,
         AT_);
 
 
  for(MInt correlationId = 0; correlationId < m_noCorrelationLines; correlationId++) {
    MInt noDomain = postData().noDomains();
    ScratchSpace<MInt> recvbuf(noDomain, "recvbuf", AT_);
    recvbuf.fill(0);
 
    MPI_Gather(&m_noCorrelationIds[correlationId], 1, MPI_INT, &recvbuf[0], 1, MPI_INT, 0, postData().mpiComm(), AT_,
               "m_noCorrelationIds[correlationId]", "postData().noDomain()");
 
    ScratchSpace<MInt> displs(noDomain, "displs", AT_);
    if(postData().domainId() == 0) {
      MInt offset = 0;
      for(MInt dom = 0; dom < noDomain; dom++) {
        displs[dom] = offset;
        offset += recvbuf[dom];
      }
    }
 
    MPI_Gatherv(&m_correlationIds[correlationId][0], m_noCorrelationIds[correlationId], MPI_INT,
                &m_globalCorrelationIds[correlationId][0], &recvbuf[postData().domainId()],
                &displs[postData().domainId()], MPI_INT, 0, postData().mpiComm(), AT_, "m_correlationIds",
                "m_globalCorrelationIds");
 
    MPI_Gatherv(&m_correlationPositions[correlationId][0], m_noCorrelationIds[correlationId], MPI_DOUBLE,
                &m_globalCorrelationPositions[correlationId][0], &recvbuf[postData().domainId()],
                &displs[postData().domainId()], MPI_DOUBLE, 0, postData().mpiComm(), AT_, "m_correlationPositions",
                "m_globalCorrelationPositions");
 
    MPI_Bcast(m_globalCorrelationIds[correlationId], m_globalNoCorrelationIds[correlationId], MPI_INT, 0,
              postData().mpiComm(), AT_, "m_probeLineAverageCoordinates");
 
    MPI_Bcast(m_globalCorrelationPositions[correlationId], m_globalNoCorrelationIds[correlationId], MPI_DOUBLE, 0,
              postData().mpiComm(), AT_, "m_globalCorrelationPositions");
 
    mAlloc(m_correlationExchangeVar[correlationId], postData().grid().noInternalCells(),
           "m_correlationExchangeVar[correlationId]", AT_);
    mAlloc(m_correlationExchangeVarMean[correlationId], postData().grid().noInternalCells(),
           "m_correlationExchangeVarMean[correlationId]", AT_);
    mAlloc(m_correlationExchangeVarRMS[correlationId], postData().grid().noInternalCells(),
           "m_correlationExchangeVarRMS[correlationId]", AT_);
 
    for(MInt dataId = 0; dataId < postData().noInternalCells(); dataId++) {
      MFloat dataPosition = postData().c_coordinate(dataId, m_correlationDirection[correlationId]);
      MFloat smallerDist = std::numeric_limits<MFloat>::max();
      MFloat biggerDist = std::numeric_limits<MFloat>::max();
      MInt index1 = -1;
      MInt index2 = -1;
      for(MInt i = 0; i < m_globalNoCorrelationIds[correlationId]; i++) {
        MFloat corrPosition = m_globalCorrelationPositions[correlationId][i];
        // change this
        if(m_correlationIndexMapping[correlationId][dataId] == -1) {
          MFloat dist = abs(corrPosition - dataPosition);
          if(corrPosition <= dataPosition && dist < smallerDist) {
            smallerDist = dist;
            index1 = i;
          }
          if(corrPosition > dataPosition && dist < biggerDist) {
            biggerDist = dist;
            index2 = i;
          }
        }
      }
 
      if(smallerDist <= biggerDist) {
        m_correlationIndexMapping[correlationId][dataId] = index1;
      } else {
        m_correlationIndexMapping[correlationId][dataId] = index2;
      }
    }
  }
}

initIsoTurbulenceStatistics()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initIsoTurbulenceStatistics ( )

inlineprotectedvirtual

Reimplemented in PostProcessingLb< nDim >.

Definition at line 167 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initLPTSolutionFile()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initLPTSolutionFile ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFvLPT< nDim, SysEqn >, PostProcessingLbLPT< nDim >, and PostProcessingLPT< nDim >.

Definition at line 137 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initMovingAverage()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initMovingAverage ( )

protectedvirtual

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 in PostProcessingFv< nDim, SysEqn >.

initParticleStatistics()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initParticleStatistics ( )

inlineprotectedvirtual

Reimplemented in PostProcessingLbLPT< nDim >, and PostProcessingLPT< nDim >.

Definition at line 139 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initPeriodicSliceAverage()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initPeriodicSliceAverage

protected

Author

Jannik Borgelt

Date

10.2023

Template Parameters

in] T celltype

Definition at line 3169 of file postprocessing.cpp.

                                                            {
  TRACE();
 
  if(!postData().grid().isActive()) return;
 
  MInt noSlicePositions = 0;
  std::multimap<MFloat, MFloat> slicePositions;
 
  std::vector<MFloat> coord(2, F0);
  for(MInt cellId = 0; cellId < postData().c_noCells(); cellId++) {
    if(postData().c_noChildren(cellId) > 0) continue; // skip non leaf cells
    if(postData().a_isHalo(cellId)) continue;         // skip halo cells
    coord[0] = postData().c_coordinate(cellId, 0);
    coord[1] = postData().c_coordinate(cellId, 1);
 
    // see if coord is already present
    MInt count = slicePositions.count(coord[0]);
 
    if(count > 0) {
      MBool alreadyInserted = false;
      for(auto it = slicePositions.equal_range(coord[0]).first; it != slicePositions.equal_range(coord[0]).second;
          ++it) {
        if(approx((*it).second, coord[1], 1e-16)) {
          alreadyInserted = true;
        }
      }
      if(!alreadyInserted) {
        slicePositions.insert(std::make_pair(coord[0], coord[1]));
        noSlicePositions++;
      }
    } else {
      // insert
      slicePositions.insert(std::make_pair(coord[0], coord[1]));
      noSlicePositions++;
    }
  }
 
  // debug output slicePositions
  //----------------------------------------------------------------------------
  // stringstream fn;
  // fn.clear();
  // fn << "slicePositions_" << postData().domainId() << ".txt";
  // MString fname = fn.str();
  // ofstream slicePositionsOutput;
  // slicePositionsOutput.precision(16);
  // slicePositionsOutput.open(fname);
  // for(auto it = slicePositions.begin(); it != slicePositions.end(); ++it){
  //   MString line = "";
  //   line.append(to_string((*it).first) + " " + to_string((*it).second) + " " + to_string(postData().domainId()));
  //   slicePositionsOutput << line << endl;
  // }
  // slicePositionsOutput.close();
  //----------------------------------------------------------------------------
 
  // exchange multimap
  MFloatScratchSpace posX(noSlicePositions, AT_, "posX");
  MFloatScratchSpace posY(noSlicePositions, AT_, "posY");
  MInt count_ = 0;
  for(auto it = slicePositions.begin(); it != slicePositions.end(); ++it) {
    posX[count_] = (*it).first;
    posY[count_] = (*it).second;
    count_++;
  }
 
  MPI_Allreduce(&noSlicePositions, &m_globalnoSlicePositions, 1, MPI_INT, MPI_SUM, postData().mpiComm(), AT_,
                "noSlicePositions", "m_globalnoSlicePositions");
 
  MFloatScratchSpace globalPosX(m_globalnoSlicePositions, AT_, "globalPosX");
  MFloatScratchSpace globalPosY(m_globalnoSlicePositions, AT_, "globalPosY");
 
  ScratchSpace<MInt> recvbuf(postData().noDomains(), "recvbuf", FUN_);
  recvbuf.fill(0);
  MPI_Gather(&noSlicePositions, 1, MPI_INT, &recvbuf[0], 1, MPI_INT, 0, postData().mpiComm(), AT_, "noSlicePositions",
             "recvbuf");
 
  ScratchSpace<MInt> displs(postData().noDomains(), "displspos", FUN_);
  if(postData().domainId() == 0) {
    MInt offset = 0;
    for(MInt dom = 0; dom < postData().noDomains(); dom++) {
      displs[dom] = offset;
      offset += recvbuf[dom];
    }
  }
 
  MPI_Gatherv(&posX[0], noSlicePositions, MPI_DOUBLE, &globalPosX[0], &recvbuf[0], &displs[postData().domainId()],
              MPI_DOUBLE, 0, postData().mpiComm(), AT_, "posX", "globalPosX");
  MPI_Gatherv(&posY[0], noSlicePositions, MPI_DOUBLE, &globalPosY[0], &recvbuf[0], &displs[postData().domainId()],
              MPI_DOUBLE, 0, postData().mpiComm(), AT_, "posY", "globalCountZ");
  MPI_Bcast(&globalPosX[0], m_globalnoSlicePositions, MPI_DOUBLE, 0, postData().mpiComm(), AT_, "globalPosX");
  MPI_Bcast(&globalPosY[0], m_globalnoSlicePositions, MPI_DOUBLE, 0, postData().mpiComm(), AT_, "globalPosY");
 
  // find double entries
  for(MInt i = 0; i < m_globalnoSlicePositions; i++) {
    coord[0] = globalPosX[i];
    coord[1] = globalPosY[i];
 
    // see if coord is already present
    MInt count = m_sliceGlobalPositions.count(coord[0]);
    if(count > 0) {
      MBool alreadyInserted = false;
      for(auto it = m_sliceGlobalPositions.equal_range(coord[0]).first;
          it != m_sliceGlobalPositions.equal_range(coord[0]).second;
          ++it) {
        if(approx((*it).second, coord[1], 1e-16)) {
          alreadyInserted = true;
          break;
        }
      }
      if(!alreadyInserted) {
        m_sliceGlobalPositions.insert(std::make_pair(coord[0], coord[1]));
      }
    } else {
      // insert
      m_sliceGlobalPositions.insert(std::make_pair(coord[0], coord[1]));
    }
  }
 
  m_globalnoSlicePositions = m_sliceGlobalPositions.size();
 
  mAlloc(m_sliceAverage, postData().noVariables(), m_globalnoSlicePositions, "m_sliceAverage", AT_);
  for(MInt i = 0; i < m_globalnoSlicePositions; i++) {
    for(MInt varId = 0; varId < postData().noVariables(); varId++) {
      m_sliceAverage[varId][i] = F0;
    }
  }
 
  // determine index of cells in globalPos
  mAlloc(m_cell2globalIndex, m_globalnoSlicePositions, "m_cell2globalIndex", AT_);
  mAlloc(m_noPeriodicSliceCells, m_globalnoSlicePositions, "m_noPeriodicSliceCells", 0, AT_);
  for(MInt cellId = 0; cellId < postData().c_noCells(); cellId++) {
    if(postData().c_noChildren(cellId) > 0) continue; // skip non leaf cells
    if(postData().a_isHalo(cellId)) continue;         // skip halo cells
    MFloat x = postData().c_coordinate(cellId, 0);
    MFloat y = postData().c_coordinate(cellId, 1);
    MInt index = 0;
    for(auto it = m_sliceGlobalPositions.begin(); it != m_sliceGlobalPositions.end(); ++it) {
      if(approx((*it).first, x, 1e-16) && approx((*it).second, y, 1e-16)) {
        m_cell2globalIndex[index].push_back(cellId);
        m_noPeriodicSliceCells[index]++;
        break;
      }
      index++;
    }
  }
 
  MPI_Allreduce(MPI_IN_PLACE, &m_noPeriodicSliceCells[0], m_globalnoSlicePositions, MPI_INT, MPI_SUM,
                postData().mpiComm(), AT_, "MPI_IN_PLACE,", "m_noPeriodicSliceCells");
 
#ifndef NDEBUG
  // debug output slicePositions
  //----------------------------------------------------------------------------
  if(postData().domainId() == 0) {
    stringstream fng;
    fng.clear();
    fng << "sliceGlobalPositions.txt";
    MString fnameg = fng.str();
    ofstream sliceGlobalPositionsOutput;
    sliceGlobalPositionsOutput.precision(16);
    sliceGlobalPositionsOutput.open(fnameg);
    MInt index = 0;
    for(auto it = m_sliceGlobalPositions.begin(); it != m_sliceGlobalPositions.end(); ++it) {
      MString line = "";
      line.append(to_string((*it).first) + " " + to_string((*it).second) + " "
                  + to_string(m_noPeriodicSliceCells[index]));
      index++;
      sliceGlobalPositionsOutput << line << endl;
    }
    sliceGlobalPositionsOutput.close();
  }
  //----------------------------------------------------------------------------
#endif
}

initPLIsoTurbulenceStatistics()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initPLIsoTurbulenceStatistics ( )

inlineprotectedvirtual

Reimplemented in PostProcessingLbLPT< nDim >.

Definition at line 143 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initPointSamplingData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initPointSamplingData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, and PostProcessingLb< nDim >.

Definition at line 161 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initPostProcessing()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initPostProcessing ( )

overridevirtual

Author

Andreas Lintermann

Date

12.09.2012_" + to_string(m_postprocessingId)

Implements PostProcessingInterface.

initProbeArbitraryLine()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initProbeArbitraryLine ( )

protected

Author

Ansgar Niemoeller

Date

07.06.2014

Parameters

[in]

grid

pointer to the grid

initProbeArbitrarySlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initProbeArbitrarySlice ( )

protected

Author

Ansgar Niemoeller, Sven Berger

Date

07.06.2014

Parameters

[in]

grid

pointer to the grid

initProbeLine()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initProbeLine ( )

protected

Author

A. Niemoeller

Date

09.12.2013

reads properties probeLineDirection and probeLineCoordinates which define a line (or multiple lines) in the specified direction with fixed coordinate(s) in the other dimensions
assembles all cell Ids for probing and communicates data for later line probing

Parameters

[in]

grid

pointer to the grid

initProbeLinePeriodic()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initProbeLinePeriodic

protected

Definition at line 1810 of file postprocessing.cpp.

                                                         {
  TRACE();
 
  if(!pp->solver().grid().isActive()) return;
 
  mAlloc(m_probeLinePeriodic, m_noProbeLines, "m_probeLinePeriodic", AT_);
 
  for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) { // read all probe line directions
    m_probeLinePeriodic[probeLineId] =
        Context::getSolverProperty<MInt>("pp_probeLinePeriodic", m_postprocessingId, AT_, probeLineId);
  }
 
  for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) { // write all lines to log
    m_log << "probeLine in periodic direction " << m_probeLinePeriodic[probeLineId] << " with probeLinePeriodic ";
    m_log << endl;
  }
 
  const MInt noVars = m_noVariables    // primitive variables
                      + 3 * (nDim - 1) // Reynolds stress components
                      + 1;             // pressure amplitude p'
 
  ScratchSpace<MInt> lineDir(m_noProbeLines, (nDim - 1), AT_, "lineDir");
 
  m_noProbeLineAverageSteps = 0;
 
  mAlloc(m_probeLineAverageDirection, m_noProbeLines, "m_probeLineAverageDirection", AT_);
 
  vector<vector<MFloat>> probeLineAverageCoordinates_temp{};
 
  MInt id = -1;
  for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) { // loop over all probe lines
    m_probeLineAverageDirection[probeLineId] = m_probeLinePeriodic[probeLineId];
    vector<MFloat> temp{};
    vector<MInt> sign{};
    for(MInt i = 0; i < m_noProbeLineIds[probeLineId]; i++) {
      MInt probeId = m_probeLineIds[probeLineId][i];
      id++;
      // periodic direction has to be z-direction
      MFloat pos = m_gridProxy->tree().coordinate(probeId, m_probeLineDirection[probeLineId]);
      temp.emplace_back(pos);
    }
 
    probeLineAverageCoordinates_temp.emplace_back(temp);
  }
 
  // Assumes constant mesh in periodic direction
  mAlloc(m_probeLineAverageCoordinates, m_noProbeLines, m_globalNoProbeLineIds[0], "m_probeLineAverageCoordinates", F0,
         AT_);
 
  for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) {
    MInt noDomain = pp->solver().noDomains();
    ScratchSpace<MInt> recvbuf(noDomain, "recvbuf", AT_);
    recvbuf.fill(0);
 
    MPI_Gather(&m_noProbeLineIds[probeLineId], 1, MPI_INT, &recvbuf[0], 1, MPI_INT, 0, pp->solver().mpiComm(), AT_,
               "m_noProbeLineIds[probeLineId]", "ppblock()->noDomain()");
 
    ScratchSpace<MInt> displs(noDomain, "displs", AT_);
    if(pp->solver().domainId() == 0) {
      MInt offset = 0;
      for(MInt dom = 0; dom < noDomain; dom++) {
        displs[dom] = offset;
        offset += recvbuf[dom];
      }
    }
 
    MPI_Gatherv(&probeLineAverageCoordinates_temp[probeLineId][0], m_noProbeLineIds[probeLineId], MPI_DOUBLE,
                &m_probeLineAverageCoordinates[probeLineId][0], &recvbuf[pp->solver().domainId()],
                &displs[pp->solver().domainId()], MPI_DOUBLE, 0, pp->solver().mpiComm(), AT_,
                "probeLineAverageCoordinates_temp", "m_probeLineAverageCoordinates");
 
    MPI_Bcast(m_probeLineAverageCoordinates[probeLineId], m_globalNoProbeLineIds[probeLineId], MPI_DOUBLE, 0,
              pp->solver().mpiComm(), AT_, "m_probeLineAverageCoordinates");
  }
 
  mAlloc(m_noProbeLineAverageIds, m_noProbeLines, m_globalNoProbeLineIds[0], "m_noProbeLineAverageIds", 0, AT_);
  mAlloc(m_probeLineAverageIds, m_noProbeLines, m_globalNoProbeLineIds[0], "m_probeLineAverageIds", AT_);
  mAlloc(m_probeLineAveragePositions, m_noProbeLines, m_globalNoProbeLineIds[0], "m_probeLineAveragePositions", AT_);
  mAlloc(m_globalNoProbeLineAverageIds, m_noProbeLines, m_globalNoProbeLineIds[0], "m_globalNoProbeLineAverageIds", 0,
         AT_);
  mAlloc(m_globalProbeLineAverageVars, m_noProbeLines, m_globalNoProbeLineIds[0], "m_globalProbeLineAverageVars", AT_);
 
 
  for(MInt probeLineId = 0; probeLineId < m_noProbeLines; probeLineId++) {
    m_probeLineAverageDirection[probeLineId] = m_probeLinePeriodic[probeLineId];
 
    for(MInt p = 0; p < m_globalNoProbeLineIds[probeLineId]; p++) {
      TERMM_IF_COND(nDim == 2, "FIXME: the size of periodicCoordiantes was nDim-1, for 2D the below code was writing "
                               "out of array bounds. Check if the code works as intended.");
      vector<MFloat> periodicCoordiantes(nDim);
 
      periodicCoordiantes[0] = m_probeLineCoordinates[probeLineId][0];
      periodicCoordiantes[1] = m_probeLineAverageCoordinates[probeLineId][p];
 
      // currently only possible for periodic in z-direction
      lineDir(probeLineId, 0) = m_probeLineDirection[probeLineId] == 0 ? 1 : 0;
      lineDir(probeLineId, 1) = m_probeLineDirection[probeLineId] == 0 ? 0 : 1;
 
      map<MFloat, MInt, coord_comp_1d_> coordinates;
      const MFloat* coord;
      MFloat halfCellLength;
      MBool ok, ok2, nghbrFound;
 
      for(MInt cellId = 0; cellId < pp->solver().grid().noInternalCells(); cellId++) {
        if(m_gridProxy->tree().noChildren(cellId) > 0) continue; // skip non leaf cells
        coord = &pp->solver().a_coordinate(cellId, 0);
        ok = true;
        ok2 = true;
        nghbrFound = false;
 
        halfCellLength = m_gridProxy->halfCellLength(cellId);
 
        for(MInt i = 0; i < nDim - 1; i++) {
          // check if distance is greater than half of the cell length (in direction i)
          if(abs(periodicCoordiantes[i] - coord[lineDir(probeLineId, i)]) >= halfCellLength) ok = 0;
 
          // check if distance is a bit more than half of the cell length (line between cells)
          if(abs(periodicCoordiantes[i] - coord[lineDir(probeLineId, i)]) < (halfCellLength + MFloatEps)) {
            for(MInt dirId = 0; dirId < 2 * nDim; dirId++) { // check all directions (x-,x+,...)
              if(dirId == 2 * m_probeLineAverageDirection[probeLineId]
                 || dirId == 2 * m_probeLineAverageDirection[probeLineId] + 1) { // skip line directions
                continue;
              }
              if(m_gridProxy->tree().hasNeighbor(cellId, dirId)
                 != 1) { // skip if cells has no equal level neighbor in direction dirId
                continue;
              }
              MInt nId = m_gridProxy->tree().neighbor(cellId, dirId);
              // check if neighbor cell is already in the probe line
              if(coordinates.find(pp->solver().a_coordinate(nId, m_probeLineAverageDirection[probeLineId]))
                 != coordinates.end()) {
                nghbrFound = true;
              }
            }
          } else {
            ok2 = false;
          }
        }
        if(ok || (ok2 && !nghbrFound)) {
          if(pp->solver().a_isBndryGhostCell(cellId)) continue;
          coordinates[coord[m_probeLineAverageDirection[probeLineId]]] = cellId;
        }
      }
 
      m_noProbeLineAverageIds[probeLineId][p] = coordinates.size(); // local number of cells
 
      if(m_noProbeLineAverageIds[probeLineId][p] > 0) {
        mAlloc(m_probeLineAverageIds[probeLineId][p], m_noProbeLineAverageIds[probeLineId][p],
               "m_probeLineAverageIds[probeLineId][p]", AT_);
        mAlloc(m_probeLineAveragePositions[probeLineId][p], m_noProbeLineAverageIds[probeLineId][p],
               "m_probeLineAveragePositions[probeLineId][p]", AT_);
      } else {
        // Allocate dummy array to avoid errors when dereferencing during writing
        mAlloc(m_probeLineAveragePositions[probeLineId][p], 1, "m_probeLineAveragePositions", AT_);
      }
 
      auto it = coordinates.begin();
      for(MInt i = 0; it != coordinates.end(); it++, i++) {
        m_probeLineAverageIds[probeLineId][p][i] = (*it).second;
        m_probeLineAveragePositions[probeLineId][p][i] = (*it).first;
      }
 
      MPI_Allreduce(&m_noProbeLineAverageIds[probeLineId][p], &m_globalNoProbeLineAverageIds[probeLineId][p], 1,
                    MPI_INT, MPI_SUM, pp->solver().mpiComm(), AT_, "m_noProbeLineAverageIds",
                    "m_globalNoProbeLineAverageIds");
 
      mAlloc(m_globalProbeLineAverageVars[probeLineId][p], noVars, "m_globalProbeLineAverageVars[probeLineId][p]", F0,
             AT_);
 
      for(MInt varId = 0; varId < m_noVariables; varId++) {
        m_globalProbeLineAverageVars[probeLineId][p][varId] = F0;
      }
    }
  }
}

initProbePoint()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initProbePoint ( )

protected

Author

Andreas Lintermann

Date

14.09.2012

Template Parameters

in] T celltype

Parameters

[in]

grid

pointer to the grid

initProbeSlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initProbeSlice ( )

protected

Author

A. Niemoeller

Date

09.12.2013

reads properties probeSliceDir1 / probeSliceDir2 and probeSliceCoordinate which define a slice (or multiple slices) in the specified directions with fixed coordinate in the remaining dimension
assembles all cell Ids for probing and communicates data for later slice probing

Parameters

[in]

grid

pointer to the grid

initReduceToLevelAvg()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initReduceToLevelAvg

protected

Author

Andreas Lintermann

Date

14.09.2012

Template Parameters

in] T celltype

Definition at line 3147 of file postprocessing.cpp.

                                                        {
  TRACE();
 
  m_ReStressesAverageFileName = "";
  m_ReStressesAverageFileName = Context::getSolverProperty<MString>("pp_ReStressesAverageFileName", m_postprocessingId,
                                                                    AT_, &m_ReStressesAverageFileName);
  if(m_ReStressesAverageFileName.empty()) {
    mTerm(1, AT_, "Please specify the property 'ReStressesAverageFileName' ...");
  }
}

initSpatialAveraging()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initSpatialAveraging ( )

protected

initSprayData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initSprayData ( )

protectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, PostProcessingFvLPT< nDim, SysEqn >, and PostProcessingLPT< nDim >.

initSurfaceSamplingData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initSurfaceSamplingData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, and PostProcessingLb< nDim >.

Definition at line 163 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initTimeStepProperties()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initTimeStepProperties ( )

protected

Author

Andreas Lintermann (last modified Ansgar Niemoeller, 07/14)

Date

14.09.2012

reads properties pp_averageStartTimestep, pp_averageStopTimestep and pp_averageInterval

Template Parameters

in] Solver solvertype

initTimeStepPropertiesLine()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initTimeStepPropertiesLine ( )

protected

initTimeStepPropertiesSlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initTimeStepPropertiesSlice ( )

protected

initVolumeSamplingData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::initVolumeSamplingData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, and PostProcessingLb< nDim >.

Definition at line 165 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

initWritePointData()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::initWritePointData ( )

protected

isActive()

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::isActive ( ) const

inlineprotected

Definition at line 111 of file postprocessing.h.

{ return pp->solver().grid().isActive(); };

isMeanFile()

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::isMeanFile ( )

inlineprotected

Definition at line 310 of file postprocessing.h.

                     {
    if(m_postData == nullptr ||
       // necessary for postprocessing without postdata
       postData().m_solverId == pp->solver().m_solverId) {
      return false;
    } else {
      return postData().isMeanFile();
    }
  }

movePointsToGrid()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::movePointsToGrid ( MFloat *  in_points, MInt  in_noPoints, MInt  in_moveType  )

protected

movingAverage()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::movingAverage ( )

protected

movingAveragePost()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::movingAveragePost ( )

protected

mSolver()

template<MInt nDim, class ppType >

Solver * PostProcessing< nDim, ppType >::mSolver ( ) const

inlineoverridevirtual

Implements PostProcessingInterface.

Definition at line 106 of file postprocessing.h.

{ return static_cast<Solver*>(&pp->solver()); };

neededMeanVarsForSourceTerm()

template<MInt nDim, class ppType >

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

protected

Definition at line 3406 of file postprocessing.cpp.

                                                                                                {
  TRACE();
 
  meanVars.clear();
  switch(sourceTerm) {
    case ST::Q_mI:
      // Mean Lamb vector
      meanVars.push_back(MV::LAMB0);
      break;
    case ST::Q_mI_linear:
      // Mean vorticities
      meanVars.push_back(MV::VORT0);
      break;
    case ST::Q_mII:
      // Mean gradient of rho
      meanVars.push_back(MV::DRHO);
 
      // Mean gradient of p
      meanVars.push_back(MV::DP);
 
      // Mean of (gradient of p divided by rho)
      meanVars.push_back(MV::GRADPRHO);
      break;
    case ST::Q_mIII:
      // Mean gradients of velocity components (contains MV::DU)
      meanVars.push_back(MV::GRADU);
 
      // Sum of products of velocity and velocity gradients:
      // u * grad(u) + v * grad(v) + w * grad(w)
      meanVars.push_back(MV::UGRADU);
      break;
    case ST::Q_e:
      // Components of divergence of u
      meanVars.push_back(MV::DU);
 
      // Mean gradient of rho
      meanVars.push_back(MV::DRHO);
 
      // Mean gradient of p
      meanVars.push_back(MV::DP);
      break;
    case ST::Q_c:
      // Components of divergence of u
      meanVars.push_back(MV::DU);
 
      // Mean gradient of rho
      meanVars.push_back(MV::DRHO);
 
      // Mean gradient of rho*div(u)
      meanVars.push_back(MV::RHODIVU);
 
      // Mean gradient of u*grad(rho)
      meanVars.push_back(MV::UGRADRHO);
      break;
    default:
      TERMM(1, "Source term '" + s_sourceTermNames[sourceTerm] + "' not implemented yet.");
      break;
  }
}

periodicSliceAverage()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::periodicSliceAverage

protected

Definition at line 3344 of file postprocessing.cpp.

                                                        {
  TRACE();
 
  if(!postData().grid().isActive()) return;
 
  postData().loadMeanFile(m_postprocessFileName);
 
  if(postData().domainId() == 0) cerr << "Calculating periodic average" << endl;
 
  for(MInt i = 0; i < m_globalnoSlicePositions; i++) {
    for(MInt c = 0; c < (MInt)m_cell2globalIndex[i].size(); c++) {
      MInt cellId = m_cell2globalIndex[i][c];
      for(MInt varId = 0; varId < postData().noVariables(); varId++) {
        m_sliceAverage[varId][i] += postData().m_averagedVars[cellId][varId] / m_noPeriodicSliceCells[i];
      }
    }
  }
 
  // exchange sliceAverage
  for(MInt varId = 0; varId < postData().noVariables(); varId++) {
    MPI_Allreduce(MPI_IN_PLACE, &m_sliceAverage[varId][0], m_globalnoSlicePositions, MPI_DOUBLE, MPI_SUM,
                  postData().mpiComm(), AT_, "MPI_IN_PLACE", "m_sliceAverage");
  }
 
  for(MInt i = 0; i < m_globalnoSlicePositions; i++) {
    for(MInt c = 0; c < (MInt)m_cell2globalIndex[i].size(); c++) {
      MInt cellId = m_cell2globalIndex[i][c];
      for(MInt varId = 0; varId < postData().noVariables(); varId++) {
        postData().a_variable(cellId, varId) = m_sliceAverage[varId][i];
      }
    }
  }
 
  postData().saveRestartFile(false);
 
 
#ifndef NDEBUG
  // debug output sliceAverage
  //----------------------------------------------------------------------------
  if(postData().domainId() == 0) {
    stringstream fng;
    fng.clear();
    fng << "sliceAverage_" << postData().domainId() << ".txt";
    MString fnameg = fng.str();
    ofstream sliceGlobalPositionsOutput;
    sliceGlobalPositionsOutput.precision(16);
    sliceGlobalPositionsOutput.open(fnameg);
    MInt i = 0;
    for(auto it = m_sliceGlobalPositions.begin(); it != m_sliceGlobalPositions.end(); ++it) {
      MString line = "";
      line.append(to_string((*it).first) + " " + to_string((*it).second) + " " + to_string(m_noPeriodicSliceCells[i])
                  + " " + to_string(m_sliceAverage[0][i]));
      i++;
      sliceGlobalPositionsOutput << line << endl;
    }
    sliceGlobalPositionsOutput.close();
  }
  //----------------------------------------------------------------------------
#endif
}

postData()

template<MInt nDim, class ppType >

Data & PostProcessing< nDim, ppType >::postData ( ) const

inline

Definition at line 108 of file postprocessing.h.

{ return *m_postData; }

postprocessInSolve()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::postprocessInSolve ( MBool  finalTimeStep )

overridevirtual

Implements PostProcessingInterface.

Definition at line 185 of file postprocessing.cpp.

                                                                         {
  TRACE();
 
  m_finalTimeStep = finalTimeStep;
  for(MInt op = 0; op < (signed)m_postprocessingMethods[1].size(); op++) {
    (this->*(m_postprocessingMethods[1][op]))();
  }
}

postprocessPostSolve()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::postprocessPostSolve

overridevirtual

Implements PostProcessingInterface.

Definition at line 206 of file postprocessing.cpp.

                                                        {
  TRACE();
 
  m_finalTimeStep = true;
  for(MInt op = 0; op < (signed)m_postprocessingMethods[2].size(); op++) {
    (this->*(m_postprocessingMethods[2][op]))();
  }
}

postprocessPreSolve()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::postprocessPreSolve

overridevirtual

Implements PostProcessingInterface.

Definition at line 175 of file postprocessing.cpp.

                                                       {
  TRACE();
 
  for(MInt op = 0; op < (signed)m_postprocessingMethods[0].size(); op++) {
    (this->*(m_postprocessingMethods[0][op]))();
  }
}

postprocessSolution()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::postprocessSolution

overridevirtual

Implements PostProcessingInterface.

Definition at line 196 of file postprocessing.cpp.

                                                       {
  TRACE();
 
  for(MInt op = 0; op < (signed)m_postprocessingSolution.size(); op++) {
    (this->*(m_postprocessingSolution[op]))();
  }
}

pp_saveCoarseSolution()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::pp_saveCoarseSolution ( )

protected

probeArbitraryLine()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeArbitraryLine ( )

protected

probeArbitraryLinePost()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeArbitraryLinePost ( )

protected

probeArbitrarySlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeArbitrarySlice ( )

protected

probeArbitrarySlicePost()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeArbitrarySlicePost ( )

protected

probeLine()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeLine ( )

protected

probeLinePeriodic()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::probeLinePeriodic ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 129 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

probeLinePeriodicPost()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::probeLinePeriodicPost ( )

protectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

probeLinePost()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeLinePost ( )

protected

probeLinePre()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeLinePre ( )

protected

probeLocation()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeLocation ( )

protected

probeSlice()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeSlice ( )

protected

probeSliceIn()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeSliceIn ( )

protected

probeSlicePost()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeSlicePost ( )

protected

probeSlicePre()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::probeSlicePre ( )

protected

savePointSamplingData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::savePointSamplingData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, and PostProcessingLb< nDim >.

Definition at line 162 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

saveSliceAiaFileFormat()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::saveSliceAiaFileFormat ( const MInt  step, const MInt  noVars, MFloatScratchSpace &  vars, const MInt  sliceId  )

protected

saveSurfaceSamplingData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::saveSurfaceSamplingData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, and PostProcessingLb< nDim >.

Definition at line 164 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

saveVolumeSamplingData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::saveVolumeSamplingData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >, and PostProcessingLb< nDim >.

Definition at line 166 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

spatialAveraging()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::spatialAveraging ( )

protected

spatialAveragingPost()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::spatialAveragingPost ( )

protected

transferSensorWeights()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::transferSensorWeights ( )

protected

vorticityAtCell()

template<MInt nDim, class ppType >

virtual MFloat & PostProcessing< nDim, ppType >::vorticityAtCell ( const MInt  cellId, const MInt  dir  )

inlineprotectedvirtual

Reimplemented in PostProcessingFv< nDim, SysEqn >.

Definition at line 261 of file postprocessing.h.

                                                                     {
    std::ignore = cellId;
    std::ignore = dir;
    TERMM(1, "Not implemented for this solverType");
  };

writeLPTSolutionFile()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::writeLPTSolutionFile ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFvLPT< nDim, SysEqn >, PostProcessingLbLPT< nDim >, and PostProcessingLPT< nDim >.

Definition at line 138 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

writePointData()

template<MInt nDim, class ppType >

void PostProcessing< nDim, ppType >::writePointData ( )

protected

writeSprayData()

template<MInt nDim, class ppType >

virtual void PostProcessing< nDim, ppType >::writeSprayData ( )

inlineprotectedvirtual

Reimplemented in PostProcessingFvLPT< nDim, SysEqn >.

Definition at line 134 of file postprocessing.h.

{ TERMM(1, "Not implemented for this solverType"); };

Member Data Documentation

m_acousticAnalysis

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_acousticAnalysis {}

Definition at line 293 of file postprocessing.h.

m_activeMeanVars

template<MInt nDim, class ppType >

std::set<MInt> PostProcessing< nDim, ppType >::m_activeMeanVars {}

protected

Definition at line 600 of file postprocessing.h.

m_activeSourceTerms

template<MInt nDim, class ppType >

std::vector<MInt> PostProcessing< nDim, ppType >::m_activeSourceTerms {}

protected

Definition at line 581 of file postprocessing.h.

m_arbLineCoordinates

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_arbLineCoordinates = nullptr

protected

Definition at line 506 of file postprocessing.h.

m_arbLineFull

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_arbLineFull = nullptr

protected

Definition at line 501 of file postprocessing.h.

m_arbLineHasNewDistribution

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_arbLineHasNewDistribution = nullptr

protected

Definition at line 500 of file postprocessing.h.

m_arbLineIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_arbLineIds = nullptr

protected

Definition at line 504 of file postprocessing.h.

m_arbLineOffsets

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_arbLineOffsets = nullptr

protected

Definition at line 505 of file postprocessing.h.

m_arbLinePoints

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_arbLinePoints = nullptr

protected

Definition at line 496 of file postprocessing.h.

m_arbLinePointsDistribution

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_arbLinePointsDistribution = nullptr

protected

Definition at line 499 of file postprocessing.h.

m_arbSliceCoordinates

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_arbSliceCoordinates = nullptr

protected

Definition at line 516 of file postprocessing.h.

m_arbSliceIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_arbSliceIds = nullptr

protected

Definition at line 514 of file postprocessing.h.

m_arbSliceOffsets

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_arbSliceOffsets = nullptr

protected

Definition at line 515 of file postprocessing.h.

m_arbSlicePoints

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_arbSlicePoints = nullptr

protected

Definition at line 509 of file postprocessing.h.

m_arbSlicePointsDistribution

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_arbSlicePointsDistribution = nullptr

protected

Definition at line 512 of file postprocessing.h.

m_averageInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_averageInterval {}

protected

Definition at line 527 of file postprocessing.h.

m_averageRestart

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_averageRestart {}

protected

Definition at line 526 of file postprocessing.h.

m_averageSpeedOfSound

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_averageSpeedOfSound = false

protected

Definition at line 364 of file postprocessing.h.

m_averageStartTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_averageStartTimestep {}

protected

Definition at line 528 of file postprocessing.h.

m_averageStopTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_averageStopTimestep {}

protected

Definition at line 529 of file postprocessing.h.

m_averageVorticity

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_averageVorticity = false

protected

Definition at line 363 of file postprocessing.h.

m_cell2globalIndex

template<MInt nDim, class ppType >

std::vector<MInt>* PostProcessing< nDim, ppType >::m_cell2globalIndex = nullptr

protected

Definition at line 354 of file postprocessing.h.

m_computeAndSaveMean

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_computeAndSaveMean = false

protected

Definition at line 331 of file postprocessing.h.

m_correlation

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_correlation = false

protected

Definition at line 351 of file postprocessing.h.

m_correlationCoordinates

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_correlationCoordinates = nullptr

protected

Definition at line 427 of file postprocessing.h.

m_correlationDirection

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_correlationDirection = nullptr

protected

Definition at line 425 of file postprocessing.h.

m_correlationExchangeVar

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_correlationExchangeVar = nullptr

protected

Definition at line 436 of file postprocessing.h.

m_correlationExchangeVarMean

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_correlationExchangeVarMean = nullptr

protected

Definition at line 437 of file postprocessing.h.

m_correlationExchangeVarRMS

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_correlationExchangeVarRMS = nullptr

protected

Definition at line 438 of file postprocessing.h.

m_correlationIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_correlationIds = nullptr

protected

Definition at line 430 of file postprocessing.h.

m_correlationIndexMapping

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_correlationIndexMapping = nullptr

protected

Definition at line 435 of file postprocessing.h.

m_correlationPositions

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_correlationPositions = nullptr

protected

Definition at line 434 of file postprocessing.h.

m_correlationVariableIndex

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_correlationVariableIndex = nullptr

protected

Definition at line 426 of file postprocessing.h.

m_forceOutput

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_forceOutput = false

protected

Definition at line 575 of file postprocessing.h.

m_gamma

template<MInt nDim, class ppType >

MFloat PostProcessing< nDim, ppType >::m_gamma = -1.0

protected

Definition at line 365 of file postprocessing.h.

m_globalCorrelationExchangeVar

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_globalCorrelationExchangeVar = nullptr

protected

Definition at line 439 of file postprocessing.h.

m_globalCorrelationExchangeVarMean

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_globalCorrelationExchangeVarMean = nullptr

protected

Definition at line 440 of file postprocessing.h.

m_globalCorrelationExchangeVarRMS

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_globalCorrelationExchangeVarRMS = nullptr

protected

Definition at line 441 of file postprocessing.h.

m_globalCorrelationIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_globalCorrelationIds = nullptr

protected

Definition at line 431 of file postprocessing.h.

m_globalCorrelationPositions

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_globalCorrelationPositions = nullptr

protected

Definition at line 432 of file postprocessing.h.

m_globalNoArbLineIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_globalNoArbLineIds = nullptr

protected

Definition at line 503 of file postprocessing.h.

m_globalNoArbSlicePoints

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_globalNoArbSlicePoints = nullptr

protected

Definition at line 513 of file postprocessing.h.

m_globalNoCorrelationIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_globalNoCorrelationIds = nullptr

protected

Definition at line 433 of file postprocessing.h.

m_globalNoProbeLineAverageIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_globalNoProbeLineAverageIds = nullptr

protected

Definition at line 451 of file postprocessing.h.

m_globalNoProbeLineIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_globalNoProbeLineIds = nullptr

protected

Definition at line 416 of file postprocessing.h.

m_globalNoProbeSliceIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_globalNoProbeSliceIds = nullptr

protected

Definition at line 462 of file postprocessing.h.

m_globalnoSlicePositions

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_globalnoSlicePositions = 0

protected

Definition at line 357 of file postprocessing.h.

m_globalProbeLineAverageVars

template<MInt nDim, class ppType >

MFloat*** PostProcessing< nDim, ppType >::m_globalProbeLineAverageVars = nullptr

protected

Definition at line 448 of file postprocessing.h.

m_gridProxy

template<MInt nDim, class ppType >

GridProxy* PostProcessing< nDim, ppType >::m_gridProxy

private

Definition at line 304 of file postprocessing.h.

m_injectionData

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_injectionData = nullptr

protected

Definition at line 568 of file postprocessing.h.

m_kurtosis

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_kurtosis = false

protected

Definition at line 330 of file postprocessing.h.

m_localVars

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_localVars = nullptr

protected

Definition at line 523 of file postprocessing.h.

m_LPTSolutionInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_LPTSolutionInterval = 50

protected

Definition at line 574 of file postprocessing.h.

m_minLvlIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_minLvlIds = nullptr

protected

Definition at line 489 of file postprocessing.h.

m_movAvgNoVariables

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movAvgNoVariables {}

protected

Definition at line 374 of file postprocessing.h.

m_movAvgVariables

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_movAvgVariables = nullptr

protected

Definition at line 373 of file postprocessing.h.

m_movAvgVarNames

template<MInt nDim, class ppType >

MString* PostProcessing< nDim, ppType >::m_movAvgVarNames = nullptr

protected

Definition at line 375 of file postprocessing.h.

m_moveLinePointsToGrid

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_moveLinePointsToGrid = nullptr

protected

Definition at line 502 of file postprocessing.h.

m_movePointsToGrid

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movePointsToGrid {}

protected

Definition at line 492 of file postprocessing.h.

m_movingAverageCounter

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movingAverageCounter {}

protected

Definition at line 372 of file postprocessing.h.

m_movingAverageDataPoints

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movingAverageDataPoints {}

protected

Definition at line 371 of file postprocessing.h.

m_movingAverageInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movingAverageInterval = 1

protected

Definition at line 370 of file postprocessing.h.

m_movingAverageStartTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movingAverageStartTimestep = 0

protected

Definition at line 368 of file postprocessing.h.

m_movingAverageStopTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_movingAverageStopTimestep = 0

protected

Definition at line 369 of file postprocessing.h.

m_needVorticity

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_needVorticity = false

protected

Definition at line 534 of file postprocessing.h.

m_noArbLineIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noArbLineIds = nullptr

protected

Definition at line 498 of file postprocessing.h.

m_noArbLines

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noArbLines = 0

protected

Definition at line 497 of file postprocessing.h.

m_noArbSlicePoints

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noArbSlicePoints = nullptr

protected

Definition at line 511 of file postprocessing.h.

m_noArbSlices

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noArbSlices {}

protected

Definition at line 510 of file postprocessing.h.

m_noAveragedVorticities

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noAveragedVorticities {}

protected

Definition at line 531 of file postprocessing.h.

m_noCorrelationIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noCorrelationIds = nullptr

protected

Definition at line 429 of file postprocessing.h.

m_noCorrelationLines

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noCorrelationLines = -1

protected

Definition at line 428 of file postprocessing.h.

m_noGlobalProbeLineIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_noGlobalProbeLineIds = nullptr

protected

Definition at line 418 of file postprocessing.h.

m_noGlobalProbeSliceIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_noGlobalProbeSliceIds = nullptr

protected

Definition at line 464 of file postprocessing.h.

m_noLocalVars

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noLocalVars {}

Definition at line 290 of file postprocessing.h.

m_noMinLvlIds

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noMinLvlIds {}

protected

Definition at line 488 of file postprocessing.h.

m_noPeriodicSliceCells

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noPeriodicSliceCells = nullptr

protected

Definition at line 355 of file postprocessing.h.

m_noPostprocessingOps

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noPostprocessingOps {}

protected

Definition at line 275 of file postprocessing.h.

m_noProbeLineAverageIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_noProbeLineAverageIds = nullptr

protected

Definition at line 447 of file postprocessing.h.

m_noProbeLineAverageSteps

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noProbeLineAverageSteps

protected

Definition at line 450 of file postprocessing.h.

m_noProbeLineIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noProbeLineIds = nullptr

protected

Definition at line 414 of file postprocessing.h.

m_noProbeLines

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noProbeLines = -1

protected

Definition at line 409 of file postprocessing.h.

m_noProbePoints

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noProbePoints {}

protected

Definition at line 544 of file postprocessing.h.

m_noProbeSliceContHilbertInfo

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_noProbeSliceContHilbertInfo = nullptr

protected

Definition at line 475 of file postprocessing.h.

m_noProbeSliceHilbertInfo

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_noProbeSliceHilbertInfo = nullptr

protected

Definition at line 472 of file postprocessing.h.

m_noProbeSliceIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noProbeSliceIds = nullptr

protected

Definition at line 460 of file postprocessing.h.

m_noProbeSliceMaxNoContHilbertIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noProbeSliceMaxNoContHilbertIds = nullptr

protected

Definition at line 474 of file postprocessing.h.

m_noProbeSliceMaxNoHilbertIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noProbeSliceMaxNoHilbertIds = nullptr

protected

Definition at line 471 of file postprocessing.h.

m_noProbeSliceNoContHilbertIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noProbeSliceNoContHilbertIds = nullptr

protected

Definition at line 473 of file postprocessing.h.

m_noProbeSliceNoHilbertIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_noProbeSliceNoHilbertIds = nullptr

protected

Definition at line 470 of file postprocessing.h.

m_noProbeSlices

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noProbeSlices = -1

protected

Definition at line 456 of file postprocessing.h.

m_noSliceVars

template<MInt nDim, class ppType >

std::vector<MInt> PostProcessing< nDim, ppType >::m_noSliceVars {}

protected

Definition at line 484 of file postprocessing.h.

m_noSourceVars

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noSourceVars {}

protected

Definition at line 533 of file postprocessing.h.

m_noSpeedOfSoundVars

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noSpeedOfSoundVars {}

protected

Definition at line 532 of file postprocessing.h.

m_noVariables

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_noVariables {}

protected

Definition at line 321 of file postprocessing.h.

m_optimizedSliceIo

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_optimizedSliceIo = true

protected

Definition at line 469 of file postprocessing.h.

m_particleCV

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_particleCV = nullptr

protected

Definition at line 564 of file postprocessing.h.

m_particlePen

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_particlePen = nullptr

protected

Definition at line 565 of file postprocessing.h.

m_pdCells

template<MInt nDim, class ppType >

std::vector<MInt> PostProcessing< nDim, ppType >::m_pdCells

protected

Definition at line 554 of file postprocessing.h.

m_pdFileName

template<MInt nDim, class ppType >

MString PostProcessing< nDim, ppType >::m_pdFileName

protected

Definition at line 549 of file postprocessing.h.

m_pdNoPoints

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_pdNoPoints {}

protected

Definition at line 556 of file postprocessing.h.

m_pdPoints

template<MInt nDim, class ppType >

std::vector<MFloat> PostProcessing< nDim, ppType >::m_pdPoints

protected

Definition at line 553 of file postprocessing.h.

m_pdRestartInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_pdRestartInterval {}

protected

Definition at line 552 of file postprocessing.h.

m_pdStartTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_pdStartTimestep {}

protected

Definition at line 550 of file postprocessing.h.

m_pdStopTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_pdStopTimestep {}

protected

Definition at line 551 of file postprocessing.h.

m_pdVars

template<MInt nDim, class ppType >

std::vector<MFloat> PostProcessing< nDim, ppType >::m_pdVars

protected

Definition at line 555 of file postprocessing.h.

m_postData

template<MInt nDim, class ppType >

Data* PostProcessing< nDim, ppType >::m_postData = nullptr

protected

Definition at line 308 of file postprocessing.h.

m_postprocessFileName

template<MInt nDim, class ppType >

MString PostProcessing< nDim, ppType >::m_postprocessFileName = ""

protected

Definition at line 519 of file postprocessing.h.

m_postprocessingMethods

template<MInt nDim, class ppType >

std::vector<tvecpost> PostProcessing< nDim, ppType >::m_postprocessingMethods

protected

Definition at line 283 of file postprocessing.h.

m_postprocessingMethodsDesc

template<MInt nDim, class ppType >

std::vector<std::vector<MString> > PostProcessing< nDim, ppType >::m_postprocessingMethodsDesc

protected

Definition at line 284 of file postprocessing.h.

m_postprocessingOps

template<MInt nDim, class ppType >

MString* PostProcessing< nDim, ppType >::m_postprocessingOps = nullptr

protected

Definition at line 276 of file postprocessing.h.

m_postprocessingSolution

template<MInt nDim, class ppType >

tvecpost PostProcessing< nDim, ppType >::m_postprocessingSolution

protected

Definition at line 282 of file postprocessing.h.

m_probeCellIds

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeCellIds = nullptr

protected

Definition at line 542 of file postprocessing.h.

m_probeCoordinates

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_probeCoordinates = nullptr

protected

Definition at line 540 of file postprocessing.h.

m_probeFileStreams

template<MInt nDim, class ppType >

std::ofstream* PostProcessing< nDim, ppType >::m_probeFileStreams = nullptr

protected

Definition at line 543 of file postprocessing.h.

m_probeInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeInterval

protected

Definition at line 545 of file postprocessing.h.

m_probeLineAverageCoordinates

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_probeLineAverageCoordinates = nullptr

protected

Definition at line 445 of file postprocessing.h.

m_probeLineAverageCoordinatesSign

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_probeLineAverageCoordinatesSign = nullptr

protected

Definition at line 446 of file postprocessing.h.

m_probeLineAverageDirection

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeLineAverageDirection = nullptr

protected

Definition at line 444 of file postprocessing.h.

m_probeLineAverageIds

template<MInt nDim, class ppType >

MInt*** PostProcessing< nDim, ppType >::m_probeLineAverageIds = nullptr

protected

Definition at line 452 of file postprocessing.h.

m_probeLineAveragePositions

template<MInt nDim, class ppType >

MFloat*** PostProcessing< nDim, ppType >::m_probeLineAveragePositions = nullptr

protected

Definition at line 453 of file postprocessing.h.

m_probeLineCoordinates

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_probeLineCoordinates = nullptr

protected

Definition at line 412 of file postprocessing.h.

m_probeLineDirection

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeLineDirection = nullptr

protected

Definition at line 410 of file postprocessing.h.

m_probeLineIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_probeLineIds = nullptr

protected

Definition at line 413 of file postprocessing.h.

m_probeLineInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeLineInterval = -1

protected

Definition at line 420 of file postprocessing.h.

m_probeLineOffsets

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeLineOffsets = nullptr

protected

Definition at line 417 of file postprocessing.h.

m_probeLinePeriodic

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeLinePeriodic = nullptr

protected

Definition at line 411 of file postprocessing.h.

m_probeLinePositions

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_probeLinePositions = nullptr

protected

Definition at line 415 of file postprocessing.h.

m_probeLineStartTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeLineStartTimestep = 0

protected

Definition at line 421 of file postprocessing.h.

m_probeLineStopTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeLineStopTimestep = -1

protected

Definition at line 422 of file postprocessing.h.

m_probePath

template<MInt nDim, class ppType >

MString PostProcessing< nDim, ppType >::m_probePath

protected

Definition at line 541 of file postprocessing.h.

m_probeSliceCoordinate

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_probeSliceCoordinate = nullptr

protected

Definition at line 458 of file postprocessing.h.

m_probeSliceDir

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeSliceDir = nullptr

protected

Definition at line 457 of file postprocessing.h.

m_probeSliceGridNames

template<MInt nDim, class ppType >

MString* PostProcessing< nDim, ppType >::m_probeSliceGridNames = nullptr

protected

Definition at line 465 of file postprocessing.h.

m_probeSliceIds

template<MInt nDim, class ppType >

MInt** PostProcessing< nDim, ppType >::m_probeSliceIds = nullptr

protected

Definition at line 459 of file postprocessing.h.

m_probeSliceInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeSliceInterval = -1

protected

Definition at line 477 of file postprocessing.h.

m_probeSliceOffsets

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_probeSliceOffsets = nullptr

protected

Definition at line 463 of file postprocessing.h.

m_probeSlicePositions

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_probeSlicePositions = nullptr

protected

Definition at line 461 of file postprocessing.h.

m_probeSliceStartTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeSliceStartTimestep = 0

protected

Definition at line 478 of file postprocessing.h.

m_probeSliceStopTimestep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeSliceStopTimestep = -1

protected

Definition at line 479 of file postprocessing.h.

m_probeWriteInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_probeWriteInterval

protected

Definition at line 546 of file postprocessing.h.

m_restartTimeStep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_restartTimeStep {}

Definition at line 291 of file postprocessing.h.

m_ReStressesAverageFileName

template<MInt nDim, class ppType >

MString PostProcessing< nDim, ppType >::m_ReStressesAverageFileName

protected

Definition at line 537 of file postprocessing.h.

m_skewness

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_skewness = false

protected

Definition at line 329 of file postprocessing.h.

m_sliceAiaFileFormat

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_sliceAiaFileFormat = false

protected

Definition at line 468 of file postprocessing.h.

m_sliceAverage

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_sliceAverage = nullptr

protected

Definition at line 356 of file postprocessing.h.

m_sliceAxis

template<MInt nDim, class ppType >

MString* PostProcessing< nDim, ppType >::m_sliceAxis = nullptr

protected

Definition at line 466 of file postprocessing.h.

m_sliceGlobalPositions

template<MInt nDim, class ppType >

std::multimap<MFloat, MFloat> PostProcessing< nDim, ppType >::m_sliceGlobalPositions

protected

Definition at line 361 of file postprocessing.h.

m_sliceIntercept

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_sliceIntercept = nullptr

protected

Definition at line 467 of file postprocessing.h.

m_sliceVarIds

template<MInt nDim, class ppType >

std::vector<MInt> PostProcessing< nDim, ppType >::m_sliceVarIds {}

protected

Definition at line 482 of file postprocessing.h.

m_sliceVarNames

template<MInt nDim, class ppType >

std::vector<std::vector<MString> > PostProcessing< nDim, ppType >::m_sliceVarNames {}

protected

Definition at line 486 of file postprocessing.h.

m_solverType

template<MInt nDim, class ppType >

MString PostProcessing< nDim, ppType >::m_solverType

private

Definition at line 299 of file postprocessing.h.

m_spatialAveraging

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_spatialAveraging {}

protected

Definition at line 493 of file postprocessing.h.

m_spatialCoordSum

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_spatialCoordSum {}

protected

Definition at line 386 of file postprocessing.h.

m_spatialDirection1

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_spatialDirection1 {}

protected

Definition at line 378 of file postprocessing.h.

m_spatialDirection2

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_spatialDirection2 {}

protected

Definition at line 379 of file postprocessing.h.

m_spatialDispls

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_spatialDispls = nullptr

protected

Definition at line 382 of file postprocessing.h.

m_spatialGlobalLineCellToMap

template<MInt nDim, class ppType >

std::map<MFloat, MFloat, coord_comp_1d_> PostProcessing< nDim, ppType >::m_spatialGlobalLineCellToMap

protected

Definition at line 392 of file postprocessing.h.

m_spatialGlobalLineCoordinates

template<MInt nDim, class ppType >

std::map<MFloat, MInt, coord_comp_1d_> PostProcessing< nDim, ppType >::m_spatialGlobalLineCoordinates

protected

Definition at line 391 of file postprocessing.h.

m_spatialGlobalPlaneCellToMap

template<MInt nDim, class ppType >

std::map<std::pair<MFloat, MFloat>, std::pair<MFloat, MFloat>, coord_comp_2d_> PostProcessing< nDim, ppType >::m_spatialGlobalPlaneCellToMap

protected

Definition at line 402 of file postprocessing.h.

m_spatialGlobalPlaneCoordinates

template<MInt nDim, class ppType >

std::map<std::pair<MFloat, MFloat>, MInt, coord_comp_2d_> PostProcessing< nDim, ppType >::m_spatialGlobalPlaneCoordinates

protected

Definition at line 401 of file postprocessing.h.

m_spatialLineAllCoord

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_spatialLineAllCoord = nullptr

protected

Definition at line 396 of file postprocessing.h.

m_spatialLineAllVars

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_spatialLineAllVars = nullptr

protected

Definition at line 395 of file postprocessing.h.

m_spatialLineCellToMap

template<MInt nDim, class ppType >

std::map<MFloat, MFloat, coord_comp_1d_> PostProcessing< nDim, ppType >::m_spatialLineCellToMap

protected

Definition at line 389 of file postprocessing.h.

m_spatialLineCoordinates

template<MInt nDim, class ppType >

std::map<MFloat, MInt, coord_comp_1d_> PostProcessing< nDim, ppType >::m_spatialLineCoordinates

protected

Definition at line 388 of file postprocessing.h.

m_spatialLineNoCells

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_spatialLineNoCells = -1

protected

Definition at line 394 of file postprocessing.h.

m_spatialLvlWeight

template<MInt nDim, class ppType >

MFloat PostProcessing< nDim, ppType >::m_spatialLvlWeight[20] {}

protected

Definition at line 381 of file postprocessing.h.

m_spatialPlaneAllCoord

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_spatialPlaneAllCoord = nullptr

protected

Definition at line 406 of file postprocessing.h.

m_spatialPlaneAllVars

template<MInt nDim, class ppType >

MFloat* PostProcessing< nDim, ppType >::m_spatialPlaneAllVars = nullptr

protected

Definition at line 405 of file postprocessing.h.

m_spatialPlaneCellToMap

template<MInt nDim, class ppType >

std::map<std::pair<MFloat, MFloat>, std::pair<MFloat, MFloat>, coord_comp_2d_> PostProcessing< nDim, ppType >::m_spatialPlaneCellToMap

protected

Definition at line 399 of file postprocessing.h.

m_spatialPlaneCoordinates

template<MInt nDim, class ppType >

std::map<std::pair<MFloat, MFloat>, MInt, coord_comp_2d_> PostProcessing< nDim, ppType >::m_spatialPlaneCoordinates

protected

Definition at line 398 of file postprocessing.h.

m_spatialPlaneNoCells

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_spatialPlaneNoCells = -1

protected

Definition at line 404 of file postprocessing.h.

m_spatialRecvcnts

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_spatialRecvcnts = nullptr

protected

Definition at line 384 of file postprocessing.h.

m_spatialVarsDispls

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_spatialVarsDispls = nullptr

protected

Definition at line 383 of file postprocessing.h.

m_spatialVarsRecvcnts

template<MInt nDim, class ppType >

MInt* PostProcessing< nDim, ppType >::m_spatialVarsRecvcnts = nullptr

protected

Definition at line 385 of file postprocessing.h.

m_spatialWeightSinglePoint

template<MInt nDim, class ppType >

MFloat PostProcessing< nDim, ppType >::m_spatialWeightSinglePoint {}

protected

Definition at line 380 of file postprocessing.h.

m_sprayComputeInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_sprayComputeInterval = 50

protected

Definition at line 559 of file postprocessing.h.

m_sprayDataSize

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_sprayDataSize = 50

protected

Definition at line 561 of file postprocessing.h.

m_sprayDataStep

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_sprayDataStep = 0

protected

Definition at line 562 of file postprocessing.h.

m_sprayStat

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_sprayStat = nullptr

protected

Definition at line 566 of file postprocessing.h.

m_sprayTimes

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_sprayTimes = nullptr

protected

Definition at line 567 of file postprocessing.h.

m_sprayWriteInterval

template<MInt nDim, class ppType >

MInt PostProcessing< nDim, ppType >::m_sprayWriteInterval = 50

protected

Definition at line 560 of file postprocessing.h.

m_square

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_square = false

protected

Definition at line 328 of file postprocessing.h.

m_statisticCombustionAnalysis

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_statisticCombustionAnalysis {}

Definition at line 292 of file postprocessing.h.

m_twoPass

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_twoPass = false

protected

Definition at line 333 of file postprocessing.h.

m_useKahan

template<MInt nDim, class ppType >

MBool PostProcessing< nDim, ppType >::m_useKahan {}

protected

Definition at line 337 of file postprocessing.h.

m_vapourCV

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_vapourCV = nullptr

protected

Definition at line 570 of file postprocessing.h.

m_vapourPen

template<MInt nDim, class ppType >

MFloat** PostProcessing< nDim, ppType >::m_vapourPen = nullptr

protected

Definition at line 571 of file postprocessing.h.

pp

template<MInt nDim, class ppType >

ppType* PostProcessing< nDim, ppType >::pp = static_cast<ppType*>(this)

private

Definition at line 300 of file postprocessing.h.

s_sourceTermNames

template<MInt nDim, class ppType >

std::array<MString, ST::totalNoSourceTerms> PostProcessing< nDim, ppType >::s_sourceTermNames

protected

Initial value:

= {
      {"q_mI", "q_mI_linear", "q_mII", "q_mIII", "q_mIV", "q_c", "q_e"}}

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