FvStructuredSolver< nDim > Class Template Reference

Base class of the structured solver. More...

#include <fvstructuredsolver.h>

Inheritance diagram for FvStructuredSolver< nDim >:

Collaboration diagram for FvStructuredSolver< nDim >:

Classes
struct	MRes

Public Types
using	Timers = maia::structured::Timers_

Public Member Functions
	FvStructuredSolver (MInt solverId, StructuredGrid< nDim > *, MBool *propertiesGroups, const MPI_Comm comm)
	Constructor of the structured solver. More...
MBool	isActive () const
void	initializeFQField ()
	Counts the number of necessary FQ fields, allocates them and corrects the indexes of the FQ variable pointers. More...
MInt	timer (const MInt timerId) const
MInt	noSolverTimers (const MBool allTimings) override
virtual void	writeHeaderAttributes (ParallelIoHdf5 *pio, MString fileType)
	Overloaded version of writeHeaderAttributes that receives ParallelIoHdf5 object pointer instead of 'fileId'. More...
virtual void	writePropertiesAsAttributes (ParallelIoHdf5 *pio, MString path)
	Overloaded version of writePropertiesAsAttributes that receives ParallelIoHdf5 object pointer instead of 'fileId'. More...
void	saveSolverSolution (MBool=false, const MBool=false) override
void	saveSolution (MBool)
	Saves the soution to hdf5 file. More...
void	savePartitions ()
	Saves the partitioned grid into an HDF5 file. Not used in production use but useful for debugging. More...
void	saveBoxes ()
virtual void	savePointsToAsciiFile (MBool)
virtual void	initPointsToAsciiFile ()
virtual void	saveInterpolatedPoints ()
virtual void	saveNodalBoxes ()
virtual void	reIntAfterRestart (MBool)
MBool	prepareRestart (MBool, MBool &) override
	Prepare the solvers for a grid-restart. More...
void	writeRestartFile (MBool) override
void	writeRestartFile (const MBool, const MBool, const MString, MInt *) override
void	shiftCellValuesRestart (MBool)
void	loadRestartFile ()
	Load Restart File (primitive and conservative output) general formulation. More...
MBool	loadBoxFile (MString, MString, MInt, MInt)
	Load Box file general formulation. More...
virtual void	loadRestartBC2600 ()
virtual void	loadRestartBC2601 ()
virtual void	loadRestartSTG (MBool)
void	saveForcesToAsciiFile (MBool)
	Function to save the force coefficients and power to an ASCII file. More...
void	saveAveragedVariables (MString, MInt, MFloat **)
	Saves the averaged (mean) variables from postprocessing to an HDF5 file. More...
void	saveProductionTerms (MString, MFloat **)
	Writes the production terms into a given file. More...
void	saveDissipation (MString, MFloat *)
	Writes the dissipation into a given file. More...
void	saveGradients (MString, MFloat **, MString *)
	Writes the gradients into a given file. More...
void	saveAverageRestart (MString, MInt, MFloat **, MFloat **, MFloat **, MFloat **)
	Writes an restart file for postprocessing. More...
void	getSolverTimings (std::vector< std::pair< MString, MFloat > > &solverTimings, const MBool allTimings) override
	Get solver timings. More...
void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &domainInfo) override
	Return decomposition information, i.e. number of local elements,... More...
virtual MFloat	getCellLengthY (MInt, MInt, MInt)
virtual MFloat	getCellCoordinate (MInt, MInt)
MInt	noInternalCells () const override
	Return the number of internal cells within this solver. More...
void	saveAuxData ()
void	saveForceCoefficient (ParallelIoHdf5 *parallelIoHdf5)
	Saves force coefficients to an HDF5 file. More...
void	computeAuxData ()
void	computeAuxDataRoot ()
virtual void	computeDomainWidth ()
void	computeForceCoef ()
	Function to compute the force coefficient cl, split split into the viscous part cLv and the pressure part cLp. More...
void	computeForceCoefRoot ()
	Function to compute the coefficient, split split into the viscous part cLv and the pressure part cLp The ROOT version is faster due to an MPI_Reduce instead of an MPI_Allreduce, but only root rank has data. More...
virtual void	computeFrictionPressureCoef (MBool)=0
virtual	~FvStructuredSolver ()
MFloat	computeRecConstSVD (const MInt ijk, const MInt noNghbrIds, MInt *nghbr, MInt ID, MInt sID, MFloatScratchSpace &tmpA, MFloatScratchSpace &tmpC, MFloatScratchSpace &weights, const MInt recDim)
	AUX DATA ENDS /////////////////////////////////////////////////////////////. More...
void	initializeFvStructuredSolver (MBool *propertiesGroups)
	Structured Solver Constructor reads and allocate properties/variables. More...
void	allocateAndInitBlockMemory ()
void	allocateAuxDataMaps ()
	AUX DATA //////////////////////////////////////////////////////////////////. More...
void	setRungeKuttaProperties ()
	This function reads the properties required for Runge Kutta time stepping. More...
void	setSamplingProperties ()
void	setNumericalProperties ()
	Reads and initializes properties associated with the numerical method. More...
void	setInputOutputProperties ()
	Reads properties and initializes variables associated with input/output. More...
void	setZonalProperties ()
	Set which zones are RANS and which are LES or if full LES or full RANS. More...
void	allocateVariables ()
void	setTestcaseProperties ()
	Reads and initializes properties associated with the Testcase. More...
void	setMovingGridProperties ()
	Reads and initializes properties associated with the Moving Grid Methods. More...
void	setBodyForceProperties ()
	Reads and initializes properties associated with the Moving Grid Methods. More...
void	setPorousProperties ()
	Set properties for porous blocks. More...
void	readAndSetSpongeLayerProperties ()
void	setSTGProperties ()
void	setProfileBCProperties ()
void	createMPIGroups ()
void	readAndSetAuxDataMap ()
void	computePV ()
MFloat	dummy (MInt) const
MFloat	pressure_twoEqRans (MInt cellId) const
MFloat	totalEnergy_twoEqRans (MInt cellId) const
void	partitionGrid ()
virtual void	computePrimitiveVariables ()
virtual void	computeConservativeVariables ()
template<MFloat(FvStructuredSolver::*)(MInt) const = &FvStructuredSolver::dummy>
void	computeConservativeVariables_ ()
void	saveVarToPrimitive (MInt, MInt, MFloat)
virtual void	gcFillGhostCells (std::vector< MFloat * > &)
void	computeSamplingInterval ()
void	checkNans ()
	Checks whole domain for NaNs and adds the number of NaNs globally. More...
void	setVolumeForce ()
void	computeVolumeForces ()
virtual void	computePorousRHS (MBool)
void	initPorous ()
virtual void	applyBoundaryCondtition ()
virtual void	moveGrid (MInt)
virtual void	initMovingGrid ()
virtual void	moveGrid (MBool, MBool)
virtual void	initBodyForce ()
virtual void	applyBodyForce (MBool, MBool)
virtual void	computeLambda2Criterion ()
virtual void	computeVorticity ()
void	exchange ()
	SVD STUFF ENDS /////////////////////////////////////////////////////////////. More...
void	exchange (std::vector< std::unique_ptr< StructuredComm< nDim > > > &, std::vector< std::unique_ptr< StructuredComm< nDim > > > &)
	Parallel exchange of primitive variables between partitions with MPI. More...
void	send (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &, std::vector< MPI_Request > &)
void	receive (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &, std::vector< MPI_Request > &)
virtual void	gather (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &)
virtual void	scatter (const MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &)
MBool	isPeriodicComm (std::unique_ptr< StructuredComm< nDim > > &)
MBool	skipPeriodicDirection (std::unique_ptr< StructuredComm< nDim > > &)
virtual void	zonalExchange ()
virtual void	spanwiseAvgZonal (std::vector< MFloat * > &)
virtual void	waveExchange ()
virtual void	spanwiseWaveReorder ()
void	setTimeStep ()
void	setLimiterVisc ()
void	fixTimeStepTravelingWave ()
void	exchangeTimeStep ()
void	initializeRungeKutta ()
virtual void	computeTimeStep ()
MBool	isInInterval (MInt)
MInt	getNoCells ()
MInt	noVariables () const override
	Return the number of variables. More...
MInt	getNoActiveCells ()
MInt *	getActiveCells ()
MInt *	getOffsetCells ()
MInt	getNoGhostLayers ()
MInt	getWaveAvrgInterval ()
MInt	getWaveStepOffset ()
MInt *	getCellGrid ()
MBool	isMovingGrid ()
MInt	getGridMovingMethod ()
MInt	getBodyForceMethod ()
MBool	isStreamwiseTravelingWave ()
MBool	isTravelingWave ()
StructuredGrid< nDim > *	getGrid ()
MFloat	getGamma ()
MFloat	getSutherlandConstant ()
MFloat	getRe0 ()
MFloat	getMa ()
MPI_Comm	getCommunicator ()
virtual void	computeCumulativeAverage (MBool)
virtual void	loadSampleFile (MString)
virtual void	getSampleVariables (MInt, MFloat *)
MFloat	getPV (MInt var, MInt cellId)
void	setPV (MInt var, MInt cellId, MFloat value)
virtual MFloat	getSampleVorticity (MInt, MInt)
virtual MFloat	dvardxyz (MInt, MInt, MFloat *)
virtual MFloat	dvardx (MInt, MFloat *)
virtual void	loadAverageRestartFile (const char *, MFloat **, MFloat **, MFloat **, MFloat **)
virtual void	loadAveragedVariables (const char *)
void	convertRestartVariables (MFloat oldMa)
virtual void	convertRestartVariablesSTG (MFloat oldMa)
virtual bool	rungeKuttaStep ()=0
virtual void	viscousFlux ()=0
virtual void	Muscl (MInt=-1)=0
virtual void	applyBoundaryCondition ()=0
virtual void	initSolutionStep (MInt)=0
virtual void	initialCondition ()=0
void	tred2 (MFloatScratchSpace &A, MInt dim, MFloat *diag, MFloat *offdiag)
	Householder Reduction according to Numercial Recipies in C: The Art of Scientific Computing. More...
void	tqli2 (MFloat *diag, MFloat *offdiag, MInt dim)
	Compute Eigenvalues with implicit shift according to Numercial Recipies in C: The Art of Scientific Computing. More...
void	insertSort (MInt dim, MFloat *list)
	Sorting function to sort list in ascending order. More...
MFloat	pythag (MFloat a, MFloat b)
void	resetRHS ()
	Reset the right hand side to zero. More...
void	rhs ()
void	rhsBnd ()
void	lhsBnd ()
void	initSolver () override
virtual MBool	maxResidual ()
MBool	solutionStep () override
void	preTimeStep () override
void	postTimeStep () override
	: Performs the post time step More...
void	finalizeInitSolver () override
void	cleanUp () override
virtual void	updateSpongeLayer ()=0
MFloat	time () const override
	Return the time. More...
MInt	determineRestartTimeStep () const override
	Load the restart time step from the restart file (useNonSpecifiedRestartFile enabled) More...
MBool	hasRestartTimeStep () const override
void	init ()
std::array< MInt, nDim >	beginP0 ()
std::array< MInt, nDim >	beginP1 ()
std::array< MInt, nDim >	beginP2 ()
std::array< MInt, nDim >	endM2 ()
std::array< MInt, nDim >	endM1 ()
std::array< MInt, nDim >	endM0 ()
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 Member Functions inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > >
	StructuredPostprocessing ()
	Constructor for the postprocessing solver. More...
	~StructuredPostprocessing ()
	Destructor for the postprocessing solver. More...
void	postprocessPreInit ()
void	postprocessPreSolve ()
void	postprocessPostSolve ()
void	postprocessInSolve ()

Public Attributes
StructuredGrid< nDim > *	m_grid
MPI_Comm	m_StructuredComm
MInt	m_restartTimeStep
MString	m_outputFormat
MInt	m_lastOutputTimeStep
Public Attributes inherited from Solver
std::set< MInt >	m_freeIndices
MBool	m_singleAdaptation = false
MBool	m_splitAdaptation = true
MBool	m_saveSensorData = false
Public Attributes inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > >
MInt	m_restartTimeStep

Protected Member Functions
void	initTimers ()
virtual void	initFsc ()
	Init for Falkner-Skan-Cooke flow. More...
virtual MFloat	getFscPressure (MInt cellId)
virtual MFloat	getFscPressure (MFloat coordX)
virtual MFloat	getFscEta (MFloat coordX, MFloat coordY)
virtual void	getFscVelocity (MInt cellId, MFloat *const vel)
	Load variables for the specified timeStep. More...
virtual void	getFscVelocity (MFloat coordX, MFloat coordY, MFloat *const vel)
virtual void	initBlasius ()
	Init for Blasius boundary layer. More...
virtual MFloat	getBlasiusEta (MFloat coordX, MFloat coordY)
virtual void	getBlasiusVelocity (MInt cellId, MFloat *const vel)
	Load variables for the specified timeStep. More...
virtual void	getBlasiusVelocity (MFloat coordX, MFloat coordY, MFloat *const vel)
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 Member Functions inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > >
void	initStructuredPostprocessing ()
void	initAverageIn ()
	Initializes properties for averaging during solver run. More...
void	initAverageVariables ()
	allocates memory for averageSolutions() and averageSolutionsInSolve() More...
void	initTimeStepProperties ()
	Initializes timestep properties for postprocessing. More...
void	initMovingAverage ()
void	initProductionVariables ()
void	initDissipationVariables ()
void	averageSolutionsInSolve ()
void	averageSolutions ()
void	addAveragingSample ()
	Adds one sample to the summedVars. More...
void	addTempWaveSample ()
	Adds for the travelling wave setups. More...
void	saveAveragedSolution (MInt)
void	computeAveragedSolution ()
	Computes the mean variables from summed vars. More...
void	computeAverageSkinFriction ()
	Computes skin friction of an averaged field. More...
void	subtractPeriodicFluctuations ()
void	subtractMean ()
void	movingAverage ()
void	movingAveragePost ()
void	computeProductionTerms ()
	Computes the production terms from an averaged field. More...
void	computeDissipationTerms ()
	Computes the production terms from an averaged field. More...
void	decomposeCf ()
void	decomposeCfDouble ()
void	writeGradients ()
void	loadAveragedSolution ()
	Loads an averaged file again. More...
void	saveAverageRestart ()
void	loadMeanFile (const MChar *fileName)
void	getSampleVariables (MInt cellId, const MFloat *&vars)
MInt	getNoPPVars ()
	Returns number of postprocessing variables. More...
MInt	getNoVars ()
MInt	getNoPPSquareVars ()
	Returns number of pp Square variables. More...

Protected Attributes
std::unique_ptr< MConservativeVariables< nDim > >	CV
std::unique_ptr< MPrimitiveVariables< nDim > >	PV
MFloat	m_eps
MFloat *	m_QLeft = nullptr
MFloat *	m_QRight = nullptr
MBool	m_movingGrid
MBool	m_mgExchangeCoordinates
MInt	m_gridMovingMethod = 0
MInt	m_movingGridStepOffset
MBool	m_synchronizedMGOutput
MInt	m_waveNoStepsPerCell
MFloat	m_wallVel
MFloat	m_movingGridTimeOffset
MBool	m_movingGridSaveGrid
MBool	m_travelingWave
MBool	m_streamwiseTravelingWave
MFloat	m_waveLengthPlus
MFloat	m_waveAmplitudePlus
MFloat	m_waveTimePlus
MFloat	m_waveTime
MFloat	m_waveLength
MFloat	m_waveAmplitude
MFloat	m_waveAmplitudeSuction
MFloat	m_waveAmplitudePressure
MFloat	m_waveGradientSuction
MFloat	m_waveGradientPressure
MFloat	m_waveSpeed
MFloat	m_waveSpeedPlus
MFloat	m_waveBeginTransition
MFloat	m_waveEndTransition
MFloat	m_waveOutBeginTransition
MFloat	m_waveOutEndTransition
MFloat	m_wavePressureBeginTransition
MFloat	m_wavePressureEndTransition
MFloat	m_wavePressureOutBeginTransition
MFloat	m_wavePressureOutEndTransition
MFloat	m_waveYBeginTransition
MFloat	m_waveYEndTransition
MFloat	m_waveAngle
MFloat	m_waveTemporalTransition
MBool	m_movingGridInitialStart
MBool	m_waveRestartFadeIn
MInt	m_waveTimeStepComputed
MInt	m_waveCellsPerWaveLength
MFloat	m_wavePenetrationHeight
MInt	m_bodyForceMethod = 0
MBool	m_bodyForce
MFloat *	m_waveForceField = nullptr
MFloat *	m_waveForceY = nullptr
MFloat *	m_waveForceZ = nullptr
MString	m_waveForceFieldFile
MFloat	m_waveDomainWidth
MFloat	m_oscAmplitude
MFloat	m_oscSr
MFloat	m_oscFreq
MFloat *	m_rhs = nullptr
MBool	m_dsIsComputed
MBool	m_useNonSpecifiedRestartFile
MInt	m_outputOffset
MBool	m_vorticityOutput
MBool	m_debugOutput
MInt	m_outputIterationNumber
MBool	m_sampleSolutionFiles
StructuredCell *	m_cells = nullptr
MString *	m_variableNames = nullptr
MString *	m_pvariableNames = nullptr
MFloat **	pointProperties = nullptr
MBool	m_ignoreUID
std::unique_ptr< FvStructuredSolverWindowInfo< nDim > >	m_windowInfo
MInt	m_noGhostLayers
MInt *	m_nPoints = nullptr
MInt *	m_nActivePoints = nullptr
MInt *	m_nOffsetPoints = nullptr
MInt	m_noCells
MInt	m_noActiveCells
MInt	m_noPoints
MInt	m_noSurfaces
MFloat	m_referenceLength
MFloat	m_physicalReferenceLength
MFloat	m_Pr
MFloat	m_rPr
MFloat	m_cfl
MInt	m_orderOfReconstruction
MFloat	m_inflowTemperatureRatio
MBool	m_considerVolumeForces
MBool	m_euler
MFloat *	m_volumeForce = nullptr
MInt	m_volumeForceMethod = 0
MInt	m_volumeForceUpdateInterval
MFloat	m_gamma
MFloat	m_gammaMinusOne
MFloat	m_fgammaMinusOne
MFloat	m_Re0
MFloat	m_ReTau
MFloat *	m_angle = nullptr
MInt	m_periodicConnection
MInt	m_channelFlow
MFloat	m_sutherlandConstant
MFloat	m_sutherlandPlusOne
MFloat	m_TinfS
MBool	m_computeLambda2
MFloat	m_hInfinity
MFloat	m_referenceEnthalpy
MString	m_rans2eq_mode
MBool	m_keps_nonDimType
MBool	m_solutionAnomaly
MFloat	m_I
MFloat	m_epsScale
MInt	m_kepsICMethod
std::unique_ptr< StructuredFQVariables >	FQ
MInt	m_maxNoVariables
MBool	m_bForce
MBool	m_bPower
MFloat *	m_forceCoef = nullptr
MBool	m_detailAuxData
MBool	m_bForceLineAverage
std::vector< MString >	m_forceHeaderNames
MInt	m_forceAveragingDir
MInt	m_forceOutputInterval
MInt	m_forceAsciiOutputInterval
MInt	m_forceAsciiComputeInterval
MFloat **	m_forceData = nullptr
MInt	m_forceCounter
MInt	m_lastForceOutputTimeStep
MInt	m_lastForceComputationTimeStep
MInt	m_noForceDataFields
MBool	m_forceSecondOrder
MFloat	m_globalDomainWidth
MBool	m_auxDataCoordinateLimits
MFloat *	m_auxDataLimits = nullptr
MBool	m_setLocalWallDistance = false
MInt	m_intpPointsOutputInterval
MInt	m_intpPointsNoLines
MInt	m_intpPointsNoLines2D
MInt	m_intpPointsNoPointsTotal
MInt *	m_intpPointsNoPoints = nullptr
MInt *	m_intpPointsNoPoints2D = nullptr
MInt *	m_intpPointsOffsets = nullptr
MFloat **	m_intpPointsStart = nullptr
MFloat **	m_intpPointsDelta = nullptr
MFloat **	m_intpPointsDelta2D = nullptr
MFloat **	m_intpPointsCoordinates = nullptr
MInt *	m_intpPointsHasPartnerGlobal = nullptr
MInt *	m_intpPointsHasPartnerLocal = nullptr
MFloat **	m_intpPointsVarsGlobal = nullptr
MFloat **	m_intpPointsVarsLocal = nullptr
MBool	m_intpPoints
MInt	m_boxNoBoxes
MInt	m_boxOutputInterval
MInt *	m_boxBlock = nullptr
MInt **	m_boxOffset = nullptr
MInt **	m_boxSize = nullptr
MBool	m_boxWriteCoordinates
std::unique_ptr< StructuredInterpolation< nDim > >	m_nodalBoxInterpolation
MInt	m_nodalBoxNoBoxes
MString	m_nodalBoxOutputDir
MInt	m_nodalBoxOutputInterval
MInt *	m_nodalBoxBlock = nullptr
MInt **	m_nodalBoxOffset = nullptr
MInt **	m_nodalBoxPoints = nullptr
MInt **	m_nodalBoxLocalOffset = nullptr
MInt **	m_nodalBoxLocalPoints = nullptr
MInt **	m_nodalBoxLocalDomainOffset = nullptr
MInt *	m_nodalBoxLocalSize = nullptr
MInt *	m_nodalBoxPartnerLocal = nullptr
MFloat **	m_nodalBoxCoordinates = nullptr
MFloat **	m_nodalBoxVariables = nullptr
MBool	m_nodalBoxWriteCoordinates
MInt	m_nodalBoxTotalLocalSize
MInt *	m_nodalBoxTotalLocalOffset = nullptr
MBool	m_nodalBoxInitialized
MInt	m_pointsToAsciiComputeInterval
MInt	m_pointsToAsciiOutputInterval
MInt	m_pointsToAsciiNoPoints
MInt	m_pointsToAsciiLastOutputStep
MInt	m_pointsToAsciiLastComputationStep
MFloat **	m_pointsToAsciiCoordinates = nullptr
MFloat **	m_pointsToAsciiVars = nullptr
MInt	m_pointsToAsciiVarId
MInt	m_pointsToAsciiCounter
MInt *	m_pointsToAsciiHasPartnerGlobal = nullptr
MInt *	m_pointsToAsciiHasPartnerLocal = nullptr
std::unique_ptr< StructuredInterpolation< nDim > >	m_pointsToAsciiInterpolation
MFloat	m_referenceTemperature
MInt	m_noSpecies
MFloat *	m_referenceComposition = nullptr
MFloat *	m_formationEnthalpy = nullptr
MInt	m_noRKSteps
MFloat *	m_RKalpha = nullptr
MFloat	m_time
MInt	m_RKStep
MFloat	m_timeStep
MBool	m_localTimeStep
MInt	m_rungeKuttaOrder
MInt	m_timeStepMethod
MInt	m_timeStepComputationInterval
MFloat	m_timeRef
MInt	m_dualTimeStepping
MFloat	m_physicalTimeStep
MFloat	m_physicalTime
MInt	m_timerGroup = -1
std::array< MInt, Timers::_count >	m_timers {}
MBool	m_constantTimeStep
MInt	m_rescalingCommGrRoot = -1
MInt	m_rescalingCommGrRootGlobal = -1
MPI_Comm	m_rescalingCommGrComm = MPI_COMM_NULL
MPI_Comm	m_commStg = MPI_COMM_NULL
MInt	m_commStgRoot = -1
MInt	m_commStgRootGlobal = -1
MInt	m_commStgMyRank = -1
MBool	m_stgIsActive
MFloat	m_stgBLT1
MFloat	m_stgBLT2
MFloat	m_stgBLT3
MFloat	m_stgDelta99Inflow
MBool	m_stgInitialStartup
MInt	m_stgNoEddieProperties
MFloat **	m_stgEddies = nullptr
MInt	m_stgNoEddies
MInt	m_stgMaxNoEddies
MFloat	m_stgExple
MFloat	m_stgEddieDistribution
MInt	m_stgBoxSize [3]
MBool	m_stgLocal
MBool	m_stgCreateNewEddies
MBool	m_stgRootRank
MInt	m_stgNoVariables
MInt	m_stgShapeFunction
MBool	m_stgEddieLengthScales
MBool	m_stgSubSup
MBool	m_stgSupersonic
MInt	m_stgFace
MFloat *	m_stgLengthFactors = nullptr
MFloat *	m_stgRSTFactors = nullptr
MInt	m_stgMyRank
MFloat	m_chi
MInt	m_noSpongeDomainInfos
MInt *	m_spongeBcWindowInfo = nullptr
MBool	m_useSponge
MInt	m_spongeLayerType
MFloat *	m_sigmaSponge = nullptr
MFloat *	m_betaSponge = nullptr
MFloat *	m_spongeLayerThickness = nullptr
MFloat	m_targetDensityFactor
MBool	m_computeSpongeFactor
MFloat	m_workload
MFloat	m_workloadIncrement
MRes *	m_residualSnd = nullptr
MRes	m_residualRcv
MInt	m_residualOutputInterval
MFloat	m_avrgResidual
MFloat	m_firstMaxResidual
MFloat	m_firstAvrgResidual
MLong	m_totalNoCells
MBool	m_residualFileExist
MPI_Op	m_resOp
MPI_Datatype	m_mpiStruct
FILE *	m_resFile
MBool	m_convergence
MFloat	m_convergenceCriterion
MBool	m_restart
MInt	m_initialCondition
MFloat	m_deltaP
MBool	m_restartInterpolation
MString	m_solutionFileName
MString	m_boxOutputDir
MString	m_intpPointsOutputDir
MString	m_auxOutputDir
MBool	m_savePartitionOutput
MInt *	m_nCells = nullptr
MInt *	m_nActiveCells = nullptr
MInt *	m_nOffsetCells = nullptr
MInt	m_blockId
MInt	m_noBlocks
MInt *	m_noWindows = nullptr
MInt **	m_bndryCndInfo = nullptr
MInt **	m_bndryCnd = nullptr
MBool	m_limiter
MString	m_limiterMethod
MFloat	m_venkFactor
MBool	m_limiterVisc
MFloat	m_CFLVISC
MString	m_musclScheme
MString	m_ausmScheme
MBool	m_viscCompact
MBool	m_zonal
MInt	m_rans
RansMethod	m_ransMethod = NORANS
MInt	m_noRansEquations
MString	m_zoneType
MFloat	m_ransTransPos
MBool	m_hasSTG
MInt	m_zonalExchangeInterval
std::vector< MFloat * >	m_zonalSpanwiseAvgVars
MPI_Comm	m_commBC2600 = MPI_COMM_NULL
MInt	m_commBC2600Root = -1
MInt	m_commBC2600RootGlobal = -1
MInt	m_commBC2600MyRank = -1
MPI_Comm *	m_commZonal = nullptr
MInt *	m_commZonalRoot = nullptr
MInt *	m_commZonalRootGlobal = nullptr
MInt	m_commZonalMyRank = -1
MBool	m_zonalRootRank = false
MBool	m_zonalExponentialAveraging
MInt	m_zonalStartAvgTime
MFloat	m_zonalAveragingFactor
MFloat	m_rhoNuTildeInfinty
MFloat	m_nutInfinity
MFloat	m_mutInfinity
std::vector< std::unique_ptr< StructuredComm< nDim > > >	m_sndComm
std::vector< std::unique_ptr< StructuredComm< nDim > > >	m_rcvComm
MInt	m_currentPeriodicDirection
std::vector< std::unique_ptr< StructuredComm< nDim > > >	m_waveSndComm
std::vector< std::unique_ptr< StructuredComm< nDim > > >	m_waveRcvComm
MInt	m_noNghbrDomains
MInt *	m_nghbrDomainId = nullptr
MInt *	m_noNghbrDomainBufferSize = nullptr
MFloat **	m_bufferCellsSndRcv = nullptr
MFloat **	m_bufferPointsSendRcv = nullptr
MInt *	m_nghbrFaceId = nullptr
MInt **	m_nghbrFaceInfo = nullptr
MPI_Request *	mpi_sndRequest = nullptr
MPI_Request *	mpi_rcvRequest = nullptr
MPI_Status *	mpi_sndRcvStatus = nullptr
MPI_Comm	m_plenumComm = MPI_COMM_NULL
MInt	m_plenumRoot = -1
MPI_Comm	m_commChannelIn = MPI_COMM_NULL
MPI_Comm	m_commChannelOut = MPI_COMM_NULL
MPI_Comm	m_commChannelWorld = MPI_COMM_NULL
MInt *	m_channelRoots = nullptr
MFloat	m_channelPresInlet
MFloat	m_channelPresOutlet
MFloat	m_channelLength
MFloat	m_channelHeight
MFloat	m_channelWidth
MFloat	m_channelInflowPlaneCoordinate
MFloat	m_channelC1
MFloat	m_channelC2
MFloat	m_channelC3
MFloat	m_channelC4
MBool	m_channelFullyPeriodic
MFloat	m_inflowVelAvg
MPI_Comm	m_commPerRotOne = MPI_COMM_NULL
MPI_Comm	m_commPerRotTwo = MPI_COMM_NULL
MPI_Comm	m_commPerRotWorld = MPI_COMM_NULL
MInt *	m_commPerRotRoots = nullptr
MInt	m_commPerRotGroup = -1
MBool	m_bc2600IsActive
MBool	m_bc2600InitialStartup
MFloat **	m_bc2600Variables = nullptr
MBool	m_bc2600
MInt *	m_bc2600noCells = nullptr
MInt *	m_bc2600noActiveCells = nullptr
MInt *	m_bc2600noOffsetCells = nullptr
MInt	m_bc2600RootRank
MInt	m_bc2600Face
MBool	m_bc2601IsActive
MBool	m_bc2601InitialStartup
MFloat **	m_bc2601Variables = nullptr
MFloat **	m_bc2601ZerothOrderSolution = nullptr
MBool	m_bc2601
MInt *	m_bc2601noCells = nullptr
MInt *	m_bc2601noActiveCells = nullptr
MInt *	m_bc2601noOffsetCells = nullptr
MFloat	m_bc2601GammaEpsilon
MBool	m_useConvectiveUnitWrite
MFloat	m_convectiveUnitInterval
MInt	m_noConvectiveOutputs
MBool	m_isInitTimers = false
MFloat	m_UInfinity
MFloat	m_VInfinity
MFloat	m_WInfinity
MFloat	m_PInfinity
MFloat	m_TInfinity
MFloat	m_DthInfinity
MFloat	m_muInfinity
MFloat	m_DInfinity
MFloat	m_VVInfinity [3]
MFloat	m_rhoUInfinity
MFloat	m_rhoVInfinity
MFloat	m_rhoWInfinity
MFloat	m_rhoEInfinity
MFloat	m_rhoInfinity
MFloat	m_rhoVVInfinity [3]
MBool	m_changeMa
MInt	m_restartBc2800
MFloat	m_restartTimeBc2800
MFloat *	m_adiabaticTemperature = nullptr
MInt	m_useAdiabaticRestartTemperature
SingularInformation *	m_singularity = nullptr
MInt	m_hasSingularity
MBool	m_useSandpaperTrip
MInt	m_tripNoTrips
MFloat *	m_tripDelta1 = nullptr
MFloat *	m_tripXOrigin = nullptr
MFloat *	m_tripXLength = nullptr
MFloat *	m_tripYOrigin = nullptr
MFloat *	m_tripYHeight = nullptr
MFloat *	m_tripCutoffZ = nullptr
MFloat *	m_tripMaxAmpSteady = nullptr
MFloat *	m_tripMaxAmpFluc = nullptr
MInt	m_tripNoModes
MFloat *	m_tripDeltaTime = nullptr
MInt *	m_tripTimeStep = nullptr
MInt	m_tripSeed
MFloat *	m_tripG = nullptr
MFloat *	m_tripH1 = nullptr
MFloat *	m_tripH2 = nullptr
MFloat *	m_tripModesG = nullptr
MFloat *	m_tripModesH1 = nullptr
MFloat *	m_tripModesH2 = nullptr
MFloat *	m_tripCoords = nullptr
MInt	m_tripNoCells
MFloat	m_tripDomainWidth
MBool	m_tripUseRestart
MBool	m_tripAirfoil
MFloat *	m_airfoilCoords = nullptr
MFloat *	m_airfoilNormalVec = nullptr
MInt	m_airfoilNoWallPoints
MFloat *	m_airfoilWallDist = nullptr
MBool	m_porous
MString	m_blockType
std::vector< MInt >	m_porousBlockIds
MFloat	m_c_Dp
MFloat	m_c_Dp_eps
MFloat	m_c_wd
MFloat	m_c_t
MFloat	m_c_eps
MInt	m_fsc
MFloat *	m_fsc_eta
MFloat *	m_fsc_fs
MFloat *	m_fsc_f
MFloat *	m_fsc_g
MInt	m_fsc_noPoints
MFloat	m_fsc_x0
MFloat	m_fsc_y0
MFloat	m_fsc_dx0
MFloat	m_fsc_m
MFloat	m_fsc_Re
MBool	m_useBlasius
MFloat *	m_blasius_eta
MFloat *	m_blasius_f
MFloat *	m_blasius_fp
MInt	m_blasius_noPoints
MFloat	m_blasius_x0
MFloat	m_blasius_y0
MFloat	m_blasius_dx0
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
Protected Attributes inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > >
MBool	m_postprocessing
MInt	m_noPostprocessingOps
MString *	m_postprocessingOps
MInt	m_dissFileStart
MInt	m_dissFileEnd
MInt	m_dissFileStep
MString	m_dissFileDir
MString	m_dissFilePrefix
MInt	m_dissFileBoxNr
std::vector< tvecpost >	m_postprocessingMethods
std::vector< std::vector< MString > >	m_postprocessingMethodsDesc
MInt	m_noVariables
MFloat **	m_summedVars
MFloat **	m_square
MFloat **	m_cube
MFloat **	m_fourth
MFloat **	m_tempWaveSample
MFloat **	m_favre
MBool	m_useKahan
MFloat **	m_cSum
MFloat **	m_ySum
MFloat **	m_tSum
MFloat **	m_cSquare
MFloat **	m_ySquare
MFloat **	m_tSquare
MFloat **	m_cCube
MFloat **	m_yCube
MFloat **	m_tCube
MFloat **	m_cFourth
MFloat **	m_yFourth
MFloat **	m_tFourth
MBool	m_twoPass
MBool	m_skewness
MBool	m_kurtosis
MBool	m_averageVorticity
MBool	m_averagingFavre
MFloat **	m_production
MString *	m_avgVariableNames
MString *	m_avgFavreNames
MFloat *	m_dissipation
MFloat **	m_gradients
MString *	m_gradientNames
MInt	m_movingAvgInterval
MInt	m_movingAvgDataPoints
MInt	m_movingAvgCounter
MInt	m_movAvgNoVariables
MFloat **	m_movAvgVariables
MString *	m_movAvgVarNames
MFloat **	m_spanAvg
MInt	m_averageInterval
MInt	m_averageStartTimestep
MInt	m_averageStopTimestep
MInt	m_averageRestartInterval
MInt	m_averageRestart
MInt	m_noSamples
MBool	m_movingGrid
MBool	m_computeProductionTerms
MBool	m_computeDissipationTerms
MString	m_postprocessFileName
MFloat	m_sutherlandConstant
MFloat	m_sutherlandPlusOne

Private Member Functions
virtual void	initStructuredPostprocessing ()
	PostProcessingSolver interface: More...
virtual void	saveAverageRestart ()

Private Attributes
MBool	m_timeStepConverged = false
	Convergence status of the current time step. More...
MBool	m_isActive = false

Friends
template<MInt nDim_>
class	StructuredBndryCnd
template<MInt nDim_>
class	StructuredInterpolation
class	FvStructuredSolver3DRans
class	FvStructuredSolver2DRans
template<class SolverType >
class	AccesorStructured

Additional Inherited Members
Protected Types inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > >
typedef void(StructuredPostprocessing::*	tpost) ()
typedef std::vector< tpost >	tvecpost
Static Protected Attributes inherited from StructuredPostprocessing< nDim, FvStructuredSolver< nDim > >
static const MInt	xsd
static const MInt	ysd
static const MInt	zsd

Detailed Description

template<MInt nDim>
class FvStructuredSolver< nDim >

This is the base class of the structured solver from which the 2D and 3D solvers are derived

Definition at line 41 of file fvstructuredsolver.h.

Member Typedef Documentation

Timers

template<MInt nDim>

using FvStructuredSolver< nDim >::Timers = maia::structured::Timers_

Definition at line 68 of file fvstructuredsolver.h.

Constructor & Destructor Documentation

FvStructuredSolver()

template<MInt nDim>

FvStructuredSolver< nDim >::FvStructuredSolver	(	MInt	solverId,
		StructuredGrid< nDim > *	grid_,
		MBool *	propertiesGroups,
		const MPI_Comm	comm
	)

Authors

Pascal Meysonnat, Marian Albers

Parameters

[in]	solverID	ID of this solver
[in]	grid_	Pointer to the StructuredGrid object for which this solver is used
[in]	propertiesGroups
[in]	comm	MPI communicator

Definition at line 33 of file fvstructuredsolver.cpp.

  : Solver(solverId, comm),
    StructuredPostprocessing<nDim, FvStructuredSolver<nDim>>(),
    m_grid(grid_),
    m_eps(std::numeric_limits<MFloat>::epsilon()) {
  (void)propertiesGroups;
  const MLong oldAllocatedBytes = allocatedBytes();
 
  // initialize all timers
  initTimers();
 
  if(domainId() == 0) {
    cout << "Initializing Structured Solver..." << endl;
  }
 
  m_isActive = true;
 
  // for the zonal approach we will have to split the communicator
  m_StructuredComm = comm;
 
  // intialize the most important properties
  initializeFvStructuredSolver(propertiesGroups);
 
  // numericals method:
  setNumericalProperties();
 
  // set testcase parameters
  setTestcaseProperties();
 
  // set moving grid parameters
  setMovingGridProperties();
 
  setBodyForceProperties();
 
  // initialize cell
  m_cells = new StructuredCell;
 
  RECORD_TIMER_START(m_timers[Timers::GridDecomposition]);
  m_grid->gridDecomposition(false);
  RECORD_TIMER_STOP(m_timers[Timers::GridDecomposition]);
 
 
  m_log << "Setting porous properties..." << endl;
  setPorousProperties();
  m_log << "Setting porous properties... SUCCESSFUL!" << endl;
 
  m_log << "Setting zonal properties..." << endl;
  setZonalProperties();
  m_log << "Setting zonal properties... SUCCESSFUL!" << endl;
 
  m_log << "Allocating variables..." << endl;
  allocateVariables();
  m_log << "Allocating variables... SUCCESSFUL!" << endl;
 
  m_log << "Reading input output properties..." << endl;
  setInputOutputProperties();
  m_log << "Reading input output properties... SUCCESSFUL!" << endl;
 
  // 4) assign window winformation (3D-2D possible because of dimension)
  //  but be careful, only 3D has been tested and implemented
  m_grid->setCells(m_cells);
  m_grid->prepareReadGrid(); // determines grid dimensions (point and cell wise) and allocates m_grid->m_coordinates
 
  m_noCells = m_grid->m_noCells;
  m_noActiveCells = m_grid->m_noActiveCells;
  m_noPoints = m_grid->m_noPoints;
  m_totalNoCells = m_grid->m_totalNoCells;
 
  m_nOffsetCells = m_grid->m_nOffsetCells;
  m_nOffsetPoints = m_grid->m_nOffsetPoints;
  m_nPoints = m_grid->m_nPoints;
  m_nActivePoints = m_grid->m_nActivePoints;
  m_nCells = m_grid->m_nCells;
  m_nActiveCells = m_grid->m_nActiveCells;
  m_noBlocks = m_grid->getNoBlocks();
  m_blockId = m_grid->getMyBlockId();
 
  m_windowInfo =
      make_unique<FvStructuredSolverWindowInfo<nDim>>(m_grid, m_StructuredComm, noDomains(), domainId(), m_solverId);
 
  m_windowInfo->readWindowInfo();
  m_windowInfo->initGlobals();
 
  m_windowInfo->readWindowCoordinates(m_grid->m_periodicDisplacements);
 
  createMPIGroups();
 
  readAndSetSpongeLayerProperties();
 
  m_setLocalWallDistance =
      Context::getSolverProperty<MBool>("setLocalWallDistance", m_solverId, AT_, &m_setLocalWallDistance);
  IF_CONSTEXPR(nDim == 3) {
    if(m_setLocalWallDistance) mTerm(-1, "Not implemented in 3D yet!");
  }
  if(m_zonal || m_rans) {
    if(!m_setLocalWallDistance) m_windowInfo->setWallInformation();
  }
 
  // Create the mapping for the boundary and domain windows
  // the windows are needed for boundary condition application
  // and data exchange between the domains
  m_windowInfo->createWindowMapping(&m_commChannelIn, &m_commChannelOut, &m_commChannelWorld, m_channelRoots,
                                    &m_commStg, &m_commStgRoot, &m_commStgRootGlobal, &m_commBC2600, &m_commBC2600Root,
                                    &m_commBC2600RootGlobal, &m_rescalingCommGrComm, &m_rescalingCommGrRoot,
                                    &m_rescalingCommGrRootGlobal, &m_commPerRotOne, &m_commPerRotTwo,
                                    &m_commPerRotWorld, m_commPerRotRoots, m_commPerRotGroup, m_grid->m_singularity,
                                    &m_grid->m_hasSingularity, &m_plenumComm, &m_plenumRoot);
 
  m_singularity = m_grid->m_singularity; // new SingularInformation[30]; //TODO_SS labels:FV,totest check this
  m_hasSingularity = m_grid->m_hasSingularity;
 
  //
  readAndSetAuxDataMap();
 
  // Creating the communication flags needed
  // for all inter-domain exchange operations
 
 
  m_periodicConnection = 0;
  // set flag for the periodic exchange
  for(MInt i = 0; i < (MInt)m_windowInfo->rcvMap.size(); i++) {
    if(m_windowInfo->rcvMap[i]->BC >= 4000 && m_windowInfo->rcvMap[i]->BC <= 4999) {
      m_periodicConnection = 1;
      break;
    }
  }
 
  // TODO_SS labels:FV,toremove the following is not used
  //  if(m_zonal || m_rans) {
  //    if (m_setLocalWallDistance)
  //      m_windowInfo->setLocalWallInformation();
  //  }
 
  // Information about singularities needs to be known for allocating metrices
  m_grid->allocateMetricsAndJacobians();
 
  allocateAndInitBlockMemory();
 
  m_windowInfo->createCommunicationExchangeFlags(m_sndComm, m_rcvComm, PV->noVariables, m_cells->pvariables);
 
  MInt averageCellsPerDomain = (MInt)(m_totalNoCells / noDomains());
  MFloat localDeviation = ((MFloat)averageCellsPerDomain - (MFloat)m_noActiveCells) / ((MFloat)averageCellsPerDomain);
  MFloat localDeviationSquare = POW2(localDeviation);
  MFloat globalMaxDeviation = F0;
  MFloat globalMinDeviation = F0;
  MFloat globalAvgDeviation = F0;
  MInt globalMaxNoCells = 0;
  MInt globalMinNoCells = 0;
  MPI_Allreduce(&localDeviation, &globalMaxDeviation, 1, MPI_DOUBLE, MPI_MAX, m_StructuredComm, AT_, "localDeviation",
                "globalMaxDeviation");
  MPI_Allreduce(&localDeviation, &globalMinDeviation, 1, MPI_DOUBLE, MPI_MIN, m_StructuredComm, AT_, "localDeviation",
                "globalMinDeviation");
  MPI_Allreduce(&localDeviationSquare, &globalAvgDeviation, 1, MPI_DOUBLE, MPI_SUM, m_StructuredComm, AT_,
                "localDeviation", "globalAvgDeviation");
  globalAvgDeviation = sqrt(globalAvgDeviation / noDomains());
  MPI_Allreduce(&m_noActiveCells, &globalMaxNoCells, 1, MPI_INT, MPI_MAX, m_StructuredComm, AT_, "m_noActiveCells",
                "globalMaxNoCells");
  MPI_Allreduce(&m_noActiveCells, &globalMinNoCells, 1, MPI_INT, MPI_MIN, m_StructuredComm, AT_, "m_noActiveCells",
                "globalMinNoCells");
 
 
  if(domainId() == 0) {
    cout << "///////////////////////////////////////////////////////////////////" << endl
         << "Total no. of grid cells: " << m_totalNoCells << endl
         << "Average cells per domain: " << averageCellsPerDomain << endl
         << "Max no of cells per domain: " << globalMaxNoCells << endl
         << "Min no of cells per domain: " << globalMinNoCells << endl
         << "Average deviation from average: " << globalAvgDeviation * 100.0 << " percent" << endl
         << "Maximum deviation from average: +" << globalMaxDeviation * 100.0 << " / " << globalMinDeviation * 100.0
         << " percent" << endl
         << "///////////////////////////////////////////////////////////////////" << endl;
  }
 
  // read the grid from partition and
  // and move coordinates to right position
  if(domainId() == 0) {
    cout << "Reading Grid..." << endl;
  }
  m_log << "->reading the grid file" << endl;
  RECORD_TIMER_START(m_timers[Timers::GridReading]);
  m_grid->readGrid();
  RECORD_TIMER_STOP(m_timers[Timers::GridReading]);
  m_log << "------------- Grid read successfully! -------------- " << endl;
  if(domainId() == 0) {
    cout << "Reading Grid SUCCESSFUL!" << endl;
  }
 
  // get the zonal BC information
  if(m_zonal) {
    m_windowInfo->setZonalBCInformation();
  }
 
  // set properties for synthetic turbulence generation method
  setSTGProperties();
 
  // set the properties for bc2600 (if existing)
  setProfileBCProperties();
 
  // initialize the postprocessing class
  initStructuredPostprocessing();
 
  // print allocated scratch memory
  if(domainId() == 0) {
    MFloat scratchMemory = (Scratch::getTotalMemory() / 1024.0) * noDomains();
    MString memoryUnit = " KB";
    if(scratchMemory > 1024.0) {
      scratchMemory /= 1024.0;
      memoryUnit = " MB";
    }
    if(scratchMemory > 1024.0) {
      scratchMemory /= 1024.0;
      memoryUnit = " GB";
    }
    cout << "=== Total global scratch space memory: " << setprecision(2) << fixed << scratchMemory << memoryUnit
         << " ===" << endl;
  }
 
  printAllocatedMemory(oldAllocatedBytes, "FvStructuredSolver", m_StructuredComm);
}

~FvStructuredSolver()

template<MInt nDim>

FvStructuredSolver< nDim >::~FvStructuredSolver

virtual

Definition at line 265 of file fvstructuredsolver.cpp.

                                              {
  RECORD_TIMER_STOP(m_timers[Timers::Structured]);
  delete m_cells;
}

Member Function Documentation

allocateAndInitBlockMemory()

template<MInt nDim>

void FvStructuredSolver< nDim >::allocateAndInitBlockMemory

Definition at line 306 of file fvstructuredsolver.cpp.

                                                          {
  if(m_movingGrid || m_bodyForce) {
    if(m_travelingWave) {
      mAlloc(m_tempWaveSample, (PV->noVariables + (2 * nDim - 3)), m_noCells, "m_tempWaveSample", F0, FUN_);
    }
  }
 
  if(m_localTimeStep) {
    mAlloc(m_cells->localTimeStep, m_noCells, "m_cells->localTimeStep", -1.01010101, AT_);
  }
 
  mAlloc(m_cells->variables, m_maxNoVariables, m_noCells, "m_cells->variables", -99999.0, AT_);
  mAlloc(m_cells->pvariables, m_maxNoVariables, m_noCells, "m_cells->pvariables", -99999.0, AT_);
  mAlloc(m_cells->temperature, m_noCells, "m_cells->temperature", -99999.0, AT_);
  mAlloc(m_cells->oldVariables, m_maxNoVariables, m_noCells, "m_cells->oldVariables", -99999.0, AT_);
  mAlloc(m_cells->dss, nDim, m_noCells, "m_cells->dss", F0, AT_);
 
 
  // always allocate moving grid volume fluxes
  // but leave them zero if not moving grid
  mAlloc(m_cells->dxt, nDim, m_noCells, "m_cells->dxt", F0, AT_);
 
  // allocate viscous flux computation variables
  MInt noVarsFluxes = (CV->noVariables - 1 + m_rans);
 
  m_log << "Allocating fFlux with " << (CV->noVariables - 1 + m_rans) << " variables for " << m_noCells << " cells"
        << endl;
 
  mAlloc(m_cells->rightHandSide, CV->noVariables, m_noCells, "m_cells->rhs", F0, AT_);
  mAlloc(m_cells->flux, CV->noVariables, m_noCells, "m_cells->flux", 10000.0, AT_);
  mAlloc(m_cells->eFlux, noVarsFluxes, m_noCells, "m_cells->eFlux", F0, AT_);
  mAlloc(m_cells->fFlux, noVarsFluxes, m_noCells, "m_cells->fFlux", F0, AT_);
  mAlloc(m_cells->gFlux, noVarsFluxes, m_noCells, "m_cells->gFlux", F0, AT_);
  // TODO_SS labels:FV,toenhance find a better way to save porous variables
  mAlloc(m_cells->viscousFlux, (nDim + m_porous), m_noCells, "m_cells->viscousFlux", 1000.0, AT_);
 
  mAlloc(m_QLeft, m_maxNoVariables, "m_QLeft", F0, AT_);
  mAlloc(m_QRight, m_maxNoVariables, "m_QRight", F0, AT_);
 
 
  IF_CONSTEXPR(nDim == 2) {
    if(m_viscCompact) mAlloc(m_cells->dT, 4, m_noCells, "m_cells->dT", F0, AT_);
  }
}

allocateAuxDataMaps()

template<MInt nDim>

void FvStructuredSolver< nDim >::allocateAuxDataMaps

Definition at line 7804 of file fvstructuredsolver.cpp.

                                                   {
  TRACE();
 
  if(m_ransMethod == RANS_KEPSILON) {
    m_bForce = true;
    m_detailAuxData = true;
  }
 
  if(m_bForce) {
    const MInt noFields = nDim + m_detailAuxData * 2 * nDim;
 
    MInt noAuxDataMaps = m_windowInfo->physicalAuxDataMap.size();
    if(noAuxDataMaps > 0) {
      mAlloc(m_cells->cfOffsets, noAuxDataMaps, "m_cells->cfOffsets", 0, AT_);
      mAlloc(m_cells->cpOffsets, noAuxDataMaps, "m_cells->cpOffsets", 0, AT_);
      mAlloc(m_cells->powerOffsets, noAuxDataMaps, "m_cells->powerOffsets", 0, AT_);
    }
    MInt totalSizeCf = 0, totalSizeCp = 0, totalSizePower = 0;
    for(MInt i = 0; i < noAuxDataMaps; ++i) {
      MInt dataSize = 1;
      for(MInt j = 0; j < nDim; ++j) {
        if(m_windowInfo->physicalAuxDataMap[i]->end1[j] == m_windowInfo->physicalAuxDataMap[i]->start1[j]) {
          continue;
        }
        dataSize *= m_windowInfo->physicalAuxDataMap[i]->end1[j] - m_windowInfo->physicalAuxDataMap[i]->start1[j];
      }
      m_cells->cfOffsets[i] = totalSizeCf;
      m_cells->cpOffsets[i] = totalSizeCp;
      m_cells->powerOffsets[i] = totalSizePower;
      totalSizeCf += dataSize * noFields;
      totalSizeCp += dataSize;
      totalSizePower += dataSize * nDim;
    }
 
    if(totalSizeCf > 0) {
      mAlloc(m_cells->cf, totalSizeCf, "m_cells->cf", -1.23456123456, AT_);
    }
    if(totalSizeCp > 0) {
      mAlloc(m_cells->cp, totalSizeCp, "m_cells->cp", -1.23456123456, AT_);
    }
 
    if(m_bPower) {
      if(totalSizePower > 0) {
        mAlloc(m_cells->powerVisc, totalSizePower, "m_cells->power", -1.23456123456, AT_);
        mAlloc(m_cells->powerPres, totalSizePower, "m_cells->power", -1.23456123456, AT_);
      }
    }
 
    m_forceHeaderNames.clear();
    m_forceHeaderNames.push_back("n");
    m_forceHeaderNames.push_back("t_ac");
    m_forceHeaderNames.push_back("t_conv");
    m_forceHeaderNames.push_back("f_x");
    m_forceHeaderNames.push_back("f_x,v");
    m_forceHeaderNames.push_back("f_x,p");
    m_forceHeaderNames.push_back("f_x,c");
    m_forceHeaderNames.push_back("f_y");
    m_forceHeaderNames.push_back("f_y,v");
    m_forceHeaderNames.push_back("f_y,p");
    m_forceHeaderNames.push_back("f_y,c");
    IF_CONSTEXPR(nDim == 3) {
      m_forceHeaderNames.push_back("f_z");
      m_forceHeaderNames.push_back("f_z,v");
      m_forceHeaderNames.push_back("f_z,p");
      m_forceHeaderNames.push_back("f_z,c");
    }
    m_forceHeaderNames.push_back("area");
    if(m_bPower) {
      m_forceHeaderNames.push_back("P_x");
      m_forceHeaderNames.push_back("P_x,v");
      m_forceHeaderNames.push_back("P_x,p");
      m_forceHeaderNames.push_back("P_y");
      m_forceHeaderNames.push_back("P_y,v");
      m_forceHeaderNames.push_back("P_y,p");
      IF_CONSTEXPR(nDim == 3) {
        m_forceHeaderNames.push_back("P_z");
        m_forceHeaderNames.push_back("P_z,v");
        m_forceHeaderNames.push_back("P_z,p");
      }
    }
 
    m_noForceDataFields = (MInt)m_forceHeaderNames.size();
    m_forceCounter = 0;
 
    const MInt noWalls = m_windowInfo->m_auxDataWindowIds.size();
    if(m_forceAsciiOutputInterval > 0 && noWalls * m_noForceDataFields > 0) {
      mAlloc(m_forceData, m_forceAsciiOutputInterval, noWalls * m_noForceDataFields, "m_forceData", F0, AT_);
    }
 
    // Allocate memory for integral coefficients
    if(noWalls * m_noForceDataFields > 0) {
      mAlloc(m_forceCoef, noWalls * m_noForceDataFields, "m_forceCoef", F0, AT_);
    }
  }
 
 
  IF_CONSTEXPR(nDim == 3) {
    if(m_bForceLineAverage) {
      // compute Domain Width for Averaging
      computeDomainWidth();
    }
  }
 
  if(domainId() == 0 && m_forceAsciiOutputInterval != 0) {
    // we need to decide how many files to open
    const MInt noWalls = m_windowInfo->m_auxDataWindowIds.size();
 
    m_lastForceOutputTimeStep = -1;
    m_lastForceComputationTimeStep = -1;
 
    // create file header if file does not exist
    for(MInt i = 0; i < noWalls; ++i) {
      stringstream iWall;
      iWall << i;
      MString filename = "./forces." + iWall.str() + ".dat";
 
 
      if(FILE* file = fopen(filename.c_str(), "r")) {
        fclose(file);
      } else {
        FILE* f_forces;
        f_forces = fopen(filename.c_str(), "a+");
 
        fprintf(f_forces,
                "# Force coefficient file, the force coefficents in the 2 or 3 space directions\n"
                "# are listed in columns, the subscript v denotes a viscous force, p a pressure force,\n"
                "# and c the compressible contribution of the stress tensor\n");
        fprintf(f_forces, "# 1:%s ", m_forceHeaderNames[0].c_str());
        for(MInt j = 1; j < (MInt)m_forceHeaderNames.size(); j++) {
          fprintf(f_forces, " %d:%s ", (j + 1), m_forceHeaderNames[j].c_str());
        }
        fprintf(f_forces, "\n");
        fclose(f_forces);
      }
    }
  }
}

allocateVariables()

template<MInt nDim>

void FvStructuredSolver< nDim >::allocateVariables

Definition at line 4361 of file fvstructuredsolver.cpp.

                                                 {
  // We will decide whether we will use RANS Variables or not depending on the solver
 
  if(m_zoneType == "RANS") {
    // number of RANS equations
    m_noRansEquations = noRansEquations(m_ransMethod);
 
    CV = make_unique<MConservativeVariables<nDim>>(m_noSpecies, m_noRansEquations);
    PV = make_unique<MPrimitiveVariables<nDim>>(m_noSpecies, m_noRansEquations);
  } else {
    // we only have LES solvers
    m_noRansEquations = 0;
    CV = make_unique<MConservativeVariables<nDim>>(m_noSpecies);
    PV = make_unique<MPrimitiveVariables<nDim>>(m_noSpecies);
  }
 
  // LES zones have 5 but RANS zone have 6 variables,
  // we have to use maxNoVariables for allocations and
  // IO related procedures which use MPI
  m_maxNoVariables = -1;
  MPI_Allreduce(&PV->noVariables, &m_maxNoVariables, 1, MPI_INT, MPI_MAX, m_StructuredComm, AT_, "PV->noVariables",
                "m_maxNoVariables");
  m_log << "Max number of variables: " << m_maxNoVariables << endl;
}

applyBodyForce()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::applyBodyForce ( MBool  , MBool    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 183 of file fvstructuredsolver.h.

{};

applyBoundaryCondition()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::applyBoundaryCondition ( )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

applyBoundaryCondtition()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::applyBoundaryCondtition ( )

inlinevirtual

Definition at line 178 of file fvstructuredsolver.h.

{};

beginP0()

template<MInt nDim>

std::array< MInt, nDim > FvStructuredSolver< nDim >::beginP0 ( )

inline

Definition at line 280 of file fvstructuredsolver.h.

                                        {
    IF_CONSTEXPR(nDim == 2) { return {0, 0}; }
    else {
      return {0, 0, 0};
    }
  }

beginP1()

template<MInt nDim>

std::array< MInt, nDim > FvStructuredSolver< nDim >::beginP1 ( )

inline

Definition at line 287 of file fvstructuredsolver.h.

                                        {
    IF_CONSTEXPR(nDim == 2) { return {1, 1}; }
    else {
      return {1, 1, 1};
    }
  }

beginP2()

template<MInt nDim>

std::array< MInt, nDim > FvStructuredSolver< nDim >::beginP2 ( )

inline

Definition at line 294 of file fvstructuredsolver.h.

                                        {
    IF_CONSTEXPR(nDim == 2) { return {2, 2}; }
    else {
      return {2, 2, 2};
    }
  }

checkNans()

template<MInt nDim>

void FvStructuredSolver< nDim >::checkNans

Author

Marian Albers

Date

19.08.2015

Definition at line 7029 of file fvstructuredsolver.cpp.

                                         {
  TRACE();
  MInt noNansLocal = 0;
  for(MInt cellid = 0; cellid < m_noCells; cellid++) {
    // go through every cell
    for(MInt i = 0; i < CV->noVariables; i++) {
      if(std::isnan(m_cells->variables[i][cellid])) {
        noNansLocal++;
      }
    }
  }
 
  MInt noNansGlobal = 0;
  MPI_Allreduce(&noNansLocal, &noNansGlobal, 1, MPI_INT, MPI_SUM, m_StructuredComm, AT_, "noNansLocal", "noNansGlobal");
 
  if(domainId() == 0) {
    cout << "GlobalTimeStep: " << globalTimeStep << " , noNansGlobal: " << noNansGlobal << endl;
  }
}

cleanUp()

template<MInt nDim>

void FvStructuredSolver< nDim >::cleanUp

overridevirtual

Implements Solver.

Definition at line 8307 of file fvstructuredsolver.cpp.

                                       {
  RECORD_TIMER_START(m_timers[Timers::Run]);
  // write a solution file before the solution run ends
 
  if(m_lastOutputTimeStep != globalTimeStep) {
    if(m_forceAsciiOutputInterval != 0) {
      saveForcesToAsciiFile(true);
    }
    if(m_pointsToAsciiOutputInterval != 0) {
      savePointsToAsciiFile(true);
    }
    saveSolution(true);
    saveAverageRestart();
  }
 
  this->postprocessPostSolve();
  RECORD_TIMER_STOP(m_timers[Timers::Run]);
}

computeAuxData()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeAuxData

Definition at line 7989 of file fvstructuredsolver.cpp.

                                              {
  if(m_bForce && m_bPower) {
    computeFrictionPressureCoef(true);
  } else {
    computeFrictionPressureCoef(false);
  }
 
  if(m_bForce) computeForceCoef();
}

computeAuxDataRoot()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeAuxDataRoot

Definition at line 8001 of file fvstructuredsolver.cpp.

                                                  {
  if(m_bForce && m_bPower) {
    computeFrictionPressureCoef(true);
  } else {
    computeFrictionPressureCoef(false);
  }
 
  if(m_bForce) computeForceCoefRoot();
}

computeConservativeVariables()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeConservativeVariables

virtual

Definition at line 4456 of file fvstructuredsolver.cpp.

                                                            {
  if(noRansEquations(m_ransMethod) == 2) {
    if(m_rans2eq_mode == "production")
      computeConservativeVariables_<&FvStructuredSolver::totalEnergy_twoEqRans>();
    else
      computeConservativeVariables_();
  } else
    computeConservativeVariables_();
}

computeConservativeVariables_()

template<MInt nDim>

template<MFloat(FvStructuredSolver< nDim >::*)(MInt) const totalEnergy_func>

void FvStructuredSolver< nDim >::computeConservativeVariables_

Definition at line 4415 of file fvstructuredsolver.cpp.

                                                             {
  m_log << "we got into the general formulation but should be in the other one" << endl;
  const MFloat FgammaMinusOne = F1 / (m_gamma - 1.0);
  MFloat** const RESTRICT cvars = m_cells->variables;
  MFloat** const RESTRICT pvars = m_cells->pvariables;
  MFloat rhoVelocity[3] = {0.0, 0.0, 0.0};
 
  for(MInt cellId = 0; cellId < m_noCells; cellId++) {
    MFloat velPOW2 = F0;
    // copy the density
    const MFloat rho = pvars[PV->RHO][cellId];
    // compute the rho * velocity
    for(MInt i = 0; i < nDim; i++) {
      rhoVelocity[i] = pvars[PV->VV[i]][cellId] * rho;
      velPOW2 += POW2(pvars[PV->VV[i]][cellId]);
    }
 
    // regular conservative variables
    cvars[CV->RHO][cellId] = rho;
    for(MInt i = 0; i < nDim; i++) {
      cvars[CV->RHO_VV[i]][cellId] = rhoVelocity[i];
    }
 
    cvars[CV->RHO_E][cellId] =
        pvars[PV->P][cellId] * FgammaMinusOne + F1B2 * rho * velPOW2 + (this->*totalEnergy_func)(cellId);
 
    // rans
    for(MInt ransVar = 0; ransVar < m_noRansEquations; ransVar++) {
      // pvars[PV->RANS_VAR[ransVar]][cellId] = mMax(pvars[PV->RANS_VAR[ransVar]][cellId], F0);
      //      cvars[CV->RANS_VAR[ransVar]][cellId] = mMax(pvars[PV->RANS_VAR[ransVar]][cellId], F0)*rho;
      cvars[CV->RANS_VAR[ransVar]][cellId] = pvars[PV->RANS_VAR[ransVar]][cellId] * rho;
    }
 
    // species
    for(MInt s = 0; s < m_noSpecies; s++) {
      cvars[CV->RHO_Y[s]][cellId] = pvars[PV->Y[s]][cellId] * rho;
    }
  }
}

computeCumulativeAverage()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computeCumulativeAverage ( MBool  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 232 of file fvstructuredsolver.h.

{};

computeDomainWidth()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computeDomainWidth ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 127 of file fvstructuredsolver.h.

{};

computeForceCoef()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeForceCoef

Authors

Marian Albers, Pascal Meysonnat

Definition at line 7948 of file fvstructuredsolver.cpp.

                                                {
  const MInt noWalls = m_windowInfo->m_auxDataWindowIds.size();
  MPI_Allreduce(MPI_IN_PLACE, m_forceCoef, noWalls * m_noForceDataFields, MPI_DOUBLE, MPI_SUM, m_StructuredComm, AT_,
                "MPI_IN_PLACE", "m_forceCoef");
 
  if(m_bForceLineAverage) {
    for(MInt i = 0; i < noWalls * m_noForceDataFields; ++i) {
      m_forceCoef[i] /= m_globalDomainWidth;
    }
  }
}

computeForceCoefRoot()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeForceCoefRoot

Author

Marian Albers

Definition at line 7969 of file fvstructuredsolver.cpp.

                                                    {
  const MInt noWalls = m_windowInfo->m_auxDataWindowIds.size();
 
  MFloatScratchSpace force(noWalls * m_noForceDataFields, AT_, "force");
  for(MInt i = 0; i < noWalls * m_noForceDataFields; ++i) {
    force(i) = m_forceCoef[i];
  }
 
 
  MPI_Reduce(force.begin(), m_forceCoef, noWalls * m_noForceDataFields, MPI_DOUBLE, MPI_SUM, 0, m_StructuredComm, AT_,
             "force", "forceCoef");
  if(m_bForceLineAverage) {
    for(MInt i = 0; i < noWalls * m_noForceDataFields; ++i) {
      m_forceCoef[i] /= m_globalDomainWidth;
    }
  }
}

computeFrictionPressureCoef()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computeFrictionPressureCoef ( MBool  )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

computeLambda2Criterion()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computeLambda2Criterion ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 184 of file fvstructuredsolver.h.

{};

computePorousRHS()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computePorousRHS ( MBool  )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 176 of file fvstructuredsolver.h.

{ mTerm(1, "called virtual computePorousRHS()"); };

computePrimitiveVariables()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computePrimitiveVariables ( )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 166 of file fvstructuredsolver.h.

{ mTerm(-1, AT_, "not implemented in general solver"); };

computePV()

template<MInt nDim>

void FvStructuredSolver< nDim >::computePV

Definition at line 4405 of file fvstructuredsolver.cpp.

                                         {
  // don't do this here, because it
  // will be executed before exchange() and
  // then wrong primitve values are in the GC
  // computePrimitiveVariables();
}

computeRecConstSVD()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::computeRecConstSVD	(	const MInt	ijk,
		const MInt	noNghbrIds,
		MInt *	nghbr,
		MInt	ID,
		MInt	sID,
		MFloatScratchSpace &	tmpA,
		MFloatScratchSpace &	tmpC,
		MFloatScratchSpace &	weights,
		const MInt	recDim
	)

SVD STUFF //////////////////////////////////////////////////////////////////

Definition at line 8020 of file fvstructuredsolver.cpp.

                                                                                                    {
  if(noNghbrIds == 0) return F0;
 
  const MFloat normalizationFactor = 1 / 0.01; // reduces the condition number of the eq system
 
  for(MInt n = 0; n < noNghbrIds; n++) {
    MInt nghbrId = nghbr[n];
    MFloat dx[nDim];
    for(MInt i = 0; i < nDim; i++) {
      dx[i] = (m_cells->coordinates[i][nghbrId] - m_grid->m_coordinates[i][ijk]) * normalizationFactor;
    }
 
    tmpA(n, 0) = F1 * normalizationFactor;
    for(MInt i = 0; i < nDim; i++) {
      tmpA(n, i + 1) = dx[i];
    }
  }
 
  maia::math::invert(tmpA, weights, tmpC, noNghbrIds, recDim);
 
  // condition number could be calculated using:
  // condNum = svd.singularValues()(0)/svd.singularValues()(size-1);
  // but would double the computational effort...
 
  for(MInt n = 0; n < noNghbrIds; n++) {
    for(MInt i = 0; i < nDim + 1; i++) {
      m_singularity[sID].ReconstructionConstants[i][ID + n] = tmpC(i, n) * normalizationFactor;
    }
  }
 
  return 0;
}

computeSamplingInterval()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeSamplingInterval

(

)

computeTimeStep()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computeTimeStep ( )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 208 of file fvstructuredsolver.h.

{};

computeVolumeForces()

template<MInt nDim>

void FvStructuredSolver< nDim >::computeVolumeForces

Definition at line 4504 of file fvstructuredsolver.cpp.

                                                   {
  TRACE();
 
  for(MInt dim = 0; dim < nDim; dim++) {
    for(MInt cellId = 0; cellId < m_noCells; cellId++) {
      m_cells->rightHandSide[CV->RHO_VV[dim]][cellId] +=
          m_cells->variables[CV->RHO][cellId] * m_volumeForce[dim] * m_cells->cellJac[cellId];
      m_cells->rightHandSide[CV->RHO_E][cellId] +=
          m_cells->variables[CV->RHO_VV[dim]][cellId] * m_volumeForce[dim] * m_cells->cellJac[cellId];
    }
  }
}

computeVorticity()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::computeVorticity ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 185 of file fvstructuredsolver.h.

{};

convertRestartVariables()

template<MInt nDim>

void FvStructuredSolver< nDim >::convertRestartVariables

(

MFloat

oldMa

)

Definition at line 7344 of file fvstructuredsolver.cpp.

                                                                   {
  TRACE();
  const MFloat eps = pow(10.0, -5.0);
  if(ABS(oldMa - m_Ma) > eps) {
    m_log << "converting restart variables from old Ma: " << oldMa << " to new Ma: " << m_Ma << " ..." << endl;
    const MFloat gammaMinusOne = m_gamma - 1.0;
    // old references
    MFloat T8old = 1.0 / (1.0 + 0.5 * gammaMinusOne * POW2(oldMa));
    MFloat p8old = pow(T8old, (m_gamma / gammaMinusOne)) / m_gamma;
    MFloat u8old = oldMa * sqrt(T8old);
    MFloat rho8old = pow(T8old, (1.0 / gammaMinusOne));
    // MFloat rhoU8old = rho8old*u8old;
    MFloat rhoE8old = p8old / gammaMinusOne + rho8old * (F1B2 * POW2(u8old));
    // new references
    MFloat T8new = 1.0 / (1.0 + 0.5 * gammaMinusOne * POW2(m_Ma));
    MFloat p8new = pow(T8new, (m_gamma / gammaMinusOne)) / m_gamma;
    MFloat u8new = m_Ma * sqrt(T8new);
    MFloat rho8new = pow(T8new, (1.0 / gammaMinusOne));
    // MFloat rhoU8new = rho8new*u8new;
    MFloat rhoE8new = p8new / gammaMinusOne + rho8new * (F1B2 * POW2(u8new));
    // ratios
    MFloat velRatio = u8new / u8old;
    MFloat rhoRatio = rho8new / rho8old;
    MFloat pRatio = p8new / p8old;
    MFloat rhoERatio = rhoE8new / rhoE8old;
 
    // conversion
    for(MInt cellId = 0; cellId < m_noCells; ++cellId) {
      // density
      m_cells->pvariables[PV->RHO][cellId] *= rhoRatio;
      // velocities
      for(MInt i = 0; i < nDim; ++i) {
        m_cells->pvariables[PV->VV[i]][cellId] *= velRatio;
      }
      // energy
      m_cells->pvariables[PV->P][cellId] *= pRatio;
    }
 
    if(m_useSponge) {
      if(m_spongeLayerType == 2) {
        for(MInt cellId = 0; cellId < m_noCells; ++cellId) {
          m_cells->fq[FQ->SPONGE_RHO][cellId] *= rhoRatio;
          m_cells->fq[FQ->SPONGE_RHO_E][cellId] *= rhoERatio;
        }
      }
 
      if(m_spongeLayerType == 4) {
        for(MInt cellId = 0; cellId < m_noCells; ++cellId) {
          m_cells->fq[FQ->SPONGE_RHO][cellId] *= rhoRatio;
        }
      }
    }
 
    computeConservativeVariables();
 
    m_log << "converting restart variables from old Ma: " << oldMa << " to new Ma: " << m_Ma << " ... SUCCESSFUL!"
          << endl;
  }
  return;
}

convertRestartVariablesSTG()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::convertRestartVariablesSTG ( MFloat  oldMa )

inlinevirtual

Definition at line 245 of file fvstructuredsolver.h.

                                                        {
    (void)oldMa;
    mTerm(-1, AT_, "not implemented for 0d,2d");
  };

createMPIGroups()

template<MInt nDim>

void FvStructuredSolver< nDim >::createMPIGroups

Definition at line 3159 of file fvstructuredsolver.cpp.

                                               {
  // Channel Communication
  mAlloc(m_channelRoots, 4, "m_channelRoots", -1, AT_);
 
  // Periodic rotation boundary condtions communicators
  mAlloc(m_commPerRotRoots, 4, "m_commPerRotRoots", -1, AT_);
 
  if(m_zonal) {
    mAlloc(m_commZonal, m_noBlocks, "m_commZonal", AT_);
    mAlloc(m_commZonalRoot, m_noBlocks, "m_commZonalRoot", -1, AT_);
    mAlloc(m_commZonalRootGlobal, m_noBlocks, "m_commZonalRoot", -1, AT_);
 
    m_commZonalMyRank = -1;
    m_zonalRootRank = false;
 
 
    // first collect the ranks of each input solver in one array and count the number
    for(MInt i = 0; i < m_noBlocks; i++) {
      MPI_Group groupZonal, newGroupZonal;
      vector<MInt> tmpPartitions;
      MInt blockDomainId = 0;
      MInt hasBlockDomain = 0;
      MInt hasBlockDomainGlobal = 0;
      MIntScratchSpace nblockDomainArray(noDomains(), AT_, "nblockDomainArray");
      MIntScratchSpace nblockDomainOffset(noDomains(), AT_, "nblockDomainOffset");
      if(m_blockId == i) {
        blockDomainId = domainId();
        hasBlockDomain = 1;
      }
      MPI_Allreduce(&hasBlockDomain, &hasBlockDomainGlobal, 1, MPI_INT, MPI_SUM, m_StructuredComm, AT_,
                    "hasBlockDomain", "hasBlockDomainGlobal");
      MPI_Allgather(&hasBlockDomain, 1, MPI_INT, &nblockDomainArray[0], 1, MPI_INT, m_StructuredComm, AT_,
                    "hasBlockDomain", "nblockDomainArray[0]");
      nblockDomainOffset[0] = 0;
      for(MInt j = 1; j < noDomains(); j++) {
        nblockDomainOffset[j] = nblockDomainOffset[j - 1] + nblockDomainArray[j - 1];
      }
      MIntScratchSpace zonalRanks(hasBlockDomainGlobal, AT_, "zonalRanks");
      MPI_Allgatherv(&blockDomainId, nblockDomainArray[domainId()], MPI_INT, &zonalRanks[0], &nblockDomainArray[0],
                     &nblockDomainOffset[0], MPI_INT, m_StructuredComm, AT_, "blockDomainId", "zonalRanks[0]");
 
 
      MInt zonalcommsize = hasBlockDomainGlobal;
 
      MPI_Comm_group(m_StructuredComm, &groupZonal, AT_, "groupZonal");
      MPI_Group_incl(groupZonal, zonalcommsize, &zonalRanks[0], &newGroupZonal, AT_);
      MPI_Comm_create(m_StructuredComm, newGroupZonal, &m_commZonal[i], AT_, "m_commZonal[i]");
 
      if(domainId() == zonalRanks[0]) {
        MPI_Comm_rank(m_commZonal[i], &m_commZonalRoot[i]);
        MPI_Comm_rank(m_StructuredComm, &m_commZonalRootGlobal[i]);
        m_zonalRootRank = true;
      }
 
      MPI_Bcast(&m_commZonalRoot[0], m_noBlocks, MPI_INT, zonalRanks[0], m_StructuredComm, AT_, "m_commZonalRoot[0]");
      MPI_Bcast(&m_commZonalRootGlobal[0], m_noBlocks, MPI_INT, zonalRanks[0], m_StructuredComm, AT_,
                "m_commZonalRootGlobal[0]");
    }
  }
}

determineRestartTimeStep()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::determineRestartTimeStep

overridevirtual

Reimplemented from Solver.

Definition at line 5606 of file fvstructuredsolver.cpp.

                                                              {
  TRACE();
 
  if(!m_useNonSpecifiedRestartFile) {
    TERMM(1, "determineRestartTimeStep should only be used with useNonSpecifiedRestartFile enabled!");
  }
 
  MString restartFile = Context::getSolverProperty<MString>("restartVariablesFileName", m_solverId, AT_);
  std::stringstream restartFileName;
  restartFileName << outputDir() << restartFile;
  ParallelIoHdf5 pio(restartFileName.str(), maia::parallel_io::PIO_READ, MPI_COMM_SELF);
  MInt timeStep = -1;
  pio.getAttribute(&timeStep, "globalTimeStep", "");
 
  return timeStep;
}

dummy()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::dummy ( MInt  ) const

inline

Definition at line 160 of file fvstructuredsolver.h.

{ return 0.0; }

dvardx()

template<MInt nDim>

virtual MFloat FvStructuredSolver< nDim >::dvardx ( MInt  , MFloat *    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 241 of file fvstructuredsolver.h.

{ return 0; };

dvardxyz()

template<MInt nDim>

virtual MFloat FvStructuredSolver< nDim >::dvardxyz ( MInt  , MInt  , MFloat *    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 240 of file fvstructuredsolver.h.

{ return 0; };

endM0()

template<MInt nDim>

std::array< MInt, nDim > FvStructuredSolver< nDim >::endM0 ( )

inline

Definition at line 315 of file fvstructuredsolver.h.

                                      {
    IF_CONSTEXPR(nDim == 2) { return {m_nCells[1], m_nCells[0]}; }
    else {
      return {m_nCells[2], m_nCells[1], m_nCells[0]};
    }
  }

endM1()

template<MInt nDim>

std::array< MInt, nDim > FvStructuredSolver< nDim >::endM1 ( )

inline

Definition at line 308 of file fvstructuredsolver.h.

                                      {
    IF_CONSTEXPR(nDim == 2) { return {m_nCells[1] - 1, m_nCells[0] - 1}; }
    else {
      return {m_nCells[2] - 1, m_nCells[1] - 1, m_nCells[0] - 1};
    }
  }

endM2()

template<MInt nDim>

std::array< MInt, nDim > FvStructuredSolver< nDim >::endM2 ( )

inline

Definition at line 301 of file fvstructuredsolver.h.

                                      {
    IF_CONSTEXPR(nDim == 2) { return {m_nCells[1] - 2, m_nCells[0] - 2}; }
    else {
      return {m_nCells[2] - 2, m_nCells[1] - 2, m_nCells[0] - 2};
    }
  }

exchange() [1/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::exchange

Definition at line 8061 of file fvstructuredsolver.cpp.

                                        {
  exchange(m_sndComm, m_rcvComm);
}

exchange() [2/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::exchange	(	std::vector< std::unique_ptr< StructuredComm< nDim > > > &	sndComm,
		std::vector< std::unique_ptr< StructuredComm< nDim > > > &	rcvComm
	)

Definition at line 8070 of file fvstructuredsolver.cpp.

                                                                                                 {
  RECORD_TIMER_START(m_timers[Timers::Exchange]);
 
 
  if(noDomains() > 1) {
    std::vector<MPI_Request> sndRequests;
    std::vector<MPI_Request> rcvRequests;
    std::vector<MPI_Status> sndStatus;
    std::vector<MPI_Status> rcvStatus;
    sndRequests.reserve(sndComm.size());
    rcvRequests.reserve(rcvComm.size());
 
    RECORD_TIMER_START(m_timers[Timers::Gather]);
    gather(false, sndComm);
    RECORD_TIMER_STOP(m_timers[Timers::Gather]);
 
    RECORD_TIMER_START(m_timers[Timers::Send]);
    send(false, sndComm, sndRequests);
    RECORD_TIMER_STOP(m_timers[Timers::Send]);
 
    RECORD_TIMER_START(m_timers[Timers::Receive]);
    receive(false, rcvComm, rcvRequests);
    RECORD_TIMER_STOP(m_timers[Timers::Receive]);
 
    RECORD_TIMER_START(m_timers[Timers::SendWait]);
    sndStatus.resize(sndRequests.size());
    MPI_Waitall(sndRequests.size(), &sndRequests[0], &sndStatus[0], AT_);
    RECORD_TIMER_STOP(m_timers[Timers::SendWait]);
 
    RECORD_TIMER_START(m_timers[Timers::ReceiveWait]);
    rcvStatus.resize(rcvRequests.size());
    MPI_Waitall(rcvRequests.size(), &rcvRequests[0], &rcvStatus[0], AT_);
    RECORD_TIMER_STOP(m_timers[Timers::ReceiveWait]);
 
    RECORD_TIMER_START(m_timers[Timers::Scatter]);
    scatter(false, rcvComm);
    RECORD_TIMER_STOP(m_timers[Timers::Scatter]);
  }
 
 
  for(MInt periodicDir = 0; periodicDir < nDim; periodicDir++) {
    std::vector<MPI_Request> sndRequests;
    std::vector<MPI_Request> rcvRequests;
    std::vector<MPI_Status> sndStatus;
    std::vector<MPI_Status> rcvStatus;
    sndRequests.reserve(sndComm.size());
    rcvRequests.reserve(rcvComm.size());
 
    m_currentPeriodicDirection = periodicDir;
    RECORD_TIMER_START(m_timers[Timers::Gather]);
    gather(true, sndComm);
    RECORD_TIMER_STOP(m_timers[Timers::Gather]);
 
    RECORD_TIMER_START(m_timers[Timers::Send]);
    send(true, sndComm, sndRequests);
    RECORD_TIMER_STOP(m_timers[Timers::Send]);
 
    RECORD_TIMER_START(m_timers[Timers::Receive]);
    receive(true, rcvComm, rcvRequests);
    RECORD_TIMER_STOP(m_timers[Timers::Receive]);
 
    RECORD_TIMER_START(m_timers[Timers::SendWait]);
    sndStatus.resize(sndRequests.size());
    MPI_Waitall(sndRequests.size(), &sndRequests[0], &sndStatus[0], AT_);
    RECORD_TIMER_STOP(m_timers[Timers::SendWait]);
 
    RECORD_TIMER_START(m_timers[Timers::ReceiveWait]);
    rcvStatus.resize(rcvRequests.size());
    MPI_Waitall(rcvRequests.size(), &rcvRequests[0], &rcvStatus[0], AT_);
    RECORD_TIMER_STOP(m_timers[Timers::ReceiveWait]);
 
    RECORD_TIMER_START(m_timers[Timers::Scatter]);
    scatter(true, rcvComm);
    RECORD_TIMER_STOP(m_timers[Timers::Scatter]);
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::Exchange]);
}

exchangeTimeStep()

template<MInt nDim>

void FvStructuredSolver< nDim >::exchangeTimeStep

Definition at line 6837 of file fvstructuredsolver.cpp.

                                                {
  TRACE();
 
  MFloat globalTimeStepMin = F0;
 
  MPI_Allreduce(&m_timeStep, &globalTimeStepMin, 1, MPI_DOUBLE, MPI_MIN, m_StructuredComm, AT_, "m_timeStep",
                "globalTimeStepMin");
 
  m_timeStep = globalTimeStepMin;
}

finalizeInitSolver()

template<MInt nDim>

void FvStructuredSolver< nDim >::finalizeInitSolver

overridevirtual

Implements Solver.

Definition at line 7795 of file fvstructuredsolver.cpp.

                                                  {
  this->postprocessPreInit();
  this->postprocessPreSolve();
}

fixTimeStepTravelingWave()

template<MInt nDim>

void FvStructuredSolver< nDim >::fixTimeStepTravelingWave

Definition at line 7096 of file fvstructuredsolver.cpp.

                                                        {
  const MFloat waveTransSpeed = fabs(m_waveSpeed);
 
  MFloat travelDist = F0;
  if(m_travelingWave) {
    if(nDim == 3) {
      travelDist = abs(m_grid->m_coordinates[2][0] - m_grid->m_coordinates[2][m_nPoints[2] * m_nPoints[1]]);
    } else {
      travelDist = abs(m_grid->m_coordinates[0][0] - m_grid->m_coordinates[0][1]);
    }
  } else if(m_streamwiseTravelingWave) {
    travelDist = m_waveLength;
  } else {
    m_log << "WARNING!!!!!!!!!!!!!!!!!!!!: dz was fixed and hardcoded !!!!!!!!!! " << endl;
    travelDist = 0.33200866159432146;
  }
 
  if(!m_waveTimeStepComputed) {
    // first compute time step as usual and exchange it
    computeTimeStep();
    if(noDomains() > 1) {
      exchangeTimeStep();
    }
 
    // number of timeSteps the wave needs to move one cell width further
    m_waveNoStepsPerCell = ceil((travelDist / waveTransSpeed) / (m_timeStep));
    if(m_waveNoStepsPerCell < 2) {
      m_waveNoStepsPerCell = 2; // although highly improbable, see Nyquist-Shannon-Theorem
    }
 
    cout.precision(18);
    if(domainId() == 0) {
      cout << "Old time step = " << m_timeStep << endl;
    }
    m_log << "/////////////////// TRAVELING WAVE /////////////////////////////" << endl;
    m_log << "Old time step = " << m_timeStep << endl;
 
    m_timeStep = (travelDist / waveTransSpeed) / (m_waveNoStepsPerCell);
    m_physicalTimeStep = m_timeStep * m_timeRef;
 
    MBool syncSolutionInterval = false;
    MBool syncForceInterval = false;
    MBool syncBoxInterval = false;
    MBool syncIntpPointsInterval = false;
 
 
    // fix output writing functions in case
    if(m_synchronizedMGOutput) {
      // change the output frequency of the different io routines to be in accordance with the new time step such that
      // only in full number of iterations in which the moving grid has traveld one cell distance is ensured
      // if(m_outputOffset){
      //  m_log << "ERROR: m_outputOffset and synchronized output cannot be combined (not implemented yet)" << endl;
      //  mTerm(1, AT_, "ERROR: m_outputOffset and synchronized output cannot be combined (not implemented yet)");
      //}
 
      if(domainId() == 0) {
        cout << "m_movingGridStepOffset: " << m_movingGridStepOffset
             << " m_movingGridInitialStart: " << m_movingGridInitialStart << endl;
      }
 
 
      if(m_outputOffset > m_movingGridStepOffset) {
        const MInt offsetCounter =
            ceil(((MFloat)m_outputOffset - (MFloat)m_movingGridStepOffset) / (MFloat)m_waveNoStepsPerCell);
        m_outputOffset = m_movingGridStepOffset + offsetCounter * m_waveNoStepsPerCell;
      } else {
        m_outputOffset = m_movingGridStepOffset; // for input output such that it works propberly
      }
 
      if(m_useConvectiveUnitWrite) {
        m_log << "ERROR: m_useConvectiveUnitWrite and synchronized output cannot be combined (not implemented yet)"
              << endl;
        mTerm(1, AT_,
              "ERROR: m_useConvetiveUnitWrite and synchronized output cannot be combined (not implemented yet)");
      }
      if(m_solutionInterval) {
        m_solutionInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_solutionInterval / (MFloat)m_waveNoStepsPerCell));
        syncSolutionInterval = true;
      }
      if(m_forceOutputInterval) {
        m_forceOutputInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_forceOutputInterval / (MFloat)m_waveNoStepsPerCell));
        syncForceInterval = true;
      }
      if(m_boxOutputInterval) {
        m_boxOutputInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_boxOutputInterval / (MFloat)m_waveNoStepsPerCell));
 
        syncBoxInterval = true;
      }
      if(m_intpPointsOutputInterval) {
        m_intpPointsOutputInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_boxOutputInterval / (MFloat)m_waveNoStepsPerCell));
        syncIntpPointsInterval = true;
      }
    }
 
    if(domainId() == 0) {
      cout << "New time step: " << m_timeStep << " new physical time step: " << m_physicalTimeStep << endl;
      cout << "Number of steps to move one cell width: " << travelDist / (m_waveSpeed * m_timeStep) << " time steps"
           << endl;
      cout << "Number of steps to move one physical time step: " << F1 / m_physicalTimeStep << endl;
      cout << "Number of steps to move one wave length: " << m_waveLength / (m_waveSpeed * m_timeStep) << endl;
      cout << "Cells per wavelength: " << m_waveLength / travelDist << " travelDist: " << travelDist << endl;
      cout << "Time for wave to travel one wave length: " << m_waveLength / m_waveSpeed << endl;
      cout << "Physical time for wave to travel one wave length: " << m_waveLength / m_waveSpeed * m_timeRef << endl;
      cout << "solution output interval was reset: " << syncSolutionInterval << " and changed to " << m_solutionInterval
           << endl;
      cout << "box output interval was reset: " << syncBoxInterval << " and changed to " << m_boxOutputInterval << endl;
      cout << "force output interval was reset: " << syncForceInterval << " and changed to " << m_forceOutputInterval
           << endl;
      cout << "intpPoints output interval was reset: " << syncIntpPointsInterval << " and changed to "
           << m_intpPointsOutputInterval << endl;
    }
 
    m_log << "New time step: " << m_timeStep << " new physical time step: " << m_physicalTimeStep << endl;
    m_log << "Number of steps to move one cell width: " << travelDist / (m_waveSpeed * m_timeStep) << " time steps"
          << endl;
    m_log << "Number of steps to move one physical time step: " << F1 / m_physicalTimeStep << endl;
    m_log << "Number of steps to move one wave length: " << m_waveLength / (m_waveSpeed * m_timeStep) << endl;
    m_log << "Cells per wavelength: " << m_waveLength / travelDist << " travelDist: " << travelDist << endl;
    m_log << "Time for wave to travel one wave length: " << m_waveLength / m_waveSpeed << endl;
    m_log << "Physical time for wave to travel one wave length: " << m_waveLength / m_waveSpeed * m_timeRef << endl;
    m_log << "solution output interval was reset: " << syncSolutionInterval << " and changed to " << m_solutionInterval
          << endl;
    m_log << "box output interval was reset: " << syncBoxInterval << " and changed to " << m_boxOutputInterval << endl;
    m_log << "force output interval was reset: " << syncForceInterval << " and changed to " << m_forceOutputInterval
          << endl;
    m_log << "intpPoints output interval was reset: " << syncIntpPointsInterval << " and changed to "
          << m_intpPointsOutputInterval << endl;
    m_log << "solution writing out will start at" << m_outputOffset << endl;
    m_log << "////////////////////////////////////////////////////////////////" << endl;
 
    m_waveTimeStepComputed = true;
  }
 
  if(globalTimeStep == 0 || globalTimeStep == m_restartTimeStep) {
    MBool syncSolutionInterval = false;
    MBool syncForceInterval = false;
    MBool syncBoxInterval = false;
    MBool syncIntpPointsInterval = false;
 
    // fix output writing functions in case
    if(m_synchronizedMGOutput) {
      // change the output frequency of the different io routines to be in accordance with the new time step such that
      // only in full number of iterations in which the moving grid has traveld one cell distance is ensured
      // if(m_outputOffset!=m_movingGridStepOffset){
      //  m_log << "ERROR: m_outputOffset and synchronized output cannot be combined (not implemented yet)" << endl;
      //  mTerm(1, AT_, "ERROR: m_outputOffset and synchronized output cannot be combined (not implemented yet)");
      //}
      // shift the starting point of the outputs for the moving grid
 
      if(m_outputOffset > m_movingGridStepOffset) {
        const MInt offsetCounter =
            ceil(((MFloat)m_outputOffset - (MFloat)m_movingGridStepOffset) / (MFloat)m_waveNoStepsPerCell);
        m_outputOffset = m_movingGridStepOffset + offsetCounter * m_waveNoStepsPerCell;
      } else {
        m_outputOffset = m_movingGridStepOffset; // for input output such that it works propberly
      }
 
 
      if(m_useConvectiveUnitWrite) {
        m_log << "ERROR: m_useConvectiveUnitWrite and synchronized output cannot be combined (not implemented yet)"
              << endl;
        mTerm(1, AT_,
              "ERROR: m_useConvetiveUnitWrite and synchronized output cannot be combined (not implemented yet)");
      }
      if(m_solutionInterval) {
        m_solutionInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_solutionInterval / (MFloat)m_waveNoStepsPerCell));
        syncSolutionInterval = true;
      }
      if(m_forceOutputInterval) {
        m_forceOutputInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_forceOutputInterval / (MFloat)m_waveNoStepsPerCell));
        syncForceInterval = true;
      }
      if(m_boxOutputInterval) {
        m_boxOutputInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_boxOutputInterval / (MFloat)m_waveNoStepsPerCell));
        syncBoxInterval = true;
      }
      if(m_intpPointsOutputInterval) {
        m_intpPointsOutputInterval =
            mMax(m_waveNoStepsPerCell,
                 m_waveNoStepsPerCell * (MInt)floor((MFloat)m_boxOutputInterval / (MFloat)m_waveNoStepsPerCell));
        syncIntpPointsInterval = true;
      }
    }
 
    m_log << "/////////////////// TRAVELING WAVE /////////////////////////////" << endl;
    m_log << "New time step: " << m_timeStep << " new physical time step: " << m_physicalTimeStep << endl;
    m_log << "Number of steps to move one cell width: " << travelDist / (m_waveSpeed * m_timeStep) << " time steps"
          << endl;
    m_log << "Number of steps to move one physical time step: " << F1 / m_physicalTimeStep << endl;
    m_log << "Number of steps to move one wave length: " << m_waveLength / (m_waveSpeed * m_timeStep) << endl;
    m_log << "Time for wave to travel one wave length: " << m_waveLength / m_waveSpeed << endl;
    m_log << "Cells per wavelength: " << m_waveLength / travelDist << " travelDist: " << travelDist << endl;
    m_log << "solution output interval was reset: " << syncSolutionInterval << " and changed to " << m_solutionInterval
          << endl;
    m_log << "box output interval was reset: " << syncBoxInterval << " and changed to " << m_boxOutputInterval << endl;
    m_log << "force output interval was reset: " << syncForceInterval << " and changed to " << m_forceOutputInterval
          << endl;
    m_log << "intpPoints output interval was reset: " << syncIntpPointsInterval << " and changed to "
          << m_intpPointsOutputInterval << endl;
    m_log << "solution writing out will start at" << m_outputOffset << endl;
    m_log << "////////////////////////////////////////////////////////////////" << endl;
    // correct Averaging Time Steps
    if(m_postprocessing) {
      const MInt waveNoStepsPerCell = m_waveNoStepsPerCell;
      if(m_averageInterval % waveNoStepsPerCell != 0) {
        m_log << "Changed averageInterval from " << m_averageInterval;
        const MInt minAverageInterval = waveNoStepsPerCell;
        m_averageInterval =
            mMax(minAverageInterval,
                 (MInt)(waveNoStepsPerCell * floor((MFloat)m_averageInterval / (MFloat)waveNoStepsPerCell)));
        m_log << " to " << m_averageInterval << ", every " << m_averageInterval * m_physicalTimeStep
              << " convective units" << endl;
      }
 
      const MInt waveStepOffset = m_movingGridStepOffset;
      if((m_averageStartTimestep - waveStepOffset) % m_averageInterval != 0) {
        m_log << "Changed averageStartTimeStep from " << m_averageStartTimestep;
        MInt offsetCounter =
            ceil(((MFloat)m_averageStartTimestep - (MFloat)waveStepOffset) / (MFloat)m_averageInterval);
        m_averageStartTimestep = waveStepOffset + offsetCounter * m_averageInterval;
        m_log << " to " << m_averageStartTimestep << ". Averaging every " << m_averageInterval << " time steps" << endl;
      }
 
      if((m_averageStopTimestep - waveStepOffset) % m_averageInterval != 0) {
        m_log << "Changed averageStopTimeStep from " << m_averageStopTimestep;
        MInt offsetCounter = ceil(((MFloat)m_averageStopTimestep - (MFloat)waveStepOffset) / (MFloat)m_averageInterval);
        m_averageStopTimestep = waveStepOffset + offsetCounter * m_averageInterval;
        m_log << " to " << m_averageStopTimestep << ". Averaging every " << m_averageInterval << " time steps" << endl;
      }
    }
  }
}

gather()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::gather ( const  MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &    )

inlinevirtual

Definition at line 193 of file fvstructuredsolver.h.

{};

gcFillGhostCells()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::gcFillGhostCells ( std::vector< MFloat * > &  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 171 of file fvstructuredsolver.h.

{};

getActiveCells()

template<MInt nDim>

MInt * FvStructuredSolver< nDim >::getActiveCells ( )

inline

Definition at line 213 of file fvstructuredsolver.h.

{ return m_grid->m_nActiveCells; };

getBlasiusEta()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getBlasiusEta ( MFloat  coordX, MFloat  coordY  )

protectedvirtual

Definition at line 7726 of file fvstructuredsolver.cpp.

                                                                           {
  const MFloat nu8 = SUTHERLANDLAW(PV->TInfinity) / CV->rhoInfinity;
  m_blasius_x0 = F1 / POW2(1.7208) * PV->UInfinity / nu8 * m_Re0;
 
  const MFloat dx = coordX - m_blasius_dx0;
  const MFloat x = m_blasius_x0 + dx;
  const MFloat y = coordY - m_blasius_y0;
 
  return y * sqrt(PV->UInfinity * m_Re0 / (nu8 * x));
}

getBlasiusVelocity() [1/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::getBlasiusVelocity ( MFloat  coordX, MFloat  coordY, MFloat *const  vel  )

protectedvirtual

Definition at line 7739 of file fvstructuredsolver.cpp.

                                                                                                 {
  // coordinates
  const MFloat nu8 = SUTHERLANDLAW(PV->TInfinity) / CV->rhoInfinity;
  m_blasius_x0 = F1 / POW2(1.7208) * PV->UInfinity / nu8 * m_Re0;
  const MFloat eta = getBlasiusEta(coordX, coordY);
  const MFloat dx = coordX - m_blasius_dx0;
  const MFloat x = m_blasius_x0 + dx;
 
  // get f, fp, and g
  MFloat fp, f;
  if(eta >= m_blasius_eta[m_blasius_noPoints - 1]) { // freestream
    fp = m_blasius_fp[m_blasius_noPoints - 1];
    f = m_blasius_f[m_blasius_noPoints - 1]
        + m_blasius_fp[m_blasius_noPoints - 1] * (eta - m_blasius_eta[m_blasius_noPoints - 1]);
  } else if(eta <= F0) { // set zero, this is wrong in case of blowing or suction
    fp = F0;
    f = F0;
  } else { // interpolate
    // get index
    const MFloat Deta = m_blasius_eta[1];
    const MInt etai = eta / Deta;
    ASSERT((etai + 1) <= (m_blasius_noPoints - 1), "error computing the index for Blasius distributions");
    const MFloat deta = eta - m_blasius_eta[etai];
    const MFloat phi = deta / Deta;
    fp = m_blasius_fp[etai] * (F1 - phi) + m_blasius_fp[etai + 1] * phi;
    f = m_blasius_f[etai] * (F1 - phi) + m_blasius_f[etai + 1] * phi;
  }
 
  vel[0] = PV->UInfinity * fp;
  vel[1] = F1B2 * sqrt(PV->UInfinity * nu8 / (x * m_Re0)) * (eta * fp - f);
  IF_CONSTEXPR(nDim == 3) { vel[2] = 0.0; }
}

getBlasiusVelocity() [2/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::getBlasiusVelocity ( MInt  cellId, MFloat *const  vel  )

protectedvirtual

Author

T.Schilden

Date

11.12.2013

Definition at line 7721 of file fvstructuredsolver.cpp.

                                                                                {
  getBlasiusVelocity(m_cells->coordinates[0][cellId], m_cells->coordinates[1][cellId], vel);
}

getBodyForceMethod()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getBodyForceMethod ( )

inline

Definition at line 221 of file fvstructuredsolver.h.

{ return m_bodyForceMethod; };

getCellCoordinate()

template<MInt nDim>

virtual MFloat FvStructuredSolver< nDim >::getCellCoordinate ( MInt  , MInt    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 118 of file fvstructuredsolver.h.

{ return 0; };

getCellGrid()

template<MInt nDim>

MInt * FvStructuredSolver< nDim >::getCellGrid ( )

inline

Definition at line 218 of file fvstructuredsolver.h.

{ return m_grid->m_nCells; };

getCellLengthY()

template<MInt nDim>

virtual MFloat FvStructuredSolver< nDim >::getCellLengthY ( MInt  , MInt  , MInt    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 117 of file fvstructuredsolver.h.

{ return 0; };

getCommunicator()

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::getCommunicator ( )

inline

Definition at line 231 of file fvstructuredsolver.h.

{ return m_StructuredComm; };

getDomainDecompositionInformation()

template<MInt nDim>

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

override

Author

Marian Albers

Definition at line 7411 of file fvstructuredsolver.cpp.

                                                                                                              {
  TRACE();
 
  const MString namePrefix = "b" + std::to_string(solverId()) + "_";
 
  // Number of Cells
  const MInt noCells = m_noCells;
 
  domainInfo.emplace_back(namePrefix + "noStructuredCells", noCells);
}

getFscEta()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getFscEta ( MFloat  coordX, MFloat  coordY  )

protectedvirtual

Definition at line 7586 of file fvstructuredsolver.cpp.

                                                                       {
  const MFloat dx = coordX - m_fsc_dx0;
  const MFloat x = m_fsc_x0 + dx;
  const MFloat y = coordY - m_fsc_y0;
  return y * sqrt((m_fsc_m + F1) * m_fsc_Re * pow(x / m_fsc_x0, m_fsc_m) / (F2 * x));
}

getFscPressure() [1/2]

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getFscPressure ( MFloat  coordX )

protectedvirtual

Definition at line 7565 of file fvstructuredsolver.cpp.

                                                             {
  const MFloat dx = coordX - m_fsc_dx0;
  const MFloat x = m_fsc_x0 + dx;
 
  const MFloat fac = CV->rhoInfinity * POW2(PV->UInfinity) * F1B2;
  return PV->PInfinity + fac * (F1 - pow(x / m_fsc_x0, F2 * m_fsc_m));
}

getFscPressure() [2/2]

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getFscPressure ( MInt  cellId )

protectedvirtual

Definition at line 7560 of file fvstructuredsolver.cpp.

                                                           {
  return getFscPressure(m_cells->coordinates[0][cellId]);
}

getFscVelocity() [1/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::getFscVelocity ( MFloat  coordX, MFloat  coordY, MFloat *const  vel  )

protectedvirtual

Definition at line 7595 of file fvstructuredsolver.cpp.

                                                                                             {
  // coordinates
  const MFloat eta = getFscEta(coordX, coordY);
  const MFloat dx = coordX - m_fsc_dx0;
  const MFloat x = m_fsc_x0 + dx;
 
  // get f, fs
  MFloat fs, f;
  if(eta >= m_fsc_eta[m_fsc_noPoints - 1]) { // freestream
    fs = m_fsc_fs[m_fsc_noPoints - 1];
    f = m_fsc_f[m_fsc_noPoints - 1] + m_fsc_fs[m_fsc_noPoints - 1] * (eta - m_fsc_eta[m_fsc_noPoints - 1]);
  } else if(eta <= F0) { // set zero, this is wrong in case of blowing or suction
    fs = F0;
    f = F0;
  } else { // interpolate
    // get index
    const MFloat Deta = m_fsc_eta[1];
    const MInt etai = eta / Deta;
    ASSERT((etai + 1) <= (m_fsc_noPoints - 1), "error computing the index for fsc distributions");
    const MFloat deta = eta - m_fsc_eta[etai];
    const MFloat phi = deta / Deta;
    fs = m_fsc_fs[etai] * (F1 - phi) + m_fsc_fs[etai + 1] * phi;
    f = m_fsc_f[etai] * (F1 - phi) + m_fsc_f[etai + 1] * phi;
  }
 
  // "streamwise"
  vel[0] = PV->UInfinity * pow(x / m_fsc_x0, m_fsc_m) * fs;
  // normal, computet as inside the eta range
  const MFloat fac = sqrt(F2 * pow(x / m_fsc_x0, m_fsc_m) / ((m_fsc_m + F1) * m_fsc_x0 * m_fsc_Re)) / F2;
  //   eta might be < 0 but then, fs and f are zero
  vel[1] = PV->UInfinity * fac * ((F1 - m_fsc_m) * fs * eta - (F1 + m_fsc_m) * f);
 
  // spanwise
  IF_CONSTEXPR(nDim > 2) {
    MFloat g;
    if(eta >= m_fsc_eta[m_fsc_noPoints - 1]) { // freestream
      g = m_fsc_g[m_fsc_noPoints - 1];
    } else if(eta <= F0) { // set zero, this is wrong in case of blowing or suction
      g = F0;
    } else { // interpolate
      // get index
      const MFloat Deta = m_fsc_eta[1];
      const MInt etai = eta / Deta;
      ASSERT((etai + 1) <= (m_fsc_noPoints - 1), "error computing the index for fsc distributions");
      const MFloat deta = eta - m_fsc_eta[etai];
      const MFloat phi = deta / Deta;
      g = m_fsc_g[etai] * (F1 - phi) + m_fsc_g[etai + 1] * phi;
    }
    vel[2] = PV->WInfinity * g;
  }
}

getFscVelocity() [2/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::getFscVelocity ( MInt  cellId, MFloat *const  vel  )

protectedvirtual

Author

T.Schilden

Date

11.12.2013

Definition at line 7581 of file fvstructuredsolver.cpp.

                                                                            {
  getFscVelocity(m_cells->coordinates[0][cellId], m_cells->coordinates[1][cellId], vel);
}

getGamma()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getGamma ( )

inline

Definition at line 227 of file fvstructuredsolver.h.

{ return m_gamma; };

getGrid()

template<MInt nDim>

StructuredGrid< nDim > * FvStructuredSolver< nDim >::getGrid ( )

inline

Definition at line 225 of file fvstructuredsolver.h.

{ return m_grid; };

getGridMovingMethod()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getGridMovingMethod ( )

inline

Definition at line 220 of file fvstructuredsolver.h.

{ return m_gridMovingMethod; };

getMa()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getMa ( )

inline

Definition at line 230 of file fvstructuredsolver.h.

{ return m_Ma; };

getNoActiveCells()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getNoActiveCells ( )

inline

Definition at line 212 of file fvstructuredsolver.h.

{ return m_grid->m_noActiveCells; };

getNoCells()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getNoCells ( )

inline

Definition at line 210 of file fvstructuredsolver.h.

{ return m_grid->m_noCells; };

getNoGhostLayers()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getNoGhostLayers ( )

inline

Definition at line 215 of file fvstructuredsolver.h.

{ return m_grid->m_noGhostLayers; };

getOffsetCells()

template<MInt nDim>

MInt * FvStructuredSolver< nDim >::getOffsetCells ( )

inline

Definition at line 214 of file fvstructuredsolver.h.

{ return m_nOffsetCells; };

getPV()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getPV ( MInt  var, MInt  cellId  )

inline

Definition at line 237 of file fvstructuredsolver.h.

{ return m_cells->pvariables[var][cellId]; }

getRe0()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getRe0 ( )

inline

Definition at line 229 of file fvstructuredsolver.h.

{ return m_Re0; };

getSampleVariables()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::getSampleVariables ( MInt  , MFloat *    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 236 of file fvstructuredsolver.h.

{};

getSampleVorticity()

template<MInt nDim>

virtual MFloat FvStructuredSolver< nDim >::getSampleVorticity ( MInt  , MInt    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 239 of file fvstructuredsolver.h.

{ return 0; };

getSolverTimings()

template<MInt nDim>

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

override

Definition at line 7425 of file fvstructuredsolver.cpp.

                                                                                 {
  TRACE();
  const MString namePrefix = "b" + std::to_string(solverId()) + "_";
 
 
  solverTimings.emplace_back(namePrefix + "Viscous Flux", RETURN_TIMER_TIME(m_timers[Timers::ViscousFlux]));
  solverTimings.emplace_back(namePrefix + "ConvectiveFlux", RETURN_TIMER_TIME(m_timers[Timers::ConvectiveFlux]));
  solverTimings.emplace_back(namePrefix + "Exchange", RETURN_TIMER_TIME(m_timers[Timers::Exchange]));
  solverTimings.emplace_back(namePrefix + "BoundaryCondition", RETURN_TIMER_TIME(m_timers[Timers::BoundaryCondition]));
  solverTimings.emplace_back(namePrefix + "RungeKutta Step", RETURN_TIMER_TIME(m_timers[Timers::RungeKutta]));
  solverTimings.emplace_back(namePrefix + "Save output", RETURN_TIMER_TIME(m_timers[Timers::SaveOutput]));
  solverTimings.emplace_back(namePrefix + "Save forces", RETURN_TIMER_TIME(m_timers[Timers::SaveForces]));
  solverTimings.emplace_back(namePrefix + "Save auxdata", RETURN_TIMER_TIME(m_timers[Timers::SaveAuxdata]));
  solverTimings.emplace_back(namePrefix + "Save boxes", RETURN_TIMER_TIME(m_timers[Timers::SaveBoxes]));
  solverTimings.emplace_back(namePrefix + "Save intp points", RETURN_TIMER_TIME(m_timers[Timers::SaveIntpPoints]));
  solverTimings.emplace_back(namePrefix + "Save solution", RETURN_TIMER_TIME(m_timers[Timers::SaveSolution]));
  solverTimings.emplace_back(namePrefix + "Sandpaper tripping", RETURN_TIMER_TIME(m_timers[Timers::SandpaperTrip]));
  solverTimings.emplace_back(namePrefix + "Moving Grid", RETURN_TIMER_TIME(m_timers[Timers::MovingGrid]));
  solverTimings.emplace_back(namePrefix + "Moving grid volume flux", RETURN_TIMER_TIME(m_timers[Timers::MGVolumeFlux]));
  solverTimings.emplace_back(namePrefix + "MG Move Grid", RETURN_TIMER_TIME(m_timers[Timers::MGMoveGrid]));
}

getSutherlandConstant()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::getSutherlandConstant ( )

inline

Definition at line 228 of file fvstructuredsolver.h.

{ return m_sutherlandConstant; };

getWaveAvrgInterval()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getWaveAvrgInterval ( )

inline

Definition at line 216 of file fvstructuredsolver.h.

{ return (m_waveNoStepsPerCell); };

getWaveStepOffset()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::getWaveStepOffset ( )

inline

Definition at line 217 of file fvstructuredsolver.h.

{ return (m_movingGridStepOffset); };

hasRestartTimeStep()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::hasRestartTimeStep ( ) const

inlineoverridevirtual

Return if the restart time step can be determined from the restart file (for useNonSpecifiedRestartFile = true) see determineRestartTimeStep()

Reimplemented from Solver.

Definition at line 276 of file fvstructuredsolver.h.

{ return true; }

init()

template<MInt nDim>

void FvStructuredSolver< nDim >::init ( )

inline

Definition at line 278 of file fvstructuredsolver.h.

{ m_log << "Called Structured::init without Implementation" << std::endl; }

initBlasius()

template<MInt nDim>

void FvStructuredSolver< nDim >::initBlasius

protectedvirtual

Author

Marian Albers

Date

03.06.2020

Definition at line 7656 of file fvstructuredsolver.cpp.

                                           {
  TRACE();
 
 
  const MFloat fppwall = 0.332051914927913096446;
 
  // Calculate Blasius solution
  const MFloat etamax = 20.0;
  const MFloat deta = 0.001;
  const MInt steps = etamax / deta;
 
  MFloatScratchSpace blasius(steps + 1, 4, "m_blasius", AT_);
  blasius.fill(F0);
  blasius(0, 3) = fppwall;
 
  // Lets use the shooting method for getting the Blasius solution
  for(MInt i = 0; i < steps; i++) {
    blasius(i + 1, 0) = blasius(i, 0) + deta;
    blasius(i + 1, 1) = blasius(i, 1) + blasius(i, 2) * deta;
    blasius(i + 1, 2) = blasius(i, 2) + blasius(i, 3) * deta;
    blasius(i + 1, 3) = blasius(i, 3) + (-0.5 * blasius(i, 1) * blasius(i, 3)) * deta;
  }
 
  m_blasius_noPoints = steps;
 
  // allocate memory for the arrays
  mAlloc(m_blasius_eta, m_blasius_noPoints, "m_blasius_eta", AT_);
  mAlloc(m_blasius_fp, m_blasius_noPoints, "m_blasius_fp", AT_);
  mAlloc(m_blasius_f, m_blasius_noPoints, "m_blasius_f", AT_);
 
  const MFloat finalfp = blasius(steps - 1, 2);
 
  for(MInt i = 0; i < steps; i++) {
    m_blasius_eta[i] = blasius(i, 0);
    m_blasius_f[i] = blasius(i, 1) / finalfp;
    m_blasius_fp[i] = blasius(i, 2) / finalfp;
  }
 
  // debug raw distributions
  if(domainId() == 0) {
    ofstream blasiusf;
    // write pressure to file
    blasiusf.open("blasius_raw.dat", ios::trunc);
    if(blasiusf) {
      blasiusf << "#eta f fp" << endl;
      for(MInt i = 0; i < m_blasius_noPoints; i++) {
        blasiusf << m_blasius_eta[i] << " " << m_blasius_f[i] << " " << m_blasius_fp[i] << endl;
      }
      blasiusf.close();
    }
  }
 
  m_blasius_dx0 = 0.0;
  m_blasius_y0 = 0.0; // position of the wall
}

initBodyForce()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::initBodyForce ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 182 of file fvstructuredsolver.h.

{};

initFsc()

template<MInt nDim>

void FvStructuredSolver< nDim >::initFsc

protectedvirtual

Author

T.Schilden

Date

11.12.2013

Definition at line 7484 of file fvstructuredsolver.cpp.

initialCondition()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::initialCondition ( )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

initializeFQField()

template<MInt nDim>

void FvStructuredSolver< nDim >::initializeFQField

Author

Marian Albers

Date

17.09.2015

Definition at line 277 of file fvstructuredsolver.cpp.

                                                 {
  TRACE();
  // count the number of needed FQ fields and allocate
  MInt noFQFieldsNeeded = 0;
  for(MInt i = 0; i < FQ->maxNoFQVariables; i++) {
    noFQFieldsNeeded += FQ->neededFQVariables[i];
  }
 
  FQ->noFQVariables = noFQFieldsNeeded;
 
  m_log << "Allocating " << noFQFieldsNeeded << " FQ fields for " << m_noCells << "..." << endl;
  mAlloc(m_cells->fq, noFQFieldsNeeded, m_noCells, "m_cells->fq", F0, AT_);
  mAlloc(FQ->loadedFromRestartFile, noFQFieldsNeeded, "FQ->loadedFromRestartFile", false, AT_);
  m_log << "Allocating " << noFQFieldsNeeded << " FQ fields for " << m_noCells << "...SUCCESSFUL" << endl;
 
  MInt currentPos = 0;
  for(MInt i = 0; i < FQ->maxNoFQVariables; i++) {
    if(FQ->neededFQVariables[i] == 0) {
      continue;
    }
 
    FQ->activateFQField(i, currentPos, FQ->outputFQVariables[i], FQ->boxOutputFQVariables[i]);
 
    FQ->noFQBoxOutput += (MInt)FQ->boxOutputFQVariables[i];
    currentPos++;
  }
}

initializeFvStructuredSolver()

template<MInt nDim>

void FvStructuredSolver< nDim >::initializeFvStructuredSolver

(

MBool *

propertiesGroups

)

Initializes the general properties of the FV Structured solver.

Author

Pascal Meysonnat

Definition at line 1876 of file fvstructuredsolver.cpp.

initializeRungeKutta()

template<MInt nDim>

void FvStructuredSolver< nDim >::initializeRungeKutta

Definition at line 3600 of file fvstructuredsolver.cpp.

                                                    {
  TRACE();
  setRungeKuttaProperties();
 
  if(!m_restart) {
    m_time = F0;
    m_physicalTime = F0;
    globalTimeStep = 0;
  } else {
    m_time = -1.0;
    m_physicalTime = -1.0;
  }
 
  m_RKStep = 0;
 
  // this is used to initialize the counter the very first time this is called
  // and to initialize the very first residual
  if(approx(m_time, F0, m_eps)) {
    m_workload = 0;
    m_workloadIncrement = 1;
    m_firstMaxResidual = F0;
    m_firstAvrgResidual = F0;
  }
}

initMovingGrid()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::initMovingGrid ( )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 180 of file fvstructuredsolver.h.

{};

initPointsToAsciiFile()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::initPointsToAsciiFile ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 88 of file fvstructuredsolver.h.

{};

initPorous()

template<MInt nDim>

void FvStructuredSolver< nDim >::initPorous

Definition at line 3027 of file fvstructuredsolver.cpp.

                                          {
  TRACE();
 
  // Assign defaults
  m_c_Dp = 0.2;
  m_c_Dp_eps = 0.2;
  m_c_wd = 5.0;
  m_c_t = 0.0;
  m_c_eps = 0.0;
 
  // Read in from property file
  m_c_Dp = Context::getSolverProperty<MFloat>("c_Dp", m_solverId, AT_, &m_c_Dp);
  m_c_Dp_eps = Context::getSolverProperty<MFloat>("c_Dp_eps", m_solverId, AT_, &m_c_Dp_eps);
  m_c_wd = Context::getSolverProperty<MFloat>("c_wd", m_solverId, AT_, &m_c_wd);
  m_c_t = Context::getSolverProperty<MFloat>("c_t", m_solverId, AT_, &m_c_t);
  m_c_eps = Context::getSolverProperty<MFloat>("c_eps", m_solverId, AT_, &m_c_eps);
 
  // Fill porosity, Da, Forch (By now each porous solver is homogeneous)
  if(m_blockType == "porous") {
    const MInt inputBoxID = m_grid->getMyBlockId();
    const MFloat por = Context::getSolverProperty<MFloat>("porosity", m_solverId, AT_,
                                                          m_porousBlockIds[inputBoxID]); // m_porousID);
    const MFloat Da =
        Context::getSolverProperty<MFloat>("Da", m_solverId, AT_, m_porousBlockIds[inputBoxID]); // m_porousID);
    const MFloat cf =
        Context::getSolverProperty<MFloat>("cf", m_solverId, AT_, m_porousBlockIds[inputBoxID]); // m_porousID);
    for(MInt cellId = 0; cellId < m_noCells; ++cellId) {
      m_cells->fq[FQ->POROSITY][cellId] = por;
      m_cells->fq[FQ->DARCY][cellId] = Da;
      m_cells->fq[FQ->FORCH][cellId] = cf;
    }
  } else {
    // Fluid solver has only porosity
    for(MInt cellId = 0; cellId < m_noCells; ++cellId) {
      m_cells->fq[FQ->POROSITY][cellId] = 1.0;
      m_cells->fq[FQ->DARCY][cellId] = std::numeric_limits<MFloat>::max();
    }
  }
 
  // TODO_SS labels:FV,toenhance Move stuff from initBc6002 into here
}

initSolutionStep()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::initSolutionStep ( MInt  )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

initSolver()

template<MInt nDim>

void FvStructuredSolver< nDim >::initSolver

overridevirtual

Initialize solver moved from methods

Author

Sven Berger

Template Parameters

nDim

Implements Solver.

Definition at line 7778 of file fvstructuredsolver.cpp.

                                          {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::RunInit]);
  initializeRungeKutta();
 
  // Note: timers needed here for subtimers started in exchange() called from initSolutionStep()
  RECORD_TIMER_START(m_timers[Timers::Run]);
  RECORD_TIMER_START(m_timers[Timers::MainLoop]);
  initSolutionStep(-1);
  RECORD_TIMER_STOP(m_timers[Timers::MainLoop]);
  RECORD_TIMER_STOP(m_timers[Timers::Run]);
 
  setTimeStep();
  RECORD_TIMER_STOP(m_timers[Timers::RunInit]);
}

initStructuredPostprocessing()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::initStructuredPostprocessing ( )

inlineprivatevirtual

Definition at line 918 of file fvstructuredsolver.h.

                                              {
    StructuredPostprocessing<nDim, FvStructuredSolver<nDim>>::initStructuredPostprocessing();
  }

initTimers()

template<MInt nDim>

void FvStructuredSolver< nDim >::initTimers

protected

Definition at line 3083 of file fvstructuredsolver.cpp.

                                          {
  TRACE();
  m_timers.fill(-1);
 
  NEW_TIMER_GROUP_NOCREATE(m_timerGroup, "Structured Solver");
  NEW_TIMER_NOCREATE(m_timers[Timers::Structured], "total object lifetime", m_timerGroup);
  RECORD_TIMER_START(m_timers[Timers::Structured]);
 
  // Create & start constructor timer
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Constructor], "Constructor", m_timers[Timers::Structured]);
  RECORD_TIMER_START(m_timers[Timers::Constructor]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::GridDecomposition], "Grid Decomposition", m_timers[Timers::Constructor]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::GridReading], "Grid reading", m_timers[Timers::Constructor]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::BuildUpSponge], "Build up sponge", m_timers[Timers::Constructor]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ComputeMetrics], "Compute Metrics", m_timers[Timers::Constructor]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ComputeJacobian], "Compute Jacobian", m_timers[Timers::Constructor]);
 
  // Create regular solver-wide timers
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::RunInit], "Init", m_timers[Timers::Structured]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadRestart], "Load restart", m_timers[Timers::RunInit]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadVariables], "load restart variables", m_timers[Timers::LoadRestart]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadSponge], "load sponge", m_timers[Timers::LoadRestart]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadSTG], "load STG", m_timers[Timers::LoadRestart]);
 
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Run], "Run function", m_timers[Timers::Structured]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MainLoop], "Main loop", m_timers[Timers::Run]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ConvectiveFlux], "Convective Flux", m_timers[Timers::MainLoop]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ViscousFlux], "Viscous Flux", m_timers[Timers::MainLoop]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGVolumeFlux], "Volume Flux", m_timers[Timers::MainLoop]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SandpaperTrip], "Sandpaper tripping", m_timers[Timers::MainLoop]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MovingGrid], "Moving Grid", m_timers[Timers::MainLoop]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGVolumeFlux], "MG Volume Flux", m_timers[Timers::MovingGrid]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGMoveGrid], "MG Move Grid", m_timers[Timers::MovingGrid]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGExchange], "MG Exchange", m_timers[Timers::MGMoveGrid]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGCellCenterCoordinates], "MG Cell Center Coordinates",
                         m_timers[Timers::MGMoveGrid]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGMetrics], "MG Metrics", m_timers[Timers::MGMoveGrid]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGSurfaceMetrics], "MG Surface Metrics", m_timers[Timers::MGMetrics]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGCellMetrics], "MG Cell Metrics", m_timers[Timers::MGMetrics]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGCornerMetrics], "MG Corner Metrics", m_timers[Timers::MGMetrics]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGJacobian], "MG Jacobian", m_timers[Timers::MGMoveGrid]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::MGSaveGrid], "MG Save Grid", m_timers[Timers::MovingGrid]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Exchange], "Exchange", m_timers[Timers::MainLoop]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Gather], "Gather", m_timers[Timers::Exchange]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Send], "Send", m_timers[Timers::Exchange]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SendWait], "SendWait", m_timers[Timers::Exchange]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Receive], "Receive", m_timers[Timers::Exchange]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ReceiveWait], "ReceiveWait", m_timers[Timers::Exchange]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Scatter], "Scatter", m_timers[Timers::Exchange]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Receive], "Receive", m_timers[Timers::Exchange]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::BoundaryCondition], "Boundary Conditions", m_timers[Timers::MainLoop]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::RungeKutta], "RungeKutta", m_timers[Timers::MainLoop]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SaveOutput], "Save output", m_timers[Timers::Run]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SaveSolution], "Save solution", m_timers[Timers::SaveOutput]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SaveForces], "Save forces", m_timers[Timers::SaveOutput]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SaveAuxdata], "Save auxdata", m_timers[Timers::SaveOutput]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SaveBoxes], "Save boxes", m_timers[Timers::SaveOutput]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SaveIntpPoints], "Save lines", m_timers[Timers::SaveOutput]);
 
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SetTimeStep], "Set Time Step", m_timers[Timers::MainLoop]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::UpdateSponge], "Update sponge", m_timers[Timers::MainLoop]);
 
  // Set status to initialized
  m_isInitTimers = true;
}

insertSort()

template<MInt nDim>

void FvStructuredSolver< nDim >::insertSort	(	MInt	dim,
		MFloat *	list
	)

sorts an array list into ascending numerical order, by straight insertion. dim is input(size of list); list is replaced on output by its sorted rearrangement.

Definition at line 6998 of file fvstructuredsolver.cpp.

                                                                {
  MFloat temp = F0;
  MInt j = 0;
  for(MInt i = 1; i < dim; i++) {
    temp = list[i];
    j = i - 1;
    while(j >= 0 && temp < list[j]) {
      list[j + 1] = list[j];
      j = j - 1;
    }
    list[j + 1] = temp;
  }
}

isActive()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::isActive ( ) const

inlinevirtual

Return if the solver is active on this rank; needs to be implemented in derived solver since access to gridproxy not possible here

Reimplemented from Solver.

Definition at line 71 of file fvstructuredsolver.h.

{ return m_isActive; }

isInInterval()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::isInInterval

(

MInt

interval

)

Definition at line 5196 of file fvstructuredsolver.cpp.

                                                          {
  if(interval > 0) {
    if((globalTimeStep - m_outputOffset) % interval == 0 && globalTimeStep - m_outputOffset >= 0) {
      return true;
    }
  }
  return false;
}

isMovingGrid()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::isMovingGrid ( )

inline

Definition at line 219 of file fvstructuredsolver.h.

{ return m_movingGrid; };

isPeriodicComm()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::isPeriodicComm

(

std::unique_ptr< StructuredComm< nDim > > &

comm

)

Definition at line 8197 of file fvstructuredsolver.cpp.

                                                                                     {
  if(comm->commType == PERIODIC_BC || comm->commType == PERIODIC_BC_SINGULAR) {
    return true;
  } else {
    return false;
  }
}

isStreamwiseTravelingWave()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::isStreamwiseTravelingWave ( )

inline

Definition at line 222 of file fvstructuredsolver.h.

{ return m_streamwiseTravelingWave; };

isTravelingWave()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::isTravelingWave ( )

inline

Definition at line 223 of file fvstructuredsolver.h.

{ return m_travelingWave; };

lhsBnd()

template<MInt nDim>

void FvStructuredSolver< nDim >::lhsBnd

Definition at line 8249 of file fvstructuredsolver.cpp.

                                      {
  computePrimitiveVariables();
 
  exchange();
 
  if(m_zonal) {
    computeCumulativeAverage(false);
    if(globalTimeStep % m_zonalExchangeInterval == 0 && m_RKStep == 0) {
      spanwiseAvgZonal(m_zonalSpanwiseAvgVars);
      zonalExchange();
    }
  }
 
  RECORD_TIMER_START(m_timers[Timers::BoundaryCondition]);
  applyBoundaryCondition();
  RECORD_TIMER_STOP(m_timers[Timers::BoundaryCondition]);
}

loadAveragedVariables()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::loadAveragedVariables ( const char *  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 243 of file fvstructuredsolver.h.

{};

loadAverageRestartFile()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::loadAverageRestartFile ( const char *  , MFloat **  , MFloat **  , MFloat **  , MFloat **    )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 242 of file fvstructuredsolver.h.

{}

loadBoxFile()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::loadBoxFile	(	MString	fileDir,
		MString	filePrefix,
		MInt	currentStep,
		MInt	boxNr
	)

Author

Marian Albers

Date

: 02.10.2019

Definition at line 5992 of file fvstructuredsolver.cpp.

                                                                                                             {
  TRACE();
 
  stringstream fileName;
  fileName << fileDir << "/" << filePrefix << currentStep << ".hdf5";
  if(FILE* file = fopen((fileName.str()).c_str(), "r")) {
    fclose(file);
    if(domainId() == 0) {
      cout << "Loading box file " << fileName.str() << endl;
    }
  } else {
    if(domainId() == 0) {
      cout << "Box file " << fileName.str() << " does not exist" << endl;
    }
    return false;
  }
 
 
  ParallelIoHdf5 pio(fileName.str(), maia::parallel_io::PIO_READ, m_StructuredComm);
  stringstream boxPath;
  boxPath << "t" << currentStep << "/box" << boxNr;
 
  MInt boxOffset[3] = {0, 0, 0};
  pio.getAttribute(&boxOffset[0], "offsetk", boxPath.str());
  pio.getAttribute(&boxOffset[1], "offsetj", boxPath.str());
  pio.getAttribute(&boxOffset[2], "offseti", boxPath.str());
  MInt boxSize[3] = {0, 0, 0};
  pio.getAttribute(&boxSize[0], "sizek", boxPath.str());
  pio.getAttribute(&boxSize[1], "sizej", boxPath.str());
  pio.getAttribute(&boxSize[2], "sizei", boxPath.str());
 
  ParallelIo::size_type localBoxSize[3] = {0, 0, 0};
  ParallelIo::size_type localBoxOffset[3] = {0, 0, 0};
  ParallelIo::size_type localDomainBoxOffset[3] = {0, 0, 0};
 
  if(((m_nOffsetCells[2] <= boxOffset[2] && boxOffset[2] < m_nOffsetCells[2] + m_nActiveCells[2])
      || (boxOffset[2] <= m_nOffsetCells[2] && m_nOffsetCells[2] < boxOffset[2] + boxSize[2]))
     && ((m_nOffsetCells[1] <= boxOffset[1] && boxOffset[1] < m_nOffsetCells[1] + m_nActiveCells[1])
         || (boxOffset[1] <= m_nOffsetCells[1] && m_nOffsetCells[1] < boxOffset[1] + boxSize[1]))
     && ((m_nOffsetCells[0] <= boxOffset[0] && boxOffset[0] < m_nOffsetCells[0] + m_nActiveCells[0])
         || (boxOffset[0] <= m_nOffsetCells[0]
             && m_nOffsetCells[0] < boxOffset[0] + boxSize[0]))) { // the box is contained
 
    // get the size of the box
    for(MInt dim = 0; dim < nDim; ++dim) {
      if(m_nOffsetCells[dim] <= boxOffset[dim]
         && boxOffset[dim] + boxSize[dim] < m_nOffsetCells[dim] + m_nActiveCells[dim]) {
        localBoxSize[dim] = boxSize[dim];
        localBoxOffset[dim] = 0;
        localDomainBoxOffset[dim] = boxOffset[dim] - m_nOffsetCells[dim];
      } else if(m_nOffsetCells[dim] <= boxOffset[dim]) {
        localBoxSize[dim] = (m_nOffsetCells[dim] + m_nActiveCells[dim]) - boxOffset[dim];
        localBoxOffset[dim] = 0;
        localDomainBoxOffset[dim] = boxOffset[dim] - m_nOffsetCells[dim];
      } else if(boxOffset[dim] <= m_nOffsetCells[dim]
                && m_nOffsetCells[dim] + m_nActiveCells[dim] < boxOffset[dim] + boxSize[dim]) {
        localBoxSize[dim] = m_nActiveCells[dim];
        localBoxOffset[dim] = m_nOffsetCells[dim] - boxOffset[dim];
        localDomainBoxOffset[dim] = 0;
      } else {
        localBoxSize[dim] = (boxOffset[dim] + boxSize[dim]) - m_nOffsetCells[dim];
        localBoxOffset[dim] = m_nOffsetCells[dim] - boxOffset[dim];
        localDomainBoxOffset[dim] = 0;
      }
    }
 
    MInt totalLocalSize = 1;
    for(MInt dim = 0; dim < nDim; ++dim) {
      totalLocalSize *= localBoxSize[dim];
    }
 
    MFloatScratchSpace localBoxVar(totalLocalSize, AT_, "local Box Variables");
    for(MInt var = 0; var < PV->noVariables; var++) {
      pio.readArray(&localBoxVar[0], boxPath.str(), m_pvariableNames[var], nDim, localBoxOffset, localBoxSize);
 
      for(MInt k = m_noGhostLayers + localDomainBoxOffset[0];
          k < m_noGhostLayers + localDomainBoxOffset[0] + localBoxSize[0];
          ++k) {
        for(MInt j = m_noGhostLayers + localDomainBoxOffset[1];
            j < m_noGhostLayers + localDomainBoxOffset[1] + localBoxSize[1];
            ++j) {
          for(MInt i = m_noGhostLayers + localDomainBoxOffset[2];
              i < m_noGhostLayers + localDomainBoxOffset[2] + localBoxSize[2];
              ++i) {
            const MInt cellId = i + (j + k * m_nCells[1]) * m_nCells[2];
            const MInt boxI = i - m_noGhostLayers - localDomainBoxOffset[2];
            const MInt boxJ = j - m_noGhostLayers - localDomainBoxOffset[1];
            const MInt boxK = k - m_noGhostLayers - localDomainBoxOffset[0];
            const MInt localId = boxI + (boxJ + boxK * localBoxSize[1]) * localBoxSize[2];
            m_cells->pvariables[var][cellId] = localBoxVar[localId];
          }
        }
      }
    }
  } else {
    for(MInt var = 0; var < PV->noVariables; var++) {
      ParallelIo::size_type offset[3] = {0, 0, 0};
      ParallelIo::size_type size[3] = {0, 0, 0};
      MFloat empty = 0;
      pio.readArray(&empty, boxPath.str(), m_pvariableNames[var], nDim, offset, size);
    }
  }
 
 
  if(domainId() == 0) {
    cout << "Done loading box file " << currentStep << endl;
  }
 
  return true;
}

loadRestartBC2600()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::loadRestartBC2600 ( )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 104 of file fvstructuredsolver.h.

{};

loadRestartBC2601()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::loadRestartBC2601 ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 105 of file fvstructuredsolver.h.

{};

loadRestartFile()

template<MInt nDim>

void FvStructuredSolver< nDim >::loadRestartFile

virtual

Author

Pascal Meysonnat

Reimplemented from Solver.

Definition at line 5638 of file fvstructuredsolver.cpp.

loadRestartSTG()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::loadRestartSTG ( MBool  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 106 of file fvstructuredsolver.h.

{ mTerm(-1, AT_, "not implemented in basic solver"); };

loadSampleFile()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::loadSampleFile ( MString  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 235 of file fvstructuredsolver.h.

{};

maxResidual()

template<MInt nDim>

virtual MBool FvStructuredSolver< nDim >::maxResidual ( )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 266 of file fvstructuredsolver.h.

{ return true; };

moveGrid() [1/2]

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::moveGrid ( MBool  , MBool    )

inlinevirtual

Reimplemented in FvStructuredSolver2D, and FvStructuredSolver3D.

Definition at line 181 of file fvstructuredsolver.h.

{};

moveGrid() [2/2]

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::moveGrid ( MInt  )

inlinevirtual

Definition at line 179 of file fvstructuredsolver.h.

{};

Muscl()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::Muscl ( MInt  = -1 )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

noInternalCells()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::noInternalCells ( ) const

inlineoverridevirtual

Implements Solver.

Definition at line 120 of file fvstructuredsolver.h.

{ return m_noCells; }

noSolverTimers()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::noSolverTimers ( const MBool  allTimings )

inlineoverride

Definition at line 76 of file fvstructuredsolver.h.

                                                       {
    TERMM_IF_COND(!allTimings, "FIXME: reduced timings mode not yet supported by StructuredFvSolver.");
    return 16; // Default: load and idle timer
  }

noVariables()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::noVariables ( ) const

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 211 of file fvstructuredsolver.h.

{ return PV->noVariables; };

partitionGrid()

template<MInt nDim>

void FvStructuredSolver< nDim >::partitionGrid

(

)

postTimeStep()

template<MInt nDim>

void FvStructuredSolver< nDim >::postTimeStep

overridevirtual

Author

Thomas Hoesgen

Implements Solver.

Definition at line 8296 of file fvstructuredsolver.cpp.

                                            {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::Run]);
  RECORD_TIMER_START(m_timers[Timers::MainLoop]);
  m_timeStepConverged = maxResidual();
  RECORD_TIMER_STOP(m_timers[Timers::MainLoop]);
  RECORD_TIMER_STOP(m_timers[Timers::Run]);
}

prepareRestart()

template<MInt nDim>

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

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 93 of file fvstructuredsolver.h.

{ return false; };

pressure_twoEqRans()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::pressure_twoEqRans ( MInt  cellId ) const

inline

Definition at line 161 of file fvstructuredsolver.h.

{ return -mMax(m_cells->variables[CV->RANS_VAR[0]][cellId], F0); }

preTimeStep()

template<MInt nDim>

void FvStructuredSolver< nDim >::preTimeStep ( )

inlineoverridevirtual

Implements Solver.

Definition at line 268 of file fvstructuredsolver.h.

{}

pythag()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::pythag	(	MFloat	a,
		MFloat	b
	)

Definition at line 7013 of file fvstructuredsolver.cpp.

                                                          {
  MFloat absa = F0, absb = F0;
  absa = fabs(a);
  absb = fabs(b);
  if(absa > absb)
    return absa * sqrt(1.0 + POW2(absb / absa));
  else
    return (approx(absb, F0, m_eps) ? F0 : absb * sqrt(1.0 + POW2(absa / absb)));
}

readAndSetAuxDataMap()

template<MInt nDim>

void FvStructuredSolver< nDim >::readAndSetAuxDataMap

Date

2020-03-19

Definition at line 3232 of file fvstructuredsolver.cpp.

readAndSetSpongeLayerProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::readAndSetSpongeLayerProperties

Definition at line 3291 of file fvstructuredsolver.cpp.

receive()

template<MInt nDim>

void FvStructuredSolver< nDim >::receive	(	const MBool	periodicExchange,
		std::vector< std::unique_ptr< StructuredComm< nDim > > > &	rcvComm,
		std::vector< MPI_Request > &	rcvRequests
	)

Definition at line 8174 of file fvstructuredsolver.cpp.

                                                                            {
  for(auto& rcv : rcvComm) {
    if(periodicExchange && skipPeriodicDirection(rcv)) continue;
 
    MPI_Request request{};
    const MInt tag = rcv->nghbrId + (rcv->tagHelper) * noDomains();
    const MInt err = MPI_Irecv((void*)&rcv->cellBuffer[0], rcv->cellBufferSize, MPI_DOUBLE, rcv->nghbrId, tag,
                               m_StructuredComm, &request, AT_, "rcv->cellBuffer");
    rcvRequests.push_back(request);
    if(err) cout << "rank " << domainId() << " sending throws error " << endl;
  }
}

reIntAfterRestart()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::reIntAfterRestart ( MBool  )

inlinevirtual

Reimplemented from Solver.

Definition at line 92 of file fvstructuredsolver.h.

{};

resetRHS()

template<MInt nDim>

void FvStructuredSolver< nDim >::resetRHS

Author

Pascal Meysonnat

Definition at line 4392 of file fvstructuredsolver.cpp.

                                        {
  // as only 1D array is used the ghostcells will also need to have a right hand side variables
  // if storage need to be saved go over the inner loops and remove storge of ghost rhs
  const MInt noVars = CV->noVariables;
  for(MInt cellId = 0; cellId < m_noCells; cellId++) {
    for(MInt varId = 0; varId < noVars; varId++) {
      m_cells->rightHandSide[varId][cellId] = F0;
    }
  }
}

rhs()

template<MInt nDim>

void FvStructuredSolver< nDim >::rhs

Compute right-hand side. moved from methods

Author

Sven Berger

Template Parameters

nDim

Definition at line 8211 of file fvstructuredsolver.cpp.

                                   {
  TRACE();
 
  resetRHS();
 
  Muscl();
 
  if(!m_euler) {
    RECORD_TIMER_START(m_timers[Timers::ViscousFlux]);
    viscousFlux();
    RECORD_TIMER_STOP(m_timers[Timers::ViscousFlux]);
  }
 
  if(m_considerVolumeForces) {
    setVolumeForce();
    computeVolumeForces();
  }
 
  if(m_blockType == "porous") {
    if(m_rans)
      computePorousRHS(true);
    else
      computePorousRHS(false);
  }
}

rhsBnd()

template<MInt nDim>

void FvStructuredSolver< nDim >::rhsBnd

Apply boundary condition moved from methods

Author

Sven Berger

Template Parameters

nDim

Definition at line 8242 of file fvstructuredsolver.cpp.

                                      {
  RECORD_TIMER_START(m_timers[Timers::UpdateSponge]);
  updateSpongeLayer();
  RECORD_TIMER_STOP(m_timers[Timers::UpdateSponge]);
}

rungeKuttaStep()

template<MInt nDim>

virtual bool FvStructuredSolver< nDim >::rungeKuttaStep ( )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

saveAuxData()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveAuxData

Definition at line 6105 of file fvstructuredsolver.cpp.

                                           {
  computeAuxData();
  stringstream fileName;
  MChar gridFile[25];
  MString tempG;
 
  fileName << m_auxOutputDir << "auxData" << m_outputIterationNumber << m_outputFormat;
 
  strcpy(gridFile, tempG.c_str());
  ParallelIoHdf5 pio(fileName.str(), maia::parallel_io::PIO_REPLACE, m_StructuredComm);
  writeHeaderAttributes(&pio, "auxdata");
  writePropertiesAsAttributes(&pio, "");
  const MString powerNamesVisc[3] = {"Pxv", "Pyv", "Pzv"};
  const MString powerNamesPres[3] = {"Pxp", "Pyp", "Pzp"};
 
  const MString dataNames3D[] = {"cfx", "cfy", "cfz", "ax", "ay", "az", "x", "y", "z"};
  MString dataNames[3 * nDim];
  MInt cnt = 0;
  for(MInt i = 0; i < 3; ++i) {
    for(MInt dim = 0; dim < nDim; ++dim)
      dataNames[cnt++] = dataNames3D[i * 3 + dim];
  }
  MInt noFields = nDim;
  if(m_detailAuxData) {
    noFields = 3 * nDim;
  }
 
  for(auto it = m_windowInfo->m_auxDataWindowIds.cbegin(); it != m_windowInfo->m_auxDataWindowIds.cend(); ++it) {
    const MInt i = it->first;
    ParallelIo::size_type datasetSize[nDim - 1];
    MInt dim1 = nDim - 2;
    for(MInt dim = 0; dim < nDim; ++dim) {
      if(m_windowInfo->globalStructuredBndryCndMaps[i]->end2[dim]
         == m_windowInfo->globalStructuredBndryCndMaps[i]->start2[dim]) {
        continue;
      }
      datasetSize[dim1--] = m_windowInfo->globalStructuredBndryCndMaps[i]->end2[dim]
                            - m_windowInfo->globalStructuredBndryCndMaps[i]->start2[dim];
    }
 
    if(m_bForce) {
      stringstream datasetId;
      datasetId << it->second; //==m_windowInfo->globalStructuredBndryCndMaps[i]->Id2;
      MString pathName = "window";
      pathName += datasetId.str();
      MString dataNamesCp = "cp";
      for(MInt j = 0; j < noFields; j++) {
        pio.defineArray(maia::parallel_io::PIO_FLOAT, pathName, dataNames[j], nDim - 1, datasetSize);
      }
      pio.defineArray(maia::parallel_io::PIO_FLOAT, pathName, dataNamesCp, nDim - 1, datasetSize);
    }
 
    if(m_bPower) {
      stringstream datasetId;
      datasetId << it->second; //==m_windowInfo->globalStructuredBndryCndMaps[i]->Id2;
      MString pathName = "window";
      pathName += datasetId.str();
      for(MInt j = 0; j < nDim; j++) {
        pio.defineArray(maia::parallel_io::PIO_FLOAT, pathName, powerNamesVisc[j], nDim - 1, datasetSize);
        pio.defineArray(maia::parallel_io::PIO_FLOAT, pathName, powerNamesPres[j], nDim - 1, datasetSize);
      }
    }
  }
 
  for(auto it = m_windowInfo->m_auxDataWindowIds.cbegin(); it != m_windowInfo->m_auxDataWindowIds.cend(); ++it) {
    stringstream datasetname;
    datasetname << it->second; //==m_windowInfo->globalStructuredBndryCndMaps[i]->Id2;
 
    MBool isLocalAuxMap = false;
    MInt localAuxMapId = 0;
    const MUint noAuxDataMaps = m_windowInfo->physicalAuxDataMap.size();
 
    // loop through all local auxDataMaps
    // to find if this partition shares a part of it
    // and then save the local id
    for(MUint j = 0; j < noAuxDataMaps; ++j) {
      stringstream datasetId;
      datasetId << m_windowInfo->physicalAuxDataMap[j]->Id2;
      if(datasetId.str() == datasetname.str()) {
        isLocalAuxMap = true;
        localAuxMapId = j;
        break;
      }
    }
 
    if(isLocalAuxMap) {
      stringstream datasetId;
      datasetId << m_windowInfo->physicalAuxDataMap[localAuxMapId]->Id2;
 
      ParallelIo::size_type offset[nDim - 1] = {};
      ParallelIo::size_type dataSize[nDim - 1] = {};
      MInt dataSetSize = 1;
      MInt dim1 = nDim - 2;
      for(MInt j = 0; j < nDim; ++j) {
        if(m_windowInfo->physicalAuxDataMap[localAuxMapId]->start2[j]
           == m_windowInfo->physicalAuxDataMap[localAuxMapId]->end2[j])
          continue;
        dataSize[dim1] = m_windowInfo->physicalAuxDataMap[localAuxMapId]->end2[j]
                         - m_windowInfo->physicalAuxDataMap[localAuxMapId]->start2[j];
        offset[dim1] = m_windowInfo->physicalAuxDataMap[localAuxMapId]->start2[j];
        dataSetSize *= dataSize[dim1];
        dim1--;
      }
 
      if(m_bForce) {
        const MInt mapOffset = m_cells->cfOffsets[localAuxMapId];
        MString pathName = "window" + datasetId.str();
        for(MInt j = 0; j < noFields; j++) {
          pio.writeArray(&m_cells->cf[mapOffset + dataSetSize * j], pathName, dataNames[j], nDim - 1, offset, dataSize);
        }
        const MInt mapOffsetCp = m_cells->cpOffsets[localAuxMapId];
        MString dataname = "cp";
        pio.writeArray(&m_cells->cp[mapOffsetCp], pathName, dataname, nDim - 1, offset, dataSize);
      }
 
      if(m_bPower) {
        const MInt mapOffset = m_cells->powerOffsets[localAuxMapId];
        MString pathName = "window" + datasetId.str();
        for(MInt j = 0; j < nDim; j++) {
          pio.writeArray(&m_cells->powerVisc[mapOffset + dataSetSize * j], pathName, powerNamesVisc[j], nDim - 1,
                         offset, dataSize);
          pio.writeArray(&m_cells->powerPres[mapOffset + dataSetSize * j], pathName, powerNamesPres[j], nDim - 1,
                         offset, dataSize);
        }
      }
    } else {
      ParallelIo::size_type offset[nDim] = {};
      ParallelIo::size_type dataSize[nDim] = {};
      for(MInt j = 0; j < nDim - 1; ++j) {
        offset[j] = 0;
        dataSize[j] = 0;
      }
      // skin-friction and pressure coefficient
      if(m_bForce) {
        MString pathName = "window" + datasetname.str();
        MFloat empty = 0;
        for(MInt j = 0; j < noFields; j++) {
          pio.writeArray(&empty, pathName, dataNames[j], nDim - 1, offset, dataSize);
        }
        MString dataname = "cp";
        pio.writeArray(&empty, pathName, dataname, nDim - 1, offset, dataSize);
      }
      // power
      if(m_bPower) {
        MString pathName = "window" + datasetname.str();
        MFloat empty = 0;
        for(MInt j = 0; j < nDim; j++) {
          pio.writeArray(&empty, pathName, powerNamesVisc[j], nDim - 1, offset, dataSize);
          pio.writeArray(&empty, pathName, powerNamesPres[j], nDim - 1, offset, dataSize);
        }
      }
    }
  }
 
  if(m_bForce) {
    saveForceCoefficient(&pio);
  }
}

saveAveragedVariables()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveAveragedVariables	(	MString	name,
		MInt	noVars,
		MFloat **	summedVars
	)

Author

Marian Albers, Nov 15, 2015

Date

15.11.2015

Definition at line 6460 of file fvstructuredsolver.cpp.

                                                                                                   {
  // Function to write the solution to file with iolibrary
  stringstream fileName;
 
  m_log << "writing Averaged Variables to file " << name << m_outputFormat << " ... " << endl;
  fileName << name << m_outputFormat;
 
  ParallelIoHdf5 pio(fileName.str(), maia::parallel_io::PIO_REPLACE, m_StructuredComm);
 
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  pio.setAttribute(m_averageStartTimestep, "averageStartTimeStep", "");
  pio.setAttribute(m_averageInterval, "averageSampleInterval", "");
  pio.setAttribute(m_noSamples, "noSamples", "");
 
  for(MInt i = 0; i < m_noBlocks; i++) {
    ParallelIo::size_type noCells[nDim] = {};
    for(MInt j = 0; j < nDim; j++) {
      noCells[j] = m_grid->getBlockNoCells(i, j);
    }
    // create datasets for the io library
    stringstream path;
    path << i;
    MString blockPathStr = "block";
    blockPathStr += path.str();
 
    // create dataset and write
    for(MInt var = 0; var < noVars; var++) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, m_avgVariableNames[var], nDim, noCells);
    }
 
    if(m_averagingFavre) {
      for(MInt var = 0; var < PV->noVariables; var++) {
        pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, m_avgFavreNames[var], nDim, noCells);
      }
    }
  }
 
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {0, 0, 0};
  ParallelIo::size_type ioGhost[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
  for(MInt dim = 0; dim < nDim; ++dim) {
    ioOffset[dim] = m_nOffsetCells[dim];
    ioSize[dim] = m_nActiveCells[dim];
  }
 
  stringstream path;
  path << m_blockId;
  MString blockPathStr = "block";
  blockPathStr += path.str();
  for(MInt var = 0; var < noVars; var++) {
    pio.writeArray(&summedVars[var][0], blockPathStr, m_avgVariableNames[var], nDim, ioOffset, ioSize, ioGhost);
  }
 
  if(m_averagingFavre) {
    for(MInt var = 0; var < PV->noVariables; var++) {
      pio.writeArray(&m_favre[var][0], blockPathStr, m_avgFavreNames[var], nDim, ioOffset, ioSize, ioGhost);
    }
  }
}

saveAverageRestart() [1/2]

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::saveAverageRestart ( )

inlineprivatevirtual

Definition at line 921 of file fvstructuredsolver.h.

{ StructuredPostprocessing<nDim, FvStructuredSolver<nDim>>::saveAverageRestart(); }

saveAverageRestart() [2/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::saveAverageRestart	(	MString	name,
		MInt	noVars,
		MFloat **	summedVars,
		MFloat **	square,
		MFloat **	cube,
		MFloat **	fourth
	)

Author

Frederik Temme

Date

12.01.2015

Definition at line 6528 of file fvstructuredsolver.cpp.

                                                                                  {
  (void)noVars;
 
  // Function to write the solution to file with iolibrary
  stringstream fileName;
 
  m_log << "writing Averaged Restart Variables to file " << name << m_outputFormat << " ... " << endl;
  fileName << name << m_outputFormat;
 
  ParallelIoHdf5 pio(fileName.str(), maia::parallel_io::PIO_REPLACE, m_StructuredComm);
 
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  pio.setAttribute(m_averageStartTimestep, "averageStartTimeStep", "");
  pio.setAttribute(m_averageInterval, "averageSampleInterval", "");
  pio.setAttribute(m_noSamples, "noSamples", "");
 
  ParallelIo::size_type allCells[3]; // not nDim because of compiler warning0
  for(MInt i = 0; i < m_noBlocks; i++) {
    for(MInt j = 0; j < nDim; j++) {
      allCells[j] = m_grid->getBlockNoCells(i, j);
    }
    // create datasets for the io library
    stringstream path;
    path << i; // m_blockId;
    MString blockPathStr = "block";
    blockPathStr += path.str();
 
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "u", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "v", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "w", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "rho", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "p", 3, allCells);
 
    if(m_averagingFavre) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "um_favre", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vm_favre", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "wm_favre", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "rhom_favre", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "pm_favre", 3, allCells);
    }
 
    if(m_averageVorticity) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vortx", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vorty", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vortz", 3, allCells);
    }
 
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "uu", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vv", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "ww", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "uv", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vw", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "uw", 3, allCells);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "pp", 3, allCells);
 
    if(m_averageVorticity) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vortxvortx", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vortyvorty", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vortzvortz", 3, allCells);
    }
 
    if(m_kurtosis || m_skewness) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "uuu", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vvv", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "www", 3, allCells);
    }
 
    if(m_kurtosis) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "uuuu", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "vvvv", 3, allCells);
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "wwww", 3, allCells);
    }
  }
 
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {0, 0, 0};
  ParallelIo::size_type ioGhost[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
  for(MInt dim = 0; dim < nDim; ++dim) {
    ioOffset[dim] = m_nOffsetCells[dim];
    ioSize[dim] = m_nActiveCells[dim];
  }
 
  stringstream path;
  path << m_blockId;
  MString blockPathStr = "block";
  blockPathStr += path.str();
  MInt offset = 0;
  pio.writeArray(&summedVars[0][0], blockPathStr, "u", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&summedVars[1][0], blockPathStr, "v", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&summedVars[2][0], blockPathStr, "w", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&summedVars[3][0], blockPathStr, "rho", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&summedVars[4][0], blockPathStr, "p", nDim, ioOffset, ioSize, ioGhost);
  offset = noVariables();
 
  if(m_averagingFavre) {
    pio.writeArray(&m_favre[0][0], blockPathStr, "um_favre", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&m_favre[1][0], blockPathStr, "vm_favre", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&m_favre[2][0], blockPathStr, "wm_favre", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&m_favre[3][0], blockPathStr, "rhom_favre", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&m_favre[4][0], blockPathStr, "pm_favre", nDim, ioOffset, ioSize, ioGhost);
  }
 
  if(m_averageVorticity) {
    pio.writeArray(&summedVars[offset + 0][0], blockPathStr, "vortx", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&summedVars[offset + 1][0], blockPathStr, "vorty", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&summedVars[offset + 2][0], blockPathStr, "vortz", nDim, ioOffset, ioSize, ioGhost);
  }
 
  pio.writeArray(&square[0][0], blockPathStr, "uu", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&square[1][0], blockPathStr, "vv", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&square[2][0], blockPathStr, "ww", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&square[3][0], blockPathStr, "uv", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&square[4][0], blockPathStr, "vw", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&square[5][0], blockPathStr, "uw", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&square[6][0], blockPathStr, "pp", nDim, ioOffset, ioSize, ioGhost);
 
  if(m_averageVorticity) {
    pio.writeArray(&square[7][0], blockPathStr, "vortxvortx", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&square[8][0], blockPathStr, "vortyvorty", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&square[9][0], blockPathStr, "vortzvortz", nDim, ioOffset, ioSize, ioGhost);
  }
 
  if(m_kurtosis || m_skewness) {
    pio.writeArray(&cube[0][0], blockPathStr, "uuu", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&cube[1][0], blockPathStr, "vvv", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&cube[2][0], blockPathStr, "www", nDim, ioOffset, ioSize, ioGhost);
  }
 
  if(m_kurtosis) {
    pio.writeArray(&fourth[0][0], blockPathStr, "uuuu", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&fourth[1][0], blockPathStr, "vvvv", nDim, ioOffset, ioSize, ioGhost);
    pio.writeArray(&fourth[2][0], blockPathStr, "wwww", nDim, ioOffset, ioSize, ioGhost);
  }
}

saveBoxes()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveBoxes

(

)

saveDissipation()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveDissipation	(	MString	name,
		MFloat *	dissipation
	)

Author

Marian Albers

Definition at line 6733 of file fvstructuredsolver.cpp.

                                                                                {
  // Function to write the solution to file with iolibrary
 
  m_log << "writing dissipation terms to file " << name << " ... " << endl;
 
  ParallelIoHdf5 pio(name, maia::parallel_io::PIO_APPEND, m_StructuredComm);
 
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  ParallelIo::size_type allCells[3];
  for(MInt i = 0; i < m_noBlocks; i++) {
    for(MInt j = 0; j < nDim; j++) {
      allCells[j] = m_grid->getBlockNoCells(i, j);
    }
    // create datasets for the io library
    stringstream path;
    path << i;
    MString blockPathStr = "block";
    blockPathStr += path.str();
 
    // create dataset and write
    if(!pio.hasDataset("diss", blockPathStr)) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "diss", nDim, allCells);
    } else {
      cout << "Dataset diss exists, not creating new" << endl;
    }
  }
 
  stringstream path;
  path << m_blockId;
  MString blockPathStr = "block";
  blockPathStr += path.str();
 
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {0, 0, 0};
  ParallelIo::size_type ioGhost[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
  for(MInt dim = 0; dim < nDim; ++dim) {
    ioOffset[dim] = m_nOffsetCells[dim];
    ioSize[dim] = m_nActiveCells[dim];
  }
 
  pio.writeArray(&dissipation[0], blockPathStr, "diss", nDim, ioOffset, ioSize, ioGhost);
}

saveForceCoefficient()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveForceCoefficient

(

ParallelIoHdf5 *

pio

)

Authors

Marian Albers, Pascal Meysonnat

Parameters

[in]

Open

ParallelIOHdf5 object to which attributes should be written

Definition at line 6273 of file fvstructuredsolver.cpp.

                                                                       {
  TRACE();
 
  MInt noWalls = m_windowInfo->m_auxDataWindowIds.size();
  MFloatScratchSpace force(noWalls, nDim, AT_, "force");
  MFloatScratchSpace forceP(noWalls, nDim, AT_, "forceP");
  MFloatScratchSpace forceC(noWalls, nDim, AT_, "forceC");
  MFloatScratchSpace forceV(noWalls, nDim, AT_, "forceV");
  MFloatScratchSpace area(noWalls, nDim, AT_, "area");
  MFloatScratchSpace power(noWalls, nDim, AT_, "Ptot");
  MFloatScratchSpace powerV(noWalls, nDim, AT_, "Pvisc");
  MFloatScratchSpace powerP(noWalls, nDim, AT_, "Ppres");
 
  for(MInt i = 0; i < noWalls; ++i) {
    for(MInt dim = 0; dim < nDim; dim++) {
      forceV(i, dim) = m_forceCoef[i * m_noForceDataFields + dim];
      forceC(i, dim) = m_forceCoef[i * m_noForceDataFields + nDim + dim];
      forceP(i, dim) = m_forceCoef[i * m_noForceDataFields + 2 * nDim + dim];
      force(i, dim) = forceV(i, dim) + forceC(i, dim) + forceP(i, dim);
      powerV(i, dim) = m_forceCoef[i * m_noForceDataFields + 3 * nDim + 1 + dim];
      powerP(i, dim) = m_forceCoef[i * m_noForceDataFields + 4 * nDim + 1 + dim];
      power(i, dim) = powerV(i, dim) + powerP(i, dim);
    }
    area[i] = m_forceCoef[i * m_noForceDataFields + 3 * nDim];
  }
 
  MInt count = 0;
  for(auto it = m_windowInfo->m_auxDataWindowIds.cbegin(); it != m_windowInfo->m_auxDataWindowIds.cend(); ++it) {
    stringstream datasetname;
    datasetname << it->second; //==m_windowInfo->globalStructuredBndryCndMaps[it->first]->Id2;
    MString pathName = "window" + datasetname.str();
 
    pio->setAttribute(force(count, 0), "forceX", pathName);
    pio->setAttribute(forceV(count, 0), "forceVX", pathName);
    pio->setAttribute(forceP(count, 0), "forcePX", pathName);
    pio->setAttribute(forceC(count, 0), "forceCX", pathName);
 
    pio->setAttribute(force(count, 1), "forceY", pathName);
    pio->setAttribute(forceV(count, 1), "forceVY", pathName);
    pio->setAttribute(forceP(count, 1), "forcePY", pathName);
    pio->setAttribute(forceC(count, 1), "forceCY", pathName);
 
    IF_CONSTEXPR(nDim == 3) {
      pio->setAttribute(force(count, 2), "forceZ", pathName);
      pio->setAttribute(forceV(count, 2), "forceVZ", pathName);
      pio->setAttribute(forceP(count, 2), "forcePZ", pathName);
      pio->setAttribute(forceC(count, 2), "forceCZ", pathName);
    }
 
    pio->setAttribute(area[count], "area", pathName);
 
    if(m_bPower) {
      pio->setAttribute(power(count, 0), "powerX", pathName);
      pio->setAttribute(power(count, 1), "powerY", pathName);
      pio->setAttribute(power(count, 2), "powerZ", pathName);
 
      pio->setAttribute(powerP(count, 0), "powerPX", pathName);
      pio->setAttribute(powerP(count, 1), "powerPY", pathName);
      pio->setAttribute(powerP(count, 2), "powerPZ", pathName);
 
      pio->setAttribute(powerV(count, 0), "powerVX", pathName);
      pio->setAttribute(powerV(count, 1), "powerVY", pathName);
      pio->setAttribute(powerV(count, 2), "powerVZ", pathName);
    }
 
    count++;
  }
}

saveForcesToAsciiFile()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveForcesToAsciiFile

(

MBool

forceWrite

)

Author

Marian Albers

Definition at line 6350 of file fvstructuredsolver.cpp.

                                                                     {
  TRACE();
  // compute the data
  if(m_bForce) {
    computeAuxDataRoot();
 
    // write all the data to files if domainId()==0
    if(domainId() == 0) {
      MInt noWalls = m_windowInfo->m_auxDataWindowIds.size();
 
      MFloatScratchSpace cForce(noWalls, nDim, AT_, "cForce");
      MFloatScratchSpace cForceP(noWalls, nDim, AT_, "cForceP");
      MFloatScratchSpace cForceC(noWalls, nDim, AT_, "cForceC");
      MFloatScratchSpace cForceV(noWalls, nDim, AT_, "cForceV");
      MFloatScratchSpace area(noWalls, AT_, "area");
      // power consumption
      MFloatScratchSpace cPower(noWalls, nDim, AT_, "cPower");
      MFloatScratchSpace cPowerV(noWalls, nDim, AT_, "cPower");
      MFloatScratchSpace cPowerP(noWalls, nDim, AT_, "cPower");
 
      for(MInt i = 0; i < noWalls; ++i) {
        for(MInt dim = 0; dim < nDim; dim++) {
          cForceV(i, dim) = m_forceCoef[i * m_noForceDataFields + dim];
          cForceC(i, dim) = m_forceCoef[i * m_noForceDataFields + nDim + dim];
          cForceP(i, dim) = m_forceCoef[i * m_noForceDataFields + 2 * nDim + dim];
          cForce(i, dim) = cForceV(i, dim) + cForceP(i, dim) + cForceC(i, dim);
          cPowerV(i, dim) = m_forceCoef[i * m_noForceDataFields + 3 * nDim + 1 + dim];
          cPowerP(i, dim) = m_forceCoef[i * m_noForceDataFields + 4 * nDim + 1 + dim];
          cPower(i, dim) = cPowerV(i, dim) + cPowerP(i, dim);
        }
        area[i] = m_forceCoef[i * m_noForceDataFields + 3 * nDim];
      }
 
      if(m_lastForceComputationTimeStep != globalTimeStep) {
        for(MInt i = 0; i < noWalls; ++i) {
          MInt cnt = 0;
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = globalTimeStep;
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = m_time;
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = m_physicalTime;
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForce(i, 0);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceV(i, 0);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceP(i, 0);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceC(i, 0);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForce(i, 1);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceV(i, 1);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceP(i, 1);
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceC(i, 1);
          IF_CONSTEXPR(nDim == 3) {
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForce(i, 2);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceV(i, 2);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceP(i, 2);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cForceC(i, 2);
          }
          m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = area[i];
 
          if(m_bPower) {
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPower(i, 0);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPowerV(i, 0);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPowerP(i, 0);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPower(i, 1);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPowerV(i, 1);
            m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPowerP(i, 1);
            IF_CONSTEXPR(nDim == 3) {
              m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPower(i, 2);
              m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPowerV(i, 2);
              m_forceData[m_forceCounter][i * m_noForceDataFields + cnt++] = cPowerP(i, 2);
            }
          }
        }
        m_forceCounter++;
        m_lastForceComputationTimeStep = globalTimeStep;
      }
 
      if((m_forceCounter >= m_forceAsciiOutputInterval || forceWrite) && m_lastForceOutputTimeStep != globalTimeStep) {
        cout << "globalTimeStep: " << globalTimeStep << " writing out to ascii file" << endl;
        // TODO_SS labels:FV why not looping over the elements of m_windowInfo->m_auxDataWindowIds and choosing windowId
        // for iWall
        for(MInt i = 0; i < noWalls; ++i) {
          stringstream iWall;
          iWall << i;
          MString filename = "./forces." + iWall.str() + ".dat";
 
          FILE* f_forces;
          f_forces = fopen(filename.c_str(), "a+");
 
          for(MInt j = 0; j < m_forceCounter; j++) {
            fprintf(f_forces, "%d ", (MInt)m_forceData[j][i * m_noForceDataFields + 0]);
            for(MInt k = 1; k < m_noForceDataFields; k++) {
              fprintf(f_forces, " %.8f ", m_forceData[j][i * m_noForceDataFields + k]);
            }
            fprintf(f_forces, "\n");
          }
          fclose(f_forces);
        }
 
        m_forceCounter = 0;
        m_lastForceOutputTimeStep = globalTimeStep;
      }
    }
  }
}

saveGradients()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveGradients	(	MString	name,
		MFloat **	gradients,
		MString *	gradientNames
	)

Author

Marian Albers

Definition at line 6784 of file fvstructuredsolver.cpp.

                                                                                                     {
  // Function to write the solution to file with iolibrary
 
  m_log << "writing gradients to file " << name << " ... " << endl;
 
  ParallelIoHdf5 pio(name, maia::parallel_io::PIO_APPEND, m_StructuredComm);
 
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  ParallelIo::size_type allCells[3];
  MInt noVars = 3 * 9;
  for(MInt i = 0; i < m_noBlocks; i++) {
    for(MInt j = 0; j < nDim; j++) {
      allCells[j] = m_grid->getBlockNoCells(i, j);
    }
    // create datasets for the io library
    stringstream path;
    path << i;
    MString blockPathStr = "block";
    blockPathStr += path.str();
 
    // create dataset and write
    for(MInt var = 0; var < noVars; var++) {
      if(!pio.hasDataset(gradientNames[var], blockPathStr)) {
        pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, gradientNames[var], nDim, allCells);
      } else {
        cout << "Dataset " << gradientNames[var] << " exists, not creating new" << endl;
      }
    }
  }
 
 
  stringstream path;
  path << m_blockId;
  MString blockPathStr = "block";
  blockPathStr += path.str();
 
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {0, 0, 0};
  ParallelIo::size_type ioGhost[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
  for(MInt dim = 0; dim < nDim; ++dim) {
    ioOffset[dim] = m_nOffsetCells[dim];
    ioSize[dim] = m_nActiveCells[dim];
  }
 
  for(MInt var = 0; var < noVars; var++) {
    pio.writeArray(&gradients[var][0], blockPathStr, gradientNames[var].c_str(), nDim, ioOffset, ioSize, ioGhost);
  }
}

saveInterpolatedPoints()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::saveInterpolatedPoints ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 89 of file fvstructuredsolver.h.

{};

saveNodalBoxes()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::saveNodalBoxes ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 90 of file fvstructuredsolver.h.

{};

savePartitions()

template<MInt nDim>

void FvStructuredSolver< nDim >::savePartitions

Author

: Pascal Meysonnat

Definition at line 5521 of file fvstructuredsolver.cpp.

                                              {
  // Function to write the solution to file with iolibrary
  stringstream fileName;
  ParallelIo::size_type noCells[3] = {0, 0, 0};
 
  fileName << m_solutionOutput << "partitioned" << globalTimeStep << m_outputFormat;
  ParallelIoHdf5 pio(fileName.str(), maia::parallel_io::PIO_REPLACE, m_StructuredComm);
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  // save with ghostcells ==> multiple solvers;
  for(MInt i = 0; i < noDomains(); i++) {
    // create datasets for the io library
    for(MInt j = 0; j < nDim; j++) {
      noCells[j] = m_grid->getActivePoints(i, j) - 1 + 2 * m_noGhostLayers;
    }
    stringstream path;
    path << i;
    MString partitionPathStr = "block";
    partitionPathStr += path.str();
    const char* partitionPath = partitionPathStr.c_str();
    // create dataset for primitive/conservative variables
    for(MInt v = 0; v < m_maxNoVariables; v++) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, partitionPath, m_pvariableNames[v], nDim, noCells);
    }
    // create dataset for fq field variables
    for(MInt v = 0; v < FQ->noFQVariables; v++) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, partitionPath, FQ->fqNames[v], nDim, noCells);
    }
 
    if(m_stgIsActive) {
      ParallelIo::size_type allCells7909[3];
      allCells7909[0] = m_grid->getActivePoints(i, 0) - 1 + 2 * m_noGhostLayers;
      allCells7909[1] = m_grid->getActivePoints(i, 1) - 1 + 2 * m_noGhostLayers;
      allCells7909[2] = 3;
 
      for(MInt var = 0; var < m_stgNoVariables; var++) {
        stringstream fieldName;
        stringstream stgPath;
        stgPath << partitionPathStr << "/stg";
        fieldName << "stgFQ" << var;
        pio.defineArray(maia::parallel_io::PIO_FLOAT, stgPath.str(), fieldName.str(), nDim, allCells7909);
      }
    }
  }
 
  // write the values into the array so that we can visualize it
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {m_nCells[0], m_nCells[1], m_nCells[2]};
  stringstream path;
  path << domainId();
  MString partitionPathStr = "block";
  partitionPathStr += path.str();
 
  // write primitive variables
  for(MInt v = 0; v < m_maxNoVariables; ++v) {
    pio.writeArray(&m_cells->pvariables[v][0], partitionPathStr, m_pvariableNames[v], nDim, ioOffset, ioSize);
  }
 
  for(MInt v = 0; v < FQ->noFQVariables; v++) {
    pio.writeArray(&m_cells->fq[v][0], partitionPathStr, FQ->fqNames[v], nDim, ioOffset, ioSize);
  }
 
  if(m_stgIsActive) {
    ParallelIo::size_type bcOffset[3] = {0, 0, 0};
    ParallelIo::size_type bcCells[3] = {m_nCells[0], m_nCells[1], 3};
 
    for(MInt var = 0; var < m_stgNoVariables; var++) {
      stringstream fieldName;
      stringstream stgPath;
      stgPath << partitionPathStr << "/stg";
      fieldName << "stgFQ" << var;
      pio.writeArray(&m_cells->stg_fq[var][0], stgPath.str(), fieldName.str(), nDim, bcOffset, bcCells);
    }
  }
}

savePointsToAsciiFile()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::savePointsToAsciiFile ( MBool  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 87 of file fvstructuredsolver.h.

{};

saveProductionTerms()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveProductionTerms	(	MString	name,
		MFloat **	production
	)

Author

Marian Albers

Definition at line 6675 of file fvstructuredsolver.cpp.

                                                                                    {
  // Function to write the solution to file with iolibrary
 
  m_log << "writing production terms to file " << name << " ... " << endl;
 
  ParallelIoHdf5 pio(name, maia::parallel_io::PIO_APPEND, m_StructuredComm);
 
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  ParallelIo::size_type allCells[3];
  for(MInt i = 0; i < m_noBlocks; i++) {
    for(MInt j = 0; j < nDim; j++) {
      allCells[j] = m_grid->getBlockNoCells(i, j);
    }
    // create datasets for the io library
    stringstream path;
    path << i;
    MString blockPathStr = "block";
    blockPathStr += path.str();
 
    // create dataset and write
    if(!pio.hasDataset("p1j", blockPathStr)) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "p1j", nDim, allCells);
    } else {
      cout << "Dataset p1j exists, not creating new" << endl;
    }
    if(!pio.hasDataset("p2j", blockPathStr)) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "p2j", nDim, allCells);
    }
    if(!pio.hasDataset("p3j", blockPathStr)) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, "p3j", nDim, allCells);
    }
  }
 
  stringstream path;
  path << m_blockId;
  MString blockPathStr = "block";
  blockPathStr += path.str();
 
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {0, 0, 0};
  ParallelIo::size_type ioGhost[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
  for(MInt dim = 0; dim < nDim; ++dim) {
    ioOffset[dim] = m_nOffsetCells[dim];
    ioSize[dim] = m_nActiveCells[dim];
  }
 
  pio.writeArray(&production[0][0], blockPathStr, "p1j", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&production[1][0], blockPathStr, "p2j", nDim, ioOffset, ioSize, ioGhost);
  pio.writeArray(&production[2][0], blockPathStr, "p3j", nDim, ioOffset, ioSize, ioGhost);
}

saveSolution()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveSolution

(

MBool

forceOutput

)

Author

Pascal S. Meysonnat

Date

17.08.2018

Definition at line 5211 of file fvstructuredsolver.cpp.

                                                             {
  stringstream fileName;
  fileName << m_solutionOutput << m_outputIterationNumber << m_outputFormat;
 
  if(m_movingGrid) {
    if(m_movingGridSaveGrid) {
      m_grid->writeGrid(m_solutionOutput, m_outputFormat);
    }
  }
 
  m_log << "writing Solution file " << fileName.str() << " ... forceOutput: " << forceOutput << endl;
 
  // Check if file exists
  MInt fileMode = -1;
  // if (FILE *file = fopen((fileName.str()).c_str(), "r")) { // file does exist
  //   fclose(file);
  //   fileMode = maia::parallel_io::PIO_APPEND;
  // } else { // file does not exist
  fileMode = maia::parallel_io::PIO_REPLACE;
  //}
 
  ParallelIoHdf5 pio(fileName.str(), fileMode, m_StructuredComm);
 
  writeHeaderAttributes(&pio, "solution");
  writePropertiesAsAttributes(&pio, "");
 
  ParallelIo::size_type allCells[3] = {0, 0, 0};
  ParallelIo::size_type stgNoEddieFields = 1200;
  MString stgGlobalPathStr = "stgGlobal";
 
  for(MInt i = 0; i < m_noBlocks; i++) {
    for(MInt j = 0; j < nDim; j++) {
      allCells[j] = m_grid->getBlockNoCells(i, j);
    }
    // create datasets for the io library
    stringstream path;
    path << i;
    MString blockPathStr = "block";
    blockPathStr += path.str();
    const char* blockPath = blockPathStr.c_str();
 
    m_log << "writing primitive Output" << endl;
    for(MInt v = 0; v < m_maxNoVariables; v++) {
      pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, m_pvariableNames[v], nDim, allCells);
    }
 
    if(FQ->noFQVariables > 0) {
      for(MInt v = 0; v < FQ->noFQVariables; ++v) {
        if(FQ->fqWriteOutput[v]) {
          pio.defineArray(maia::parallel_io::PIO_FLOAT, blockPathStr, FQ->fqNames[v], nDim, allCells);
        }
      }
    }
 
    if(m_bc2600IsActive) {
      ParallelIo::size_type allCells2600[3] = {allCells[0], allCells[1], allCells[2]};
      allCells2600[nDim - 1] = m_noGhostLayers;
      stringstream path2600Str;
      path2600Str << blockPath << "/bc2600";
      std::string path2600 = path2600Str.str();
 
      for(MInt var = 0; var < m_maxNoVariables; var++) {
        pio.defineArray(maia::parallel_io::PIO_FLOAT, path2600, m_pvariableNames[var], nDim, allCells2600);
      }
    }
 
    // ////////////////////////////////////////////////
    // ///////// Create BC2601 Information ////////////
    // ////////////////////////////////////////////////
    if(m_bc2601IsActive) {
      ParallelIo::size_type allCells2601[3] = {allCells[0], allCells[1], allCells[2]};
      allCells2601[nDim - 2] = m_noGhostLayers;
      stringstream path2601Str;
      path2601Str << blockPath << "/bc2601";
      std::string path2601 = path2601Str.str();
 
      for(MInt var = 0; var < m_maxNoVariables; var++) {
        pio.defineArray(maia::parallel_io::PIO_FLOAT, path2601, m_pvariableNames[var], nDim, allCells2601);
      }
    }
 
    if(m_stgIsActive) {
      ParallelIo::size_type allCells7909[3];
      allCells7909[0] = allCells[0];
      allCells7909[1] = allCells[1];
      allCells7909[2] = 3;
      for(MInt var = 0; var < m_stgNoVariables; var++) {
        stringstream stgPath;
        stgPath << blockPathStr << "/stg";
        stringstream fieldName;
        fieldName << "stgFQ" << var;
        pio.defineArray(maia::parallel_io::PIO_FLOAT, stgPath.str(), fieldName.str(), nDim, allCells7909);
      }
    }
  }
 
  if(m_useSandpaperTrip) {
    stringstream tripPath;
    tripPath << "/trip";
    ParallelIo::size_type dataSize = m_tripNoTrips * 2 * m_tripNoModes;
 
    pio.defineArray(maia::parallel_io::PIO_FLOAT, tripPath.str(), "tripModesG", 1, &dataSize);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, tripPath.str(), "tripModesH1", 1, &dataSize);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, tripPath.str(), "tripModesH2", 1, &dataSize);
  }
 
  if(m_stgIsActive) {
    stgNoEddieFields = MInt(m_stgNoEddieProperties * m_stgMaxNoEddies);
    pio.defineArray(maia::parallel_io::PIO_FLOAT, stgGlobalPathStr, "FQeddies", 1, &stgNoEddieFields);
  }
 
  stringstream path;
  path << m_blockId;
  MString blockPathStr = "block";
  blockPathStr += path.str();
  // write out the data
  ParallelIo::size_type ioOffset[3] = {0, 0, 0};
  ParallelIo::size_type ioSize[3] = {0, 0, 0};
  ParallelIo::size_type ioGhost[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
  for(MInt dim = 0; dim < nDim; ++dim) {
    ioOffset[dim] = m_nOffsetCells[dim];
    ioSize[dim] = m_nActiveCells[dim];
  }
 
  for(MInt v = 0; v < m_maxNoVariables; ++v) {
    pio.writeArray(&(m_cells->pvariables[v][0]), blockPathStr, m_pvariableNames[v], nDim, ioOffset, ioSize, ioGhost);
  }
 
  if(FQ->noFQVariables > 0) {
    for(MInt v = 0; v < FQ->noFQVariables; ++v) {
      if(FQ->fqWriteOutput[v]) {
        pio.writeArray(&m_cells->fq[v][0], blockPathStr, FQ->fqNames[v], nDim, ioOffset, ioSize, ioGhost);
      }
    }
  }
 
 
  if(m_bc2600IsActive) {
    stringstream path2600Str;
    path2600Str << blockPathStr << "/bc2600";
    std::string path2600 = path2600Str.str();
 
    ParallelIo::size_type ioSize2600[3] = {0, 0, 0};
    ParallelIo::size_type ioOffset2600[3] = {0, 0, 0};
    ParallelIo::size_type ioGhost2600[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
    for(MInt dim = 0; dim < nDim; ++dim) {
      ioSize2600[dim] = m_bc2600noActiveCells[dim];
      ioOffset2600[dim] = m_bc2600noOffsetCells[dim];
    }
 
    ioGhost2600[nDim - 1] = 0;
    if(m_bc2600) {
      for(MInt var = 0; var < m_maxNoVariables; var++) {
        pio.writeArray(&m_bc2600Variables[var][0], path2600, m_pvariableNames[var], nDim, ioOffset2600, ioSize2600,
                       ioGhost2600);
      }
    } else {
      MFloat empty = 0;
      for(MInt var = 0; var < m_maxNoVariables; var++) {
        pio.writeArray(&empty, path2600, m_pvariableNames[var], nDim, ioOffset2600, ioSize2600, ioGhost2600);
      }
    }
  }
 
  if(m_bc2601IsActive) {
    stringstream path2601Str;
    path2601Str << blockPathStr << "/bc2601";
    std::string path2601 = path2601Str.str();
 
    ParallelIo::size_type ioSize2601[3] = {0, 0, 0};
    ParallelIo::size_type ioOffset2601[3] = {0, 0, 0};
    ParallelIo::size_type ioGhost2601[3] = {m_noGhostLayers, m_noGhostLayers, m_noGhostLayers};
    for(MInt dim = 0; dim < nDim; ++dim) {
      ioSize2601[dim] = m_bc2601noActiveCells[dim];
      ioOffset2601[dim] = m_bc2601noOffsetCells[dim];
    }
 
    ioGhost2601[nDim - 2] = 0;
    if(m_bc2601) {
      for(MInt var = 0; var < m_maxNoVariables; var++) {
        pio.writeArray(&m_bc2601Variables[var][0], path2601, m_pvariableNames[var], nDim, ioOffset2601, ioSize2601,
                       ioGhost2601);
      }
    } else {
      MFloat empty = 0;
      for(MInt var = 0; var < m_maxNoVariables; var++) {
        pio.writeArray(&empty, path2601, m_pvariableNames[var], nDim, ioOffset2601, ioSize2601, ioGhost2601);
      }
    }
  }
 
  if(m_stgIsActive) {
    ParallelIo::size_type VBOffset = 0;
    if(m_stgRootRank) {
      pio.writeArray(&m_stgEddies[0][0], stgGlobalPathStr, "FQeddies", 1, &VBOffset, &stgNoEddieFields);
    } else {
      stgNoEddieFields = 0;
      MFloat empty = 0;
      pio.writeArray(&empty, stgGlobalPathStr, "FQeddies", 1, &VBOffset, &stgNoEddieFields);
    }
 
    // if this domain has part of the STG bc write value, otherwise only write nullptr
    if(m_stgLocal) {
      MInt noActiveStgCells = (m_stgBoxSize[0] - 2 * m_noGhostLayers) * (m_stgBoxSize[1] - 2 * m_noGhostLayers) * 3;
      MFloatScratchSpace stgFqDummy(m_stgNoVariables, noActiveStgCells, AT_, "stgFqDummy");
 
      for(MInt var = 0; var < m_stgNoVariables; var++) {
        for(MInt k = m_noGhostLayers; k < m_stgBoxSize[0] - m_noGhostLayers; k++) {
          for(MInt j = m_noGhostLayers; j < m_stgBoxSize[1] - m_noGhostLayers; j++) {
            for(MInt i = 0; i < m_stgBoxSize[2]; i++) {
              MInt cellIdBC = i + (j + k * m_stgBoxSize[1]) * 3;
              MInt cellIdDummy =
                  i + ((j - m_noGhostLayers) + (k - m_noGhostLayers) * (m_stgBoxSize[1] - 2 * m_noGhostLayers)) * 3;
              stgFqDummy(var, cellIdDummy) = m_cells->stg_fq[var][cellIdBC];
            }
          }
        }
      }
 
      ParallelIo::size_type bcOffset[3] = {m_nOffsetCells[0], m_nOffsetCells[1], 0};
      ParallelIo::size_type bcCells[3] = {m_stgBoxSize[0] - 2 * m_noGhostLayers, m_stgBoxSize[1] - 2 * m_noGhostLayers,
                                          m_stgBoxSize[2]};
 
      for(MInt var = 0; var < m_stgNoVariables; var++) {
        stringstream fieldName;
        stringstream stgPath;
        stgPath << blockPathStr << "/stg";
        fieldName << "stgFQ" << var;
        pio.writeArray(&stgFqDummy(var, 0), stgPath.str(), fieldName.str(), nDim, bcOffset, bcCells);
      }
    } else {
      ParallelIo::size_type bcOffset[3] = {0, 0, 0};
      ParallelIo::size_type bcCells[3] = {0, 0, 0};
      MFloat empty = 0;
 
      for(MInt var = 0; var < m_stgNoVariables; var++) {
        stringstream fieldName;
        stringstream stgPath;
        stgPath << blockPathStr << "/stg";
        fieldName << "stgFQ" << var;
        pio.writeArray(&empty, stgPath.str(), fieldName.str(), nDim, bcOffset, bcCells);
      }
    }
  }
 
  if(m_useSandpaperTrip) {
    stringstream tripPath;
    tripPath << "trip";
 
    if(domainId() == 0) {
      ParallelIo::size_type offset = 0;
      ParallelIo::size_type dataSize = m_tripNoTrips * m_tripNoModes * 2;
 
      pio.writeArray(m_tripModesG, tripPath.str(), "tripModesG", 1, &offset, &dataSize);
      pio.writeArray(m_tripModesH1, tripPath.str(), "tripModesH1", 1, &offset, &dataSize);
      pio.writeArray(m_tripModesH2, tripPath.str(), "tripModesH2", 1, &offset, &dataSize);
    } else {
      ParallelIo::size_type offset = 0;
      ParallelIo::size_type dataSize = 0;
      MFloat empty = 0;
      pio.writeArray(&empty, tripPath.str(), "tripModesG", 1, &offset, &dataSize);
      pio.writeArray(&empty, tripPath.str(), "tripModesH1", 1, &offset, &dataSize);
      pio.writeArray(&empty, tripPath.str(), "tripModesH2", 1, &offset, &dataSize);
    }
  }
 
  m_log << "...-> OK " << endl;
}

saveSolverSolution()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveSolverSolution ( MBool  forceOutput = false, const MBool  finalTimeStep = false  )

override

Author

Pascal S. Meysonnat

Date

03.03.2016

Definition at line 5073 of file fvstructuredsolver.cpp.

                                                                                              {
  RECORD_TIMER_START(m_timers[Timers::Run]);
  RECORD_TIMER_START(m_timers[Timers::SaveOutput]);
 
  // run postprocessing in-solve routines
  this->postprocessInSolve();
 
  // Function to write the solution to file with iolibrary
  MBool writeSolution = false;
  MBool writeBox = false;
  MBool writeNodalBox = false;
  MBool writeIntpPoints = false;
  MBool writeAux = false;
  MBool computeForces = false;
  MBool writeForces = false;
  MBool computeAsciiCells = false;
  MBool writeAsciiCells = false;
 
  // first find out which writeOut-mode we use (iteration or convective unit intervals)
  // then check which functions should write out in this timestep
  if(m_useConvectiveUnitWrite) {
    // in this mode we check the convective unit intervals
    // and write out files of each type if activated
    // activation is done by setting the interval
    // to a value greater than 0 (boxOutputInterval = 1)
    if(m_physicalTime - (MFloat)(m_noConvectiveOutputs)*m_convectiveUnitInterval >= m_convectiveUnitInterval) {
      // restart file output is still triggered by iteration counter
      writeSolution = isInInterval(m_solutionInterval);
      forceOutput = writeSolution;
 
      // activate the desired outputs
      writeSolution = m_sampleSolutionFiles;
      writeBox = (m_boxOutputInterval > 0);
      writeNodalBox = (m_nodalBoxOutputInterval > 0);
      writeIntpPoints = (m_intpPointsOutputInterval > 0);
      writeAux = (m_forceOutputInterval > 0);
      computeForces = (m_forceAsciiComputeInterval > 0);
 
      m_noConvectiveOutputs++;
      m_outputIterationNumber = m_noConvectiveOutputs;
    }
  } else {
    // in this mode we check the iteration intervals
    // for each writeOut-type (solution, box, line, aux)
    writeSolution = isInInterval(m_solutionInterval);
    writeBox = isInInterval(m_boxOutputInterval);
    writeNodalBox = isInInterval(m_nodalBoxOutputInterval);
    writeIntpPoints = isInInterval(m_intpPointsOutputInterval);
    writeAux = isInInterval(m_forceOutputInterval);
    computeForces = isInInterval(m_forceAsciiComputeInterval);
    computeAsciiCells = isInInterval(m_pointsToAsciiComputeInterval);
    if(writeSolution || finalTimeStep) {
      writeForces = true;
      writeAsciiCells = true;
    }
 
 
    m_outputIterationNumber = globalTimeStep;
  }
 
  // compute vorticity if necessary
  if(m_vorticityOutput && (writeSolution || writeBox || forceOutput)) {
    computeVorticity();
  }
 
  // compute velocity if wanted
  if(m_computeLambda2 && (writeSolution || writeBox || forceOutput)) {
    computeLambda2Criterion();
  }
 
  // boxes, auxdata and lines
  // are only available for 3D checked by function pointer
 
  RECORD_TIMER_START(m_timers[Timers::SaveBoxes]);
  if(writeBox) {
    saveBoxes();
  }
  if(writeNodalBox) {
    saveNodalBoxes();
  }
  RECORD_TIMER_STOP(m_timers[Timers::SaveBoxes]);
 
  RECORD_TIMER_START(m_timers[Timers::SaveAuxdata]);
  if(writeAux) {
    saveAuxData();
  }
  RECORD_TIMER_STOP(m_timers[Timers::SaveAuxdata]);
  RECORD_TIMER_START(m_timers[Timers::SaveForces]);
  if(computeForces) {
    saveForcesToAsciiFile(writeForces);
  }
 
  if(computeAsciiCells) {
    savePointsToAsciiFile(writeAsciiCells);
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::SaveForces]);
  IF_CONSTEXPR(nDim > 2) { // needs also to be implemented for 2d !!!!!!!!!!!!!!
    RECORD_TIMER_START(m_timers[Timers::SaveIntpPoints]);
    if(writeIntpPoints) {
      saveInterpolatedPoints();
    }
    RECORD_TIMER_STOP(m_timers[Timers::SaveIntpPoints]);
  }
 
  if(writeSolution || forceOutput || finalTimeStep) {
    RECORD_TIMER_START(m_timers[Timers::SaveSolution]);
    // save out the partitions also if desired, i.e, for debugging purposses
    if(m_savePartitionOutput) {
      savePartitions();
    }
    // save postprocessing variables if activated
    saveAverageRestart();
    // save solution/restart file
    saveSolution(forceOutput);
    m_lastOutputTimeStep = globalTimeStep;
    RECORD_TIMER_STOP(m_timers[Timers::SaveSolution]);
  }
  RECORD_TIMER_STOP(m_timers[Timers::SaveOutput]);
  RECORD_TIMER_STOP(m_timers[Timers::Run]);
}

saveVarToPrimitive()

template<MInt nDim>

void FvStructuredSolver< nDim >::saveVarToPrimitive	(	MInt	cellId,
		MInt	varId,
		MFloat	var
	)

Definition at line 4468 of file fvstructuredsolver.cpp.

                                                                                     {
  m_cells->pvariables[varId][cellId] = var;
}

scatter()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::scatter ( const  MBool, std::vector< std::unique_ptr< StructuredComm< nDim > > > &    )

inlinevirtual

Definition at line 194 of file fvstructuredsolver.h.

{};

send()

template<MInt nDim>

void FvStructuredSolver< nDim >::send	(	const MBool	periodicExchange,
		std::vector< std::unique_ptr< StructuredComm< nDim > > > &	sndComm,
		std::vector< MPI_Request > &	sndRequests
	)

Definition at line 8158 of file fvstructuredsolver.cpp.

                                                                         {
  for(auto& snd : sndComm) {
    if(periodicExchange && skipPeriodicDirection(snd)) continue;
 
    MPI_Request request{};
    const MInt tag = domainId() + (snd->tagHelper) * noDomains();
    const MInt err = MPI_Isend((void*)&snd->cellBuffer[0], snd->cellBufferSize, MPI_DOUBLE, snd->nghbrId, tag,
                               m_StructuredComm, &request, AT_, "snd->cellBuffer");
    sndRequests.push_back(request);
    if(err) cout << "rank " << domainId() << " sending throws error " << endl;
  }
}

setBodyForceProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setBodyForceProperties

Definition at line 2574 of file fvstructuredsolver.cpp.

setInputOutputProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setInputOutputProperties

Definition at line 363 of file fvstructuredsolver.cpp.

setLimiterVisc()

template<MInt nDim>

void FvStructuredSolver< nDim >::setLimiterVisc

Definition at line 7069 of file fvstructuredsolver.cpp.

                                              {
  TRACE();
 
  if(m_limiterVisc) {
    // NOTE: currently only implemented in 2D
    ASSERT(nDim == 2, "Not implemented for 3D yet!");
    // xsd = 0, ysd = 1
 
    for(MInt cellId = 0; cellId < m_noCells; cellId++) {
      const MFloat metricScale =
          POW2(m_cells->cellMetrics[0 * 2 + 0][cellId]) + POW2(m_cells->cellMetrics[0 * 2 + 1][cellId])
          + POW2(m_cells->cellMetrics[1 * 2 + 0][cellId]) + POW2(m_cells->cellMetrics[1 * 2 + 1][cellId])
          + 2.0
                * (m_cells->cellMetrics[0 * 2 + 0][cellId] * m_cells->cellMetrics[1 * 2 + 0][cellId]
                   + m_cells->cellMetrics[0 * 2 + 1][cellId] * m_cells->cellMetrics[1 * 2 + 1][cellId]);
      // TODO_SS labels:FV,totest with localTimeStepping m_physicalTimeStep might not be set properly
      // TODO_SS labels:FV in some cases if Jacobian is negative the time step can also get negative -> think if current
      // implementation
      //       would also work in those cases
      m_cells->fq[FQ->LIMITERVISC][cellId] =
          m_CFLVISC * POW2(m_cells->cellJac[cellId]) / (m_physicalTimeStep * metricScale);
    }
  }
}

setMovingGridProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setMovingGridProperties

Definition at line 2439 of file fvstructuredsolver.cpp.

setNumericalProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setNumericalProperties

Definition at line 2704 of file fvstructuredsolver.cpp.

setPorousProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setPorousProperties

Date

2020-03-19

Definition at line 2953 of file fvstructuredsolver.cpp.

setProfileBCProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setProfileBCProperties

Definition at line 4052 of file fvstructuredsolver.cpp.

setPV()

template<MInt nDim>

void FvStructuredSolver< nDim >::setPV ( MInt  var, MInt  cellId, MFloat  value  )

inline

Definition at line 238 of file fvstructuredsolver.h.

{ m_cells->pvariables[var][cellId] = value; }

setRungeKuttaProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setRungeKuttaProperties

Author

Pascal S. Meysonnat (see FV-> Gonzalo G-B)

Date

July, 2013

Allocate and initialize Runge-Kutta coefficients:

Definition at line 3528 of file fvstructuredsolver.cpp.

setSamplingProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setSamplingProperties

(

)

setSTGProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setSTGProperties

Definition at line 3635 of file fvstructuredsolver.cpp.

setTestcaseProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setTestcaseProperties

Author

Pascal Meysonnat

Definition at line 1909 of file fvstructuredsolver.cpp.

setTimeStep()

template<MInt nDim>

void FvStructuredSolver< nDim >::setTimeStep

virtual

Reimplemented from Solver.

Definition at line 7051 of file fvstructuredsolver.cpp.

                                           {
  TRACE();
  if(m_travelingWave || m_streamwiseTravelingWave) return;
 
  if((!m_constantTimeStep && globalTimeStep % m_timeStepComputationInterval == 0) || globalTimeStep == 0) {
    computeTimeStep();
    if(noDomains() > 1) {
      exchangeTimeStep();
    }
 
    m_physicalTimeStep = m_timeStep * m_timeRef;
 
    setLimiterVisc();
  }
}

setVolumeForce()

template<MInt nDim>

void FvStructuredSolver< nDim >::setVolumeForce

Definition at line 4474 of file fvstructuredsolver.cpp.

                                              {
  TRACE();
 
  switch(m_volumeForceMethod) {
    case 0:
      // default
      break;
    case 1:
      // To be used in combination with bc2402
      if(globalTimeStep % m_volumeForceUpdateInterval == 0 && m_RKStep == 0) {
        const MFloat relaxationFactor = 0.02;
        MPI_Allreduce(MPI_IN_PLACE, &m_inflowVelAvg, 1, MPI_DOUBLE, MPI_MAX, m_StructuredComm, AT_, "MPI_IN_PLACE",
                      "inflowVelAvg");
        m_log << "GlobalTimeStep=" << globalTimeStep << setprecision(6)
              << ": inflowVelAvg(targetVelAvg)=" << m_inflowVelAvg << "(" << PV->UInfinity
              << "), volumeForce=" << m_volumeForce[0] << " -> ";
        const MFloat deltaVelAvg = PV->UInfinity - m_inflowVelAvg;
        m_volumeForce[0] += deltaVelAvg / (m_volumeForceUpdateInterval * m_timeStep) * relaxationFactor;
        m_volumeForce[0] = std::max(m_volumeForce[0], 0.0);
        m_log << setprecision(6) << m_volumeForce[0] << endl;
        m_inflowVelAvg = -1.0;
      }
      break;
    default:
      mTerm(1, "Unknown volume force method!");
  }
}

setZonalProperties()

template<MInt nDim>

void FvStructuredSolver< nDim >::setZonalProperties

Date

Jan, 2015

Definition at line 4163 of file fvstructuredsolver.cpp.

shiftCellValuesRestart()

template<MInt nDim>

void FvStructuredSolver< nDim >::shiftCellValuesRestart

(

MBool

)

skipPeriodicDirection()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::skipPeriodicDirection

(

std::unique_ptr< StructuredComm< nDim > > &

comm

)

Definition at line 8191 of file fvstructuredsolver.cpp.

                                                                                            {
  const MInt currentDirection = (comm->bcId - 4401) / 2;
  return ((MBool)(m_currentPeriodicDirection - currentDirection));
}

solutionStep()

template<MInt nDim>

MBool FvStructuredSolver< nDim >::solutionStep

overridevirtual

Reimplemented from Solver.

Definition at line 8268 of file fvstructuredsolver.cpp.

                                             {
  RECORD_TIMER_START(m_timers[Timers::Run]);
  RECORD_TIMER_START(m_timers[Timers::MainLoop]);
  rhs();
 
  rhsBnd();
 
  RECORD_TIMER_START(m_timers[Timers::RungeKutta]);
  const MBool step = rungeKuttaStep();
  RECORD_TIMER_STOP(m_timers[Timers::RungeKutta]);
 
  RECORD_TIMER_START(m_timers[Timers::SetTimeStep]);
  if(step) setTimeStep();
  RECORD_TIMER_STOP(m_timers[Timers::SetTimeStep]);
 
  lhsBnd();
 
  RECORD_TIMER_STOP(m_timers[Timers::MainLoop]);
  RECORD_TIMER_STOP(m_timers[Timers::Run]);
  return step;
}

spanwiseAvgZonal()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::spanwiseAvgZonal ( std::vector< MFloat * > &  )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 199 of file fvstructuredsolver.h.

{};

spanwiseWaveReorder()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::spanwiseWaveReorder ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 202 of file fvstructuredsolver.h.

{};

time()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::time ( ) const

inlineoverridevirtual

Implements Solver.

Definition at line 274 of file fvstructuredsolver.h.

{ return m_time; }

timer()

template<MInt nDim>

MInt FvStructuredSolver< nDim >::timer

(

const MInt

timerId

)

const

Definition at line 3071 of file fvstructuredsolver.cpp.

                                                             {
  TRACE();
 
  // Abort if timers not initialized
  if(!m_isInitTimers) {
    TERMM(1, "Timers were not initialized.");
  }
 
  return m_timers[timerId];
}

totalEnergy_twoEqRans()

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::totalEnergy_twoEqRans ( MInt  cellId ) const

inline

Definition at line 162 of file fvstructuredsolver.h.

                                                  {
    return mMax(m_cells->pvariables[PV->RANS_VAR[0]][cellId], F0) * m_cells->pvariables[PV->RHO][cellId];
  }

tqli2()

template<MInt nDim>

void FvStructuredSolver< nDim >::tqli2	(	MFloat *	diag,
		MFloat *	offdiag,
		MInt	dim
	)

QL algorithm with implicit shifts, to determine the eigenvalues of a real symmetric matrix previously reduced by tred2. diag is a vector of length np. On input, its first n elements are the diagonal elements of the tridiagonal matrix. On output, it returns the eigenvalues. The vector offdiag inputs the subdiagonal elements of the tridiagonal matrix, with offidag(0) arbitrary. On output offdiag is destroyed.

Definition at line 6934 of file fvstructuredsolver.cpp.

{
  const MFloat eps = numeric_limits<MFloat>::epsilon();
  MInt m, l, iter, i, k;
  MFloat s, r, p, g, f, dd, c, b;
  MInt n = dim;
  for(i = 1; i < n; ++i)
    offdiag[i - 1] = offdiag[i];
  offdiag[n - 1] = 0.0;
  for(l = 0; l < n; ++l) {
    iter = 0;
    do {
      for(m = l; m < n - 1; m++) {
        dd = fabs(diag[m]) + fabs(diag[m + 1]);
        if(fabs(offdiag[m]) <= eps * dd) break;
      }
      if(m != l) {
        if(iter++ == 30) {
          for(k = 0; k < dim; ++k) {
            diag[k] = F0;
          }
          return;
        }
        g = (diag[l + 1] - diag[l]) / (2.0 * offdiag[l]);
        r = pythag(g, F1);
        r = abs(r);
        if(g < F0) r *= -F1;
        g = diag[m] - diag[l] + offdiag[l] / (g + r);
        s = c = F1;
        p = F0;
        for(i = m - 1; i >= l; i--) {
          f = s * offdiag[i];
          b = c * offdiag[i];
          offdiag[i + 1] = (r = pythag(f, g));
          if(approx(r, F0, eps)) {
            diag[i + 1] -= p;
            offdiag[m] = F0;
            break;
          }
          s = f / r;
          c = g / r;
          g = diag[i + 1] - p;
          r = (diag[i] - g) * s + 2.0 * c * b;
          diag[i + 1] = g + (p = s * r);
          g = c * r - b;
        }
        if(approx(r, F0, eps) && i >= l) continue;
        diag[l] -= p;
        offdiag[l] = g;
        offdiag[m] = F0;
      }
    } while(m != l);
  }
}

tred2()

template<MInt nDim>

void FvStructuredSolver< nDim >::tred2	(	MFloatScratchSpace &	A,
		MInt	dim,
		MFloat *	diag,
		MFloat *	offdiag
	)

Householder reduction of a real, symmetric matrix A. On output A is replaced by the orthogonla matrix Q (omitted here) diag returns the diagonla elements of the tridiagonal matrix offdiag the off-diagonal elements with offdiag[1]=0;

Definition at line 6859 of file fvstructuredsolver.cpp.

                                                                                                   {
  // formulation from book pp. 582
  MInt n = dim;
  MInt l = 0, k = 0, j = 0, i = 0;
  MFloat scale = F0, hh = F0, h = F0, g = F0, f = F0;
 
  for(i = dim - 1; i > 0; i--) {
    l = i - 1;
    h = F0;
    scale = F0;
    if(l > 0) {
      for(k = 0; k < i; ++k) {
        scale += abs(A(i, k));
      }
      if(approx(scale, F0, m_eps)) {
        offdiag[i] = A(i, l);
      } else {
        for(k = 0; k < i; ++k) {
          A(i, k) /= scale;
          h += A(i, k) * A(i, k);
        }
        f = A(i, l);
        g = (f >= F0 ? -sqrt(h) : sqrt(h));
        offdiag[i] = scale * g;
        h -= f * g;
        A(i, l) = f - g;
        f = F0;
        for(j = 0; j < i; ++j) {
          g = F0;
          for(k = 0; k < j + 1; ++k) {
            g += A(j, k) * A(i, k);
          }
          for(k = j + 1; k < i; ++k) {
            g += A(k, j) * A(i, k);
          }
          offdiag[j] = g / h;
          f += offdiag[j] * A(i, j);
        }
        hh = f / (h + h);
        for(j = 0; j < i; j++) {
          f = A(i, j);
          g = offdiag[j] - hh * f;
          offdiag[j] = g;
          for(k = 0; k < j + 1; k++) {
            A(j, k) -= f * offdiag[k] + g * A(i, k);
          }
        }
      }
    } else {
      offdiag[i] = A(i, l);
    }
    diag[i] = h;
  }
 
  offdiag[0] = F0;
  for(i = 0; i < n; ++i) {
    diag[i] = A(i, i);
  }
}

updateSpongeLayer()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::updateSpongeLayer ( )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

viscousFlux()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::viscousFlux ( )

pure virtual

Implemented in FvStructuredSolver2D, and FvStructuredSolver3D.

waveExchange()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::waveExchange ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 201 of file fvstructuredsolver.h.

{};

writeHeaderAttributes()

template<MInt nDim>

void FvStructuredSolver< nDim >::writeHeaderAttributes ( ParallelIoHdf5 *  pio, MString  fileType  )

virtual

Definition at line 5007 of file fvstructuredsolver.cpp.

                                                                                          {
  stringstream gridFileName;
  MString gridNameStr = "";
  if(m_movingGrid && m_movingGridSaveGrid) {
    gridFileName << "grid" << globalTimeStep << m_outputFormat;
    gridNameStr = gridFileName.str();
  } else {
    gridNameStr = "../" + m_grid->m_gridInputFileName;
  }
 
  pio->setAttribute(gridNameStr, "gridFile", "");
  pio->setAttribute(m_grid->m_uID, "UID", "");
  pio->setAttribute(fileType, "filetype", "");
 
  const MInt zonal = (MInt)m_zonal;
  pio->setAttribute(zonal, "zonal", "");
  pio->setAttribute(m_noBlocks, "noBlocks", "");
}

writePropertiesAsAttributes()

template<MInt nDim>

void FvStructuredSolver< nDim >::writePropertiesAsAttributes ( ParallelIoHdf5 *  pio, MString  path  )

virtual

Definition at line 5033 of file fvstructuredsolver.cpp.

                                                                                            {
  pio->setAttribute(m_Ma, "Ma", path);
  pio->setAttribute(m_Re, "Re", path);
  pio->setAttribute(m_Pr, "Pr", path);
  pio->setAttribute(m_timeStep, "timeStep", path);
  pio->setAttribute(m_time, "time", path);
  pio->setAttribute(m_physicalTimeStep, "physicalTimeStep", path);
  pio->setAttribute(m_physicalTime, "physicalTime", path);
  pio->setAttribute(globalTimeStep, "globalTimeStep", path);
  pio->setAttribute(m_firstMaxResidual, "firstMaxResidual", path);
  pio->setAttribute(m_firstAvrgResidual, "firstAvrgResidual", path);
 
  // save the time(Step) at which the grid motion started
  // does only work safely for constant time step
  if(m_movingGrid) {
    pio->setAttribute(m_movingGridStepOffset, "movingGridStepOffset", path);
    pio->setAttribute(m_movingGridTimeOffset, "movingGridTimeOffset", path);
    // save whether or not the wave time step has been computed
    if(m_travelingWave || m_streamwiseTravelingWave) {
      pio->setAttribute(m_waveTimeStepComputed, "waveTimeStepComputed", path);
      pio->setAttribute(m_waveNoStepsPerCell, "waveNoStepsPerCell", path);
    }
  }
 
  if(m_stgIsActive) {
    pio->setAttribute(m_stgMaxNoEddies, "stgNRAN", path);
  }
 
  if(m_volumeForceMethod != 0) {
    pio->setAttribute(m_volumeForce[0], "volumeForce", path);
  }
}

writeRestartFile() [1/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::writeRestartFile ( const  MBool, const  MBool, const  MString, MInt *    )

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 95 of file fvstructuredsolver.h.

{};

writeRestartFile() [2/2]

template<MInt nDim>

void FvStructuredSolver< nDim >::writeRestartFile ( MBool  )

inlineoverridevirtual

Reimplemented from Solver.

Definition at line 94 of file fvstructuredsolver.h.

{};

zonalExchange()

template<MInt nDim>

virtual void FvStructuredSolver< nDim >::zonalExchange ( )

inlinevirtual

Reimplemented in FvStructuredSolver3D.

Definition at line 198 of file fvstructuredsolver.h.

{};

Friends And Related Function Documentation

AccesorStructured

template<MInt nDim>

template<class SolverType >

friend class AccesorStructured

friend

Definition at line 49 of file fvstructuredsolver.h.

FvStructuredSolver2DRans

template<MInt nDim>

friend class FvStructuredSolver2DRans

friend

Definition at line 47 of file fvstructuredsolver.h.

FvStructuredSolver3DRans

template<MInt nDim>

friend class FvStructuredSolver3DRans

friend

Definition at line 46 of file fvstructuredsolver.h.

StructuredBndryCnd

template<MInt nDim>

template<MInt nDim_>

friend class StructuredBndryCnd

friend

Definition at line 43 of file fvstructuredsolver.h.

StructuredInterpolation

template<MInt nDim>

template<MInt nDim_>

friend class StructuredInterpolation

friend

Definition at line 45 of file fvstructuredsolver.h.

Member Data Documentation

CV

template<MInt nDim>

std::unique_ptr<MConservativeVariables<nDim> > FvStructuredSolver< nDim >::CV

protected

Definition at line 332 of file fvstructuredsolver.h.

FQ

template<MInt nDim>

std::unique_ptr<StructuredFQVariables> FvStructuredSolver< nDim >::FQ

protected

Definition at line 469 of file fvstructuredsolver.h.

m_adiabaticTemperature

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_adiabaticTemperature = nullptr

protected

Definition at line 831 of file fvstructuredsolver.h.

m_airfoilCoords

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_airfoilCoords = nullptr

protected

Definition at line 865 of file fvstructuredsolver.h.

m_airfoilNormalVec

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_airfoilNormalVec = nullptr

protected

Definition at line 866 of file fvstructuredsolver.h.

m_airfoilNoWallPoints

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_airfoilNoWallPoints

protected

Definition at line 867 of file fvstructuredsolver.h.

m_airfoilWallDist

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_airfoilWallDist = nullptr

protected

Definition at line 868 of file fvstructuredsolver.h.

m_angle

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_angle = nullptr

protected

Definition at line 447 of file fvstructuredsolver.h.

m_ausmScheme

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_ausmScheme

protected

Definition at line 690 of file fvstructuredsolver.h.

m_auxDataCoordinateLimits

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_auxDataCoordinateLimits

protected

Definition at line 489 of file fvstructuredsolver.h.

m_auxDataLimits

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_auxDataLimits = nullptr

protected

Definition at line 490 of file fvstructuredsolver.h.

m_auxOutputDir

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_auxOutputDir

protected

Definition at line 668 of file fvstructuredsolver.h.

m_avrgResidual

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_avrgResidual

protected

Definition at line 645 of file fvstructuredsolver.h.

m_bc2600

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bc2600

protected

Definition at line 780 of file fvstructuredsolver.h.

m_bc2600Face

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_bc2600Face

protected

Definition at line 785 of file fvstructuredsolver.h.

m_bc2600InitialStartup

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bc2600InitialStartup

protected

Definition at line 778 of file fvstructuredsolver.h.

m_bc2600IsActive

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bc2600IsActive

protected

Definition at line 777 of file fvstructuredsolver.h.

m_bc2600noActiveCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_bc2600noActiveCells = nullptr

protected

Definition at line 782 of file fvstructuredsolver.h.

m_bc2600noCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_bc2600noCells = nullptr

protected

Definition at line 781 of file fvstructuredsolver.h.

m_bc2600noOffsetCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_bc2600noOffsetCells = nullptr

protected

Definition at line 783 of file fvstructuredsolver.h.

m_bc2600RootRank

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_bc2600RootRank

protected

Definition at line 784 of file fvstructuredsolver.h.

m_bc2600Variables

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_bc2600Variables = nullptr

protected

Definition at line 779 of file fvstructuredsolver.h.

m_bc2601

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bc2601

protected

Definition at line 792 of file fvstructuredsolver.h.

m_bc2601GammaEpsilon

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_bc2601GammaEpsilon

protected

Definition at line 796 of file fvstructuredsolver.h.

m_bc2601InitialStartup

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bc2601InitialStartup

protected

Definition at line 789 of file fvstructuredsolver.h.

m_bc2601IsActive

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bc2601IsActive

protected

Definition at line 788 of file fvstructuredsolver.h.

m_bc2601noActiveCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_bc2601noActiveCells = nullptr

protected

Definition at line 794 of file fvstructuredsolver.h.

m_bc2601noCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_bc2601noCells = nullptr

protected

Definition at line 793 of file fvstructuredsolver.h.

m_bc2601noOffsetCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_bc2601noOffsetCells = nullptr

protected

Definition at line 795 of file fvstructuredsolver.h.

m_bc2601Variables

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_bc2601Variables = nullptr

protected

Definition at line 790 of file fvstructuredsolver.h.

m_bc2601ZerothOrderSolution

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_bc2601ZerothOrderSolution = nullptr

protected

Definition at line 791 of file fvstructuredsolver.h.

m_betaSponge

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_betaSponge = nullptr

protected

Definition at line 623 of file fvstructuredsolver.h.

m_bForce

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bForce

protected

Definition at line 472 of file fvstructuredsolver.h.

m_bForceLineAverage

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bForceLineAverage

protected

Definition at line 476 of file fvstructuredsolver.h.

m_blasius_dx0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_blasius_dx0

protected

Definition at line 905 of file fvstructuredsolver.h.

m_blasius_eta

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_blasius_eta

protected

Definition at line 899 of file fvstructuredsolver.h.

m_blasius_f

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_blasius_f

protected

Definition at line 900 of file fvstructuredsolver.h.

m_blasius_fp

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_blasius_fp

protected

Definition at line 901 of file fvstructuredsolver.h.

m_blasius_noPoints

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_blasius_noPoints

protected

Definition at line 902 of file fvstructuredsolver.h.

m_blasius_x0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_blasius_x0

protected

Definition at line 903 of file fvstructuredsolver.h.

m_blasius_y0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_blasius_y0

protected

Definition at line 904 of file fvstructuredsolver.h.

m_blockId

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_blockId

protected

Definition at line 674 of file fvstructuredsolver.h.

m_blockType

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_blockType

protected

Definition at line 872 of file fvstructuredsolver.h.

m_bndryCnd

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_bndryCnd = nullptr

protected

Definition at line 680 of file fvstructuredsolver.h.

m_bndryCndInfo

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_bndryCndInfo = nullptr

protected

Definition at line 679 of file fvstructuredsolver.h.

m_bodyForce

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bodyForce

protected

Definition at line 384 of file fvstructuredsolver.h.

m_bodyForceMethod

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_bodyForceMethod = 0

protected

Definition at line 383 of file fvstructuredsolver.h.

m_boxBlock

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_boxBlock = nullptr

protected

Definition at line 512 of file fvstructuredsolver.h.

m_boxNoBoxes

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_boxNoBoxes

protected

Definition at line 510 of file fvstructuredsolver.h.

m_boxOffset

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_boxOffset = nullptr

protected

Definition at line 513 of file fvstructuredsolver.h.

m_boxOutputDir

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_boxOutputDir

protected

Definition at line 666 of file fvstructuredsolver.h.

m_boxOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_boxOutputInterval

protected

Definition at line 511 of file fvstructuredsolver.h.

m_boxSize

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_boxSize = nullptr

protected

Definition at line 514 of file fvstructuredsolver.h.

m_boxWriteCoordinates

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_boxWriteCoordinates

protected

Definition at line 515 of file fvstructuredsolver.h.

m_bPower

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_bPower

protected

Definition at line 473 of file fvstructuredsolver.h.

m_bufferCellsSndRcv

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_bufferCellsSndRcv = nullptr

protected

Definition at line 739 of file fvstructuredsolver.h.

m_bufferPointsSendRcv

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_bufferPointsSendRcv = nullptr

protected

Definition at line 740 of file fvstructuredsolver.h.

m_c_Dp

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_c_Dp

protected

Definition at line 875 of file fvstructuredsolver.h.

m_c_Dp_eps

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_c_Dp_eps

protected

Definition at line 875 of file fvstructuredsolver.h.

m_c_eps

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_c_eps

protected

Definition at line 875 of file fvstructuredsolver.h.

m_c_t

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_c_t

protected

Definition at line 875 of file fvstructuredsolver.h.

m_c_wd

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_c_wd

protected

Definition at line 875 of file fvstructuredsolver.h.

m_cells

template<MInt nDim>

StructuredCell* FvStructuredSolver< nDim >::m_cells = nullptr

protected

Definition at line 409 of file fvstructuredsolver.h.

m_cfl

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_cfl

protected

Definition at line 434 of file fvstructuredsolver.h.

m_CFLVISC

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_CFLVISC

protected

Definition at line 687 of file fvstructuredsolver.h.

m_changeMa

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_changeMa

protected

Definition at line 826 of file fvstructuredsolver.h.

m_channelC1

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelC1

protected

Definition at line 762 of file fvstructuredsolver.h.

m_channelC2

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelC2

protected

Definition at line 763 of file fvstructuredsolver.h.

m_channelC3

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelC3

protected

Definition at line 764 of file fvstructuredsolver.h.

m_channelC4

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelC4

protected

Definition at line 765 of file fvstructuredsolver.h.

m_channelFlow

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_channelFlow

protected

Definition at line 449 of file fvstructuredsolver.h.

m_channelFullyPeriodic

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_channelFullyPeriodic

protected

Definition at line 766 of file fvstructuredsolver.h.

m_channelHeight

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelHeight

protected

Definition at line 759 of file fvstructuredsolver.h.

m_channelInflowPlaneCoordinate

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelInflowPlaneCoordinate

protected

Definition at line 761 of file fvstructuredsolver.h.

m_channelLength

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelLength

protected

Definition at line 758 of file fvstructuredsolver.h.

m_channelPresInlet

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelPresInlet

protected

Definition at line 756 of file fvstructuredsolver.h.

m_channelPresOutlet

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelPresOutlet

protected

Definition at line 757 of file fvstructuredsolver.h.

m_channelRoots

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_channelRoots = nullptr

protected

Definition at line 755 of file fvstructuredsolver.h.

m_channelWidth

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_channelWidth

protected

Definition at line 760 of file fvstructuredsolver.h.

m_chi

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_chi

protected

Definition at line 615 of file fvstructuredsolver.h.

m_commBC2600

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commBC2600 = MPI_COMM_NULL

protected

Definition at line 705 of file fvstructuredsolver.h.

m_commBC2600MyRank

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commBC2600MyRank = -1

protected

Definition at line 708 of file fvstructuredsolver.h.

m_commBC2600Root

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commBC2600Root = -1

protected

Definition at line 706 of file fvstructuredsolver.h.

m_commBC2600RootGlobal

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commBC2600RootGlobal = -1

protected

Definition at line 707 of file fvstructuredsolver.h.

m_commChannelIn

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commChannelIn = MPI_COMM_NULL

protected

Definition at line 752 of file fvstructuredsolver.h.

m_commChannelOut

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commChannelOut = MPI_COMM_NULL

protected

Definition at line 753 of file fvstructuredsolver.h.

m_commChannelWorld

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commChannelWorld = MPI_COMM_NULL

protected

Definition at line 754 of file fvstructuredsolver.h.

m_commPerRotGroup

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commPerRotGroup = -1

protected

Definition at line 774 of file fvstructuredsolver.h.

m_commPerRotOne

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commPerRotOne = MPI_COMM_NULL

protected

Definition at line 770 of file fvstructuredsolver.h.

m_commPerRotRoots

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_commPerRotRoots = nullptr

protected

Definition at line 773 of file fvstructuredsolver.h.

m_commPerRotTwo

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commPerRotTwo = MPI_COMM_NULL

protected

Definition at line 771 of file fvstructuredsolver.h.

m_commPerRotWorld

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commPerRotWorld = MPI_COMM_NULL

protected

Definition at line 772 of file fvstructuredsolver.h.

m_commStg

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_commStg = MPI_COMM_NULL

protected

Definition at line 584 of file fvstructuredsolver.h.

m_commStgMyRank

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commStgMyRank = -1

protected

Definition at line 587 of file fvstructuredsolver.h.

m_commStgRoot

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commStgRoot = -1

protected

Definition at line 585 of file fvstructuredsolver.h.

m_commStgRootGlobal

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commStgRootGlobal = -1

protected

Definition at line 586 of file fvstructuredsolver.h.

m_commZonal

template<MInt nDim>

MPI_Comm* FvStructuredSolver< nDim >::m_commZonal = nullptr

protected

Definition at line 710 of file fvstructuredsolver.h.

m_commZonalMyRank

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_commZonalMyRank = -1

protected

Definition at line 713 of file fvstructuredsolver.h.

m_commZonalRoot

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_commZonalRoot = nullptr

protected

Definition at line 711 of file fvstructuredsolver.h.

m_commZonalRootGlobal

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_commZonalRootGlobal = nullptr

protected

Definition at line 712 of file fvstructuredsolver.h.

m_computeLambda2

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_computeLambda2

protected

Definition at line 453 of file fvstructuredsolver.h.

m_computeSpongeFactor

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_computeSpongeFactor

protected

Definition at line 626 of file fvstructuredsolver.h.

m_considerVolumeForces

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_considerVolumeForces

protected

Definition at line 437 of file fvstructuredsolver.h.

m_constantTimeStep

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_constantTimeStep

protected

Definition at line 575 of file fvstructuredsolver.h.

m_convectiveUnitInterval

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_convectiveUnitInterval

protected

Definition at line 800 of file fvstructuredsolver.h.

m_convergence

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_convergence

protected

Definition at line 655 of file fvstructuredsolver.h.

m_convergenceCriterion

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_convergenceCriterion

protected

Definition at line 656 of file fvstructuredsolver.h.

m_currentPeriodicDirection

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_currentPeriodicDirection

protected

Definition at line 731 of file fvstructuredsolver.h.

m_debugOutput

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_debugOutput

protected

Definition at line 404 of file fvstructuredsolver.h.

m_deltaP

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_deltaP

protected

Definition at line 661 of file fvstructuredsolver.h.

m_detailAuxData

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_detailAuxData

protected

Definition at line 475 of file fvstructuredsolver.h.

m_DInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_DInfinity

protected

Definition at line 817 of file fvstructuredsolver.h.

m_dsIsComputed

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_dsIsComputed

protected

Definition at line 398 of file fvstructuredsolver.h.

m_DthInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_DthInfinity

protected

Definition at line 815 of file fvstructuredsolver.h.

m_dualTimeStepping

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_dualTimeStepping

protected

Definition at line 564 of file fvstructuredsolver.h.

m_eps

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_eps

protected

Definition at line 336 of file fvstructuredsolver.h.

m_epsScale

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_epsScale

protected

Definition at line 466 of file fvstructuredsolver.h.

m_euler

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_euler

protected

Definition at line 438 of file fvstructuredsolver.h.

m_fgammaMinusOne

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_fgammaMinusOne

protected

Definition at line 444 of file fvstructuredsolver.h.

m_firstAvrgResidual

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_firstAvrgResidual

protected

Definition at line 647 of file fvstructuredsolver.h.

m_firstMaxResidual

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_firstMaxResidual

protected

Definition at line 646 of file fvstructuredsolver.h.

m_forceAsciiComputeInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_forceAsciiComputeInterval

protected

Definition at line 481 of file fvstructuredsolver.h.

m_forceAsciiOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_forceAsciiOutputInterval

protected

Definition at line 480 of file fvstructuredsolver.h.

m_forceAveragingDir

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_forceAveragingDir

protected

Definition at line 478 of file fvstructuredsolver.h.

m_forceCoef

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_forceCoef = nullptr

protected

Definition at line 474 of file fvstructuredsolver.h.

m_forceCounter

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_forceCounter

protected

Definition at line 483 of file fvstructuredsolver.h.

m_forceData

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_forceData = nullptr

protected

Definition at line 482 of file fvstructuredsolver.h.

m_forceHeaderNames

template<MInt nDim>

std::vector<MString> FvStructuredSolver< nDim >::m_forceHeaderNames

protected

Definition at line 477 of file fvstructuredsolver.h.

m_forceOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_forceOutputInterval

protected

Definition at line 479 of file fvstructuredsolver.h.

m_forceSecondOrder

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_forceSecondOrder

protected

Definition at line 487 of file fvstructuredsolver.h.

m_formationEnthalpy

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_formationEnthalpy = nullptr

protected

Definition at line 553 of file fvstructuredsolver.h.

m_fsc

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_fsc

protected

Definition at line 878 of file fvstructuredsolver.h.

m_fsc_dx0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_fsc_dx0

protected

Definition at line 886 of file fvstructuredsolver.h.

m_fsc_eta

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_fsc_eta

protected

Definition at line 879 of file fvstructuredsolver.h.

m_fsc_f

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_fsc_f

protected

Definition at line 881 of file fvstructuredsolver.h.

m_fsc_fs

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_fsc_fs

protected

Definition at line 880 of file fvstructuredsolver.h.

m_fsc_g

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_fsc_g

protected

Definition at line 882 of file fvstructuredsolver.h.

m_fsc_m

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_fsc_m

protected

Definition at line 887 of file fvstructuredsolver.h.

m_fsc_noPoints

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_fsc_noPoints

protected

Definition at line 883 of file fvstructuredsolver.h.

m_fsc_Re

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_fsc_Re

protected

Definition at line 888 of file fvstructuredsolver.h.

m_fsc_x0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_fsc_x0

protected

Definition at line 884 of file fvstructuredsolver.h.

m_fsc_y0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_fsc_y0

protected

Definition at line 885 of file fvstructuredsolver.h.

m_gamma

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_gamma

protected

Definition at line 442 of file fvstructuredsolver.h.

m_gammaMinusOne

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_gammaMinusOne

protected

Definition at line 443 of file fvstructuredsolver.h.

m_globalDomainWidth

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_globalDomainWidth

protected

Definition at line 488 of file fvstructuredsolver.h.

m_grid

template<MInt nDim>

StructuredGrid<nDim>* FvStructuredSolver< nDim >::m_grid

Definition at line 52 of file fvstructuredsolver.h.

m_gridMovingMethod

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_gridMovingMethod = 0

protected

Definition at line 345 of file fvstructuredsolver.h.

m_hasSingularity

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_hasSingularity

protected

Definition at line 836 of file fvstructuredsolver.h.

m_hasSTG

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_hasSTG

protected

Definition at line 701 of file fvstructuredsolver.h.

m_hInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_hInfinity

protected

Definition at line 457 of file fvstructuredsolver.h.

m_I

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_I

protected

Definition at line 465 of file fvstructuredsolver.h.

m_ignoreUID

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_ignoreUID

protected

Definition at line 417 of file fvstructuredsolver.h.

m_inflowTemperatureRatio

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_inflowTemperatureRatio

protected

Definition at line 436 of file fvstructuredsolver.h.

m_inflowVelAvg

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_inflowVelAvg

protected

Definition at line 767 of file fvstructuredsolver.h.

m_initialCondition

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_initialCondition

protected

Definition at line 660 of file fvstructuredsolver.h.

m_intpPoints

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_intpPoints

protected

Definition at line 508 of file fvstructuredsolver.h.

m_intpPointsCoordinates

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_intpPointsCoordinates = nullptr

protected

Definition at line 503 of file fvstructuredsolver.h.

m_intpPointsDelta

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_intpPointsDelta = nullptr

protected

Definition at line 501 of file fvstructuredsolver.h.

m_intpPointsDelta2D

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_intpPointsDelta2D = nullptr

protected

Definition at line 502 of file fvstructuredsolver.h.

m_intpPointsHasPartnerGlobal

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_intpPointsHasPartnerGlobal = nullptr

protected

Definition at line 504 of file fvstructuredsolver.h.

m_intpPointsHasPartnerLocal

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_intpPointsHasPartnerLocal = nullptr

protected

Definition at line 505 of file fvstructuredsolver.h.

m_intpPointsNoLines

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_intpPointsNoLines

protected

Definition at line 494 of file fvstructuredsolver.h.

m_intpPointsNoLines2D

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_intpPointsNoLines2D

protected

Definition at line 495 of file fvstructuredsolver.h.

m_intpPointsNoPoints

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_intpPointsNoPoints = nullptr

protected

Definition at line 497 of file fvstructuredsolver.h.

m_intpPointsNoPoints2D

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_intpPointsNoPoints2D = nullptr

protected

Definition at line 498 of file fvstructuredsolver.h.

m_intpPointsNoPointsTotal

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_intpPointsNoPointsTotal

protected

Definition at line 496 of file fvstructuredsolver.h.

m_intpPointsOffsets

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_intpPointsOffsets = nullptr

protected

Definition at line 499 of file fvstructuredsolver.h.

m_intpPointsOutputDir

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_intpPointsOutputDir

protected

Definition at line 667 of file fvstructuredsolver.h.

m_intpPointsOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_intpPointsOutputInterval

protected

Definition at line 493 of file fvstructuredsolver.h.

m_intpPointsStart

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_intpPointsStart = nullptr

protected

Definition at line 500 of file fvstructuredsolver.h.

m_intpPointsVarsGlobal

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_intpPointsVarsGlobal = nullptr

protected

Definition at line 506 of file fvstructuredsolver.h.

m_intpPointsVarsLocal

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_intpPointsVarsLocal = nullptr

protected

Definition at line 507 of file fvstructuredsolver.h.

m_isActive

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_isActive = false

private

Definition at line 916 of file fvstructuredsolver.h.

m_isInitTimers

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_isInitTimers = false

protected

Definition at line 807 of file fvstructuredsolver.h.

m_keps_nonDimType

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_keps_nonDimType

protected

Definition at line 463 of file fvstructuredsolver.h.

m_kepsICMethod

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_kepsICMethod

protected

Definition at line 467 of file fvstructuredsolver.h.

m_lastForceComputationTimeStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_lastForceComputationTimeStep

protected

Definition at line 485 of file fvstructuredsolver.h.

m_lastForceOutputTimeStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_lastForceOutputTimeStep

protected

Definition at line 484 of file fvstructuredsolver.h.

m_lastOutputTimeStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_lastOutputTimeStep

Definition at line 328 of file fvstructuredsolver.h.

m_limiter

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_limiter

protected

Definition at line 683 of file fvstructuredsolver.h.

m_limiterMethod

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_limiterMethod

protected

Definition at line 684 of file fvstructuredsolver.h.

m_limiterVisc

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_limiterVisc

protected

Definition at line 686 of file fvstructuredsolver.h.

m_localTimeStep

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_localTimeStep

protected

Definition at line 559 of file fvstructuredsolver.h.

m_maxNoVariables

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_maxNoVariables

protected

Definition at line 470 of file fvstructuredsolver.h.

m_mgExchangeCoordinates

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_mgExchangeCoordinates

protected

Definition at line 344 of file fvstructuredsolver.h.

m_movingGrid

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_movingGrid

protected

Definition at line 343 of file fvstructuredsolver.h.

m_movingGridInitialStart

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_movingGridInitialStart

protected

Definition at line 378 of file fvstructuredsolver.h.

m_movingGridSaveGrid

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_movingGridSaveGrid

protected

Definition at line 351 of file fvstructuredsolver.h.

m_movingGridStepOffset

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_movingGridStepOffset

protected

Definition at line 346 of file fvstructuredsolver.h.

m_movingGridTimeOffset

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_movingGridTimeOffset

protected

Definition at line 350 of file fvstructuredsolver.h.

m_mpiStruct

template<MInt nDim>

MPI_Datatype FvStructuredSolver< nDim >::m_mpiStruct

protected

Definition at line 651 of file fvstructuredsolver.h.

m_muInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_muInfinity

protected

Definition at line 816 of file fvstructuredsolver.h.

m_musclScheme

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_musclScheme

protected

Definition at line 689 of file fvstructuredsolver.h.

m_mutInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_mutInfinity

protected

Definition at line 725 of file fvstructuredsolver.h.

m_nActiveCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nActiveCells = nullptr

protected

Definition at line 672 of file fvstructuredsolver.h.

m_nActivePoints

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nActivePoints = nullptr

protected

Definition at line 422 of file fvstructuredsolver.h.

m_nCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nCells = nullptr

protected

Definition at line 671 of file fvstructuredsolver.h.

m_nghbrDomainId

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nghbrDomainId = nullptr

protected

Definition at line 737 of file fvstructuredsolver.h.

m_nghbrFaceId

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nghbrFaceId = nullptr

protected

Definition at line 741 of file fvstructuredsolver.h.

m_nghbrFaceInfo

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_nghbrFaceInfo = nullptr

protected

Definition at line 742 of file fvstructuredsolver.h.

m_noActiveCells

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noActiveCells

protected

Definition at line 425 of file fvstructuredsolver.h.

m_noBlocks

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noBlocks

protected

Definition at line 675 of file fvstructuredsolver.h.

m_noCells

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noCells

protected

Definition at line 424 of file fvstructuredsolver.h.

m_noConvectiveOutputs

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noConvectiveOutputs

protected

Definition at line 801 of file fvstructuredsolver.h.

m_nodalBoxBlock

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nodalBoxBlock = nullptr

protected

Definition at line 521 of file fvstructuredsolver.h.

m_nodalBoxCoordinates

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_nodalBoxCoordinates = nullptr

protected

Definition at line 529 of file fvstructuredsolver.h.

m_nodalBoxInitialized

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_nodalBoxInitialized

protected

Definition at line 534 of file fvstructuredsolver.h.

m_nodalBoxInterpolation

template<MInt nDim>

std::unique_ptr<StructuredInterpolation<nDim> > FvStructuredSolver< nDim >::m_nodalBoxInterpolation

protected

Definition at line 517 of file fvstructuredsolver.h.

m_nodalBoxLocalDomainOffset

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_nodalBoxLocalDomainOffset = nullptr

protected

Definition at line 526 of file fvstructuredsolver.h.

m_nodalBoxLocalOffset

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_nodalBoxLocalOffset = nullptr

protected

Definition at line 524 of file fvstructuredsolver.h.

m_nodalBoxLocalPoints

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_nodalBoxLocalPoints = nullptr

protected

Definition at line 525 of file fvstructuredsolver.h.

m_nodalBoxLocalSize

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nodalBoxLocalSize = nullptr

protected

Definition at line 527 of file fvstructuredsolver.h.

m_nodalBoxNoBoxes

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_nodalBoxNoBoxes

protected

Definition at line 518 of file fvstructuredsolver.h.

m_nodalBoxOffset

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_nodalBoxOffset = nullptr

protected

Definition at line 522 of file fvstructuredsolver.h.

m_nodalBoxOutputDir

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_nodalBoxOutputDir

protected

Definition at line 519 of file fvstructuredsolver.h.

m_nodalBoxOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_nodalBoxOutputInterval

protected

Definition at line 520 of file fvstructuredsolver.h.

m_nodalBoxPartnerLocal

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nodalBoxPartnerLocal = nullptr

protected

Definition at line 528 of file fvstructuredsolver.h.

m_nodalBoxPoints

template<MInt nDim>

MInt** FvStructuredSolver< nDim >::m_nodalBoxPoints = nullptr

protected

Definition at line 523 of file fvstructuredsolver.h.

m_nodalBoxTotalLocalOffset

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nodalBoxTotalLocalOffset = nullptr

protected

Definition at line 533 of file fvstructuredsolver.h.

m_nodalBoxTotalLocalSize

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_nodalBoxTotalLocalSize

protected

Definition at line 532 of file fvstructuredsolver.h.

m_nodalBoxVariables

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_nodalBoxVariables = nullptr

protected

Definition at line 530 of file fvstructuredsolver.h.

m_nodalBoxWriteCoordinates

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_nodalBoxWriteCoordinates

protected

Definition at line 531 of file fvstructuredsolver.h.

m_nOffsetCells

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nOffsetCells = nullptr

protected

Definition at line 673 of file fvstructuredsolver.h.

m_nOffsetPoints

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nOffsetPoints = nullptr

protected

Definition at line 423 of file fvstructuredsolver.h.

m_noForceDataFields

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noForceDataFields

protected

Definition at line 486 of file fvstructuredsolver.h.

m_noGhostLayers

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noGhostLayers

protected

Definition at line 420 of file fvstructuredsolver.h.

m_noNghbrDomainBufferSize

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_noNghbrDomainBufferSize = nullptr

protected

Definition at line 738 of file fvstructuredsolver.h.

m_noNghbrDomains

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noNghbrDomains

protected

Definition at line 736 of file fvstructuredsolver.h.

m_noPoints

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noPoints

protected

Definition at line 426 of file fvstructuredsolver.h.

m_noRansEquations

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noRansEquations

protected

Definition at line 698 of file fvstructuredsolver.h.

m_noRKSteps

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noRKSteps

protected

Definition at line 554 of file fvstructuredsolver.h.

m_noSpecies

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noSpecies

protected

Definition at line 551 of file fvstructuredsolver.h.

m_noSpongeDomainInfos

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noSpongeDomainInfos

protected

Definition at line 618 of file fvstructuredsolver.h.

m_noSurfaces

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_noSurfaces

protected

Definition at line 428 of file fvstructuredsolver.h.

m_noWindows

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_noWindows = nullptr

protected

Definition at line 678 of file fvstructuredsolver.h.

m_nPoints

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_nPoints = nullptr

protected

Definition at line 421 of file fvstructuredsolver.h.

m_nutInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_nutInfinity

protected

Definition at line 724 of file fvstructuredsolver.h.

m_orderOfReconstruction

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_orderOfReconstruction

protected

Definition at line 435 of file fvstructuredsolver.h.

m_oscAmplitude

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_oscAmplitude

protected

Definition at line 391 of file fvstructuredsolver.h.

m_oscFreq

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_oscFreq

protected

Definition at line 393 of file fvstructuredsolver.h.

m_oscSr

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_oscSr

protected

Definition at line 392 of file fvstructuredsolver.h.

m_outputFormat

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_outputFormat

Definition at line 327 of file fvstructuredsolver.h.

m_outputIterationNumber

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_outputIterationNumber

protected

Definition at line 405 of file fvstructuredsolver.h.

m_outputOffset

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_outputOffset

protected

Definition at line 402 of file fvstructuredsolver.h.

m_periodicConnection

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_periodicConnection

protected

Definition at line 448 of file fvstructuredsolver.h.

m_physicalReferenceLength

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_physicalReferenceLength

protected

Definition at line 431 of file fvstructuredsolver.h.

m_physicalTime

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_physicalTime

protected

Definition at line 566 of file fvstructuredsolver.h.

m_physicalTimeStep

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_physicalTimeStep

protected

Definition at line 565 of file fvstructuredsolver.h.

m_PInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_PInfinity

protected

Definition at line 813 of file fvstructuredsolver.h.

m_plenumComm

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_plenumComm = MPI_COMM_NULL

protected

Definition at line 748 of file fvstructuredsolver.h.

m_plenumRoot

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_plenumRoot = -1

protected

Definition at line 749 of file fvstructuredsolver.h.

m_pointsToAsciiComputeInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiComputeInterval

protected

Definition at line 536 of file fvstructuredsolver.h.

m_pointsToAsciiCoordinates

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_pointsToAsciiCoordinates = nullptr

protected

Definition at line 541 of file fvstructuredsolver.h.

m_pointsToAsciiCounter

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiCounter

protected

Definition at line 544 of file fvstructuredsolver.h.

m_pointsToAsciiHasPartnerGlobal

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_pointsToAsciiHasPartnerGlobal = nullptr

protected

Definition at line 545 of file fvstructuredsolver.h.

m_pointsToAsciiHasPartnerLocal

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_pointsToAsciiHasPartnerLocal = nullptr

protected

Definition at line 546 of file fvstructuredsolver.h.

m_pointsToAsciiInterpolation

template<MInt nDim>

std::unique_ptr<StructuredInterpolation<nDim> > FvStructuredSolver< nDim >::m_pointsToAsciiInterpolation

protected

Definition at line 547 of file fvstructuredsolver.h.

m_pointsToAsciiLastComputationStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiLastComputationStep

protected

Definition at line 540 of file fvstructuredsolver.h.

m_pointsToAsciiLastOutputStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiLastOutputStep

protected

Definition at line 539 of file fvstructuredsolver.h.

m_pointsToAsciiNoPoints

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiNoPoints

protected

Definition at line 538 of file fvstructuredsolver.h.

m_pointsToAsciiOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiOutputInterval

protected

Definition at line 537 of file fvstructuredsolver.h.

m_pointsToAsciiVarId

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_pointsToAsciiVarId

protected

Definition at line 543 of file fvstructuredsolver.h.

m_pointsToAsciiVars

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_pointsToAsciiVars = nullptr

protected

Definition at line 542 of file fvstructuredsolver.h.

m_porous

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_porous

protected

Definition at line 871 of file fvstructuredsolver.h.

m_porousBlockIds

template<MInt nDim>

std::vector<MInt> FvStructuredSolver< nDim >::m_porousBlockIds

protected

Definition at line 874 of file fvstructuredsolver.h.

m_Pr

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_Pr

protected

Definition at line 432 of file fvstructuredsolver.h.

m_pvariableNames

template<MInt nDim>

MString* FvStructuredSolver< nDim >::m_pvariableNames = nullptr

protected

Definition at line 411 of file fvstructuredsolver.h.

m_QLeft

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_QLeft = nullptr

protected

Definition at line 339 of file fvstructuredsolver.h.

m_QRight

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_QRight = nullptr

protected

Definition at line 340 of file fvstructuredsolver.h.

m_rans

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_rans

protected

Definition at line 696 of file fvstructuredsolver.h.

m_rans2eq_mode

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_rans2eq_mode

protected

Definition at line 461 of file fvstructuredsolver.h.

m_ransMethod

template<MInt nDim>

RansMethod FvStructuredSolver< nDim >::m_ransMethod = NORANS

protected

Definition at line 697 of file fvstructuredsolver.h.

m_ransTransPos

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_ransTransPos

protected

Definition at line 700 of file fvstructuredsolver.h.

m_rcvComm

template<MInt nDim>

std::vector<std::unique_ptr<StructuredComm<nDim> > > FvStructuredSolver< nDim >::m_rcvComm

protected

Definition at line 729 of file fvstructuredsolver.h.

m_Re0

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_Re0

protected

Definition at line 445 of file fvstructuredsolver.h.

m_referenceComposition

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_referenceComposition = nullptr

protected

Definition at line 552 of file fvstructuredsolver.h.

m_referenceEnthalpy

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_referenceEnthalpy

protected

Definition at line 458 of file fvstructuredsolver.h.

m_referenceLength

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_referenceLength

protected

Definition at line 430 of file fvstructuredsolver.h.

m_referenceTemperature

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_referenceTemperature

protected

Definition at line 550 of file fvstructuredsolver.h.

m_rescalingCommGrComm

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_rescalingCommGrComm = MPI_COMM_NULL

protected

Definition at line 580 of file fvstructuredsolver.h.

m_rescalingCommGrRoot

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_rescalingCommGrRoot = -1

protected

Definition at line 578 of file fvstructuredsolver.h.

m_rescalingCommGrRootGlobal

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_rescalingCommGrRootGlobal = -1

protected

Definition at line 579 of file fvstructuredsolver.h.

m_resFile

template<MInt nDim>

FILE* FvStructuredSolver< nDim >::m_resFile

protected

Definition at line 652 of file fvstructuredsolver.h.

m_residualFileExist

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_residualFileExist

protected

Definition at line 649 of file fvstructuredsolver.h.

m_residualOutputInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_residualOutputInterval

protected

Definition at line 643 of file fvstructuredsolver.h.

m_residualRcv

template<MInt nDim>

MRes FvStructuredSolver< nDim >::m_residualRcv

protected

Definition at line 641 of file fvstructuredsolver.h.

m_residualSnd

template<MInt nDim>

MRes* FvStructuredSolver< nDim >::m_residualSnd = nullptr

protected

Definition at line 640 of file fvstructuredsolver.h.

m_resOp

template<MInt nDim>

MPI_Op FvStructuredSolver< nDim >::m_resOp

protected

Definition at line 650 of file fvstructuredsolver.h.

m_restart

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_restart

protected

Definition at line 659 of file fvstructuredsolver.h.

m_restartBc2800

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_restartBc2800

protected

Definition at line 829 of file fvstructuredsolver.h.

m_restartInterpolation

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_restartInterpolation

protected

Definition at line 662 of file fvstructuredsolver.h.

m_restartTimeBc2800

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_restartTimeBc2800

protected

Definition at line 830 of file fvstructuredsolver.h.

m_restartTimeStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_restartTimeStep

Definition at line 326 of file fvstructuredsolver.h.

m_ReTau

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_ReTau

protected

Definition at line 446 of file fvstructuredsolver.h.

m_rhoEInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoEInfinity

protected

Definition at line 822 of file fvstructuredsolver.h.

m_rhoInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoInfinity

protected

Definition at line 823 of file fvstructuredsolver.h.

m_rhoNuTildeInfinty

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoNuTildeInfinty

protected

Definition at line 723 of file fvstructuredsolver.h.

m_rhoUInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoUInfinity

protected

Definition at line 819 of file fvstructuredsolver.h.

m_rhoVInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoVInfinity

protected

Definition at line 820 of file fvstructuredsolver.h.

m_rhoVVInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoVVInfinity[3]

protected

Definition at line 824 of file fvstructuredsolver.h.

m_rhoWInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rhoWInfinity

protected

Definition at line 821 of file fvstructuredsolver.h.

m_rhs

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_rhs = nullptr

protected

Definition at line 396 of file fvstructuredsolver.h.

m_RKalpha

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_RKalpha = nullptr

protected

Definition at line 555 of file fvstructuredsolver.h.

m_RKStep

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_RKStep

protected

Definition at line 557 of file fvstructuredsolver.h.

m_rPr

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_rPr

protected

Definition at line 433 of file fvstructuredsolver.h.

m_rungeKuttaOrder

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_rungeKuttaOrder

protected

Definition at line 560 of file fvstructuredsolver.h.

m_sampleSolutionFiles

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_sampleSolutionFiles

protected

Definition at line 406 of file fvstructuredsolver.h.

m_savePartitionOutput

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_savePartitionOutput

protected

Definition at line 669 of file fvstructuredsolver.h.

m_setLocalWallDistance

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_setLocalWallDistance = false

protected

Definition at line 491 of file fvstructuredsolver.h.

m_sigmaSponge

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_sigmaSponge = nullptr

protected

Definition at line 622 of file fvstructuredsolver.h.

m_singularity

template<MInt nDim>

SingularInformation* FvStructuredSolver< nDim >::m_singularity = nullptr

protected

Definition at line 835 of file fvstructuredsolver.h.

m_sndComm

template<MInt nDim>

std::vector<std::unique_ptr<StructuredComm<nDim> > > FvStructuredSolver< nDim >::m_sndComm

protected

Definition at line 728 of file fvstructuredsolver.h.

m_solutionAnomaly

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_solutionAnomaly

protected

Definition at line 464 of file fvstructuredsolver.h.

m_solutionFileName

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_solutionFileName

protected

Definition at line 665 of file fvstructuredsolver.h.

m_spongeBcWindowInfo

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_spongeBcWindowInfo = nullptr

protected

Definition at line 619 of file fvstructuredsolver.h.

m_spongeLayerThickness

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_spongeLayerThickness = nullptr

protected

Definition at line 624 of file fvstructuredsolver.h.

m_spongeLayerType

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_spongeLayerType

protected

Definition at line 621 of file fvstructuredsolver.h.

m_stgBLT1

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_stgBLT1

protected

Definition at line 589 of file fvstructuredsolver.h.

m_stgBLT2

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_stgBLT2

protected

Definition at line 590 of file fvstructuredsolver.h.

m_stgBLT3

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_stgBLT3

protected

Definition at line 591 of file fvstructuredsolver.h.

m_stgBoxSize

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgBoxSize[3]

protected

Definition at line 600 of file fvstructuredsolver.h.

m_stgCreateNewEddies

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgCreateNewEddies

protected

Definition at line 602 of file fvstructuredsolver.h.

m_stgDelta99Inflow

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_stgDelta99Inflow

protected

Definition at line 592 of file fvstructuredsolver.h.

m_stgEddieDistribution

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_stgEddieDistribution

protected

Definition at line 599 of file fvstructuredsolver.h.

m_stgEddieLengthScales

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgEddieLengthScales

protected

Definition at line 606 of file fvstructuredsolver.h.

m_stgEddies

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::m_stgEddies = nullptr

protected

Definition at line 595 of file fvstructuredsolver.h.

m_stgExple

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_stgExple

protected

Definition at line 598 of file fvstructuredsolver.h.

m_stgFace

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgFace

protected

Definition at line 609 of file fvstructuredsolver.h.

m_stgInitialStartup

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgInitialStartup

protected

Definition at line 593 of file fvstructuredsolver.h.

m_stgIsActive

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgIsActive

protected

Definition at line 588 of file fvstructuredsolver.h.

m_stgLengthFactors

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_stgLengthFactors = nullptr

protected

Definition at line 610 of file fvstructuredsolver.h.

m_stgLocal

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgLocal

protected

Definition at line 601 of file fvstructuredsolver.h.

m_stgMaxNoEddies

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgMaxNoEddies

protected

Definition at line 597 of file fvstructuredsolver.h.

m_stgMyRank

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgMyRank

protected

Definition at line 612 of file fvstructuredsolver.h.

m_stgNoEddieProperties

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgNoEddieProperties

protected

Definition at line 594 of file fvstructuredsolver.h.

m_stgNoEddies

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgNoEddies

protected

Definition at line 596 of file fvstructuredsolver.h.

m_stgNoVariables

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgNoVariables

protected

Definition at line 604 of file fvstructuredsolver.h.

m_stgRootRank

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgRootRank

protected

Definition at line 603 of file fvstructuredsolver.h.

m_stgRSTFactors

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_stgRSTFactors = nullptr

protected

Definition at line 611 of file fvstructuredsolver.h.

m_stgShapeFunction

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_stgShapeFunction

protected

Definition at line 605 of file fvstructuredsolver.h.

m_stgSubSup

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgSubSup

protected

Definition at line 607 of file fvstructuredsolver.h.

m_stgSupersonic

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_stgSupersonic

protected

Definition at line 608 of file fvstructuredsolver.h.

m_streamwiseTravelingWave

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_streamwiseTravelingWave

protected

Definition at line 353 of file fvstructuredsolver.h.

m_StructuredComm

template<MInt nDim>

MPI_Comm FvStructuredSolver< nDim >::m_StructuredComm

Definition at line 324 of file fvstructuredsolver.h.

m_sutherlandConstant

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_sutherlandConstant

protected

Definition at line 450 of file fvstructuredsolver.h.

m_sutherlandPlusOne

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_sutherlandPlusOne

protected

Definition at line 451 of file fvstructuredsolver.h.

m_synchronizedMGOutput

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_synchronizedMGOutput

protected

Definition at line 347 of file fvstructuredsolver.h.

m_targetDensityFactor

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_targetDensityFactor

protected

Definition at line 625 of file fvstructuredsolver.h.

m_time

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_time

protected

Definition at line 556 of file fvstructuredsolver.h.

m_timeRef

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_timeRef

protected

Definition at line 563 of file fvstructuredsolver.h.

m_timerGroup

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_timerGroup = -1

protected

Definition at line 570 of file fvstructuredsolver.h.

m_timers

template<MInt nDim>

std::array<MInt, Timers::_count> FvStructuredSolver< nDim >::m_timers {}

protected

Definition at line 572 of file fvstructuredsolver.h.

m_timeStep

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_timeStep

protected

Definition at line 558 of file fvstructuredsolver.h.

m_timeStepComputationInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_timeStepComputationInterval

protected

Definition at line 562 of file fvstructuredsolver.h.

m_timeStepConverged

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_timeStepConverged = false

private

Definition at line 914 of file fvstructuredsolver.h.

m_timeStepMethod

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_timeStepMethod

protected

Definition at line 561 of file fvstructuredsolver.h.

m_TInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_TInfinity

protected

Definition at line 814 of file fvstructuredsolver.h.

m_TinfS

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_TinfS

protected

Definition at line 452 of file fvstructuredsolver.h.

m_totalNoCells

template<MInt nDim>

MLong FvStructuredSolver< nDim >::m_totalNoCells

protected

Definition at line 648 of file fvstructuredsolver.h.

m_travelingWave

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_travelingWave

protected

Definition at line 352 of file fvstructuredsolver.h.

m_tripAirfoil

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_tripAirfoil

protected

Definition at line 863 of file fvstructuredsolver.h.

m_tripCoords

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripCoords = nullptr

protected

Definition at line 859 of file fvstructuredsolver.h.

m_tripCutoffZ

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripCutoffZ = nullptr

protected

Definition at line 846 of file fvstructuredsolver.h.

m_tripDelta1

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripDelta1 = nullptr

protected

Definition at line 841 of file fvstructuredsolver.h.

m_tripDeltaTime

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripDeltaTime = nullptr

protected

Definition at line 850 of file fvstructuredsolver.h.

m_tripDomainWidth

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_tripDomainWidth

protected

Definition at line 861 of file fvstructuredsolver.h.

m_tripG

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripG = nullptr

protected

Definition at line 853 of file fvstructuredsolver.h.

m_tripH1

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripH1 = nullptr

protected

Definition at line 854 of file fvstructuredsolver.h.

m_tripH2

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripH2 = nullptr

protected

Definition at line 855 of file fvstructuredsolver.h.

m_tripMaxAmpFluc

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripMaxAmpFluc = nullptr

protected

Definition at line 848 of file fvstructuredsolver.h.

m_tripMaxAmpSteady

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripMaxAmpSteady = nullptr

protected

Definition at line 847 of file fvstructuredsolver.h.

m_tripModesG

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripModesG = nullptr

protected

Definition at line 856 of file fvstructuredsolver.h.

m_tripModesH1

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripModesH1 = nullptr

protected

Definition at line 857 of file fvstructuredsolver.h.

m_tripModesH2

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripModesH2 = nullptr

protected

Definition at line 858 of file fvstructuredsolver.h.

m_tripNoCells

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_tripNoCells

protected

Definition at line 860 of file fvstructuredsolver.h.

m_tripNoModes

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_tripNoModes

protected

Definition at line 849 of file fvstructuredsolver.h.

m_tripNoTrips

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_tripNoTrips

protected

Definition at line 840 of file fvstructuredsolver.h.

m_tripSeed

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_tripSeed

protected

Definition at line 852 of file fvstructuredsolver.h.

m_tripTimeStep

template<MInt nDim>

MInt* FvStructuredSolver< nDim >::m_tripTimeStep = nullptr

protected

Definition at line 851 of file fvstructuredsolver.h.

m_tripUseRestart

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_tripUseRestart

protected

Definition at line 862 of file fvstructuredsolver.h.

m_tripXLength

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripXLength = nullptr

protected

Definition at line 843 of file fvstructuredsolver.h.

m_tripXOrigin

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripXOrigin = nullptr

protected

Definition at line 842 of file fvstructuredsolver.h.

m_tripYHeight

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripYHeight = nullptr

protected

Definition at line 845 of file fvstructuredsolver.h.

m_tripYOrigin

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_tripYOrigin = nullptr

protected

Definition at line 844 of file fvstructuredsolver.h.

m_UInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_UInfinity

protected

Definition at line 810 of file fvstructuredsolver.h.

m_useAdiabaticRestartTemperature

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_useAdiabaticRestartTemperature

protected

Definition at line 832 of file fvstructuredsolver.h.

m_useBlasius

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_useBlasius

protected

Definition at line 898 of file fvstructuredsolver.h.

m_useConvectiveUnitWrite

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_useConvectiveUnitWrite

protected

Definition at line 799 of file fvstructuredsolver.h.

m_useNonSpecifiedRestartFile

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_useNonSpecifiedRestartFile

protected

Definition at line 401 of file fvstructuredsolver.h.

m_useSandpaperTrip

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_useSandpaperTrip

protected

Definition at line 839 of file fvstructuredsolver.h.

m_useSponge

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_useSponge

protected

Definition at line 620 of file fvstructuredsolver.h.

m_variableNames

template<MInt nDim>

MString* FvStructuredSolver< nDim >::m_variableNames = nullptr

protected

Definition at line 410 of file fvstructuredsolver.h.

m_venkFactor

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_venkFactor

protected

Definition at line 685 of file fvstructuredsolver.h.

m_VInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_VInfinity

protected

Definition at line 811 of file fvstructuredsolver.h.

m_viscCompact

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_viscCompact

protected

Definition at line 692 of file fvstructuredsolver.h.

m_volumeForce

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_volumeForce = nullptr

protected

Definition at line 439 of file fvstructuredsolver.h.

m_volumeForceMethod

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_volumeForceMethod = 0

protected

Definition at line 440 of file fvstructuredsolver.h.

m_volumeForceUpdateInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_volumeForceUpdateInterval

protected

Definition at line 441 of file fvstructuredsolver.h.

m_vorticityOutput

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_vorticityOutput

protected

Definition at line 403 of file fvstructuredsolver.h.

m_VVInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_VVInfinity[3]

protected

Definition at line 818 of file fvstructuredsolver.h.

m_wallVel

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_wallVel

protected

Definition at line 349 of file fvstructuredsolver.h.

m_waveAmplitude

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveAmplitude

protected

Definition at line 359 of file fvstructuredsolver.h.

m_waveAmplitudePlus

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveAmplitudePlus

protected

Definition at line 355 of file fvstructuredsolver.h.

m_waveAmplitudePressure

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveAmplitudePressure

protected

Definition at line 361 of file fvstructuredsolver.h.

m_waveAmplitudeSuction

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveAmplitudeSuction

protected

Definition at line 360 of file fvstructuredsolver.h.

m_waveAngle

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveAngle

protected

Definition at line 376 of file fvstructuredsolver.h.

m_waveBeginTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveBeginTransition

protected

Definition at line 366 of file fvstructuredsolver.h.

m_waveCellsPerWaveLength

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_waveCellsPerWaveLength

protected

Definition at line 381 of file fvstructuredsolver.h.

m_waveDomainWidth

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveDomainWidth

protected

Definition at line 389 of file fvstructuredsolver.h.

m_waveEndTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveEndTransition

protected

Definition at line 367 of file fvstructuredsolver.h.

m_waveForceField

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_waveForceField = nullptr

protected

Definition at line 385 of file fvstructuredsolver.h.

m_waveForceFieldFile

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_waveForceFieldFile

protected

Definition at line 388 of file fvstructuredsolver.h.

m_waveForceY

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_waveForceY = nullptr

protected

Definition at line 386 of file fvstructuredsolver.h.

m_waveForceZ

template<MInt nDim>

MFloat* FvStructuredSolver< nDim >::m_waveForceZ = nullptr

protected

Definition at line 387 of file fvstructuredsolver.h.

m_waveGradientPressure

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveGradientPressure

protected

Definition at line 363 of file fvstructuredsolver.h.

m_waveGradientSuction

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveGradientSuction

protected

Definition at line 362 of file fvstructuredsolver.h.

m_waveLength

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveLength

protected

Definition at line 358 of file fvstructuredsolver.h.

m_waveLengthPlus

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveLengthPlus

protected

Definition at line 354 of file fvstructuredsolver.h.

m_waveNoStepsPerCell

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_waveNoStepsPerCell

protected

Definition at line 348 of file fvstructuredsolver.h.

m_waveOutBeginTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveOutBeginTransition

protected

Definition at line 368 of file fvstructuredsolver.h.

m_waveOutEndTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveOutEndTransition

protected

Definition at line 369 of file fvstructuredsolver.h.

m_wavePenetrationHeight

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_wavePenetrationHeight

protected

Definition at line 382 of file fvstructuredsolver.h.

m_wavePressureBeginTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_wavePressureBeginTransition

protected

Definition at line 370 of file fvstructuredsolver.h.

m_wavePressureEndTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_wavePressureEndTransition

protected

Definition at line 371 of file fvstructuredsolver.h.

m_wavePressureOutBeginTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_wavePressureOutBeginTransition

protected

Definition at line 372 of file fvstructuredsolver.h.

m_wavePressureOutEndTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_wavePressureOutEndTransition

protected

Definition at line 373 of file fvstructuredsolver.h.

m_waveRcvComm

template<MInt nDim>

std::vector<std::unique_ptr<StructuredComm<nDim> > > FvStructuredSolver< nDim >::m_waveRcvComm

protected

Definition at line 734 of file fvstructuredsolver.h.

m_waveRestartFadeIn

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_waveRestartFadeIn

protected

Definition at line 379 of file fvstructuredsolver.h.

m_waveSndComm

template<MInt nDim>

std::vector<std::unique_ptr<StructuredComm<nDim> > > FvStructuredSolver< nDim >::m_waveSndComm

protected

Definition at line 733 of file fvstructuredsolver.h.

m_waveSpeed

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveSpeed

protected

Definition at line 364 of file fvstructuredsolver.h.

m_waveSpeedPlus

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveSpeedPlus

protected

Definition at line 365 of file fvstructuredsolver.h.

m_waveTemporalTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveTemporalTransition

protected

Definition at line 377 of file fvstructuredsolver.h.

m_waveTime

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveTime

protected

Definition at line 357 of file fvstructuredsolver.h.

m_waveTimePlus

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveTimePlus

protected

Definition at line 356 of file fvstructuredsolver.h.

m_waveTimeStepComputed

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_waveTimeStepComputed

protected

Definition at line 380 of file fvstructuredsolver.h.

m_waveYBeginTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveYBeginTransition

protected

Definition at line 374 of file fvstructuredsolver.h.

m_waveYEndTransition

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_waveYEndTransition

protected

Definition at line 375 of file fvstructuredsolver.h.

m_windowInfo

template<MInt nDim>

std::unique_ptr<FvStructuredSolverWindowInfo<nDim> > FvStructuredSolver< nDim >::m_windowInfo

protected

Definition at line 419 of file fvstructuredsolver.h.

m_WInfinity

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_WInfinity

protected

Definition at line 812 of file fvstructuredsolver.h.

m_workload

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_workload

protected

Definition at line 629 of file fvstructuredsolver.h.

m_workloadIncrement

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_workloadIncrement

protected

Definition at line 630 of file fvstructuredsolver.h.

m_zonal

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_zonal

protected

Definition at line 695 of file fvstructuredsolver.h.

m_zonalAveragingFactor

template<MInt nDim>

MFloat FvStructuredSolver< nDim >::m_zonalAveragingFactor

protected

Definition at line 720 of file fvstructuredsolver.h.

m_zonalExchangeInterval

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_zonalExchangeInterval

protected

Definition at line 702 of file fvstructuredsolver.h.

m_zonalExponentialAveraging

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_zonalExponentialAveraging

protected

Definition at line 718 of file fvstructuredsolver.h.

m_zonalRootRank

template<MInt nDim>

MBool FvStructuredSolver< nDim >::m_zonalRootRank = false

protected

Definition at line 714 of file fvstructuredsolver.h.

m_zonalSpanwiseAvgVars

template<MInt nDim>

std::vector<MFloat*> FvStructuredSolver< nDim >::m_zonalSpanwiseAvgVars

protected

Definition at line 703 of file fvstructuredsolver.h.

m_zonalStartAvgTime

template<MInt nDim>

MInt FvStructuredSolver< nDim >::m_zonalStartAvgTime

protected

Definition at line 719 of file fvstructuredsolver.h.

m_zoneType

template<MInt nDim>

MString FvStructuredSolver< nDim >::m_zoneType

protected

Definition at line 699 of file fvstructuredsolver.h.

mpi_rcvRequest

template<MInt nDim>

MPI_Request* FvStructuredSolver< nDim >::mpi_rcvRequest = nullptr

protected

Definition at line 744 of file fvstructuredsolver.h.

mpi_sndRcvStatus

template<MInt nDim>

MPI_Status* FvStructuredSolver< nDim >::mpi_sndRcvStatus = nullptr

protected

Definition at line 745 of file fvstructuredsolver.h.

mpi_sndRequest

template<MInt nDim>

MPI_Request* FvStructuredSolver< nDim >::mpi_sndRequest = nullptr

protected

Definition at line 743 of file fvstructuredsolver.h.

pointProperties

template<MInt nDim>

MFloat** FvStructuredSolver< nDim >::pointProperties = nullptr

protected

Definition at line 414 of file fvstructuredsolver.h.

PV

template<MInt nDim>

std::unique_ptr<MPrimitiveVariables<nDim> > FvStructuredSolver< nDim >::PV

protected

Definition at line 333 of file fvstructuredsolver.h.

---

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

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstructuredbndrycnd.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstructuredsolver.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FV/fvstructuredsolver.cpp