#include <postprocessinglpt.h>

Inheritance diagram for PostProcessingLPT< nDim >:

Collaboration diagram for PostProcessingLPT< nDim >:

Public Types
using	SolverType = LPT< nDim >

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

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

using	Cell = typename PPGrid::Cell

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

using	Data = PostData< nDim >

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

virtual	~PostProcessingLPT ()

SolverType &	solver () const

void	initSprayData () override
	init arrays More...

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

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

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

void	postprocessPreSolve () override

void	postprocessPostSolve () override

void	postprocessInSolve (MBool finalTimeStep) override

void	postprocessSolution () override

Solver *	mSolver () const override

Data &	postData () const

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

virtual	~PostProcessingInterface ()=default

	PostProcessingInterface (const PostProcessingInterface &)=delete

PostProcessingInterface &	operator= (const PostProcessingInterface &)=delete

virtual void	initPostProcessing ()=0

virtual void	postprocessPreSolve ()=0

virtual void	postprocessPostSolve ()=0

virtual void	postprocessInSolve (MBool finalTimeStep)=0

virtual void	postprocessSolution ()=0

virtual Solver *	mSolver () const =0

MInt	a_postprocessingId () const

Protected Member Functions
void	initLPTSolutionFile () override
	init function for LPT particle solution file More...

void	writeLPTSolutionFile () override
	base function which is called every time-Step in postprocessInSolve More...

void	initParticleStatistics () override
	init function for LPT particle statistics file More...

void	computeParticleStatistics () override
	compute average quantites of particle phase average particle Reynolds number ReP the root mean square particle velocity vrms the total kinetic energy of the particles More...

void	initParticleLog ()
	initialize particle.log More...

void	writeParticleLog ()
	write particle Log file, containing particle position and velocity at timestep t More...

void	particleMass ()
	computes conervation variables (mass/momentum/energy!) More...

void	parcelStatistics ()
	computes parcel statistics More...

void	particlePenetration ()
	calculate vertical and horizontal penetration from given coordinate More...

MInt	getInjectionData ()

void	advanceDataStep ()

void	resetDataStep ()

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

void	transferSensorWeights ()

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

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

void	initTimeStepPropertiesSlice ()

void	initTimeStepPropertiesLine ()

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

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

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

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

void	initSpatialAveraging ()

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

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

void	initProbeLinePeriodic ()

virtual void	probeLinePeriodic ()

virtual void	probeLinePeriodicPost ()

virtual void	initSprayData ()

virtual void	computeSprayData ()

virtual void	writeSprayData ()

virtual void	initLPTSolutionFile ()

virtual void	writeLPTSolutionFile ()

virtual void	initParticleStatistics ()

virtual void	computeParticleStatistics ()

virtual void	initPLIsoTurbulenceStatistics ()

virtual void	computePLIsoTurbulenceStatistics ()

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

void	pp_saveCoarseSolution ()

void	averageSolutions ()
	Averages solutions. More...

virtual void	averageSolutionsInSolve ()

void	computeAndSaveDivergence ()

void	computeAndSaveMean ()

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

void	averageSolutionsSlice ()

void	probeLocation ()

void	findClosestProbePointsGridCells ()

virtual void	initPointSamplingData ()

virtual void	savePointSamplingData ()

virtual void	initSurfaceSamplingData ()

virtual void	saveSurfaceSamplingData ()

virtual void	initVolumeSamplingData ()

virtual void	saveVolumeSamplingData ()

virtual void	initIsoTurbulenceStatistics ()

virtual void	computeIsoTurbulenceStatistics ()

void	initWritePointData ()

void	writePointData ()

void	spatialAveraging ()

void	spatialAveragingPost ()

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

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

void	probeLine ()

void	probeLinePre ()

void	probeLinePost ()

void	probeSlice ()

void	probeSliceIn ()

void	probeSlicePre ()

void	probeSlicePost ()

void	collectMinLvlCells ()

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

void	probeArbitraryLine ()

void	probeArbitraryLinePost ()

void	probeArbitrarySlice ()

void	probeArbitrarySlicePost ()

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

void	movingAverage ()

void	movingAveragePost ()

void	initCorrelation ()

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

void	periodicSliceAverage ()

MInt	findNearestGridCell (const MFloat *coord)

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

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

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

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

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

MFloat	calcDivergence (const MInt cellIdSolver)

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

virtual void	getVorticity (MFloat *const vorticity)

virtual void	getVorticityT (MFloat *const vorticity)

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

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

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

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

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

virtual MFloat	getBoundaryHeatFlux (const MInt cellId) const

virtual void	getPrimitiveVarNames (MString *names) const

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

MBool	isMeanFile ()

Protected Attributes
SolverType *	m_ppSolver

MFloat **	m_cInjData = nullptr

MFloat	m_AvgRe_p = F0

MFloat	m_VpRMS = F0

MFloat	m_EkinP = F0

MBool	m_writeParLog = false

MInt	m_parLogInterval = 50

MBool	m_parLogApp = false

Protected Attributes inherited from PostProcessing< nDim, PostProcessingLPT< nDim > >
MInt	m_noPostprocessingOps

MString *	m_postprocessingOps

tvecpost	m_postprocessingSolution

std::vector< tvecpost >	m_postprocessingMethods

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

Data *	m_postData

MInt	m_noVariables

MBool	m_square

MBool	m_skewness

MBool	m_kurtosis

MBool	m_computeAndSaveMean

MBool	m_twoPass

MBool	m_useKahan

MBool	m_correlation

std::vector< MInt > *	m_cell2globalIndex

MInt *	m_noPeriodicSliceCells

MFloat **	m_sliceAverage

MInt	m_globalnoSlicePositions

std::multimap< MFloat, MFloat >	m_sliceGlobalPositions

MBool	m_averageVorticity

MBool	m_averageSpeedOfSound

MFloat	m_gamma

MInt	m_movingAverageStartTimestep

MInt	m_movingAverageStopTimestep

MInt	m_movingAverageInterval

MInt	m_movingAverageDataPoints

MInt	m_movingAverageCounter

MFloat **	m_movAvgVariables

MInt	m_movAvgNoVariables

MString *	m_movAvgVarNames

MInt	m_spatialDirection1

MInt	m_spatialDirection2

MFloat	m_spatialWeightSinglePoint

MFloat	m_spatialLvlWeight [20]

MInt *	m_spatialDispls

MInt *	m_spatialVarsDispls

MInt *	m_spatialRecvcnts

MInt *	m_spatialVarsRecvcnts

MInt	m_spatialCoordSum

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

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

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

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

MInt	m_spatialLineNoCells

MFloat *	m_spatialLineAllVars

MFloat *	m_spatialLineAllCoord

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

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

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

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

MInt	m_spatialPlaneNoCells

MFloat *	m_spatialPlaneAllVars

MFloat *	m_spatialPlaneAllCoord

MInt	m_noProbeLines

MInt *	m_probeLineDirection

MInt *	m_probeLinePeriodic

MFloat **	m_probeLineCoordinates

MInt **	m_probeLineIds

MInt *	m_noProbeLineIds

MFloat **	m_probeLinePositions

MInt *	m_globalNoProbeLineIds

MInt *	m_probeLineOffsets

MInt **	m_noGlobalProbeLineIds

MInt	m_probeLineInterval

MInt	m_probeLineStartTimestep

MInt	m_probeLineStopTimestep

MInt *	m_correlationDirection

MInt *	m_correlationVariableIndex

MFloat **	m_correlationCoordinates

MInt	m_noCorrelationLines

MInt *	m_noCorrelationIds

MInt **	m_correlationIds

MInt **	m_globalCorrelationIds

MFloat **	m_globalCorrelationPositions

MInt *	m_globalNoCorrelationIds

MFloat **	m_correlationPositions

MInt **	m_correlationIndexMapping

MFloat **	m_correlationExchangeVar

MFloat **	m_correlationExchangeVarMean

MFloat **	m_correlationExchangeVarRMS

MFloat **	m_globalCorrelationExchangeVar

MFloat **	m_globalCorrelationExchangeVarMean

MFloat **	m_globalCorrelationExchangeVarRMS

MInt *	m_probeLineAverageDirection

MFloat **	m_probeLineAverageCoordinates

MInt **	m_probeLineAverageCoordinatesSign

MInt **	m_noProbeLineAverageIds

MFloat ***	m_globalProbeLineAverageVars

MInt	m_noProbeLineAverageSteps

MInt **	m_globalNoProbeLineAverageIds

MInt ***	m_probeLineAverageIds

MFloat ***	m_probeLineAveragePositions

MInt	m_noProbeSlices

MInt *	m_probeSliceDir

MFloat *	m_probeSliceCoordinate

MInt **	m_probeSliceIds

MInt *	m_noProbeSliceIds

MFloat **	m_probeSlicePositions

MInt *	m_globalNoProbeSliceIds

MInt *	m_probeSliceOffsets

MInt **	m_noGlobalProbeSliceIds

MString *	m_probeSliceGridNames

MString *	m_sliceAxis

MFloat *	m_sliceIntercept

MBool	m_sliceAiaFileFormat

MBool	m_optimizedSliceIo

MInt *	m_noProbeSliceNoHilbertIds

MInt *	m_noProbeSliceMaxNoHilbertIds

MInt **	m_noProbeSliceHilbertInfo

MInt *	m_noProbeSliceNoContHilbertIds

MInt *	m_noProbeSliceMaxNoContHilbertIds

MInt **	m_noProbeSliceContHilbertInfo

MInt	m_probeSliceInterval

MInt	m_probeSliceStartTimestep

MInt	m_probeSliceStopTimestep

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

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

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

MInt	m_noMinLvlIds

MInt *	m_minLvlIds

MInt	m_movePointsToGrid

MBool	m_spatialAveraging

MFloat *	m_arbLinePoints

MInt	m_noArbLines

MInt *	m_noArbLineIds

MFloat *	m_arbLinePointsDistribution

MInt *	m_arbLineHasNewDistribution

MInt *	m_arbLineFull

MInt *	m_moveLinePointsToGrid

MInt *	m_globalNoArbLineIds

MInt **	m_arbLineIds

MInt *	m_arbLineOffsets

MFloat **	m_arbLineCoordinates

MFloat *	m_arbSlicePoints

MInt	m_noArbSlices

MInt *	m_noArbSlicePoints

MFloat *	m_arbSlicePointsDistribution

MInt *	m_globalNoArbSlicePoints

MInt **	m_arbSliceIds

MInt *	m_arbSliceOffsets

MFloat **	m_arbSliceCoordinates

MString	m_postprocessFileName

MFloat **	m_localVars

MBool	m_averageRestart

MInt	m_averageInterval

MInt	m_averageStartTimestep

MInt	m_averageStopTimestep

MInt	m_noAveragedVorticities

MInt	m_noSpeedOfSoundVars

MInt	m_noSourceVars

MBool	m_needVorticity

MString	m_ReStressesAverageFileName

MFloat **	m_probeCoordinates

MString	m_probePath

MInt *	m_probeCellIds

std::ofstream *	m_probeFileStreams

MInt	m_noProbePoints

MInt	m_probeInterval

MInt	m_probeWriteInterval

MString	m_pdFileName

MInt	m_pdStartTimestep

MInt	m_pdStopTimestep

MInt	m_pdRestartInterval

std::vector< MFloat >	m_pdPoints

std::vector< MInt >	m_pdCells

std::vector< MFloat >	m_pdVars

MInt	m_pdNoPoints

MInt	m_sprayComputeInterval

MInt	m_sprayWriteInterval

MInt	m_sprayDataSize

MInt	m_sprayDataStep

MFloat **	m_particleCV

MFloat **	m_particlePen

MFloat **	m_sprayStat

MFloat **	m_sprayTimes

MFloat **	m_injectionData

MFloat **	m_vapourCV

MFloat **	m_vapourPen

MInt	m_LPTSolutionInterval

MBool	m_forceOutput

std::vector< MInt >	m_activeSourceTerms

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

std::set< MInt >	m_activeMeanVars

Protected Attributes inherited from PostProcessingInterface
MInt	m_postprocessingId

Friends
template<MInt nDim_, class ppType >
class	PostProcessing

template<MInt nDim_>
class	LPT

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

MInt	m_restartTimeStep

MBool	m_statisticCombustionAnalysis

MBool	m_acousticAnalysis

Public Attributes inherited from PostProcessingInterface
MBool	m_finalTimeStep = false

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

typedef std::vector< tpost >	tvecpost

Detailed Description

template<MInt nDim>
class PostProcessingLPT< nDim >

Definition at line 23 of file postprocessinglpt.h.

Member Typedef Documentation

◆ Base

template<MInt nDim>

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

Definition at line 32 of file postprocessinglpt.h.

◆ SolverType

template<MInt nDim>

using PostProcessingLPT< nDim >::SolverType = LPT<nDim>

Definition at line 31 of file postprocessinglpt.h.

Constructor & Destructor Documentation

◆ PostProcessingLPT()

template<MInt nDim>

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

Definition at line 16 of file postprocessinglpt.cpp.

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

◆ ~PostProcessingLPT()

template<MInt nDim>

virtual PostProcessingLPT< nDim >::~PostProcessingLPT ( )

inlinevirtual

Definition at line 46 of file postprocessinglpt.h.

46{};

Member Function Documentation

◆ advanceDataStep()

template<MInt nDim>

void PostProcessingLPT< nDim >::advanceDataStep ( )

inlineprotected

Definition at line 68 of file postprocessinglpt.h.

68{ m_sprayDataStep++; };

PostProcessing< nDim, PostProcessingLPT< nDim > >::m_sprayDataStep

MInt m_sprayDataStep

Definition: postprocessing.h:562

◆ computeParticleStatistics()

template<MInt nDim>

void PostProcessingLPT< nDim >::computeParticleStatistics

overrideprotectedvirtual

Author: Johannes Grafen

Date: Jul 2022

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

Definition at line 601 of file postprocessinglpt.cpp.

                                                        {
  TRACE();
 
  if((m_LPTSolutionInterval > 0 && globalTimeStep % m_LPTSolutionInterval == 0) || this->m_finalTimeStep
     || this->m_forceOutput) {
    const MInt globalNoPart = solver().globalNoParticles();
    MFloat RePSum = F0;
    MFloat VelmagnitudeSqSum = F0;
    MFloat EkinSum = F0;
 
    for(LPTSpherical<nDim>& part : solver().m_partList) {
      const MFloat T = solver().a_fluidTemperature(part.m_cellId);
      const MFloat fluidViscosity = solver().m_material->dynViscosityFun(T);
      const MFloat relVel = part.magRelVel(&part.m_oldFluidVel[0], &part.m_oldVel[0]);
 
      RePSum += part.particleRe(relVel, part.m_oldFluidDensity, fluidViscosity) * part.s_Re;
 
      MFloat VelmagnitudeSq = F0;
      for(MInt j = 0; j < nDim; j++) {
        VelmagnitudeSq += POW2(part.m_velocity[j]);
      }
      VelmagnitudeSqSum += VelmagnitudeSq;
 
      EkinSum += part.sphericalMass() * VelmagnitudeSq;
    }
 
    MPI_Allreduce(MPI_IN_PLACE, &RePSum, 1, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "INPLACE", "RePsum");
 
    MFloat AverageReP = RePSum / globalNoPart;
 
    MPI_Allreduce(MPI_IN_PLACE, &VelmagnitudeSqSum, 1, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "INPLACE",
                  "VelMagnitudesum");
 
    MFloat VpRMS = sqrt(VelmagnitudeSqSum / globalNoPart);
 
    MPI_Allreduce(MPI_IN_PLACE, &EkinSum, 1, MPI_DOUBLE, MPI_SUM, solver().mpiComm(), AT_, "INPLACE", "EkinSum");
 
    MFloat EkinP = 0.5 * EkinSum;
 
    if(solver().domainId() == 0) {
      std::ofstream Plog;
      Plog.open("ParticleStatistics.log", ios::app);
      Plog << std::setw(5) << globalTimeStep << "\t" << std::setw(10) << VpRMS << "\t" << std::setw(10) << AverageReP
           << "\t" << std::setw(10) << EkinP << endl;
      Plog.close();
    }
  } else {
    return;
  }
}

◆ getInjectionData()

template<MInt nDim>

MInt PostProcessingLPT< nDim >::getInjectionData

protected

Definition at line 378 of file postprocessinglpt.cpp.

                                               {
  TRACE();
 
 
  if(solver().m_sprayModel == nullptr) {
    return 0;
  }
 
  if(!solver().isActive()) {
    solver().m_injData.clear();
    return 0;
  }
 
  const MInt injectorCellId = solver().injectorCellId();
  MInt count = 0;
 
  // gather and sum all spray injection solver data
  for(auto it = solver().m_injData.begin(); it != solver().m_injData.end(); it++) {
    const MInt timeStep = it->first;
    if(solver().domainId() == 0) {
      m_injectionData[count][0] = timeStep;
    } else {
      m_injectionData[count][0] = 0.0;
    }
 
    for(MInt i = 0; i < 14; i++) {
      const MFloat data = (it->second)[i];
      m_injectionData[count][i + 1] = data;
    }
    count++;
  }
  count = 0;
 
  MPI_Allreduce(MPI_IN_PLACE, &(m_injectionData[0][0]), 15 * this->m_sprayWriteInterval, MPI_DOUBLE, MPI_SUM,
                solver().mpiComm(), AT_, "INPLACE", "m_injectionData");
 
  MPI_Allreduce(MPI_IN_PLACE, &(m_cInjData[0][0]), (nDim + 5) * (this->m_sprayWriteInterval + 1), MPI_DOUBLE, MPI_MAX,
                solver().mpiComm(), AT_, "INPLACE", "m_cInjData");
 
  if(injectorCellId > -1) {
    // get storage value
    for(MInt i = 0; i < nDim + 5; i++) {
      m_cInjData[0][i] = m_cInjData[this->m_sprayWriteInterval][i];
    }
 
    for(auto it = solver().m_injData.begin(); it != solver().m_injData.end(); it++) {
      // add data from:
      // injMass, injXMom, injYMom, injZMom, injEnergy, sumEvapMass, noRT-breakup, noKH-breakup
      for(MInt i = 0; i < nDim + 5; i++) {
        m_cInjData[count][i] += m_injectionData[count][7 + i];
      }
      count++;
 
      // set pervious mass as mass in the next timeStep
      for(MInt i = 0; i < nDim + 5; i++) {
        m_cInjData[count][i] = m_cInjData[count - 1][i];
      }
    }
    // put last value into storage
    for(MInt i = 0; i < nDim + 5; i++) {
      m_cInjData[this->m_sprayWriteInterval][i] = m_cInjData[count][i];
    }
 
  } else {
    for(MInt id = 0; id < this->m_sprayWriteInterval + 1; id++) {
      for(MInt j = 0; j < nDim + 5; j++) {
        m_cInjData[id][j] = 0;
      }
    }
  }
 
  solver().m_injData.clear();
 
  return count;
}

◆ initLPTSolutionFile()

template<MInt nDim>

void PostProcessingLPT< nDim >::initLPTSolutionFile

overrideprotectedvirtual

Author: Tim Wegmann

Date: Jan 2021

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

Definition at line 459 of file postprocessinglpt.cpp.

                                                  {
  TRACE();
  m_LPTSolutionInterval =
      Context::getSolverProperty<MInt>("particleSolutionInterval", m_postprocessingId, AT_, &m_LPTSolutionInterval);
 
  m_writeParLog = Context::getSolverProperty<MBool>("writeParLog", m_postprocessingId, AT_, &m_writeParLog);
  if(m_writeParLog) initParticleLog();
}

◆ initParticleLog()

template<MInt nDim>

void PostProcessingLPT< nDim >::initParticleLog

protected

Author: Johannes Grafen

Definition at line 506 of file postprocessinglpt.cpp.

                                              {
  if(solver().m_restart && m_writeParLog) m_parLogApp = true;
 
  m_parLogInterval =
      Context::getSolverProperty<MInt>("particleLogInterval", m_postprocessingId, AT_, &m_parLogInterval);
 
  if(solver().domainId() == 0) {
    std::ofstream parLog;
    if(m_parLogApp) {
      parLog.open("particle.log", ios::app);
    } else {
      parLog.open("particle.log");
      const MString columns[9] = {"x", "y", "z", "vel_x", "vel_y", "vel_z", "Re", "C_D"};
      parLog << std::setw(5) << "t"
             << "\t";
      for(auto& i : columns) {
        parLog << std::setw(15) << i << "\t";
      }
    }
    parLog << std::endl;
    parLog.close();
  }
}

◆ initParticleStatistics()

template<MInt nDim>

void PostProcessingLPT< nDim >::initParticleStatistics

overrideprotectedvirtual

Author: Johannes Grafen

Date: Jul 2022

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

Definition at line 578 of file postprocessinglpt.cpp.

                                                     {
  TRACE();
 
  if(solver().domainId() == 0) {
    std::ofstream Plog;
    Plog.open("ParticleStatistics.log", ios::app);
    Plog << std::setw(5) << "t"
         << "\t" << std::setw(10) << "VpRMS"
         << "\t" << std::setw(10) << "AverageReP"
         << "\t" << std::setw(10) << "EkinP" << endl;
    Plog.close();
  }
}

◆ initSprayData()

template<MInt nDim>

void PostProcessingLPT< nDim >::initSprayData

overridevirtual

Author: Tim Wegmann

Date: Jan. 2021

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

Definition at line 28 of file postprocessinglpt.cpp.

                                            {
  PostProcessing<nDim, PostProcessingLPT<nDim>>::initSprayData();
  TRACE();
 
  if(solver().domainId() == 0) {
    cerr << "Allocating Post-processing LPT data!" << endl;
  }
 
  // gatherd in the postProcTimeInterval
  mAlloc(m_particleCV, m_sprayDataSize, 2 + nDim, "m_particleCV", F0, AT_);
  mAlloc(m_particlePen, m_sprayDataSize, 19, "m_particlePen", F0, AT_);
  mAlloc(m_sprayStat, m_sprayDataSize, 5, "m_sprayStat", F0, AT_);
  mAlloc(m_sprayTimes, m_sprayDataSize, 3, "m_sprayTimes", F0, AT_);
 
  if(solver().m_sprayModel == nullptr) return;
 
  // gatherd every timeStep
  mAlloc(m_injectionData, this->m_sprayWriteInterval, 15, "m_injectionData", F0, AT_);
  mAlloc(m_cInjData, this->m_sprayWriteInterval + 1, nDim + 5, "m_cInjData", F0, AT_);
 
  if(!solver().isActive()) return;
 
  array<MFloat, nDim + 5> loadedVariables = {};
  // load the sum of the injected mass from last file
  if(solver().m_restartFile && solver().domainId() == 0) {
    ifstream readFile;
    stringstream filename;
    filename.clear();
    filename.str("");
    filename << solver().restartDir() << "injSums";
    readFile.open(filename.str(), ios_base::in);
    if(!readFile) {
      filename.clear();
      filename.str("");
      filename << solver().restartDir() << "injSums_" << globalTimeStep;
      readFile.open(filename.str(), ios_base::in);
      if(!readFile) {
        mTerm(1, AT_, "Error reading injection file!");
      }
    } else {
      // file found -> create backup
      MString backupName = solver().restartDir() + "injSums_" + to_string(globalTimeStep);
      std::ifstream src(filename.str(), std::ios::binary);
      std::ofstream dst(backupName, std::ios::binary);
      dst << src.rdbuf();
    }
    readFile.seekg(-1, ios_base::end);
 
    MChar ch;
    MString lastLine;
    readFile.get(ch);
    if(ch == '\n') {
      readFile.seekg(-2, ios::cur);
      readFile.seekg(-1, ios::cur);
      readFile.get(ch);
      while(ch != '\n') {
        readFile.seekg(-2, std::ios::cur);
        readFile.get(ch);
      }
      getline(readFile, lastLine);
    } else {
      mTerm(1, AT_, "Wrong injection file-format!");
    }
    stringstream ss(lastLine);
    MFloat timeStep;
    ss >> timeStep;
 
    if((MInt)timeStep == globalTimeStep) {
      // matching time-step -> load data
      for(MInt i = 0; i < nDim + 5; i++) {
        ss >> loadedVariables[i];
        cerr << "Loaded injected Data " << i << " is " << loadedVariables[i] << endl;
      }
    } else if((MInt)timeStep > globalTimeStep) {
      cerr << "Searching correct line in injection data-file for " << globalTimeStep << " from last output " << timeStep
           << endl;
      while(timeStep > globalTimeStep) {
        ss.str("");
        readFile.seekg(-2, std::ios::cur);
        readFile.seekg(-1, std::ios::cur);
        readFile.get(ch);
        const MInt oldPos = readFile.tellg();
        while(ch != '\n') {
          readFile.seekg(-2, std::ios::cur);
          readFile.get(ch);
        }
        MString lastLine2;
        getline(readFile, lastLine2);
        const MInt newPos = readFile.tellg();
        const MInt difPos = -(newPos - oldPos);
        readFile.seekg(difPos, std::ios::cur);
        ss.str(lastLine2);
        ss >> timeStep;
      }
      for(MInt i = 0; i < nDim + 5; i++) {
        ss >> loadedVariables[i];
        cerr << "Loaded injected Data " << i << " is " << loadedVariables[i] << endl;
      }
 
    } else if((MInt)timeStep < globalTimeStep) {
      for(MInt i = 0; i < nDim + 5; i++) {
        loadedVariables[i] = 0;
      }
      readFile.close();
 
      // if the restart timeStep is smaller than the last computed/written timeStep info
      //-> search for matching timeStep in the backup file
      filename.clear();
      filename.str("");
      filename << solver().restartDir() << "injSums_" << globalTimeStep;
      readFile.open(filename.str(), ios_base::in);
      if(readFile) {
        mTerm(1, AT_, "Error reading injection file!");
      }
      readFile.seekg(-1, ios_base::end);
      readFile.get(ch);
      MString lastLine2;
      if(ch == '\n') {
        readFile.seekg(-2, ios::cur);
        readFile.seekg(-1, ios::cur);
        readFile.get(ch);
        while(ch != '\n') {
          readFile.seekg(-2, std::ios::cur);
          readFile.get(ch);
        }
        getline(readFile, lastLine2);
      } else {
        mTerm(1, AT_, "Wrong injection file-format!");
      }
      stringstream ss2(lastLine2);
      ss2 >> timeStep;
      if((MInt)timeStep == globalTimeStep) {
        for(MInt i = 0; i < nDim + 5; i++) {
          ss2 >> loadedVariables[i];
          if(solver().domainId() == 0) {
            cerr << "Loaded injected Data " << i << " is " << loadedVariables[i] << endl;
          }
        }
      } else {
        cerr << "Correct Timestep count not be found at the end of in any of the injSums files!"
             << "Either trunkate the files of implement version which checks through all lines!" << endl;
      }
    }
    readFile.close();
 
    for(MInt i = 0; i < nDim + 5; i++) {
      m_cInjData[this->m_sprayWriteInterval][i] = loadedVariables[i];
    }
  }
 
  if(solver().m_restartFile) {
    MPI_Allreduce(MPI_IN_PLACE, &(m_cInjData[0][0]), (nDim + 5) * (this->m_sprayWriteInterval + 1), MPI_DOUBLE, MPI_MAX,
                  solver().mpiComm(), AT_, "INPLACE", "m_cInjData");
  }
}

◆ parcelStatistics()

template<MInt nDim>

void PostProcessingLPT< nDim >::parcelStatistics

protected

Author: Sven Berger, Tim Wegmann

Date: Jan. 2021

Definition at line 349 of file postprocessinglpt.cpp.

                                               {
  TRACE();
 
  const MInt noPart = solver().a_noParticles();
 
  MLong noDroplets = 0;
  MFloat diameter = 0;
  MFloat surfaceArea = 0;
  MFloat volume = 0;
  for(MInt id = 0; id < noPart; ++id) {
    noDroplets += solver().m_partList[id].m_noParticles;
    diameter += solver().m_partList[id].m_noParticles * solver().m_partList[id].m_diameter;
    surfaceArea += solver().m_partList[id].m_noParticles * POW2(solver().m_partList[id].m_diameter);
    volume += solver().m_partList[id].m_noParticles * POW3(solver().m_partList[id].m_diameter);
  }
 
 
  // const MFloat SMD = volume / surfaceArea;
  // const MFloat meanD = diameter / noDroplets;
 
  m_sprayStat[m_sprayDataStep][0] = noPart;
  m_sprayStat[m_sprayDataStep][1] = noDroplets;
  m_sprayStat[m_sprayDataStep][2] = diameter;
  m_sprayStat[m_sprayDataStep][3] = surfaceArea;
  m_sprayStat[m_sprayDataStep][4] = volume;
}

◆ particleMass()

template<MInt nDim>

void PostProcessingLPT< nDim >::particleMass

protected

Author: Sven Berger, Tim Wegmann

Date: Jan. 2021

Definition at line 191 of file postprocessinglpt.cpp.

                                           {
  TRACE();
 
  // calculate conservative particle values
  MFloat partMass = 0;
  MFloat partE = 0;
  MFloat partMomentum[nDim] = {};
  for(MInt i = 0; i < nDim; i++) {
    partMomentum[i] = 0;
  }
  for(MInt id = 0; id < solver().a_noParticles(); ++id) {
    if(solver().m_partList[id].isInvalid()) continue;
    MFloat mass = solver().m_partList[id].sphericalMass() * solver().m_partList[id].m_noParticles;
    partMass += mass;
    partE +=
        solver().m_material->cp() / solver().m_material->gammaMinusOne() * mass * solver().m_partList[id].m_temperature;
    MFloat velMagSquared = 0;
    for(MInt i = 0; i < nDim; i++) {
      partMomentum[i] += (mass * solver().m_partList[id].m_velocity[i]);
      velMagSquared += POW2(solver().m_partList[id].m_velocity[i]);
    }
    partE += 0.5 * mass * velMagSquared;
  }
  m_particleCV[m_sprayDataStep][0] = partMass;
  m_particleCV[m_sprayDataStep][1] = partE;
  for(MInt i = 0; i < nDim; i++) {
    m_particleCV[m_sprayDataStep][2 + i] = partMomentum[i];
  }
}

◆ particlePenetration()

template<MInt nDim>

void PostProcessingLPT< nDim >::particlePenetration

protected

Author: Sven Berger, Tim Wegmann

Date: Jan. 2021

Definition at line 229 of file postprocessinglpt.cpp.

                                                  {
  TRACE();
 
  // different penetration measurements
  // 0: overal all maximum
  // 1: parcel with 90% liquid mass fraction
  // 2: parcel with LVFlimit
  // 3: parcel with LVFlimit on refLvl
  const MInt noPen = 4;
  array<array<MFloat, noPen>, nDim + 1> maxLiqPen{};
 
  const MFloat massFracLimit = 0.90;
  const MFloat LVFlimit = 0.025; // 0.01 as first estimate
  const MInt refLvl = 10;
 
  // spray-width measurements in certain plans
  static constexpr MInt nPlanes = 3;
  // static constexpr MFloat yPlaneBorder = 0.1/75.0;
  static constexpr MFloat yPlaneBorder = 0.001333;
  // static constexpr MFloat yPlanes[nPlanes] = {15.0/75.0 , 25.0/75.0, 35.0/75.0};
  static constexpr MFloat yPlanes[nPlanes] = {0.2, 0.3333, 0.46667};
 
  vector<MFloat> width(nPlanes);
  for(MInt n = 0; n < nPlanes; n++) {
    width[n] = 0.0;
  }
 
  auto assignLarger = [&](MFloat& A, MFloat b) {
    if(b > A) {
      A = b;
    }
  };
 
 
  for(MInt id = 0; id < solver().a_noParticles(); ++id) {
    array<MFloat, nDim + 1> distance{};
    for(MInt i = 0; i < nDim; i++) {
      distance[i] = abs(solver().m_partList[id].m_position[i] - solver().m_spawnCoord[i]);
    }
 
    distance[nDim] = sqrt(POW2(distance[0]) + POW2(distance[1]) + POW2(distance[2]));
 
 
    for(MInt i = 0; i < nDim + 1; i++) {
      assignLarger(maxLiqPen[i][0], distance[i]);
    }
 
    for(MInt i = 0; i < nPlanes; i++) {
      if(fabs(distance[1] - yPlanes[i]) < yPlaneBorder) {
        assignLarger(width[i], distance[0]);
        assignLarger(width[i], distance[2]);
      }
    }
    const MInt cellId = solver().m_partList[id].m_cellId;
    if(cellId < 0) continue;
    if(solver().a_volumeFraction(cellId) > LVFlimit) {
      for(MInt i = 0; i < nDim + 1; i++) {
        assignLarger(maxLiqPen[i][1], distance[i]);
      }
    }
  }
 
  for(MInt cellId = 0; cellId < solver().noInternalCells(); cellId++) {
    const MFloat massFraction =
        solver().a_volumeFraction(cellId) * solver().m_material->density() / solver().a_fluidDensity(cellId);
    array<MFloat, nDim + 1> distance{};
 
    if(massFraction > massFracLimit) {
      array<MFloat, nDim> cellCoordinate{};
      for(MInt i = 0; i < nDim; i++) {
        cellCoordinate[i] = solver().c_coordinate(cellId, i);
        distance[i] = abs(cellCoordinate[i] - solver().m_spawnCoord[i]);
      }
      distance[nDim] = sqrt(POW2(distance[0]) + POW2(distance[1]) + POW2(distance[2]));
 
      for(MInt i = 0; i < nDim + 1; i++) {
        assignLarger(maxLiqPen[i][2], distance[i]);
      }
    }
    if(solver().a_level(cellId) == refLvl) {
      solver().reduceData(cellId, &solver().a_volumeFraction(0), 1);
      if(solver().a_volumeFraction(cellId) > LVFlimit) {
        array<MFloat, nDim> cellCoordinate{};
        for(MInt i = 0; i < nDim; i++) {
          cellCoordinate[i] = solver().c_coordinate(cellId, i);
          distance[i] = abs(cellCoordinate[i] - solver().m_spawnCoord[i]);
        }
        distance[nDim] = sqrt(POW2(distance[0]) + POW2(distance[1]) + POW2(distance[2]));
 
        for(MInt i = 0; i < nDim + 1; i++) {
          assignLarger(maxLiqPen[i][3], distance[i]);
        }
      }
    }
  }
 
  // save data:
  MInt it = 0;
  for(MInt n = 0; n < noPen; n++) {
    for(MInt i = 0; i < nDim + 1; i++) {
      m_particlePen[m_sprayDataStep][it++] = maxLiqPen[i][n];
    }
  }
 
  for(MInt n = 0; n < nPlanes; n++) {
    m_particlePen[m_sprayDataStep][it++] = width[n];
  }
 
  if(it > 19) {
    mTerm(1, AT_, "PP: Penetration-Storage not matching!");
  }
}

◆ resetDataStep()

template<MInt nDim>

void PostProcessingLPT< nDim >::resetDataStep ( )

inlineprotected

Definition at line 69 of file postprocessinglpt.h.

69{ m_sprayDataStep = 0; };

◆ solver()

template<MInt nDim>

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

inline

Definition at line 48 of file postprocessinglpt.h.

48{ return *m_ppSolver; }

◆ writeLPTSolutionFile()

template<MInt nDim>

void PostProcessingLPT< nDim >::writeLPTSolutionFile

overrideprotectedvirtual

Author: Tim Wegmann, Johannes Grafen

Date: Jan. 2021

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

Definition at line 475 of file postprocessinglpt.cpp.

                                                   {
  TRACE();
 
  if(!solver().isActive()) return;
 
  solver().crankAngleSolutionOutput();
 
  if(m_writeParLog && globalTimeStep % m_parLogInterval == 0) writeParticleLog();
 
  if((m_LPTSolutionInterval > 0 && globalTimeStep % m_LPTSolutionInterval == 0) || this->m_finalTimeStep
     || this->m_forceOutput) {
    if(solver().domainId() == 0) {
      cerr << "Writing particle File @" << globalTimeStep << "(" << solver().m_time << ")... ";
    }
    solver().writePartData();
 
    if(solver().m_collisions > 0) {
      solver().writeCollData();
    }
 
    if(solver().domainId() == 0) {
      cerr << " done. " << endl;
    }
  }
}

◆ writeParticleLog()

template<MInt nDim>

void PostProcessingLPT< nDim >::writeParticleLog

protected

Author: Johannes Grafen

Definition at line 537 of file postprocessinglpt.cpp.

                                               {
  if(solver().globalNoParticles() > 1) {
    m_writeParLog = false;
    std::cerr << "writing particle.log is currently only implemented for single particles!" << std::endl;
    return;
  }
 
  if(solver().m_partList.size() < 1) return;
 
 
  std::ofstream parLog;
  LPTSpherical<nDim>& part = solver().m_partList[0];
  if(m_writeParLog) {
    parLog.open("particle.log", std::ios::app);
 
    parLog << std::setw(5) << globalTimeStep << "\t";
    for(const MFloat& i : part.m_position) {
      parLog << std::setw(10) << std::setprecision(12) << i << "\t";
    }
    for(const MFloat& i : part.m_velocity) {
      parLog << std::setw(10) << i << "\t";
    }
 
    const MFloat T = solver().a_fluidTemperature(part.m_cellId);
    const MFloat fluidViscosity = solver().m_material->dynViscosityFun(T);
    const MFloat relVel = part.magRelVel(&part.m_oldFluidVel[0], &part.m_oldVel[0]);
 
    const MFloat ReP = part.particleRe(relVel, part.m_oldFluidDensity, fluidViscosity) * part.s_Re;
    const MFloat CD = part.dragFactor(ReP) * 24 / ReP;
 
    parLog << std::setw(10) << ReP << "\t";
    parLog << std::setw(10) << CD << "\t" << std::endl;
    parLog.close();
  }
}

Friends And Related Function Documentation

◆ LPT

template<MInt nDim>

template<MInt nDim_>

friend class LPT

friend

Definition at line 28 of file postprocessinglpt.h.

◆ PostProcessing

template<MInt nDim>

template<MInt nDim_, class ppType >

friend class PostProcessing

friend

Definition at line 26 of file postprocessinglpt.h.

Member Data Documentation

◆ m_AvgRe_p

template<MInt nDim>

MFloat PostProcessingLPT< nDim >::m_AvgRe_p = F0

protected

Definition at line 72 of file postprocessinglpt.h.

◆ m_cInjData

template<MInt nDim>

MFloat** PostProcessingLPT< nDim >::m_cInjData = nullptr

protected

Definition at line 71 of file postprocessinglpt.h.

◆ m_EkinP

template<MInt nDim>

MFloat PostProcessingLPT< nDim >::m_EkinP = F0

protected

Definition at line 74 of file postprocessinglpt.h.

◆ m_parLogApp

template<MInt nDim>

MBool PostProcessingLPT< nDim >::m_parLogApp = false

protected

Definition at line 78 of file postprocessinglpt.h.

◆ m_parLogInterval

template<MInt nDim>

MInt PostProcessingLPT< nDim >::m_parLogInterval = 50

protected

Definition at line 77 of file postprocessinglpt.h.

◆ m_ppSolver

template<MInt nDim>

SolverType* PostProcessingLPT< nDim >::m_ppSolver

protected

Definition at line 58 of file postprocessinglpt.h.

◆ m_VpRMS

template<MInt nDim>

MFloat PostProcessingLPT< nDim >::m_VpRMS = F0

protected

Definition at line 73 of file postprocessinglpt.h.

◆ m_writeParLog

template<MInt nDim>

MBool PostProcessingLPT< nDim >::m_writeParLog = false

protected

Definition at line 76 of file postprocessinglpt.h.

The documentation for this class was generated from the following files:

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/POST/postprocessinglpt.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/POST/postprocessinglpt.cpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ SolverType

Constructor & Destructor Documentation

◆ PostProcessingLPT()

◆ ~PostProcessingLPT()

Member Function Documentation

◆ advanceDataStep()

◆ computeParticleStatistics()

◆ getInjectionData()

◆ initLPTSolutionFile()

◆ initParticleLog()

◆ initParticleStatistics()

◆ initSprayData()

◆ parcelStatistics()

◆ particleMass()

◆ particlePenetration()

◆ resetDataStep()

◆ solver()

◆ writeLPTSolutionFile()

◆ writeParticleLog()

Friends And Related Function Documentation

◆ LPT

◆ PostProcessing

Member Data Documentation

◆ m_AvgRe_p

◆ m_cInjData

◆ m_EkinP

◆ m_parLogApp

◆ m_parLogInterval

◆ m_ppSolver

◆ m_VpRMS

◆ m_writeParLog