#include <postdata.h>

Inheritance diagram for PostData< nDim_ >:

Collaboration diagram for PostData< nDim_ >:

Public Types
using	CartesianSolver = typename maia::CartesianSolver< nDim, PostData >

using	Grid = typename CartesianSolver::Grid

using	GridProxy = typename CartesianSolver::GridProxy

using	SolverCell = PostCell

using	Cell = typename maia::grid::tree::Tree< nDim >::Cell

using	Geom = Geometry< nDim >

Public Types inherited from maia::CartesianSolver< nDim_, PostData< nDim_ > >
using	Grid = CartesianGrid< nDim >

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

using	Geom = Geometry< nDim >

using	TreeProxy = maia::grid::tree::TreeProxy< nDim >

using	Cell = maia::grid::tree::Cell

Public Member Functions
	PostData (MInt, GridProxy &gridProxy_, Geom &geometry_, const MPI_Comm comm)

	~PostData ()

Geom &	geometry () const
	Access the solver's geometry. More...

MInt	noInternalCells () const override
	Return the number of internal cells within this solver. More...

MFloat	timeStep () const

MFloat	time () const override
	Return the time. More...

void	preTimeStep () override

void	postTimeStep () override

MBool	solutionStep () override

void	initSolver () override

void	finalizeInitSolver () override

MBool	prepareRestart (MBool, MBool &) override
	Prepare the solvers for a grid-restart. More...

void	writeRestartFile (const MBool, const MBool, const MString, MInt *) override

void	writeRestartFile (MBool) override

void	saveDataFile (const MBool writeBackup, const MString fileName, const MInt noVars, std::vector< MString > &variablesName, MFloat *variables)

void	saveRestartFile (const MBool writeBackup)

void	loadRestartFile ()

void	loadMeanFile (const MString fileName)
	load a file for averaging More...

void	loadGridFlowVars (const MChar *fileName, MInt noVariables, std::vector< MString > name)
	This function reads the parallel Netcdf cartesian grid cell based solution/restart file currently used in postData! More...

void	saveSolverSolution (const MBool, const MBool)

void	reIntAfterRestart (MBool)
	This function resets the grid-trigger after a restart that is handled by the grid-controller! More...

void	prepareAdaptation () override
	prepare solver adaptation More...

void	postAdaptation () override
	reinit the solver after a single adaptation step More...

void	finalizeAdaptation () override
	reinit the solver after the full adaptation loop! More...

void	setSensors (std::vector< std::vector< MFloat > > &sensors, std::vector< MFloat > &sensorWeight, std::vector< std::bitset< 64 > > &sensorCellFlag, std::vector< MInt > &sensorSolverId) override
	set the sensors for a single adaptation step More...

void	removeChilds (const MInt) override
	Coarsen the given cell. More...

void	removeCell (const MInt) override
	Remove the given cell. More...

void	refineCell (const MInt) override

void	swapCells (const MInt, const MInt) override

void	swapProxy (const MInt cellId0, const MInt cellId1) override

MInt	cellOutside (const MFloat *, const MInt, const MInt) override
	checks if a child lies outSide of the domain! necessary for refinement at the bndry! More...

void	resizeGridMap () override
	Swap the given cells. More...

virtual void	cleanUp ()

void	copyGridProperties ()

void	setAndAllocateSolverData (const MBool)

void	setVariableNames ()

MInt	c_noCells () const
	Returns the number of grid-cells. More...

MInt	a_noCells () const

MInt	a_hasNeighbor (const MInt cellId, const MInt dir) const
	Returns wether cell `cellId` has a neighbor in dir `dir`. More...

const MFloat &	c_coordinate (const MInt cellId, const MInt dim)
	Returns the coordinate of the cell from the grid().tree() `cellId` for dimension `dir`. More...

MFloat	c_coordinate (const MInt cellId, const MInt dim) const
	Returns the coordinate of the cell from the grid().tree() `cellId` for dimension `dir`. More...

MInt	c_level (const MInt cellId) const
	Returns the grid level of the cell `cellId`. More...

MInt	a_level (const MInt) const

MInt	c_noChildren (const MInt cellId) const
	Returns the number of children of the cell `cellId`. More...

MLong	c_parentId (const MInt cellId) const
	Returns the grid parent id of the cell `cellId`. More...

MLong	c_globalId (const MInt cellId) const
	Returns the global grid id of the grid cell `cellId`. More...

MLong	c_childId (const MInt cellId, const MInt pos) const

MInt	noVariables () const
	Return the number of primitive variables. More...

MFloat &	a_variable (const MInt cellId, const MInt varId)
	Returns conservative variable `v` of the cell `cellId` for variables `varId`. More...

MFloat	a_variable (const MInt cellId, const MInt varId) const
	Returns conservative variable `v` of the cell `cellId` for variables `varId`. More...

MFloat &	a_averagedVariable (const MInt cellId, const MInt varId)

MBool	isMeanFile () const

MInt	fileNoVars () const

std::vector< MString >	fileVarNames () const

MBool	a_isHalo (const MInt cellId) const
	Returns IsHalo of the cell `cellId`. More...

maia::post::cell::BitsetType::reference	a_isHalo (const MInt cellId)
	Returns IsHalo of the cell `cellId`. More...

MBool	a_isWindow (const MInt cellId) const
	Returns IsWindow of the cell `cellId`. More...

maia::post::cell::BitsetType::reference	a_isWindow (const MInt cellId)
	Returns IsWindow of the cell `cellId`. More...

void	a_resetPropertiesSolver (const MInt cellId)
	Returns property `p` of the cell `cellId`. More...

std::pair< MInt, MInt >	getPropertyVariableOffset (MString s)

void	setPropertyVariableOffset (MString s, MInt start, MInt length)

MString	getVariableName (MInt offset)

void	setCellWeights (MFloat *) override
	sets the cell-weight for balancing and a restarting More...

MInt	noLoadTypes () const override
	Return the number of Ls load types. More...

void	getDefaultWeights (MFloat *weights, std::vector< MString > &names) const
	Return the default weights for all load quantities. More...

void	getLoadQuantities (MInt *const loadQuantities) const override
	Return the cumulative load quantities on this domain. More...

MFloat	getCellLoad (const MInt cellId, const MFloat *const weights) const override
	Return the load of a single cell (given computational weights). More...

void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &domainInfo) override
	Return decomposition information, i.e. number of local elements,... More...

void	getSolverTimings (std::vector< std::pair< MString, MFloat > > &solverTimings, const MBool) override
	Get solver timings. More...

MInt	noCellDataDlb () const override
	Methods to inquire solver data information. More...

MInt	cellDataTypeDlb (const MInt dataId) const override

MInt	cellDataSizeDlb (const MInt dataId, const MInt gridCellId) override
	Return data size to be communicated during DLB for a grid cell and given data id. More...

void	getCellDataDlb (const MInt dataId, const MInt oldNoCells, const MInt const bufferIdToCellId, MFloat const data) override

void	setCellDataDlb (const MInt dataId, const MFloat *const data) override
	Set solver data for DLB. More...

Public Member Functions inherited from maia::CartesianSolver< nDim_, PostData< nDim_ > >
	CartesianSolver (const MInt solverId, GridProxy &gridProxy_, const MPI_Comm comm, const MBool checkActive=false)

MInt	minLevel () const
	Read-only accessors for grid data. More...

MInt	maxLevel () const

MInt	maxNoGridCells () const

MInt	maxRefinementLevel () const

MInt	maxUniformRefinementLevel () const

MInt	noNeighborDomains () const

MInt	neighborDomain (const MInt id) const

MLong	domainOffset (const MInt id) const

MInt	noHaloLayers () const

MInt	noHaloCells (const MInt domainId) const

MInt	haloCellId (const MInt domainId, const MInt cellId) const

MInt	noWindowCells (const MInt domainId) const

MInt	windowCellId (const MInt domainId, const MInt cellId) const

MString	gridInputFileName () const

MFloat	reductionFactor () const

MFloat	centerOfGravity (const MInt dir) const

MInt	neighborList (const MInt cellId, const MInt dir) const

const MLong &	localPartitionCellGlobalIds (const MInt cellId) const

MLong	localPartitionCellOffsets (const MInt index) const

MInt	noMinCells () const

MInt	minCell (const MInt id) const

const MInt &	haloCell (const MInt domainId, const MInt cellId) const

const MInt &	windowCell (const MInt domainId, const MInt cellId) const

MBool	isActive () const override

constexpr GridProxy &	grid () const

GridProxy &	grid ()

virtual void	sensorDerivative (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorDivergence (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorTotalPressure (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorEntropyGrad (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorEntropyQuot (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorVorticity (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorInterface (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

void	sensorLimit (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt, std::function< MFloat(MInt)>, const MFloat, const MInt *, const MBool, const MBool allowCoarsening=true)
	simple sensor to apply a limit for a value More...

void	sensorSmooth (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)
	sensor to smooth level jumps NOTE: only refines additional cells to ensure a smooth level transition this requires that all other sensors are frozen i.e. no refine/coarse sensors set! More...

void	sensorBand (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)
	This sensor generates a max refinement band around the cells with max refinement level. In order for it to work, the property addedAdaptationSteps has to be equal to /maxRefinementLevel() - minLevel()/. This sensor also ensures a smooth transition between levels. Do not use together with sensorSmooth. More...

virtual void	sensorMeanStress (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorParticle (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorSpecies (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorPatch (std::vector< std::vector< MFloat > > &sensor, std::vector< std::bitset< 64 > > &sensorCellFlag, std::vector< MFloat > &sensorWeight, MInt sensorOffset, MInt sen)

virtual void	sensorCutOff (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

void	saveSensorData (const std::vector< std::vector< MFloat > > &sensors, const MInt &level, const MString &gridFileName, const MInt *const recalcIds) override
	Saves all sensor values for debug/tunig purposes. More...

void	assertValidGridCellId (const MInt) const

MLong	c_parentId (const MInt cellId) const
	Returns the grid parent id of the cell `cellId`. More...

MLong	c_neighborId (const MInt cellId, const MInt dir) const
	Returns the grid neighbor id of the grid cell `cellId` `dir`. More...

MInt	c_noCells () const

MInt	c_level (const MInt cellId) const

MLong	c_globalGridId (const MInt cellId)

void	exchangeData (T *data, const MInt dataBlockSize=1)
	Exchange memory in 'data' assuming a solver size of 'dataBlockSize' per cell. More...

void	exchangeLeafData (std::function< T &(MInt, MInt)> data, const MInt noDat=1)
	Blocking exchange memory in 'data' assuming a solver size of 'dataBlockSize' per cell NOTE: exchange is only performed on leaf-cells and leaf-NeighborDomains Assumes, that updateLeafCellExchange has been called in the proxy previously! More...

void	exchangeSparseLeafValues (G getData, S setData, const MInt dataSize, M cellMapping)
	Exchange of sparse data structures on max Level. More...

void	exchangeAzimuthalPer (T *data, MInt dataBlockSize=1, MInt firstBlock=0)
	Exchange of sparse data structures on max Level. More...

void	collectVariables (T *variablesIn, ScratchSpace< T > &variablesOut, const std::vector< MString > &variablesNameIn, std::vector< MString > &variablesNameOut, const MInt noVars, const MInt noCells, const MBool reverseOrder=false)
	generalised helper function for writing restart files! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	collectVariables (T **variablesIn, ScratchSpace< T > &variablesOut, const std::vector< MString > &variablesNameIn, std::vector< MString > &variablesNameOut, const MInt noVars, const MInt noCells)
	generalised helper function for writing restart files! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	saveGridFlowVars (const MChar fileName, const MChar gridFileName, const MInt noTotalCells, const MInt noInternal, MFloatScratchSpace &dbVariables, std::vector< MString > &dbVariablesName, MInt noDbVars, MIntScratchSpace &idVariables, std::vector< MString > &idVariablesName, MInt noIdVars, MFloatScratchSpace &dbParameters, std::vector< MString > &dbParametersName, MIntScratchSpace &idParameters, std::vector< MString > &idParametersName, MInt *recalcIds, MFloat time)
	This function writes the parallel Netcdf cartesian grid cell based solution/restart file currently used in PostData, LPT and LS solvers! More...

void	collectParameters (T, ScratchSpace< T > &, const MChar *, std::vector< MString > &)
	This function collects a single parameters for the massivley parallel IO functions. More...

void	calcRecalcCellIdsSolver (const MInt *const recalcIdsTree, MInt &noCells, MInt &noInternalCellIds, std::vector< MInt > &recalcCellIdsSolver, std::vector< MInt > &reorderedCellIds)
	Derive recalc cell ids of the solver and reordered cell ids. More...

Public Member Functions inherited from Solver
MString	getIdentifier (const MBool useSolverId=false, const MString preString="", const MString postString="_")

virtual	~Solver ()=default

virtual MInt	noInternalCells () const =0
	Return the number of internal cells within this solver. More...

virtual MFloat	time () const =0
	Return the time. More...

virtual MInt	noVariables () const
	Return the number of variables. More...

virtual void	getDimensionalizationParams (std::vector< std::pair< MFloat, MString > > &) const
	Return the dimensionalization parameters of this solver. More...

void	updateDomainInfo (const MInt domainId, const MInt noDomains, const MPI_Comm mpiComm, const MString &loc)
	Set new domain information. More...

virtual MFloat &	a_slope (const MInt, MInt const, const MInt)

virtual MBool	a_isBndryCell (const MInt) const

virtual MFloat &	a_FcellVolume (MInt)

virtual MInt	getCurrentTimeStep () const

virtual void	accessSampleVariables (MInt, MFloat *&)

virtual void	getSampleVariableNames (std::vector< MString > &NotUsed(varNames))

virtual MBool	a_isBndryGhostCell (MInt) const

virtual void	saveCoarseSolution ()

virtual void	getSolverSamplingProperties (std::vector< MInt > &NotUsed(samplingVarIds), std::vector< MInt > &NotUsed(noSamplingVars), std::vector< std::vector< MString > > &NotUsed(samplingVarNames), const MString NotUsed(featureName)="")

virtual void	initSolverSamplingVariables (const std::vector< MInt > &NotUsed(varIds), const std::vector< MInt > &NotUsed(noSamplingVars))

virtual void	calcSamplingVariables (const std::vector< MInt > &NotUsed(varIds), const MBool NotUsed(exchange))

virtual void	calcSamplingVarAtPoint (const MFloat NotUsed(point), const MInt NotUsed(id), const MInt NotUsed(sampleVarId), MFloat NotUsed(state), const MBool NotUsed(interpolate)=false)

virtual void	balance (const MInt const NotUsed(noCellsToReceiveByDomain), const MInt const NotUsed(noCellsToSendByDomain), const MInt *const NotUsed(targetDomainsByCell), const MInt NotUsed(oldNoCells))
	Perform load balancing. More...

virtual MBool	hasSplitBalancing () const
	Return if load balancing for solver is split into multiple methods or implemented in balance() More...

virtual void	balancePre ()

virtual void	balancePost ()

virtual void	finalizeBalance ()

virtual void	resetSolver ()
	Reset the solver/solver for load balancing. More...

virtual void	cancelMpiRequests ()
	Cancel open mpi (receive) requests in the solver (e.g. due to interleaved execution) More...

virtual void	setCellWeights (MFloat *)
	Set cell weights. More...

virtual MInt	noLoadTypes () const

virtual void	getDefaultWeights (MFloat *NotUsed(weights), std::vector< MString > &NotUsed(names)) const

virtual void	getLoadQuantities (MInt *const NotUsed(loadQuantities)) const

virtual MFloat	getCellLoad (const MInt NotUsed(cellId), const MFloat *const NotUsed(weights)) const

virtual void	limitWeights (MFloat *NotUsed(weights))

virtual void	localToGlobalIds ()

virtual void	globalToLocalIds ()

virtual MInt	noCellDataDlb () const
	Methods to inquire solver data information. More...

virtual MInt	cellDataTypeDlb (const MInt NotUsed(dataId)) const

virtual MInt	cellDataSizeDlb (const MInt NotUsed(dataId), const MInt NotUsed(cellId))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MInt const NotUsed(data))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MLong const NotUsed(data))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MFloat const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MInt *const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MLong *const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MFloat *const NotUsed(data))

virtual void	getGlobalSolverVars (std::vector< MFloat > &NotUsed(globalFloatVars), std::vector< MInt > &NotUsed(globalIntVars))

virtual void	setGlobalSolverVars (std::vector< MFloat > &NotUsed(globalFloatVars), std::vector< MInt > &NotUsed(globalIdVars))

void	enableDlbTimers ()

void	reEnableDlbTimers ()

void	disableDlbTimers ()

MBool	dlbTimersEnabled ()

void	startLoadTimer (const MString name)

void	stopLoadTimer (const MString &name)

void	stopIdleTimer (const MString &name)

void	startIdleTimer (const MString &name)

MBool	isLoadTimerRunning ()

virtual MInt	noSolverTimers (const MBool NotUsed(allTimings))

virtual void	getSolverTimings (std::vector< std::pair< MString, MFloat > > &NotUsed(solverTimings), const MBool NotUsed(allTimings))

virtual void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &NotUsed(domainInfo))

void	setDlbTimer (const MInt timerId)

virtual void	prepareAdaptation (std::vector< std::vector< MFloat > > &, std::vector< MFloat > &, std::vector< std::bitset< 64 > > &, std::vector< MInt > &)

virtual void	reinitAfterAdaptation ()

virtual void	prepareAdaptation ()
	prepare adaptation for split adaptation before the adaptation loop More...

virtual void	setSensors (std::vector< std::vector< MFloat > > &, std::vector< MFloat > &, std::vector< std::bitset< 64 > > &, std::vector< MInt > &)
	set solver sensors for split adaptation within the adaptation loop More...

virtual void	saveSensorData (const std::vector< std::vector< MFloat > > &, const MInt &, const MString &, const MInt *const)

virtual void	postAdaptation ()
	post adaptation for split adaptation within the adaptation loop More...

virtual void	finalizeAdaptation ()
	finalize adaptation for split sadptation after the adaptation loop More...

virtual void	refineCell (const MInt)
	Refine the given cell. More...

virtual void	removeChilds (const MInt)
	Coarsen the given cell. More...

virtual void	removeCell (const MInt)
	Remove the given cell. More...

virtual void	swapCells (const MInt, const MInt)
	Swap the given cells. More...

virtual void	swapProxy (const MInt, const MInt)
	Swap the given cells. More...

virtual MInt	cellOutside (const MFloat *, const MInt, const MInt)
	Check whether cell is outside the fluid domain. More...

virtual void	resizeGridMap ()
	Swap the given cells. More...

virtual MBool	prepareRestart (MBool, MBool &)
	Prepare the solvers for a grid-restart. More...

virtual void	reIntAfterRestart (MBool)

MPI_Comm	mpiComm () const
	Return the MPI communicator used by this solver. More...

virtual MInt	domainId () const
	Return the domainId (rank) More...

virtual MInt	noDomains () const

virtual MBool	isActive () const

void	setSolverStatus (const MBool status)

MBool	getSolverStatus ()
	Get the solver status indicating if the solver is currently active in the execution recipe. More...

MString	testcaseDir () const
	Return the testcase directory. More...

MString	outputDir () const
	Return the directory for output files. More...

MString	restartDir () const
	Return the directory for restart files. More...

MString	solverMethod () const
	Return the solverMethod of this solver. More...

MString	solverType () const
	Return the solverType of this solver. More...

MInt	restartInterval () const
	Return the restart interval of this solver. More...

MInt	restartTimeStep () const
	Return the restart interval of this solver. More...

MInt	solverId () const
	Return the solverId. More...

MBool	restartFile ()

MInt	readSolverSamplingVarNames (std::vector< MString > &varNames, const MString featureName="") const
	Read sampling variables names, store in vector and return the number of sampling variables. More...

virtual MBool	hasRestartTimeStep () const

virtual MBool	forceAdaptation ()

virtual void	preTimeStep ()=0

virtual void	postTimeStep ()=0

virtual void	initSolver ()=0

virtual void	finalizeInitSolver ()=0

virtual void	saveSolverSolution (const MBool NotUsed(forceOutput)=false, const MBool NotUsed(finalTimeStep)=false)=0

virtual void	cleanUp ()=0

virtual MBool	solutionStep ()

virtual void	preSolutionStep (MInt)

virtual MBool	postSolutionStep ()

virtual MBool	solverConverged ()

virtual void	getInterpolatedVariables (MInt, const MFloat , MFloat )

virtual void	loadRestartFile ()

virtual MInt	determineRestartTimeStep () const

virtual void	writeRestartFile (MBool)

virtual void	writeRestartFile (const MBool, const MBool, const MString, MInt *)

virtual void	setTimeStep ()

virtual void	implicitTimeStep ()

virtual void	prepareNextTimeStep ()

Public Attributes
maia::post::collector::PostCellCollector< nDim >	m_cells
	Collector for POST data. More...

Geom *	m_geometry

MBool	m_forceWriteRestart = false

MFloat	m_timeStep = NAN

MFloat	m_time = NAN

MString	m_outputFormat

MInt	m_sourceVarsIndex

std::vector< MString >	m_variablesName

MFloat **	m_averagedVars = nullptr

Public Attributes inherited from Solver
std::set< MInt >	m_freeIndices

MBool	m_singleAdaptation = false

MBool	m_splitAdaptation = true

MBool	m_saveSensorData = false

Static Public Attributes
static constexpr MInt	nDim = nDim_

Protected Member Functions
MInt	getVariablePropertyIndex (MString s)
	Return the number of primitive variables. More...

void	readProperties ()

MBool	hasSplitBalancing () const override
	Return if load balancing for solver is split into multiple methods or implemented in balance() More...

void	resetSolver () override
	Reset the solver prior to load balancing. More...

void	balancePre () override
	Reinitialize solver for DLB prior to setting solution data. More...

void	balancePost () override
	Reinitialize solver for DLB after to setting solution data. More...

void	finalizeBalance () override
	Reinitialize solver after all data structures have been recreated. More...

const std::vector< std::vector< MString > >	m_averageVariableName

const std::vector< std::vector< MString > >	m_averageVariableName

Protected Member Functions inherited from maia::CartesianSolver< nDim_, PostData< nDim_ > >
void	identifyBoundaryCells (MBool *const isInterface, const std::vector< MInt > &bndCndIds=std::vector< MInt >())

void	identifyBoundaryCells ()

MBool	cellIsOnGeometry (MInt cellId, Geometry< nDim > *geom)
	checks whether a cell lies on a certain geometry copied the essential part from identifyBoundaryCells More...

void	setBoundaryDistance (const MBool const interfaceCell, const MFloat const outerBandWidth, MFloatScratchSpace &distance)
	transverses over all neighboring cells for a specified length More...

void	markSurrndCells (MIntScratchSpace &inList, const MInt bandWidth, const MInt level, const MBool refineDiagonals=true)

void	receiveWindowTriangles ()
	Receives triangles from neighbors contained in their window cells and inserts them locally. More...

void	compactCells ()
	Removes all holes in the cell collector and moves halo cells to the back of the collector. More...

MInt	createCellId (const MInt gridCellId)

void	removeCellId (const MInt cellId)

MInt	inCell (const MInt cellId, MFloat *point, MFloat fac=F1)

MInt	setUpInterpolationStencil (const MInt cellId, MInt , const MFloat , std::function< MBool(MInt, MInt)>, MBool allowIncompleteStencil)

MFloat	interpolateFieldData (MInt , MFloat , MInt varId, std::function< MFloat(MInt, MInt)> scalarField, std::function< MFloat(MInt, MInt)> coordinate)

MFloat	leastSquaresInterpolation (MInt , MFloat , MInt varId, std::function< MFloat(MInt, MInt)> scalarField, std::function< MFloat(MInt, MInt)> coordinate)

void	checkNoHaloLayers ()
	check that each solver has the required number of haloLayers for leaf cells!!! TODO labels:toenhance under production, needs to be cleaned up! More...

void	mapInterpolationCells (std::map< MInt, MInt > &cellMap)

void	setHaloCellsOnInactiveRanks ()

void	patchRefinement (std::vector< std::vector< MFloat > > &sensors, std::vector< std::bitset< 64 > > &sensorCellFlag, std::vector< MFloat > &sensorWeight, MInt sensorOffset, MInt sen)

void	reOrderCellIds (std::vector< MInt > &reOrderedCells)
	reOrder cellIds before writing the restart file! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	recomputeGlobalIds (std::vector< MInt > &, std::vector< MLong > &)
	reOrder cellIds before writing the restart file! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	extractPointIdsFromGrid (Collector< PointBasedCell< nDim > > &, Collector< CartesianGridPoint< nDim > > &, const MBool, const std::map< MInt, MInt > &, MInt levelThreshold=999999, MFloat *bBox=nullptr, MBool levelSetMb=false) const
	Creates a list of unique corner points for all cells using a hash map levelThreshold optionally specifies the maximum cell level to be extracted bBox optionally specifies a bounding to box to which the extracted domain shall be truncated. More...

Protected Member Functions inherited from Solver
	Solver (const MInt solverId, const MPI_Comm comm, const MBool isActive=true)

MFloat	returnLoadRecord () const

MFloat	returnIdleRecord () const

Protected Attributes
const std::vector< MString >	m_propertyName

std::vector< std::pair< MInt, MInt > >	m_variableOffset

MInt	m_noVariables = 0

MInt	m_adaptationLevel = -1

MBool	m_forceAdaptation = false

MBool	m_adaptationSinceLastRestart = false

MString	m_currentGridFileName {}

MInt	m_loadBalancingReinitStage = -1

MBool	m_isMeanFile = false

MInt	m_fileNoVars = -1

std::vector< MString >	m_fileVarNames {}

Protected Attributes inherited from maia::CartesianSolver< nDim_, PostData< nDim_ > >
MInt *	m_rfnBandWidth

MInt	m_noSensors

MInt	m_adaptationInterval

MInt	m_adaptationStep

std::vector< MInt >	m_maxSensorRefinementLevel

std::vector< MFloat >	m_sensorWeight

std::vector< MFloat >	m_sensorDerivativeVariables

MBool	m_adaptation

MBool	m_adapts

MInt	m_noInitialSensors

MBool	m_resTriggeredAdapt

MInt	m_noSmoothingLayers

MInt	m_sensorBandAdditionalLayers

MBool	m_sensorInterface

MBool	m_sensorParticle

std::vector< MString >	m_sensorType

MInt *	m_recalcIds

std::vector< fun >	m_sensorFnPtr

MInt	m_maxNoSets

std::vector< MFloat >	m_azimuthalCartRecCoord

const MInt	m_revDir [6]

const MInt	m_noDirs

Protected Attributes inherited from Solver
MFloat	m_Re {}
	the Reynolds number More...

MFloat	m_Ma {}
	the Mach number More...

MInt	m_solutionInterval
	The number of timesteps before writing the next solution file. More...

MInt	m_solutionOffset {}

std::set< MInt >	m_solutionTimeSteps

MInt	m_restartInterval
	The number of timesteps before writing the next restart file. More...

MInt	m_restartTimeStep

MInt	m_restartOffset

MString	m_solutionOutput

MBool	m_useNonSpecifiedRestartFile = false

MBool	m_initFromRestartFile

MInt	m_residualInterval
	The number of timesteps before writing the next residual. More...

const MInt	m_solverId
	a unique solver identifier More...

MFloat *	m_outerBandWidth = nullptr

MFloat *	m_innerBandWidth = nullptr

MInt *	m_bandWidth = nullptr

MBool	m_restart = false

MBool	m_restartFile = false

Static Protected Attributes
static const std::vector< std::vector< MString > >	m_averageVariableName

Private Member Functions
template<typename dataType >
void	setCellDataDlb_ (const MInt dataId, const dataType *const data)
	Set the solver cell data after DLB. More...

template<typename dataType >
void	getCellDataDlb_ (const MInt dataId, const MInt oldNoCells, const MInt const bufferIdToCellId, dataType const data)
	Store the solver data for a given data id ordered in the given buffer for DLB. More...

Static Private Member Functions
static constexpr std::array< MInt, nDim >	getArray012 ()
	Static indices for accessing post variables in nDim spatial dimensions. More...

Additional Inherited Members
Protected Types inherited from maia::CartesianSolver< nDim_, PostData< nDim_ > >
using	fun = void(CartesianSolver< nDim, PostData< nDim_ > >::*)(std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

Detailed Description

template<MInt nDim_>
class PostData< nDim_ >

Definition at line 23 of file postdata.h.

Member Typedef Documentation

◆ CartesianSolver

template<MInt nDim_>

using PostData< nDim_ >::CartesianSolver = typename maia::CartesianSolver<nDim, PostData>

Definition at line 27 of file postdata.h.

◆ Cell

template<MInt nDim_>

using PostData< nDim_ >::Cell = typename maia::grid::tree::Tree<nDim>::Cell

Definition at line 31 of file postdata.h.

◆ Geom

template<MInt nDim_>

using PostData< nDim_ >::Geom = Geometry<nDim>

Definition at line 73 of file postdata.h.

◆ Grid

template<MInt nDim_>

using PostData< nDim_ >::Grid = typename CartesianSolver::Grid

Definition at line 28 of file postdata.h.

◆ GridProxy

template<MInt nDim_>

using PostData< nDim_ >::GridProxy = typename CartesianSolver::GridProxy

Definition at line 29 of file postdata.h.

◆ SolverCell

template<MInt nDim_>

using PostData< nDim_ >::SolverCell = PostCell

Definition at line 30 of file postdata.h.

Constructor & Destructor Documentation

◆ PostData()

template<MInt nDim>

PostData< nDim >::PostData	(	MInt	solverId_,
		GridProxy &	gridProxy_,
		Geom &	geometry_,
		const MPI_Comm	comm
	)

Definition at line 61 of file postdata.cpp.

  : maia::CartesianSolver<nDim, PostData<nDim>>(solverId_, gridProxy_, comm, true),
    m_geometry(&geometry_),
    m_time(0.0) {
  TRACE();
 
  readProperties();
 
  for(MInt i = 0; i < (MInt)m_propertyName.size(); i++) {
    m_variableOffset.push_back(std::make_pair(std::numeric_limits<MInt>::max(), -std::numeric_limits<MInt>::max()));
  }
}

◆ ~PostData()

template<MInt nDim_>

PostData< nDim_ >::~PostData ( )

inline

Definition at line 77 of file postdata.h.

77{};

Member Function Documentation

◆ a_averagedVariable()

template<MInt nDim_>

MFloat & PostData< nDim_ >::a_averagedVariable	(	const MInt	cellId,
		const MInt	varId
	)

inline

Definition at line 173 of file postdata.h.

173{ return m_averagedVars[cellId][varId]; }

PostData::m_averagedVars

MFloat ** m_averagedVars

Definition: postdata.h:257

maia::collector_memory::cellId

void const MInt cellId

Definition: collector.h:239

◆ a_hasNeighbor()

template<MInt nDim_>

MInt PostData< nDim_ >::a_hasNeighbor	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 137 of file postdata.h.

                                                              {
    if(cellId > (m_cells.size() - 1)) return -1;
    return grid().tree().hasNeighbor(cellId, dir);
  }

◆ a_isHalo() [1/2]

template<MInt nDim_>

maia::post::cell::BitsetType::reference PostData< nDim_ >::a_isHalo ( const MInt cellId )

inline

Definition at line 185 of file postdata.h.

                                                              {
    return m_cells.hasProperty(cellId, SolverCell::IsHalo);
  }

◆ a_isHalo() [2/2]

template<MInt nDim_>

MBool PostData< nDim_ >::a_isHalo ( const MInt cellId ) const

inline

Definition at line 182 of file postdata.h.

182{ return m_cells.hasProperty(cellId, SolverCell::IsHalo); }

◆ a_isWindow() [1/2]

template<MInt nDim_>

maia::post::cell::BitsetType::reference PostData< nDim_ >::a_isWindow ( const MInt cellId )

inline

Definition at line 193 of file postdata.h.

                                                                {
    return m_cells.hasProperty(cellId, SolverCell::IsWindow);
  }

◆ a_isWindow() [2/2]

template<MInt nDim_>

MBool PostData< nDim_ >::a_isWindow ( const MInt cellId ) const

inline

Definition at line 190 of file postdata.h.

190{ return m_cells.hasProperty(cellId, SolverCell::IsWindow); }

◆ a_level()

template<MInt nDim_>

MInt PostData< nDim_ >::a_level ( const MInt ) const

inline

Definition at line 152 of file postdata.h.

152{ TERMM(1, "Make this function return something meaningful in future!"); }

◆ a_noCells()

template<MInt nDim_>

MInt PostData< nDim_ >::a_noCells ( ) const

inline

Definition at line 134 of file postdata.h.

134{ return m_cells.size(); }

◆ a_resetPropertiesSolver()

template<MInt nDim_>

void PostData< nDim_ >::a_resetPropertiesSolver ( const MInt cellId )

inline

Definition at line 198 of file postdata.h.

198{ m_cells.resetProperties(cellId); }

◆ a_variable() [1/2]

template<MInt nDim_>

MFloat & PostData< nDim_ >::a_variable	(	const MInt	cellId,
		const MInt	varId
	)

inline

Definition at line 168 of file postdata.h.

168{ return m_cells.variable(cellId, varId); }

◆ a_variable() [2/2]

template<MInt nDim_>

MFloat PostData< nDim_ >::a_variable	(	const MInt	cellId,
		const MInt	varId
	)		const

inline

Definition at line 171 of file postdata.h.

171{ return m_cells.variable(cellId, varId); }

◆ balancePost()

template<MInt nDim>

void PostData< nDim >::balancePost

overrideprotectedvirtual

Author: Thomas Hoesgen

Reimplemented from Solver.

Definition at line 1087 of file postdata.cpp.

                                 {
  TRACE();
 
  m_loadBalancingReinitStage = 1;
  m_adaptationSinceLastRestart = true;
 
  // Nothing to do if solver is not active
  if(!grid().isActive()) return;
 
  m_loadBalancingReinitStage = 2;
}

◆ balancePre()

template<MInt nDim>

void PostData< nDim >::balancePre

overrideprotectedvirtual

Author: Thomas Hoesgen

Reimplemented from Solver.

Definition at line 1046 of file postdata.cpp.

                                {
  TRACE();
 
  // Note: every function that allocates persistent memory should first deallocate that memory, for
  // this to work initialize all pointers with nullptr in the class definition
 
  // Set reinitialization stage
  m_loadBalancingReinitStage = 0;
 
  // Store currently used memory
  /* const MLong previouslyAllocated = allocatedBytes(); */
 
  // Update the grid proxy for this solver
  grid().update();
 
  if(!grid().isActive()) {
    // Reset parallelization information if solver is not active
    updateDomainInfo(-1, -1, MPI_COMM_NULL, AT_);
  } else {
    // Set new domain info for solver
    updateDomainInfo(grid().domainId(), grid().noDomains(), grid().mpiComm(), AT_);
  }
 
  // Return if solver is not active
  if(!grid().isActive()) {
    m_cells.reset(grid().maxNoCells());
    this->setHaloCellsOnInactiveRanks();
    return;
  }
 
  // Resize cell collector to internal cells
  m_cells.reset(grid().raw().treeb().capacity());
 
  setAndAllocateSolverData(false);
  this->checkNoHaloLayers();
}

◆ c_childId()

template<MInt nDim_>

MLong PostData< nDim_ >::c_childId	(	const MInt	cellId,
		const MInt	pos
	)		const

inline

Definition at line 162 of file postdata.h.

162{ return grid().tree().child(cellId, pos); }

◆ c_coordinate() [1/2]

template<MInt nDim_>

const MFloat & PostData< nDim_ >::c_coordinate	(	const MInt	cellId,
		const MInt	dim
	)

inline

Definition at line 143 of file postdata.h.

143{ return grid().tree().coordinate(cellId, dim); }

◆ c_coordinate() [2/2]

template<MInt nDim_>

MFloat PostData< nDim_ >::c_coordinate	(	const MInt	cellId,
		const MInt	dim
	)		const

inline

Definition at line 146 of file postdata.h.

146{ return grid().tree().coordinate(cellId, dim); }

◆ c_globalId()

template<MInt nDim_>

MLong PostData< nDim_ >::c_globalId ( const MInt cellId ) const

inline

Definition at line 160 of file postdata.h.

160{ return grid().tree().globalId(cellId); }

◆ c_level()

template<MInt nDim_>

MInt PostData< nDim_ >::c_level ( const MInt cellId ) const

inline

Definition at line 149 of file postdata.h.

149{ return grid().tree().level(cellId); }

◆ c_noCells()

template<MInt nDim_>

MInt PostData< nDim_ >::c_noCells ( ) const

inline

Definition at line 132 of file postdata.h.

132{ return grid().tree().size(); }

◆ c_noChildren()

template<MInt nDim_>

MInt PostData< nDim_ >::c_noChildren ( const MInt cellId ) const

inline

Definition at line 154 of file postdata.h.

154{ return grid().tree().noChildren(cellId); }

◆ c_parentId()

template<MInt nDim_>

MLong PostData< nDim_ >::c_parentId ( const MInt cellId ) const

inline

Definition at line 157 of file postdata.h.

157{ return grid().tree().parent(cellId); }

◆ cellDataSizeDlb()

template<MInt nDim>

MInt PostData< nDim >::cellDataSizeDlb	(	const MInt	dataId,
		const MInt	gridCellId
	)

override

Definition at line 1113 of file postdata.cpp.

                                                                             {
  // Inactive ranks do not have any data to communicate
  if(!isActive()) {
    return 0;
  }
 
  // Convert to solver cell id and check
  const MInt cellId = grid().tree().grid2solver(gridCellId);
  if(cellId < 0 || cellId >= noInternalCells()) {
    return 0;
  }
 
  MInt dataSize = 0;
 
  switch(dataId) {
    case 0: // variables
      dataSize = noVariables();
      break;
    default:
      TERMM(1, "Unknown data id.");
      break;
  }
 
  return dataSize;
}

◆ cellDataTypeDlb()

template<MInt nDim_>

MInt PostData< nDim_ >::cellDataTypeDlb ( const MInt dataId ) const

inlineoverride

Definition at line 236 of file postdata.h.

                                                         {
    if(dataId == 0) {
      return MFLOAT;
    } else {
      TERMM(1, "solverCelldataType: invalid data id " + std::to_string(dataId));
    }
  };

◆ cellOutside()

template<MInt nDim>

MInt PostData< nDim >::cellOutside	(	const MFloat *	coords,
		const MInt	level,
		const MInt	gridCellId
	)

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 1025 of file postdata.cpp.

                                                                                              {
  return -1;
 
  std::ignore = coords;
  std::ignore = level;
  std::ignore = gridCellId;
}

◆ cleanUp()

template<MInt nDim_>

virtual void PostData< nDim_ >::cleanUp ( )

inlinevirtual

Implements Solver.

Definition at line 125 of file postdata.h.

125{};

◆ copyGridProperties()

template<MInt nDim>

void PostData< nDim >::copyGridProperties

Definition at line 112 of file postdata.cpp.

                                        {
  TRACE();
 
  // d) Set Properties for valid-grid-cells
  for(MInt i = 0; i < noNeighborDomains(); i++) {
    for(MInt c = 0; c < noHaloCells(i); c++) {
      a_isHalo(haloCellId(i, c)) = true;
    }
    for(MInt j = 0; j < noWindowCells(i); j++) {
      a_isWindow(windowCellId(i, j)) = true;
    }
  }
 
  // Inactive can only have halo cells, however noNeighborDomains=-1
  if(!isActive()) {
    for(MInt c = 0; c < a_noCells(); c++) {
      a_isHalo(c) = true;
    }
  }
}

◆ fileNoVars()

template<MInt nDim_>

MInt PostData< nDim_ >::fileNoVars ( ) const

inline

Definition at line 178 of file postdata.h.

178{ return m_fileNoVars; }

PostData::m_fileNoVars

MInt m_fileNoVars

Definition: postdata.h:315

◆ fileVarNames()

template<MInt nDim_>

std::vector< MString > PostData< nDim_ >::fileVarNames ( ) const

inline

Definition at line 179 of file postdata.h.

179{ return m_fileVarNames; }

PostData::m_fileVarNames

std::vector< MString > m_fileVarNames

Definition: postdata.h:317

◆ finalizeAdaptation()

template<MInt nDim>

void PostData< nDim >::finalizeAdaptation

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 882 of file postdata.cpp.

                                        {
  TRACE();
 
  m_forceAdaptation = false;
  m_adaptationSinceLastRestart = true;
}

◆ finalizeBalance()

template<MInt nDim>

void PostData< nDim >::finalizeBalance

overrideprotectedvirtual

Author: Thomas Hoesgen

Reimplemented from Solver.

Definition at line 1102 of file postdata.cpp.

                                     {
  TRACE();
 
  // Nothing to do if solver is not active
  if(!grid().isActive()) return;
 
  m_loadBalancingReinitStage = -1;
}

◆ finalizeInitSolver()

template<MInt nDim>

void PostData< nDim >::finalizeInitSolver

overridevirtual

Implements Solver.

Definition at line 276 of file postdata.cpp.

                                        {
  TRACE();
 
  if(!isActive()) return;
 
  if(m_restart) {
    // TODO labels:PP allow to skip loading restart, e.g. if we want to start the averaging after adding the pp-solver
    // at some point and just need everything set to zero instead?
    loadRestartFile();
  }
}

◆ geometry()

template<MInt nDim_>

Geom & PostData< nDim_ >::geometry ( ) const

inline

Definition at line 82 of file postdata.h.

82{ return *m_geometry; }

◆ getArray012()

template<MInt nDim_>

static constexpr std::array< MInt, nDim > PostData< nDim_ >::getArray012 ( )

inlinestaticconstexprprivate

Definition at line 375 of file postdata.h.

                                                      {
    IF_CONSTEXPR(nDim == 2) {
      std::array<MInt, 2> a = {0, 1};
      return a;
    }
    else {
      std::array<MInt, 3> a = {0, 1, 2};
      return a;
    }
  }

◆ getCellDataDlb()

template<MInt nDim_>

void PostData< nDim_ >::getCellDataDlb	(	const MInt	dataId,
		const MInt	oldNoCells,
		const MInt *const	bufferIdToCellId,
		MFloat *const	data
	)

inlineoverride

Definition at line 245 of file postdata.h.

                                                   {
    getCellDataDlb_(dataId, oldNoCells, bufferIdToCellId, data);
  };

◆ getCellDataDlb_()

template<MInt nDim_>

template<typename dataType >

void PostData< nDim_ >::getCellDataDlb_	(	const MInt	dataId,
		const MInt	oldNoCells,
		const MInt *const	bufferIdToCellId,
		dataType *const	data
	)

inlineprivate

Definition at line 344 of file postdata.h.

                                             {
    TRACE();
 
    MInt localBufferId = 0;
    for(MInt i = 0; i < oldNoCells; i++) {
      const MInt gridCellId = bufferIdToCellId[i];
 
      if(gridCellId < 0) continue;
 
      const MInt cellId = grid().tree().grid2solver(gridCellId);
      if(cellId < 0 || cellId >= noInternalCells()) {
        continue;
      }
 
      switch(dataId) {
        case 0: {
          const MInt dataSize = noVariables();
          std::copy_n(&a_variable(cellId, 0), dataSize, &data[localBufferId * dataSize]);
          break;
        }
        default:
          TERMM(1, "Unknown data id.");
          break;
      }
      localBufferId++;
    }
  }

◆ getCellLoad()

template<MInt nDim>

MFloat PostData< nDim >::getCellLoad	(	const MInt	gridCellId,
		const MFloat *const	weights
	)		const

override

Parameters

[in]	cellId	Requested grid cell id.
[in]	weights	Computational weights for different simulation components.

Returns: Cell load.

Author: Tim Wegmann

Definition at line 770 of file postdata.cpp.

                                                                                           {
  TRACE();
 
  ASSERT(isActive(), "solver is not active");
 
  // Convert to solver cell id and check
  const MInt cellId = grid().tree().grid2solver(gridCellId);
  if(cellId < 0) {
    return 0;
  }
 
  if(cellId < 0 || cellId >= grid().noInternalCells()) {
    TERMM(1, "The given cell id is invalid.");
  }
 
  // Default cell load
  MFloat cellLoad = 0.0;
 
  cellLoad = weights[0];
 
  // TODO: add other load types!
 
  return cellLoad;
}

◆ getDefaultWeights()

template<MInt nDim>

void PostData< nDim >::getDefaultWeights	(	MFloat *	weights,
		std::vector< MString > &	names
	)		const

Author: Tim Wegmann

Definition at line 683 of file postdata.cpp.

                                                                                       {
  TRACE();
 
  // TODO set sensible default values
  weights[0] = 1.0;
  names[0] = "pp_cell";
  MInt count = 1;
 
  // TODO: add other load types!
 
  if(noLoadTypes() != count) {
    TERMM(1, "Count does not match noLoadTypes.");
  }
}

◆ getDomainDecompositionInformation()

template<MInt nDim>

void PostData< nDim >::getDomainDecompositionInformation ( std::vector< std::pair< MString, MInt > > & domainInfo )

override

Author: Tim Wegmann

Definition at line 703 of file postdata.cpp.

                                                                                                    {
  TRACE();
 
  const MString namePrefix = "s" + std::to_string(solverId()) + "_";
 
  // Number of Post-Data-Cells
  const MInt noCells = c_noCells();
 
  domainInfo.emplace_back(namePrefix + "noPostCells", noCells);
 
  // additionally add cells for probing
}

◆ getLoadQuantities()

template<MInt nDim>

void PostData< nDim >::getLoadQuantities ( MInt *const loadQuantities ) const

override

Parameters

[out] loadQuantities Storage for load quantities.

Author: Tim Wegmann

Definition at line 742 of file postdata.cpp.

                                                                       {
  TRACE();
 
  // Nothing to do if solver is not active
  if(!isActive()) {
    return;
  }
 
  // reset
  for(MInt type = 0; type < noLoadTypes(); type++) {
    loadQuantities[type] = 0;
  }
 
  loadQuantities[0] = c_noCells();
 
  // TODO: add other load types!
}

◆ getPropertyVariableOffset()

template<MInt nDim_>

std::pair< MInt, MInt > PostData< nDim_ >::getPropertyVariableOffset ( MString s )

inline

Definition at line 207 of file postdata.h.

                                                           {
    MInt index = getVariablePropertyIndex(s);
    return (index > -1) ? m_variableOffset[index]
                        : std::make_pair(std::numeric_limits<MInt>::max(), std::numeric_limits<MInt>::min());
  }

◆ getSolverTimings()

template<MInt nDim>

void PostData< nDim >::getSolverTimings	(	std::vector< std::pair< MString, MFloat > > &	solverTimings,
		const	MBool
	)

override

Author: Tim Wegmann

Definition at line 648 of file postdata.cpp.

                                                                                                     {
  TRACE();
 
  const MString namePrefix = "s" + std::to_string(solverId()) + "_";
 
  const MFloat load = returnLoadRecord();
  const MFloat idle = returnIdleRecord();
 
  solverTimings.emplace_back(namePrefix + "loadPostData", load);
  solverTimings.emplace_back(namePrefix + "idlePostData", idle);
}

◆ getVariableName()

template<MInt nDim>

MString PostData< nDim >::getVariableName ( MInt offset )

Definition at line 197 of file postdata.cpp.

                                                   {
  MString s = "var" + std::to_string(offset);
  if(offset >= getPropertyVariableOffset("primitive").first && offset < getPropertyVariableOffset("primitive").second) {
    MInt index = offset - getPropertyVariableOffset("primitive").first;
    s = m_averageVariableName[0][index];
  }
  if(offset >= getPropertyVariableOffset("square").first && offset < getPropertyVariableOffset("square").second) {
    MInt index = offset - getPropertyVariableOffset("square").first;
    s = m_averageVariableName[1][index];
  }
  if(offset >= getPropertyVariableOffset("skewness").first && offset < getPropertyVariableOffset("skewness").second) {
    MInt index = offset - getPropertyVariableOffset("skewness").first;
    s = m_averageVariableName[2][index];
  }
  if(offset >= getPropertyVariableOffset("kurtosis").first && offset < getPropertyVariableOffset("kurtosis").second) {
    MInt index = offset - getPropertyVariableOffset("kurtosis").first;
    s = m_averageVariableName[3][index];
  }
  if(offset >= getPropertyVariableOffset("statisticCombustionAnalysis").first
     && offset < getPropertyVariableOffset("statisticCombustionAnalysis").second) {
    MInt index = offset - getPropertyVariableOffset("statisticCombustionAnalysis").first;
    s = m_averageVariableName[4][index];
  }
  if(offset >= getPropertyVariableOffset("averageVorticity").first
     && offset < getPropertyVariableOffset("averageVorticity").second) {
    MInt index = offset - getPropertyVariableOffset("averageVorticity").first;
    s = m_averageVariableName[5][index];
  }
  if(offset >= getPropertyVariableOffset("averageSpeedOfSound").first
     && offset < getPropertyVariableOffset("averageSpeedOfSound").second) {
    MInt index = offset - getPropertyVariableOffset("averageSpeedOfSound").first;
    s = m_averageVariableName[6][index];
  }
  if(offset >= getPropertyVariableOffset("lamb0").first && offset < getPropertyVariableOffset("lamb0").second) {
    MInt index = offset - getPropertyVariableOffset("lamb0").first;
    s = m_averageVariableName[7][index];
  }
  if(offset >= getPropertyVariableOffset("du").first && offset < getPropertyVariableOffset("du").second) {
    MInt index = offset - getPropertyVariableOffset("du").first;
    s = m_averageVariableName[8][index];
  }
  if(offset >= getPropertyVariableOffset("drho").first && offset < getPropertyVariableOffset("drho").second) {
    MInt index = offset - getPropertyVariableOffset("drho").first;
    s = m_averageVariableName[9][index];
  }
  if(offset >= getPropertyVariableOffset("dp").first && offset < getPropertyVariableOffset("dp").second) {
    MInt index = offset - getPropertyVariableOffset("dp").first;
    s = m_averageVariableName[10][index];
  }
  if(offset >= getPropertyVariableOffset("gradu").first && offset < getPropertyVariableOffset("gradu").second) {
    MInt index = offset - getPropertyVariableOffset("gradu").first;
    s = m_averageVariableName[11][index];
  }
  if(offset >= getPropertyVariableOffset("ugradu").first && offset < getPropertyVariableOffset("ugradu").second) {
    MInt index = offset - getPropertyVariableOffset("ugradu").first;
    s = m_averageVariableName[12][index];
  }
  if(offset >= getPropertyVariableOffset("ugradrho").first && offset < getPropertyVariableOffset("ugradrho").second) {
    MInt index = offset - getPropertyVariableOffset("ugradrho").first;
    s = m_averageVariableName[13][index];
  }
  if(offset >= getPropertyVariableOffset("gradprho").first && offset < getPropertyVariableOffset("gradprho").second) {
    MInt index = offset - getPropertyVariableOffset("gradprho").first;
    s = m_averageVariableName[14][index];
  }
  if(offset >= getPropertyVariableOffset("rhodivu").first && offset < getPropertyVariableOffset("rhodivu").second) {
    MInt index = offset - getPropertyVariableOffset("rhodivu").first;
    s = m_averageVariableName[15][index];
  }
  if(offset >= getPropertyVariableOffset("correlation").first
     && offset < getPropertyVariableOffset("correlation").second) {
    MInt index = offset - getPropertyVariableOffset("correlation").first;
    s = m_averageVariableName[16][0 /*index*/] + to_string(index);
  }
  return s;
}

◆ getVariablePropertyIndex()

template<MInt nDim_>

MInt PostData< nDim_ >::getVariablePropertyIndex ( MString s )

inlineprotected

Definition at line 261 of file postdata.h.

                                           {
    auto entry = std::find(m_propertyName.begin(), m_propertyName.end(), s);
    if(entry != m_propertyName.end()) {
      return std::distance(m_propertyName.begin(), entry);
    } else {
      return -1;
    }
  };

◆ hasSplitBalancing()

template<MInt nDim_>

MBool PostData< nDim_ >::hasSplitBalancing ( ) const

inlineoverrideprotectedvirtual

Reimplemented from Solver.

Definition at line 304 of file postdata.h.

304{ return true; }

◆ initSolver()

template<MInt nDim>

void PostData< nDim >::initSolver

overridevirtual

Implements Solver.

Definition at line 135 of file postdata.cpp.

                                {
  TRACE();
 
  if(!isActive()) {
    m_cells.clear();
    m_cells.reset(grid().maxNoCells());
    this->setHaloCellsOnInactiveRanks();
    return;
  }
 
  setAndAllocateSolverData(true);
}

◆ isMeanFile()

template<MInt nDim_>

MBool PostData< nDim_ >::isMeanFile ( ) const

inline

Definition at line 177 of file postdata.h.

177{ return m_isMeanFile; }

PostData::m_isMeanFile

MBool m_isMeanFile

Definition: postdata.h:313

◆ loadGridFlowVars()

template<MInt nDim>

void PostData< nDim >::loadGridFlowVars	(	const MChar *	fileName,
		MInt	noVariables,
		std::vector< MString >	name
	)

Author: Jannik Borgelt

Definition at line 545 of file postdata.cpp.

                                                                                                    {
  TRACE();
 
  // File loading.
  stringstream variables;
 
  using namespace maia::parallel_io;
  ParallelIo parallelIo(fileName, PIO_READ, mpiComm());
 
  // This should be the same for all the variables
  ParallelIo::size_type dimLen = noInternalCells();
  ParallelIo::size_type start = domainOffset(domainId()) - grid().bitOffset();
 
  // set offset for all read operations
  parallelIo.setOffset(dimLen, start);
 
  for(MInt vId = 0; vId < noVariables; vId++) {
    MString varName = names[vId]; // varNames[vId];//
 
    // Load our variables
    MFloatScratchSpace tmpVar((MInt)dimLen, AT_, "tmpVar");
 
    parallelIo.readArray(tmpVar.getPointer(), "variables" + to_string(vId));
    for(MInt i = 0; i < (MInt)dimLen; ++i) {
      a_variable(i, vId) = tmpVar.p[i];
    }
  }
}

◆ loadMeanFile()

template<MInt nDim>

void PostData< nDim >::loadMeanFile ( const MString fileName )

Author: A. Niemoeller

Date: 23.04.14

checks for attribute "isMeanFile", if found all variables are loaded (e.g. means and statistical moments).

Parameters

[in] fileName name of data file to load

Definition at line 488 of file postdata.cpp.

                                                        {
  TRACE();
 
  if(!isActive()) return;
 
  ParallelIo parallelIo(fileName, maia::parallel_io::PIO_READ, mpiComm());
 
  if(parallelIo.hasAttribute(MString("isMeanFile"))) {
    // This should be the same for all the variables
    ParallelIo::size_type dimLen = noInternalCells();
    ParallelIo::size_type start = domainOffset(domainId()) - grid().bitOffset();
 
    // set offset for all read operations
    parallelIo.setOffset(dimLen, start);
 
    vector<MString> var_names = parallelIo.getDatasetNames(1);
    m_fileNoVars = var_names.size();
    const MInt noCells = noInternalCells();
 
    // Note: allocate new storage for all variables from the file
    mAlloc(m_averagedVars, noCells, m_fileNoVars, "m_averagedVars", AT_);
    ScratchSpace<MFloat> tmpVars(noCells, AT_, "tmpVars");
 
    m_fileVarNames.clear();
    for(MInt varId = 0; varId < m_fileNoVars; varId++) {
      // Check for variable 'name' attribute
      if(parallelIo.hasAttribute("name", var_names[varId])) {
        MString varName = "";
        parallelIo.getAttribute(&varName, "name", var_names[varId]);
        m_fileVarNames.push_back(varName);
      } else {
        TERMM(1, "Variable has no attribute 'name'.");
      }
 
      parallelIo.readArray(tmpVars.begin(), var_names[varId]);
      for(MInt cellId = 0; cellId < noCells; cellId++) {
        m_averagedVars[cellId][varId] = tmpVars[cellId];
      }
    }
    TERMM_IF_COND(m_fileVarNames.size() > 0 && (MInt)m_fileVarNames.size() != m_fileNoVars,
                  "Error: not every variable in '" + MString(fileName) + "' has the 'name' attribute.");
 
    m_isMeanFile = true;
  } else {
    TERMM(1, "FIXME try to load regular data file");
    m_isMeanFile = false;
    // loadGridFlowVars(...);
  }
}

◆ loadRestartFile()

template<MInt nDim>

void PostData< nDim >::loadRestartFile

virtual

Reimplemented from Solver.

Definition at line 454 of file postdata.cpp.

                                     {
  TRACE();
 
  stringstream fileName;
  fileName << restartDir() << "restartFile_" << solverId() << "_" << globalTimeStep << ParallelIo::fileExt();
 
  if(domainId() == 0) {
    cerr << "loading post data for solver " << solverId() << " at time step " << globalTimeStep << " ...";
  }
 
  vector<MString> name;
  for(MInt v = 0; v < noVariables(); v++) {
    name.push_back(m_variablesName[v]);
  }
 
  m_log << "loading postprocessing variables ... ";
 
  loadGridFlowVars((fileName.str()).c_str(), noVariables(), name);
 
  m_log << "ok" << endl;
}

◆ m_averageVariableName() [1/2]

const std::vector< std::vector< MString > > PostData< 3 >::m_averageVariableName

protected

Definition at line 20 of file postdata.cpp.

◆ m_averageVariableName() [2/2]

const std::vector< std::vector< MString > > PostData< 2 >::m_averageVariableName

protected

Definition at line 41 of file postdata.cpp.

◆ noCellDataDlb()

template<MInt nDim_>

MInt PostData< nDim_ >::noCellDataDlb ( ) const

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 235 of file postdata.h.

235{ return 1; }; // communicated data: variables

◆ noInternalCells()

template<MInt nDim_>

MInt PostData< nDim_ >::noInternalCells ( ) const

inlineoverridevirtual

Implements Solver.

Definition at line 84 of file postdata.h.

84{ return grid().noInternalCells(); }

◆ noLoadTypes()

template<MInt nDim>

MInt PostData< nDim >::noLoadTypes

overridevirtual

Type 1: number of cells Type 2: ??? number cells used for probing Type 3: ??? number cells used for averaging

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 670 of file postdata.cpp.

                                       {
  TRACE();
 
  const MInt noLsLoadTypes = 1;
 
  return noLsLoadTypes;
}

◆ noVariables()

template<MInt nDim_>

MInt PostData< nDim_ >::noVariables ( ) const

inlinevirtual

Reimplemented from Solver.

Definition at line 165 of file postdata.h.

165{ return m_noVariables; };

PostData::m_noVariables

MInt m_noVariables

Definition: postdata.h:293

◆ postAdaptation()

template<MInt nDim>

void PostData< nDim >::postAdaptation

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 854 of file postdata.cpp.

                                    {
  TRACE();
 
  if(isActive()) {
    this->compactCells();
    m_freeIndices.clear();
  } else {
    grid().updateGridMap();
  }
 
  grid().updateOther();
 
  updateDomainInfo(grid().domainId(), grid().noDomains(), grid().mpiComm(), AT_);
  this->checkNoHaloLayers();
 
  // Nothing further to be done if solver inactive
  if(!isActive()) return;
 
  copyGridProperties();
 
  m_adaptationLevel++;
}

◆ postTimeStep()

template<MInt nDim_>

void PostData< nDim_ >::postTimeStep ( )

inlineoverridevirtual

Implements Solver.

Definition at line 89 of file postdata.h.

89{};

◆ prepareAdaptation()

template<MInt nDim>

void PostData< nDim >::prepareAdaptation

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 800 of file postdata.cpp.

                                       {
  TRACE();
 
  ASSERT(m_freeIndices.empty(), "");
 
  m_adaptationLevel = maxUniformRefinementLevel();
 
  if(!isActive()) return;
}

◆ prepareRestart()

template<MInt nDim>

MBool PostData< nDim >::prepareRestart	(	MBool	,
		MBool &
	)

overridevirtual

Reimplemented from Solver.

Definition at line 312 of file postdata.cpp.

                                                                                {
  TRACE();
 
  writeGridRestart = false;
 
  // write intermediate restart file
  if(m_restartInterval == -1 && !writeRestart) {
    writeRestart = false;
  }
 
  MInt relativeTimeStep = globalTimeStep - m_restartOffset;
  MInt relativeRestartTimeStep = m_restartTimeStep - m_restartOffset;
 
  if(((relativeTimeStep % m_restartInterval) == 0 && relativeTimeStep > relativeRestartTimeStep) || writeRestart) {
    writeRestart = true;
  }
 
  if(m_forceWriteRestart) {
    writeRestart = true;
    if(m_adaptationSinceLastRestart) {
      writeGridRestart = true;
    }
  }
 
  return writeRestart;
}

◆ preTimeStep()

template<MInt nDim_>

void PostData< nDim_ >::preTimeStep ( )

inlineoverridevirtual

Implements Solver.

Definition at line 88 of file postdata.h.

88{};

◆ readProperties()

template<MInt nDim_>

void PostData< nDim_ >::readProperties ( )

protected

◆ refineCell()

template<MInt nDim>

void PostData< nDim >::refineCell ( const MInt gridCellId )

overridevirtual

Author: Tim Wegmann, Jannik Borgelt

Reimplemented from Solver.

Definition at line 894 of file postdata.cpp.

                                                     {
  TRACE();
 
  const MInt solverCellId = grid().tree().grid2solver(gridCellId);
 
  for(MInt child = 0; child < grid().m_maxNoChilds; child++) {
    const MInt childId = grid().raw().treeb().child(gridCellId, child);
    if(childId == -1) continue;
 
    if(!grid().raw().a_hasProperty(childId, Cell::WasNewlyCreated)
       && grid().raw().a_hasProperty(gridCellId, Cell::IsPartLvlAncestor)) {
      continue;
    }
 
    if(!g_multiSolverGrid) ASSERT(grid().raw().a_hasProperty(childId, Cell::WasNewlyCreated), "");
 
    // If solver is inactive all cells musst be halo cells!
    if(!isActive()) ASSERT(grid().raw().a_isHalo(childId), "");
    // If child exists in grid but is not located inside solver geometry
    if(!grid().solverFlag(childId, solverId())) continue;
 
    const MInt solverChildId = this->createCellId(childId);
 
    if(!g_multiSolverGrid) ASSERT(solverChildId == childId, "");
 
    for(MInt v = 0; v < noVariables(); v++) {
      a_variable(solverChildId, v) = a_variable(solverCellId, v);
    }
 
    // check-child-values
#if !defined NDEBUG
    for(MInt v = 0; v < noVariables(); v++) {
      if(std::isnan(a_variable(solverChildId, v))) {
        cerr << "Invalid-value in refined-Cell! "
             << " " << solverChildId << " in rank " << domainId() << endl;
      }
    }
#endif
  }
}

◆ reIntAfterRestart()

template<MInt nDim>

void PostData< nDim >::reIntAfterRestart ( MBool doneRestart )

virtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 345 of file postdata.cpp.

                                                        {
  TRACE();
 
  if(doneRestart) {
    m_adaptationSinceLastRestart = false;
  }
 
  m_forceWriteRestart = false;
}

◆ removeCell()

template<MInt nDim>

void PostData< nDim >::removeCell ( const MInt MInt )

overridevirtual

Reimplemented from Solver.

Definition at line 966 of file postdata.cpp.

                                                     {
  TRACE();
  // If solver is inactive cell musst never be a internal cell
  if(!isActive()) {
    ASSERT(grid().raw().a_isHalo(gridCellId), "");
  }
 
  const MInt solverCellId = grid().tree().grid2solver(gridCellId);
 
  ASSERT(gridCellId > -1 && gridCellId < grid().raw().treeb().size() && solverCellId > -1
             && solverCellId < m_cells.size() && grid().tree().solver2grid(solverCellId) == gridCellId,
         "");
 
  this->removeCellId(solverCellId);
}

◆ removeChilds()

template<MInt nDim>

void PostData< nDim >::removeChilds ( const MInt MInt )

overridevirtual

Reimplemented from Solver.

Definition at line 937 of file postdata.cpp.

                                                       {
  TRACE();
  // If solver is inactive cell must never be an internal cell
  if(!isActive()) {
    ASSERT(grid().raw().a_isHalo(gridCellId), "");
  }
 
  const MInt solverCellId = grid().tree().grid2solver(gridCellId);
 
  ASSERT(solverCellId > -1 && solverCellId < m_cells.size(), "solverCellId is: " << solverCellId);
 
  if(!g_multiSolverGrid) ASSERT(solverCellId == gridCellId, "");
 
  for(MInt c = 0; c < grid().m_maxNoChilds; c++) {
    MInt childId = c_childId(solverCellId, c);
    if(childId < 0) continue;
    this->removeCellId(childId);
  }
 
  if(!g_multiSolverGrid) {
    ASSERT((grid().raw().treeb().size() - m_cells.size()) <= grid().m_maxNoChilds, "");
  }
}

◆ resetSolver()

template<MInt nDim>

void PostData< nDim >::resetSolver

overrideprotectedvirtual

Author: Thomas Hoesgen

Reimplemented from Solver.

Definition at line 1037 of file postdata.cpp.

                                 {
  TRACE();
  mDeallocate(m_recalcIds);
}

◆ resizeGridMap()

template<MInt nDim>

void PostData< nDim >::resizeGridMap

overridevirtual

Reimplemented from Solver.

Definition at line 984 of file postdata.cpp.

                                   {
  grid().resizeGridMap(m_cells.size());
}

◆ saveDataFile()

template<MInt nDim>

void PostData< nDim >::saveDataFile	(	const MBool	writeBackup,
		const MString	fileName,
		const MInt	noVars,
		std::vector< MString > &	variablesName,
		MFloat *	variables
	)

Definition at line 372 of file postdata.cpp.

                                                                                        {
  TRACE();
 
  ASSERT(noVars > 0, "No variables set for PostData restart!");
  ASSERT((MInt)variablesName.size() == noVars, "");
 
  if(domainId() == 0) {
    cerr << "Writing post data file '" << fileName << "' for solver " << solverId() << " at time step "
         << globalTimeStep << " ...";
  }
 
  vector<MInt> reOrderedCells;
  MInt countInternal = 0;
  if(grid().newMinLevel() > 0) {
    if(domainId() == 0) {
      cerr << "Increasing minLevel for solver " << m_solverId;
    }
    this->reOrderCellIds(reOrderedCells);
    for(MUint i = 0; i < reOrderedCells.size(); i++) {
      if(a_isHalo(reOrderedCells[i])) continue;
      countInternal++;
    }
    m_recalcIds = nullptr;
  }
  const MInt noCells = grid().newMinLevel() < 0 ? noInternalCells() : reOrderedCells.size();
  const MInt noInternalCellIds = grid().newMinLevel() < 0 ? noInternalCells() : countInternal;
 
  MFloatScratchSpace dbVariables(noCells * noVars, AT_, "dbVariables");
  MIntScratchSpace idVariables(noCells * 2, AT_, "idVariables");
  MFloatScratchSpace dbParameters(0, AT_, "dbParameters");
  MIntScratchSpace idParameters(1, AT_, "idParameters");
  vector<MString> dbVariablesName;
  vector<MString> idVariablesName;
  vector<MString> dbParametersName;
  vector<MString> idParametersName;
 
  this->collectVariables(variables, dbVariables, variablesName, dbVariablesName, noVars, noCells);
 
  this->collectParameters(globalTimeStep, idParameters, "globalTimeStep", idParametersName);
 
  MIntScratchSpace recalcIdsSolver(grid().tree().size(), AT_, "recalcIds");
  if(m_recalcIds != nullptr) {
    MInt cellId = 0;
    for(MInt gridcell = 0; gridcell < grid().raw().m_noInternalCells; gridcell++) {
      if(grid().raw().a_hasProperty(gridcell, Cell::IsHalo)) continue;
      MInt l_solverId = grid().tree().grid2solver(m_recalcIds[gridcell]);
      if(l_solverId > -1) {
        recalcIdsSolver[cellId] = l_solverId;
        cellId++;
        ASSERT(grid().solverFlag(m_recalcIds[gridcell], m_solverId), "");
      }
    }
    ASSERT(cellId == grid().noInternalCells(), "recalc ids size is wrong");
  }
 
  MString gridFile = (m_currentGridFileName == "") ? grid().gridInputFileName() : m_currentGridFileName;
 
  saveGridFlowVars(fileName.c_str(), gridFile.c_str(), noCells, noInternalCellIds, dbVariables, dbVariablesName, 0,
                   idVariables, idVariablesName, 0, dbParameters, dbParametersName, idParameters, idParametersName,
                   recalcIdsSolver.begin(), -1);
 
  // TODO labels:PP this is still specific to restart files
  if(writeBackup) {
    stringstream backupFileName;
    backupFileName.clear();
    backupFileName.str("");
    backupFileName << outputDir() << "restartFileBackup_" << solverId() << "_" << globalTimeStep;
    backupFileName << ParallelIo::fileExt();
    if(domainId() == 0) cerr << "Writing post data (backup) for solver " << solverId() << "... ";
 
    saveGridFlowVars((backupFileName.str()).c_str(), gridFile.c_str(), noCells, noInternalCellIds, dbVariables,
                     dbVariablesName, 0, idVariables, idVariablesName, 0, dbParameters, dbParametersName, idParameters,
                     idParametersName, recalcIdsSolver.begin(), -1);
  }
 
 
  if(domainId() == 0) cerr << "ok" << endl;
}

◆ saveRestartFile()

template<MInt nDim>

void PostData< nDim >::saveRestartFile ( const MBool writeBackup )

Definition at line 356 of file postdata.cpp.

                                                            {
  TRACE();
 
  ASSERT(noVariables() > 0, "No variables set for PostData restart!");
  ASSERT(!m_variablesName.empty(), "");
  ASSERT((MInt)m_variablesName.size() == noVariables(), "");
 
  // TODO labels:IO use same restart file name format for all solvers, e.g. restart_s[solverId]_[timeStep].[ext] with
  // zero padded formatted timeStep
  stringstream fileName;
  fileName << outputDir() << "restartFile_" << solverId() << "_" << globalTimeStep << ParallelIo::fileExt();
 
  saveDataFile(writeBackup, fileName.str(), noVariables(), m_variablesName, &a_variable(0, 0));
}

◆ saveSolverSolution()

template<MInt nDim>

void PostData< nDim >::saveSolverSolution	(	const	MBool,
		const	MBool
	)

Definition at line 575 of file postdata.cpp.

                                                                {
  TRACE();
 
  if(!isActive()) return;
 
  MInt offset = m_solutionOffset;
 
  // solution output
  // ---------------
  if((((globalTimeStep - offset) % m_solutionInterval) == 0 && globalTimeStep >= offset)
     || (m_solutionTimeSteps.count(globalTimeStep) > 0)) {
    if(domainId() == 0)
      cerr << "solverId: " << m_solverId << ", Writing " << m_outputFormat << " output at time step " << globalTimeStep
           << ", time " << m_time << " ... ";
 
    m_log << "Writing " << m_outputFormat << " output at time step " << globalTimeStep << ", time " << m_time
          << " for postData ... ";
 
    MFloatScratchSpace dbVariables(a_noCells() * noVariables(), AT_, "dbVariables");
    MIntScratchSpace idVariables(a_noCells() * 2, AT_, "idVariables");
    MFloatScratchSpace dbParameters(4, AT_, "dbParameters");
    MIntScratchSpace idParameters(2, AT_, "idParameters");
    vector<MString> dbVariablesName;
    vector<MString> idVariablesName;
    vector<MString> dbParametersName;
    vector<MString> idParametersName;
    vector<MString> name;
 
    stringstream fileName;
 
    fileName << m_solutionOutput << "ppQOUT_" << globalTimeStep;
 
    for(MInt v = 0; v < noVariables(); v++) {
      name.push_back(m_variablesName[v]);
    }
 
    this->collectVariables(&a_variable(0, 0), dbVariables, name, dbVariablesName, noVariables(), a_noCells());
 
    this->collectParameters(globalTimeStep, idParameters, "globalTimeStep", idParametersName);
 
    switch(string2enum(m_outputFormat)) {
      case NETCDF: {
        fileName << ParallelIo::fileExt();
        // TODO: currently not working for adaptation, check save restartFile
        //      and get solver recalcIds!
        //
        saveGridFlowVars((fileName.str()).c_str(), grid().gridInputFileName().c_str(), a_noCells(), noInternalCells(),
                         dbVariables, dbVariablesName, 0, idVariables, idVariablesName, 0, dbParameters,
                         dbParametersName, idParameters, idParametersName, m_recalcIds, -1);
        break;
      }
      case VTK:
      case VTU:
      case VTP: {
        break;
      }
      default: {
        stringstream errorMessage;
        errorMessage << "PostData::saveSolverSolution(): switch variable 'm_outputFormat' with value " << m_outputFormat
                     << " not matching any case." << endl;
        mTerm(1, AT_, errorMessage.str());
      }
    }
 
    if(domainId() == 0) cerr << "ok" << endl;
  }
}

◆ setAndAllocateSolverData()

template<MInt nDim>

void PostData< nDim >::setAndAllocateSolverData ( const MBool fullReset )

Definition at line 150 of file postdata.cpp.

                                                                   {
  TRACE();
 
  const MInt maxNoCells = maxNoGridCells();
 
  mAlloc(m_recalcIds, maxNoCells, "m_recalcIds", -1, AT_);
  for(MInt i = 0; i < maxNoCells; i++) {
    m_recalcIds[i] = i;
  }
 
  m_cells.setNoVariables(noVariables());
 
  m_cells.reset(grid().raw().treeb().capacity());
  m_cells.append(c_noCells());
 
  copyGridProperties();
 
  // NOTE: setting default here
  setVariableNames();
 
  if(fullReset) {
    for(MInt cellId = 0; cellId < noInternalCells(); cellId++) {
      for(MInt v = 0; v < noVariables(); v++) {
        a_variable(cellId, v) = 0;
      }
    }
  }
}

◆ setCellDataDlb()

template<MInt nDim_>

void PostData< nDim_ >::setCellDataDlb	(	const MInt	dataId,
		const MFloat *const	data
	)

inlineoverride

Definition at line 251 of file postdata.h.

251{ setCellDataDlb_(dataId, data); };

PostData::setCellDataDlb_

void setCellDataDlb_(const MInt dataId, const dataType *const data)

Set the solver cell data after DLB.

Definition: postdata.h:323

◆ setCellDataDlb_()

template<MInt nDim_>

template<typename dataType >

void PostData< nDim_ >::setCellDataDlb_	(	const MInt	dataId,
		const dataType *const	data
	)

inlineprivate

Definition at line 323 of file postdata.h.

                                                                      {
    TRACE();
 
    // Nothing to do if solver is not active
    if(!isActive()) {
      return;
    }
 
    // Set the variables if this is the correct reinitialization stage
    if(dataId == 0) {
      if(m_loadBalancingReinitStage == 0) {
        std::copy_n(data, noInternalCells() * noVariables(), &a_variable(0, 0));
      }
    } else {
      TERMM(1, "Unknown data id.");
    }
  }

◆ setCellWeights()

template<MInt nDim>

void PostData< nDim >::setCellWeights ( MFloat * solverCellWeight )

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 721 of file postdata.cpp.

                                                            {
  TRACE();
  const MInt noCellsGrid = grid().raw().treeb().size();
  const MInt offset = noCellsGrid * solverId();
 
  for(MInt cellId = 0; cellId < c_noCells(); cellId++) {
    const MInt gridCellId = grid().tree().solver2grid(cellId);
    const MInt id = gridCellId + offset;
    // TODO: find good value for postData!
    solverCellWeight[id] = 0.2;
  }
}

◆ setPropertyVariableOffset()

template<MInt nDim_>

void PostData< nDim_ >::setPropertyVariableOffset	(	MString	s,
		MInt	start,
		MInt	length
	)

inline

Definition at line 213 of file postdata.h.

                                                                     {
    MInt index = getVariablePropertyIndex(s);
    if(index > -1) {
      m_variableOffset[index].first = start;
      m_variableOffset[index].second = start + length;
    }
  }

◆ setSensors()

template<MInt nDim>

void PostData< nDim >::setSensors	(	std::vector< std::vector< MFloat > > &	sensors,
		std::vector< MFloat > &	sensorWeight,
		std::vector< std::bitset< 64 > > &	sensorCellFlag,
		std::vector< MInt > &	sensorSolverId
	)

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 815 of file postdata.cpp.

                                                                 {
  TRACE();
 
  const MInt sensorOffset = (signed)sensors.size();
  ASSERT(sensorOffset == 0 || grid().raw().treeb().noSolvers() > 1, "");
  sensors.resize(sensorOffset + this->m_noSensors, vector<MFloat>(grid().raw().m_noInternalCells, F0));
  sensorWeight.resize(sensorOffset + this->m_noSensors, -1);
  sensorCellFlag.resize(grid().raw().m_noInternalCells, sensorOffset + this->m_noSensors);
  sensorSolverId.resize(sensorOffset + this->m_noSensors, solverId());
  ASSERT(sensorOffset + this->m_noSensors < CartesianGrid<nDim>::m_maxNoSensors, "Increase bitset size!");
 
  for(MInt sen = 0; sen < this->m_noSensors; sen++) {
    sensorWeight[sensorOffset + sen] = this->m_sensorWeight[sen];
  }
 
  ASSERT(m_freeIndices.empty(), "");
  m_freeIndices.clear();
 
  if(!isActive()) return;
  if(!this->m_adapts) return;
 
  if(domainId() == 0) {
    cerr << "Setting " << this->m_noSensors << " sensors for post-Data adaptation." << endl;
  }
 
  for(MInt sen = 0; sen < this->m_noSensors; sen++) {
    (this->*(this->m_sensorFnPtr[sen]))(sensors, sensorCellFlag, sensorWeight, sensorOffset, sen);
  }
}

◆ setVariableNames()

template<MInt nDim>

void PostData< nDim >::setVariableNames

Definition at line 181 of file postdata.cpp.

                                      {
  TRACE();
 
  m_variablesName.clear();
 
  for(MInt i = 0; i < noVariables(); i++) {
    MString s = getVariableName(i);
    auto it = std::find(m_variablesName.begin(), m_variablesName.end(), s);
    if(it == m_variablesName.end()) {
      m_variablesName.push_back(getVariableName(i));
    }
  }
}

◆ solutionStep()

template<MInt nDim_>

MBool PostData< nDim_ >::solutionStep ( )

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 90 of file postdata.h.

90{ return true; };

◆ swapCells()

template<MInt nDim>

void PostData< nDim >::swapCells	(	const MInt	cellId0,
		const MInt	cellId1
	)

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 994 of file postdata.cpp.

                                                                     {
  TRACE();
 
  const MInt size = m_cells.size();
  m_cells.append();
  m_cells.erase(size);
  m_cells.copy(cellId0, size);
  m_cells.copy(cellId1, cellId0);
  m_cells.copy(size, cellId1);
  m_cells.erase(size);
  m_cells.size(size);
}

◆ swapProxy()

template<MInt nDim>

void PostData< nDim >::swapProxy	(	const MInt	cellId0,
		const MInt	cellId1
	)

overridevirtual

Author: Tim Wegmann

Reimplemented from Solver.

Definition at line 1013 of file postdata.cpp.

                                                                     {
  grid().swapGridIds(cellId0, cellId1);
}

◆ time()

template<MInt nDim_>

MFloat PostData< nDim_ >::time ( ) const

inlineoverridevirtual

Implements Solver.

Definition at line 86 of file postdata.h.

86{ return globalTimeStep; }

◆ timeStep()

template<MInt nDim_>

MFloat PostData< nDim_ >::timeStep ( ) const

inline

Definition at line 85 of file postdata.h.

85{ return m_timeStep; }

PostData::m_timeStep

MFloat m_timeStep

Definition: postdata.h:201

◆ writeRestartFile() [1/2]

template<MInt nDim>

void PostData< nDim >::writeRestartFile	(	const MBool	writeRestart,
		const MBool	writeBackup,
		const MString	gridFileName,
		MInt *	recalcIdTree
	)

overridevirtual

Reimplemented from Solver.

Definition at line 290 of file postdata.cpp.

                                                          {
  TRACE();
 
  // post-data has no cell-data
  if(noVariables() == 0) return;
 
  m_currentGridFileName = gridFileName;
 
  if(m_recalcIds != nullptr) {
    for(MInt cellId = 0; cellId < maxNoGridCells(); cellId++) {
      m_recalcIds[cellId] = recalcIdTree[cellId];
    }
  }
 
  if(writeRestart) {
    saveRestartFile(writeBackup);
  }
}

◆ writeRestartFile() [2/2]

template<MInt nDim_>

void PostData< nDim_ >::writeRestartFile ( MBool )

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 96 of file postdata.h.

96{};

Member Data Documentation

◆ m_adaptationLevel

template<MInt nDim_>

MInt PostData< nDim_ >::m_adaptationLevel = -1

protected

Definition at line 294 of file postdata.h.

◆ m_adaptationSinceLastRestart

template<MInt nDim_>

MBool PostData< nDim_ >::m_adaptationSinceLastRestart = false

protected

Definition at line 296 of file postdata.h.

◆ m_averagedVars

template<MInt nDim_>

MFloat** PostData< nDim_ >::m_averagedVars = nullptr

Definition at line 257 of file postdata.h.

◆ m_averageVariableName

template<MInt nDim_>

const std::vector<std::vector<MString> > PostData< nDim_ >::m_averageVariableName

staticprotected

Definition at line 288 of file postdata.h.

◆ m_cells

template<MInt nDim_>

maia::post::collector::PostCellCollector<nDim> PostData< nDim_ >::m_cells

Definition at line 34 of file postdata.h.

◆ m_currentGridFileName

template<MInt nDim_>

MString PostData< nDim_ >::m_currentGridFileName {}

protected

Definition at line 300 of file postdata.h.

◆ m_fileNoVars

template<MInt nDim_>

MInt PostData< nDim_ >::m_fileNoVars = -1

protected

Definition at line 315 of file postdata.h.

◆ m_fileVarNames

template<MInt nDim_>

std::vector<MString> PostData< nDim_ >::m_fileVarNames {}

protected

Definition at line 317 of file postdata.h.

◆ m_forceAdaptation

template<MInt nDim_>

MBool PostData< nDim_ >::m_forceAdaptation = false

protected

Definition at line 295 of file postdata.h.

◆ m_forceWriteRestart

template<MInt nDim_>

MBool PostData< nDim_ >::m_forceWriteRestart = false

Definition at line 175 of file postdata.h.

◆ m_geometry

template<MInt nDim_>

Geom* PostData< nDim_ >::m_geometry

Definition at line 79 of file postdata.h.

◆ m_isMeanFile

template<MInt nDim_>

MBool PostData< nDim_ >::m_isMeanFile = false

protected

Definition at line 313 of file postdata.h.

◆ m_loadBalancingReinitStage

template<MInt nDim_>

MInt PostData< nDim_ >::m_loadBalancingReinitStage = -1

protected

Definition at line 305 of file postdata.h.

◆ m_noVariables

template<MInt nDim_>

MInt PostData< nDim_ >::m_noVariables = 0

protected

Definition at line 293 of file postdata.h.

◆ m_outputFormat

template<MInt nDim_>

MString PostData< nDim_ >::m_outputFormat

Definition at line 205 of file postdata.h.

◆ m_propertyName

template<MInt nDim_>

const std::vector<MString> PostData< nDim_ >::m_propertyName

protected

Initial value:

= {"primitive",
                                               "square",
                                               "kurtosis",
                                               "skewness",
                                               "statisticCombustionAnalysis",
                                               "averageVorticity",
                                               "averageSpeedOfSound",
                                               "lamb0",
                                               "du",
                                               "drho",
                                               "dp",
                                               "gradu",
                                               "ugradu",
                                               "ugradrho",
                                               "gradprho",
                                               "rhodivu",
                                               "correlation"}

Definition at line 270 of file postdata.h.

◆ m_sourceVarsIndex

template<MInt nDim_>

MInt PostData< nDim_ >::m_sourceVarsIndex

Definition at line 223 of file postdata.h.

◆ m_time

template<MInt nDim_>

MFloat PostData< nDim_ >::m_time = NAN

Definition at line 202 of file postdata.h.

◆ m_timeStep

template<MInt nDim_>

MFloat PostData< nDim_ >::m_timeStep = NAN

Definition at line 201 of file postdata.h.

◆ m_variableOffset

template<MInt nDim_>

std::vector<std::pair<MInt, MInt> > PostData< nDim_ >::m_variableOffset

protected

Definition at line 290 of file postdata.h.

◆ m_variablesName

template<MInt nDim_>

std::vector<MString> PostData< nDim_ >::m_variablesName

Definition at line 254 of file postdata.h.

◆ nDim

template<MInt nDim_>

constexpr MInt PostData< nDim_ >::nDim = nDim_

staticconstexpr

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

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CartesianSolver

◆ Cell

◆ Geom

◆ Grid

◆ GridProxy

◆ SolverCell

Constructor & Destructor Documentation

◆ PostData()

◆ ~PostData()

Member Function Documentation

◆ a_averagedVariable()

◆ a_hasNeighbor()

◆ a_isHalo() [1/2]

◆ a_isHalo() [2/2]

◆ a_isWindow() [1/2]

◆ a_isWindow() [2/2]

◆ a_level()

◆ a_noCells()

◆ a_resetPropertiesSolver()

◆ a_variable() [1/2]

◆ a_variable() [2/2]

◆ balancePost()

◆ balancePre()

◆ c_childId()

◆ c_coordinate() [1/2]

◆ c_coordinate() [2/2]

◆ c_globalId()

◆ c_level()

◆ c_noCells()

◆ c_noChildren()

◆ c_parentId()

◆ cellDataSizeDlb()

◆ cellDataTypeDlb()

◆ cellOutside()

◆ cleanUp()

◆ copyGridProperties()

◆ fileNoVars()

◆ fileVarNames()

◆ finalizeAdaptation()

◆ finalizeBalance()

◆ finalizeInitSolver()

◆ geometry()

◆ getArray012()

◆ getCellDataDlb()

◆ getCellDataDlb_()

◆ getCellLoad()

◆ getDefaultWeights()

◆ getDomainDecompositionInformation()

◆ getLoadQuantities()

◆ getPropertyVariableOffset()

◆ getSolverTimings()

◆ getVariableName()

◆ getVariablePropertyIndex()

◆ hasSplitBalancing()

◆ initSolver()

◆ isMeanFile()

◆ loadGridFlowVars()

◆ loadMeanFile()

◆ loadRestartFile()

◆ m_averageVariableName() [1/2]

◆ m_averageVariableName() [2/2]

◆ noCellDataDlb()

◆ noInternalCells()

◆ noLoadTypes()

◆ noVariables()

◆ postAdaptation()

◆ postTimeStep()

◆ prepareAdaptation()