Coupling condition for direct-hybrid LES-CAA computations. More...

#include <dgccacousticperturbsourcefiles.h>

Inheritance diagram for DgCcAcousticPerturb< nDim, FvSysEqn >:

Collaboration diagram for DgCcAcousticPerturb< nDim, FvSysEqn >:

Public Types
using	Base = Coupling

using	BaseFv = CouplingFv< nDim, FvSysEqn >

using	FvCartesianSolverType = typename BaseFv::solverType

using	BaseDg = CouplingDgApe< nDim, BaseFv >

using	DgCartesianSolverType = typename BaseDg::DgCartesianSolverType

using	ProjectionType = typename BaseDg::ProjectionType

using	CV = typename BaseDg::CV

using	MV = typename BaseDg::MV

using	ST = typename BaseDg::ST

using	SysEqn = typename BaseDg::SysEqn

using	Timers = typename BaseDg::Timers

Public Types inherited from CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >
using	Base = Coupling

using	BaseDonor = CouplingFv< nDim, FvSysEqn >

using	DonorSolverType = typename BaseDonor::solverType

using	SysEqn = DgSysEqnAcousticPerturb< nDim >

using	ProjectionType = DgGalerkinProjection< nDim >

using	BaseDg = CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >

using	DgCartesianSolverType = typename BaseDg::solverType

using	MV = MeanVariables< nDim >
	Hold indices for mean variables. More...

Public Types inherited from CouplingFv< nDim, FvSysEqn >
using	solverType = FvCartesianSolverXD< nDim, FvSysEqn >

Public Types inherited from CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >
using	solverType = DgCartesianSolver< nDim, DgSysEqnAcousticPerturb< nDim > >

using	CV = typename SysEqn::CV

Public Member Functions
	DgCcAcousticPerturb (const MInt couplingId, FvCartesianSolverType fvSolver_, DgCartesianSolverType const dgSolver_)

virtual	~DgCcAcousticPerturb ()
	Stop the object lifetime timer and calculate global maximum errors. More...

void	init () override

void	finalizeCouplerInit () override

void	balancePre () override
	Load balancing. More...

void	balancePost () override

MInt	noCellDataDlb () const override
	Methods to inquire coupler data during balancing. More...

MInt	cellDataTypeDlb (const MInt dataId) const override

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

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

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

MBool	forceTimeStep () const
	Return true if time step calculation should be overruled by coupling. More...

MInt	noMeanVars () const
	Return number of mean variables. More...

Public Member Functions inherited from CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >
	CouplingDgApe (const MInt couplingId, DgCartesianSolverType dg, DonorSolverType ds)
	Initialize timers and read properties in c'tor. More...

virtual	~CouplingDgApe ()=default

void	init () override

void	finalizeSubCoupleInit (MInt) override final

void	preCouple (MInt) final
	Calculate source terms and add to the external source terms of the DG solver. More...

void	subCouple (MInt, MInt, std::vector< MBool > &) override final

void	postCouple (MInt) override final

void	cleanUp () override final

void	getCouplingTimings (std::vector< std::pair< MString, MFloat > > &timings, const MBool allTimings) override

void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &domainInfo) override final

MInt	noCouplingTimers (const MBool allTimings) const override

MInt	noMeanVars () const
	Return number of mean variables. More...

void	startLoadTimer (const MString &name) const
	Start the load timer of the coupler. More...

void	stopLoadTimer (const MString &name) const
	Stop the load timer of the coupler. More...

Public Member Functions inherited from CouplingFv< nDim, FvSysEqn >
	CouplingFv (const MInt couplingId, std::vector< FvCartesianSolverXD< nDim, FvSysEqn > * > fvSolvers, const MInt noSolvers)

	CouplingFv (const MInt couplingId, Solver *solvers)

	CouplingFv (const CouplingFv &)=delete

	~CouplingFv () override=default

CouplingFv &	operator= (const CouplingFv &)=delete

Public Member Functions inherited from Coupling
	Coupling (const MInt couplingId)

virtual	~Coupling ()=default

	Coupling (const Coupling &)=delete

Coupling &	operator= (const Coupling &)=delete

MInt	couplerId () const

virtual void	init ()=0

virtual void	finalizeSubCoupleInit (MInt solverId)=0

virtual void	finalizeCouplerInit ()=0

virtual void	preCouple (MInt recipeStep)=0

virtual void	subCouple (MInt recipeStep, MInt solverId, std::vector< MBool > &solverCompleted)=0

virtual void	postCouple (MInt recipeStep)=0

virtual void	cleanUp ()=0

virtual void	balancePre ()
	Load balancing. More...

virtual void	balancePost ()

virtual void	reinitAfterBalance ()

virtual void	prepareAdaptation ()

virtual void	postAdaptation ()

virtual void	finalizeAdaptation (const MInt)

virtual void	writeRestartFile (const MInt)

virtual MInt	noCellDataDlb () const
	Methods to inquire coupler data during balancing. 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	finalizeBalance (const MInt)

virtual MInt	noCouplingTimers (const MBool NotUsed(allTimings)) const
	Number of coupling timers. More...

virtual void	getCouplingTimings (std::vector< std::pair< MString, MFloat > > &NotUsed(timings), const MBool NotUsed(allTimings))
	Return coupling timings. More...

virtual void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &NotUsed(domainInfo))
	Return information on current domain decomposition (e.g. number of coupled cells/elements/...) More...

void	setDlbTimer (const MInt timerId)

void	startLoadTimer (const MString &name) const
	Start the load timer of the coupler. More...

void	stopLoadTimer (const MString &name) const
	Stop the load timer of the coupler. More...

Public Member Functions inherited from CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >
	CouplingDg (const MInt couplingId, solverType *b)

virtual	~CouplingDg ()=default

solverType &	dgSolver () const
	Return MPI communicator. More...

MInt	solverId () const
	Return solver id. More...

DgSysEqnAcousticPerturb< nDim > &	sysEqn ()
	Return reference to SysEqn object. More...

ElementCollector &	elements ()
	Return reference to elements. More...

MInt	noElements () const
	Return number of elements. More...

MFloat *	externalSource () const
	Return pointer to external source memory. More...

MInt	getElementByCellId (const MInt cellId)
	Return element id for cell id. More...

MInt	minPolyDeg () const
	Return the minimum polynomial degree. More...

MInt	maxPolyDeg () const
	Return the maximum polynomial degree. More...

MString	outputDir () const
	Return output directory. More...

void	saveNodalData (const MString &fileNameBase, const MInt noVars, const std::vector< MString > &varNames, const MFloat *const data) const
	Save nodal data to file. More...

Static Public Member Functions
static constexpr MInt	noVelocities ()
	Return number of velocity variables. More...

static constexpr MInt	noVorticities ()
	Return number of vorticity variables. More...

Static Public Member Functions inherited from CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >
static constexpr MInt	noVelocities ()
	Return number of velocity variables. More...

static constexpr MInt	noVorticities ()
	Return number of vorticity variables. More...

Public Attributes
MBool	m_calcProjectionError
	Calculate the L2 error of the Galerkin projection. More...

std::vector< MInt >	m_calcSourceDonorCells
	List of all donor cell ids for which source terms need to be computed. More...

MBool	m_checkConservation
	Check if each Galerkin projection is conservative. More...

MFloat	m_fixedTimeStep
	Fixed time step to use. More...

MBool	m_hasDgCartesianSolver
	Store whether this domain has DG cells/elements. More...

MBool	m_hasDonorCartesianSolver
	Store whether this domain has Cartesian donor solver cells. More...

MBool	m_isFirstSourceCalculation
	Store whether this is the first calculation of the source terms. More...

MBool	m_isRestart
	Store whether this is a restart (in case special treatment is necessary) More...

MFloat	m_maxConservationError
	Maximum conservation error. More...

MFloat	m_maxL2Error
	Maximum computed L2 error of the Galerkin projection. More...

std::vector< MFloat >	m_meanVars
	Local storage for mean variables of the donor cells. More...

std::array< MInt, s_totalNoMeanVars >	m_meanVarsIndex

MInt	m_noActiveDonorCells

MInt	m_noDonorCells
	Total number of donor cells on this domain. More...

MFloat	m_previousTime
	Previous time for the calculation of time derivatives. More...

std::array< MInt, Timers::_count >	m_timers

Private Member Functions
void	sanityCheck ()
	Perform sanity checks. More...

FvCartesianSolverType &	donorSolver (const MInt xSolverId=0) const override

void	getDonorVelocityAndVorticity (const std::vector< MInt > &donorCellIds, MFloatScratchSpace &p_velocity, MFloatScratchSpace &p_vorticity) override

MFloat	calcTimeStep ()
	Return the time step size dt as determined by the coupling condition. More...

void	calcSourceLambLinearized (const MFloat const velocity, const MFloat const vorticity, MFloat *sourceTerms) override
	Calculate the linearized Lamb vector coupling source terms on all donor cells where it is needed. More...

void	calcSourceLambNonlinear (const MFloat const velocity, const MFloat const vorticity, MFloat *const sourceTerms) override
	Calculate the nonlinear Lamb vector coupling source terms on all donor cells where it is needed. More...

void	calcSourceQmII (const MFloat const velocity, MFloat const sourceTerms) override
	Calculate the q_mII source terms on all donor cells where it is needed. More...

void	calcSourceQmIII (const MFloat const velocity, MFloat sourceTerms) override
	Calculate the q_mIII source terms on all donor cells where it is needed. More...

void	calcSourceQe (const MFloat const velocity, const MFloat time, MFloat const sourceTerms) override
	Calculate the q_e source terms on all donor cells where it is needed. More...

void	calcSourceQc (const MFloat const velocity, MFloat const sourceTerms, const MFloat time, const MInt timeStep) override
	Calculate the q_c source terms on all donor cells where it is needed. More...

Private Attributes
MInt	m_loadBalancingReinitStage = -1
	DLB reinitialization stage. More...

std::vector< MFloat >	m_oldPressure {}
	Store previous pressure term for dp/dt calculation. More...

Additional Inherited Members
Protected Types inherited from CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >
using	ElementCollector = maia::dg::collector::ElementCollector< nDim, DgSysEqnAcousticPerturb< nDim > >

Protected Member Functions inherited from CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >
void	calcInitialCondition (const MFloat time)
	Apply initial conditions for this coupling condition. More...

void	initCoupler ()
	Initialize the coupling condition (data structures). More...

void	initData ()
	Initialize the data (initial conditions or for a restart) of the coupling condition. More...

void	initProjection ()
	Initialize the projection information for spatial coupling. More...

void	initRestart (const MFloat time, const MFloat dt)
	Perform initializations for a restart. More...

void	initSourceFilter ()
	Calculate source filter values for all elements and store element ids on which source terms need to be computed. More...

void	initTimers ()
	Create timers. More...

MBool	loadCouplingData (const MString &filename, const MString &name_, const MInt stride, MFloat *data)
	Auxiliary method to load coupling data (i.e. anything coming from the LES) from a file. More...

void	loadMeanQuantities (const MBool skipNodeVars=false)
	Load mean velocities from file and store them to the node variables. More...

void	projectToElement (const MInt elementId, const MInt noVars, const MFloat data, const MFloat defaultValues, MFloat *target)
	Project the given data fields onto a single element. More...

void	saveFilterValues ()
	Save filter values to file. More...

void	saveFilterValuesDonor ()
	Save the filter values on the donor cells. More...

void	applyStoredSources (const MFloat time)
	Apply the stored source terms to the time derivative. More...

void	storeSources (const MFloat time, const MInt timeStep)
	Load coupling data from LES, then calculate, accumulate, project and store coupling source terms. More...

virtual void	performUnitConversion (const MString &, const MInt, const MInt, MFloat *)

virtual void	calcSourceLambLinearized (const MFloat const velocity, const MFloat const vorticity, MFloat *sourceTerms)=0

virtual void	calcSourceLambNonlinear (const MFloat const velocity, const MFloat const vorticity, MFloat *const sourceTerms)=0

virtual void	calcSourceQmII (const MFloat const velocity, MFloat const sourceTerms)=0

virtual void	calcSourceQmIII (const MFloat const velocity, MFloat sourceTerms)=0

virtual void	calcSourceQe (const MFloat const velocity, const MFloat time, MFloat const sourceTerms)=0

virtual void	calcSourceQc (const MFloat const velocity, MFloat const sourceTerms, const MFloat time, const MInt timeStep)=0

void	saveSourceTermsDonorGrid (const MInt timeStep, const MFloat *const data)
	Store the source terms on the donor grid. More...

void	saveSourceTermsTargetGrid (const MInt timeStep)
	Store the source terms on the target grid, i.e. after interpolation. More...

void	readProperties () override final
	Read properties and store in member variables. More...

void	checkProperties () override final

virtual DonorSolverType &	donorSolver (const MInt solverId=0) const=0

virtual void	getDonorVelocityAndVorticity (const std::vector< MInt > &donorCellIds, MFloatScratchSpace &p_velocity, MFloatScratchSpace &p_vorticity)=0

Protected Member Functions inherited from CouplingFv< nDim, FvSysEqn >
MInt	noSolvers () const

solverType &	fvSolver (const MInt solverId=0) const

MInt	a_noFvCells () const

MInt	a_noFvGridCells () const

Protected Member Functions inherited from Coupling
MFloat	returnLoadRecord () const

MFloat	returnIdleRecord () const

Protected Attributes inherited from CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >
MBool	m_isRestart
	Store whether this is a restart (in case special treatment is necessary) More...

MBool	m_hasDgCartesianSolver
	Store whether this domain has DG cells/elements. More...

MBool	m_hasDonorCartesianSolver
	Store whether this domain has Cartesian donor solver cells. More...

MInt	m_maxNoNodesXD
	Maximum number of nodes of an element (corresponding to maxPolyDeg) More...

MFloat	m_fixedTimeStep
	Fixed time step to use. More...

MFloat	m_previousTime
	Previous time for the calculation of time derivatives. More...

MInt	m_previousTimeStep
	Previous time step (to determine whether new sources need to be calculated) More...

std::vector< MInt >	m_activeMeanVars
	List of active mean variables for all active source terms. More...

MString	m_meanDataFileName
	File name for mean quantities. More...

std::vector< MInt >	m_activeSourceTerms
	List of active source terms. More...

MBool	m_saveSourceTermsDonorGrid
	Store whether the sources on the donor grid should be saved as well. More...

MInt	m_saveSourceTermsInterval
	Interval at which source term data should be saved to disk. More...

MBool	m_calcProjectionError
	Calculate the L2 error of the Galerkin projection. More...

MInt	m_noActiveDonorCells

MInt	m_noDonorCells
	Total number of donor cells on this domain. More...

std::vector< std::vector< MInt > >	m_elementDonorLevels
	Donor cell levels relative to element. More...

std::vector< std::vector< MInt > >	m_elementDonorMap
	Mapping from donor cells to elements. More...

std::vector< std::vector< MInt > >	m_elementDonorPos
	Donor cell positions on the corresponding cell level. More...

std::vector< ProjectionType >	m_projection
	Galerkin projection (access by polynomial degree) More...

MBool	m_isFirstSourceCalculation
	Store whether this is the first calculation of the source terms. More...

std::vector< MFloat >	m_sourceTerms
	Local storage for source terms. More...

std::vector< MInt >	m_calcSourceDonorCells
	List of all donor cell ids for which source terms need to be computed. More...

std::vector< MInt >	m_calcSourceElements
	List of all element ids for which source terms need to be computed. More...

MFloat	m_sourceFactor
	Factor by which the source terms are multiplied. More...

MBool	m_checkConservation
	Check if each Galerkin projection is conservative. More...

MFloat	m_maxConservationError
	Maximum conservation error. More...

MFloat	m_maxL2Error
	Maximum computed L2 error of the Galerkin projection. More...

std::vector< MFloat >	m_meanVars
	Local storage for mean variables of the donor cells. More...

std::vector< MInt >	m_elementInsideBody
	Marker if elements are inside a geometric object. More...

Filter< nDim >	m_sourceTermFilter
	Auxiliary object that handles source filtering. More...

std::vector< MFloat >	m_filter
	Local storage for source filter values. More...

std::vector< MFloat >	m_filterDonor
	Local storage for source filter values on donor cells. More...

MInt	m_noCutModesLowPass
	Number of modes to cut using the low-pass source term. More...

MBool	m_useLowPassFilter
	Switch low pass on and off to allow disabling e.g. for node vars. More...

std::vector< MFloatTensor >	m_vdmLowPass
	Vandermonde matrix/matrices for the low-pass filter. More...

MBool	m_applySourceFilterDonor
	Apply source filter on donor cells or on DG elements after projection. More...

MBool	m_saveSourceTermFilter
	Store whether filter values should be written to a file at initialization. More...

MBool	m_projectionFilter
	Use spatial projection filter (i.e. exclude elements from the projection) More...

std::vector< MFloat >	m_projectionFilterBox
	Spatial projection filter box (excluding) More...

std::array< MInt, s_totalNoMeanVars >	m_meanVarsIndex

std::array< MInt, Timers::_count >	m_timers

Protected Attributes inherited from CouplingFv< nDim, FvSysEqn >
std::vector< solverType * >	m_fvSolvers

Protected Attributes inherited from CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >
solverType *	m_dgSolver

Static Protected Attributes inherited from CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >
static const MInt	s_totalNoMeanVars

static const std::array< MString, ST::totalNoSourceTerms >	s_sourceTermNames
	Hold indices for source terms. More...

Detailed Description

template<MInt nDim, class FvSysEqn>
class DgCcAcousticPerturb< nDim, FvSysEqn >

Author: Michael Schlottke-Lakemper (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: 2016-07-08

TODO labels:COUPLER,toremove Re-enable offline coupling or remove it entirely

Definition at line 40 of file dgccacousticperturbsourcefiles.h.

Member Typedef Documentation

◆ Base

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::Base = Coupling

Definition at line 43 of file dgccacousticperturbsourcefiles.h.

◆ BaseDg

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::BaseDg = CouplingDgApe<nDim, BaseFv>

Definition at line 49 of file dgccacousticperturbsourcefiles.h.

◆ BaseFv

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::BaseFv = CouplingFv<nDim, FvSysEqn>

Definition at line 45 of file dgccacousticperturbsourcefiles.h.

◆ CV

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::CV = typename BaseDg::CV

Definition at line 74 of file dgccacousticperturbsourcefiles.h.

◆ DgCartesianSolverType

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::DgCartesianSolverType = typename BaseDg::DgCartesianSolverType

Definition at line 72 of file dgccacousticperturbsourcefiles.h.

◆ FvCartesianSolverType

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::FvCartesianSolverType = typename BaseFv::solverType

Definition at line 46 of file dgccacousticperturbsourcefiles.h.

◆ MV

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::MV = typename BaseDg::MV

Definition at line 75 of file dgccacousticperturbsourcefiles.h.

◆ ProjectionType

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::ProjectionType = typename BaseDg::ProjectionType

Definition at line 73 of file dgccacousticperturbsourcefiles.h.

◆ ST

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::ST = typename BaseDg::ST

Definition at line 76 of file dgccacousticperturbsourcefiles.h.

◆ SysEqn

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::SysEqn = typename BaseDg::SysEqn

Definition at line 77 of file dgccacousticperturbsourcefiles.h.

◆ Timers

template<MInt nDim, class FvSysEqn >

using DgCcAcousticPerturb< nDim, FvSysEqn >::Timers = typename BaseDg::Timers

Definition at line 78 of file dgccacousticperturbsourcefiles.h.

Constructor & Destructor Documentation

◆ DgCcAcousticPerturb()

template<MInt nDim, class FvSysEqn >

DgCcAcousticPerturb< nDim, FvSysEqn >::DgCcAcousticPerturb	(	const MInt	couplingId,
		FvCartesianSolverType *	fvSolver_,
		DgCartesianSolverType *const	dgSolver_
	)

inline

Definition at line 84 of file dgccacousticperturbsourcefiles.h.

85 : Base(couplingId), BaseDg(couplingId, dgSolver_, fvSolver_) {}

DgCcAcousticPerturb::Base

Coupling Base

Definition: dgccacousticperturbsourcefiles.h:43

DgCcAcousticPerturb::BaseDg

CouplingDgApe< nDim, BaseFv > BaseDg

Definition: dgccacousticperturbsourcefiles.h:49

◆ ~DgCcAcousticPerturb()

template<MInt nDim, class FvSysEqn >

DgCcAcousticPerturb< nDim, FvSysEqn >::~DgCcAcousticPerturb

virtual

Author: Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: 2015-10-01

Definition at line 164 of file dgccacousticperturbsourcefiles.h.

                                                          {
  TRACE();
 
  MFloat maxGlobalConservationError = -1.0;
  MFloat maxGlobalL2Error = -1.0;
 
  // Compute global maximum conservation error if activated
  if(m_checkConservation && m_hasDgCartesianSolver) {
    MPI_Allreduce(&m_maxConservationError, &maxGlobalConservationError, 1, maia::type_traits<MFloat>::mpiType(),
                  MPI_MAX, dgSolver().mpiComm(), AT_, "m_maxConservationError", "maxGlobalConservationError");
 
    m_log << "Global maximum Galerkin projection conservation error: " << std::scientific << maxGlobalConservationError
          << std::endl;
    m_log << "Local maximum Galerkin projection conservation error: " << std::scientific << m_maxConservationError
          << std::endl;
  }
 
  // Compute global maximum L2 projection error if activated
  if(m_calcProjectionError && m_hasDgCartesianSolver) {
    MPI_Allreduce(&m_maxL2Error, &maxGlobalL2Error, 1, maia::type_traits<MFloat>::mpiType(), MPI_MAX,
                  dgSolver().mpiComm(), AT_, "m_maxL2Error", "maxGlobalL2Error");
 
    m_log << "Global maximum Galerking projection L2 error: " << std::scientific << maxGlobalL2Error << std::endl;
    m_log << "Local maximum Galerking projection L2 error: " << std::scientific << m_maxL2Error << std::endl;
  }
 
  // Write the maximum global errors to file
  if(m_hasDgCartesianSolver && dgSolver().domainId() == 0 && (m_checkConservation || m_calcProjectionError)) {
    std::ofstream errorFile(outputDir() + "errors.txt");
 
    if(m_checkConservation) {
      errorFile << "maxGlobalConservationError: " << std::scientific << maxGlobalConservationError << std::endl;
    }
    if(m_calcProjectionError) {
      errorFile << "maxGlobalProjectionError:   " << std::scientific << maxGlobalL2Error << std::endl;
    }
 
    errorFile.close();
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::Class]);
}

Member Function Documentation

◆ balancePost()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::balancePost ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 101 of file dgccacousticperturbsourcefiles.h.

                              {
    // Nothing to be done here
    m_loadBalancingReinitStage = -1; // Reset reinitialization stage
  };

◆ balancePre()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::balancePre ( )

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 97 of file dgccacousticperturbsourcefiles.h.

                             {
    m_loadBalancingReinitStage = 0; // Set reinitialization stage
    this->initCoupler();            // Perform main (re-)initialization of coupler
  };

◆ calcSourceLambLinearized()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::calcSourceLambLinearized	(	const MFloat *const	velocity,
		const MFloat *const	vorticity,
		MFloat *	sourceTerms
	)

overrideprivatevirtual

Author: Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: 2015-10-01

Parameters

[in]	velocity	Velocities of all donor cells.
[in]	vorticity	Vorticities of all donor cells.
[out]	sourceTerms	Storage for computed source terms.

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 412 of file dgccacousticperturbsourcefiles.h.

                                                                                        {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::CalcSourceLamb]);
 
  // Indices of first velocity/vorticity component in m_meanVars
  const MInt veloIndex = m_meanVarsIndex[MV::UU0[0]];
  const MInt vortIndex = m_meanVarsIndex[MV::VORT0[0]];
 
  std::array<MFloat, MAX_SPACE_DIMENSIONS> veloP{};
  std::array<MFloat, MAX_SPACE_DIMENSIONS> vortP{};
 
  // Calculate source terms on all 'active' donor leaf cells, i.e. that are
  // mapped to elements with nonzero filter values
  for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
    const MInt donorId = m_calcSourceDonorCells[donorIndex];
    // Create convenience pointers
    const MFloat* meanVars = &m_meanVars[donorIndex * noMeanVars()];
    const MFloat* velo = &velocity[donorId * noVelocities()];
    const MFloat* vort = &vorticity[donorId * noVorticities()];
 
    // Compute velocity fluctuations
    for(MInt dim = 0; dim < nDim; dim++) {
      veloP[dim] = velo[dim] - meanVars[veloIndex + dim];
    }
    // Compute vorticity fluctuations
    for(MInt i = 0; i < noVorticities(); i++) {
      vortP[i] = vort[i] - meanVars[vortIndex + i];
    }
 
    // The complete source term is:
    // S = -L' = -(w' X u0 + w0 X u')
    // Since the Lamb vector is defined with vorticity as 'nabla x u' but MAIA
    // calculates it as '0.5 nabla x u', we multiply the resulting Lamb vector
    // by 2.0
    const MInt sourcesOffset = donorId * SysEqn::noVars() + CV::UU[0];
    IF_CONSTEXPR(nDim == 2) { // 2D
      // x-component: -(-wz' * u0y - w0z * uy')
      sourceTerms[sourcesOffset] += -2.0 * (-vortP[0] * meanVars[veloIndex + 1] - meanVars[vortIndex] * veloP[1]);
 
      // y-component: -(wz' * u0x + w0z * ux')
      sourceTerms[sourcesOffset + 1] += -2.0 * (vortP[0] * meanVars[veloIndex] + meanVars[vortIndex] * veloP[0]);
    }
    else { // 3D
      // x-component: -(wy' * u0z - wz' * u0y + w0y * uz' - w0z * uy')
      sourceTerms[sourcesOffset] += -2.0
                                    * (vortP[1] * meanVars[veloIndex + 2] - vortP[2] * meanVars[veloIndex + 1]
                                       + meanVars[vortIndex + 1] * veloP[2] - meanVars[vortIndex + 2] * veloP[1]);
 
      // y-component: -(wz' * u0x - wx' * u0z + w0z * ux' - w0x * uz')
      sourceTerms[sourcesOffset + 1] += -2.0
                                        * (vortP[2] * meanVars[veloIndex] - vortP[0] * meanVars[veloIndex + 2]
                                           + meanVars[vortIndex + 2] * veloP[0] - meanVars[vortIndex] * veloP[2]);
 
      // z-component: -(wx' * u0y - wy' * u0x + w0x * uy' - w0y * ux')
      sourceTerms[sourcesOffset + 2] += -2.0
                                        * (vortP[0] * meanVars[veloIndex + 1] - vortP[1] * meanVars[veloIndex]
                                           + meanVars[vortIndex] * veloP[1] - meanVars[vortIndex + 1] * veloP[0]);
    }
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CalcSourceLamb]);
}

◆ calcSourceLambNonlinear()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::calcSourceLambNonlinear	(	const MFloat *const	velocity,
		const MFloat *const	vorticity,
		MFloat *const	sourceTerms
	)

overrideprivatevirtual

Author: Ansgar Niemoeller (ansgar) a.nie.nosp@m.moel.nosp@m.ler@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: 2016-08-18

Parameters

[in]	velocity	Velocities of all donor cells.
[in]	vorticity	Vorticities of all donor cells.
[out]	sourceTerms	Storage for computed source terms.

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 233 of file dgccacousticperturbsourcefiles.h.

                                                                                             {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::CalcSourceLamb]);
 
  // Index of first lamb vector component in m_meanVars
  const MInt lambIndex = m_meanVarsIndex[MV::LAMB0[0]];
 
  std::array<MFloat, MAX_SPACE_DIMENSIONS> lambVector{};
 
  // Calculate source terms on all 'active' donor leaf cells, i.e. that are
  // mapped to elements with nonzero filter values
  for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
    const MInt donorId = m_calcSourceDonorCells[donorIndex];
    // Create convenience pointers
    const MFloat* meanVars = &m_meanVars[donorIndex * noMeanVars()];
    const MFloat* velo = &velocity[donorId * noVelocities()];
    const MFloat* vort = &vorticity[donorId * noVorticities()];
 
    // Compute instantaneous Lamb vector
    if constexpr(nDim == 2) {
      lambVector[0] = -vort[0] * velo[1];
      lambVector[1] = vort[0] * velo[0];
    } else {
      lambVector[0] = vort[1] * velo[2] - vort[2] * velo[1];
      lambVector[1] = vort[2] * velo[0] - vort[0] * velo[2];
      lambVector[2] = vort[0] * velo[1] - vort[1] * velo[0];
    }
 
    // The complete source term is:
    // S = -L' = -(w x u - bar(w x u))
    // Since the Lamb vector is defined with vorticity as 'nabla x u' but MAIA
    // calculates it as '0.5 nabla x u', we multiply the resulting Lamb vector
    // by 2.0
    for(MInt dim = 0; dim < nDim; dim++) {
      // Note: source terms are accumulated, thus "+=" and not "="
      sourceTerms[donorId * SysEqn::noVars() + dim] += -2.0 * (lambVector[dim] - meanVars[lambIndex + dim]);
    }
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CalcSourceLamb]);
}

◆ calcSourceQc()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::calcSourceQc	(	const MFloat *const	velocity,
		MFloat *const	sourceTerms,
		const MFloat	time,
		const MInt	timeStep
	)

overrideprivatevirtual

Author: Bjoern Peeters (bjoern) b.pee.nosp@m.ters.nosp@m.@aia..nosp@m.rwth.nosp@m.-aach.nosp@m.en.d.nosp@m.e

Date: 2017-05-01

Parameters

[in]	velocity	Velocities of all donor cells.
[in]	time	Current simulation time.
[in]	timeStep	Current simulation time step.
[out]	sourceTerms	Storage for computed source terms.

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 633 of file dgccacousticperturbsourcefiles.h.

                                                                                     {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::CalcSourceQc]);
 
  const MInt veloIndex = m_meanVarsIndex[MV::UU0[0]];
  const MInt drhoIndex = m_meanVarsIndex[MV::DRHO[0]];
  const MInt rhoDivUIndex = m_meanVarsIndex[MV::RHODIVU[0]];
  const MInt uGradRhoIndex = m_meanVarsIndex[MV::UGRADRHO[0]];
  std::array<MInt, nDim> divIndex;
  for(MInt i = 0; i < nDim; i++) {
    divIndex[i] = m_meanVarsIndex[MV::DU[i]];
  }
  const MInt cIndex = m_meanVarsIndex[MV::C0];
  const MInt rhoIndex = m_meanVarsIndex[MV::RHO0];
 
  // Calculate source terms on all donor leaf cells that are mapped to
  // elements
  // with nonzero filter values
  for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
    const MInt donorId = m_calcSourceDonorCells[donorIndex];
 
    // Create convenience pointer
    const MFloat* const meanVars = &m_meanVars[donorIndex * noMeanVars()];
 
    // bar(u)
    std::array<MFloat, nDim> veloM;
    for(MInt dim = 0; dim < nDim; dim++) {
      veloM[dim] = meanVars[veloIndex + dim];
    }
 
    // bar(grad(rho))
    std::array<MFloat, nDim> drhoM;
    for(MInt dim = 0; dim < nDim; dim++) {
      drhoM[dim] = meanVars[drhoIndex + dim];
    }
 
    // bar(rho * div(u))
    MFloat rhodivuM = 0.0;
    for(MInt dim = 0; dim < nDim; dim++) {
      rhodivuM += meanVars[rhoDivUIndex + dim];
    }
 
    // bar(u * grad(rho))
    MFloat ugradrhoM = 0.0;
    for(MInt dim = 0; dim < nDim; dim++) {
      ugradrhoM += meanVars[uGradRhoIndex + dim];
    }
 
    MFloat divUm = 0.0;
    for(MInt dim = 0; dim < nDim; dim++) {
      divUm += meanVars[divIndex[dim]];
    }
 
    MFloat divU = 0.0;
    divU += fvSolver().a_slope(donorId, fvSolver().PV->U, 0);
    divU += fvSolver().a_slope(donorId, fvSolver().PV->V, 1);
    IF_CONSTEXPR(nDim == 3) { divU += fvSolver().a_slope(donorId, fvSolver().PV->W, 2); }
 
    // Compute q_c
    const MFloat rhoM = meanVars[rhoIndex];
    const MFloat curRho = fvSolver().a_variable(donorId, fvSolver().CV->RHO);
    const MFloat* const velo = &velocity[donorId * noVelocities()];
    MFloat qcSource = 0.0;
    qcSource += (curRho - rhoM) * (divU - divUm);
    qcSource -= rhodivuM;
    qcSource -= ugradrhoM;
    qcSource += rhoM * divUm;
    for(MInt dim = 0; dim < nDim; dim++) {
      qcSource += (velo[dim] - veloM[dim]) * ((fvSolver().a_slope(donorId, fvSolver().PV->RHO, dim)) - drhoM[dim]);
      qcSource += veloM[dim] * drhoM[dim];
    }
 
    // Note: the multiplication with c^2 is technically not part of q_c
    qcSource *= -meanVars[cIndex] * meanVars[cIndex];
 
    // Store source term at output memory location
    // Note: source terms are accumulated, thus "+=" and not "="
    sourceTerms[donorId * SysEqn::noVars() + CV::P] += qcSource;
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CalcSourceQc]);
}

◆ calcSourceQe()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::calcSourceQe	(	const MFloat *const	velocity,
		const MFloat	time,
		MFloat *const	sourceTerms
	)

overrideprivatevirtual

Author: Bjoern Peeters (bjoern) b.pee.nosp@m.ters.nosp@m.@aia..nosp@m.rwth.nosp@m.-aach.nosp@m.en.d.nosp@m.e

Date: 2017-05-01

Parameters

[in]	velocity	Velocities of all donor cells.
[in]	time	Current simulation time.
[out]	sourceTerms	Storage for computed source terms.

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 487 of file dgccacousticperturbsourcefiles.h.

                                                                                  {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::CalcSourceQe]);
  TERMM(1, "untested in new coupling condition");
 
  // If this is the first invocation, we need to perform some initializations.
  if(m_isFirstSourceCalculation) {
    // Create persistent storage for old pressure values
    m_oldPressure.resize(m_noActiveDonorCells);
 
    if(m_isRestart) {
      // If this is a restart, initialize old pressure values from oldVariables, which should have
      // been loaded by setting the property "restartOldVariables" to true.
      // @ansgar TODO labels:COUPLER,FV support for balance, redistribute oldPressure/oldVariables in FV solver
      MFloatScratchSpace buffer(m_noDonorCells, AT_, "buffer");
      fvSolver().oldPressure(&buffer[0]);
      for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
        const MInt donorId = m_calcSourceDonorCells[donorIndex];
        m_oldPressure[donorIndex] = buffer[donorId];
      }
    } else {
      // If this is *not* a restart, assume that this is the first time step. In this case, the old
      // pressure values are initialized with the current values to have a gradient of zero
      for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
        const MInt donorId = m_calcSourceDonorCells[donorIndex];
        m_oldPressure[donorIndex] = fvSolver().a_pvariable(donorId, fvSolver().PV->P);
      }
    }
 
    // Calculate slopes for the calculation of the velocity divergence
    fvSolver().LSReconstructCellCenter();
  }
 
  // Calculate dt (set to infinity if this is the first time step of a non-restarted simulation)
  const MFloat dt =
      (m_isFirstSourceCalculation && !m_isRestart) ? std::numeric_limits<MFloat>::infinity() : time - m_previousTime;
 
  // Calculate source terms on all donor leaf cells that are mapped to elements with nonzero filter
  // values
  const MInt rhoIndex = m_meanVarsIndex[MV::RHO0];
  const MInt pIndex = m_meanVarsIndex[MV::P0];
  const MInt cIndex = m_meanVarsIndex[MV::C0];
  const MInt veloIndex = m_meanVarsIndex[MV::UU0[0]];
  const MInt dcIndex = m_meanVarsIndex[MV::DC0[0]];
  std::array<MInt, nDim> divIndex;
  for(MInt i = 0; i < nDim; i++) {
    divIndex[i] = m_meanVarsIndex[MV::DU[i]];
  }
  const MInt drhoIndex = m_meanVarsIndex[MV::DRHO[0]];
  const MInt dpIndex = m_meanVarsIndex[MV::DP[0]];
 
  for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
    const MInt donorId = m_calcSourceDonorCells[donorIndex];
 
    // Calculate dp/dt and store current pressure for the next time step
    const MFloat curP = fvSolver().a_pvariable(donorId, fvSolver().PV->P);
    const MFloat dpdt = (curP - m_oldPressure[donorIndex]) / dt;
    m_oldPressure[donorIndex] = curP;
 
    // Create convenience pointers
    const MFloat* meanVars = &m_meanVars[donorIndex * noMeanVars()];
 
    // bar(u)
    std::array<MFloat, nDim> veloM;
    for(MInt dim = 0; dim < nDim; dim++) {
      veloM[dim] = meanVars[veloIndex + dim];
    }
 
    // bar(grad(c))
    std::array<MFloat, nDim> dcM;
    for(MInt dim = 0; dim < nDim; dim++) {
      dcM[dim] = meanVars[dcIndex + dim];
    }
 
    // bar(grad(rho))
    std::array<MFloat, nDim> drhoM;
    for(MInt dim = 0; dim < nDim; dim++) {
      drhoM[dim] = meanVars[drhoIndex + dim];
    }
 
    // bar(grad(p))
    std::array<MFloat, nDim> dpM;
    for(MInt dim = 0; dim < nDim; dim++) {
      dpM[dim] = meanVars[dpIndex + dim];
    }
 
    // Mean of du/dx, dv/dy, dw/dz for the divergence u
    MFloat divUm = 0.0;
    for(MInt dim = 0; dim < nDim; dim++) {
      divUm += meanVars[divIndex[dim]];
    }
 
    MFloat divU = 0.0;
    for(MInt dim = 0; dim < nDim; dim++) {
      divU += fvSolver().a_slope(donorId, fvSolver().PV->VV[dim], dim);
    }
 
    // Compute drho/dt = -(rho* div(u)  + u * grad(rho))
    const MFloat* const velo = &velocity[donorId * noVelocities()];
    MFloat drhodttmp = 0.0;
    for(MInt dim = 0; dim < nDim; dim++) {
      drhodttmp += velo[dim] * fvSolver().a_slope(donorId, fvSolver().PV->RHO, dim);
    }
    const MFloat curRho = fvSolver().a_variable(donorId, fvSolver().CV->RHO);
    const MFloat drhodt = -curRho * divU - drhodttmp;
 
    // Compute q_e
    const MFloat rhoM = meanVars[rhoIndex];
    const MFloat pM = meanVars[pIndex];
    const MFloat cM = meanVars[cIndex];
    const MFloat cTerm = cM * cM;
    MFloat qeSource = 0.0;
    qeSource += drhodt - (1.0 / cTerm) * dpdt;
    qeSource += (curRho - rhoM) * divUm;
    qeSource -= ((curP - pM) / cTerm) * divUm;
    for(MInt dim = 0; dim < nDim; dim++) {
      // bar(u) * (grad(rho) - bar(grad(rho)))
      qeSource += veloM[dim] * ((fvSolver().a_slope(donorId, fvSolver().PV->RHO, dim)) - drhoM[dim]);
      qeSource -= (1.0 / cTerm) * veloM[dim] * ((fvSolver().a_slope(donorId, fvSolver().PV->P, dim)) - dpM[dim]);
      qeSource += 2.0 * ((curP - pM) / (cM * cM * cM)) * veloM[dim] * dcM[dim];
    }
 
    // Note: the multiplication with c^2 is technically not part of q_e
    qeSource *= -cTerm;
 
    // Store source term at output memory location
    // Note: source terms are accumulated, thus "+=" and not "="
    sourceTerms[donorId * SysEqn::noVars() + CV::P] += qeSource;
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CalcSourceQe]);
}

◆ calcSourceQmII()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::calcSourceQmII	(	const MFloat *const	velocity,
		MFloat *const	sourceTerms
	)

overrideprivatevirtual

Author: Bjoern Peeters (bjoern) b.pee.nosp@m.ters.nosp@m.@aia..nosp@m.rwth.nosp@m.-aach.nosp@m.en.d.nosp@m.e

Date: 2017-05-01

Parameters

[in]	velocity	Velocities of all donor cells.
[in]	time	Current simulation time.
[out]	sourceTerms	Storage for computed source terms.

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 287 of file dgccacousticperturbsourcefiles.h.

                                                                                    {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::CalcSourceQmII]);
 
  const MInt rhoIndex = m_meanVarsIndex[MV::RHO0];
  const MInt pIndex = m_meanVarsIndex[MV::P0];
  const MInt drhoIndex = m_meanVarsIndex[MV::DRHO[0]];
  const MInt dpIndex = m_meanVarsIndex[MV::DP[0]];
  const MInt dprhoIndex = m_meanVarsIndex[MV::GRADPRHO[0]];
 
  // Calculate source terms on all donor leaf cells that are mapped to elements
  // with nonzero filter values
  for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
    const MInt donorId = m_calcSourceDonorCells[donorIndex];
    // Create convenience pointers
    const MFloat* meanVars = &m_meanVars[donorIndex * noMeanVars()];
    const MFloat curRho = fvSolver().a_variable(donorId, fvSolver().CV->RHO);
    const MFloat curP = fvSolver().a_pvariable(donorId, fvSolver().PV->P);
    const MFloat rhoM = meanVars[rhoIndex];
    const MFloat pM = meanVars[pIndex];
 
    // bar(grad(rho))
    std::array<MFloat, nDim> drhoM;
    for(MInt dim = 0; dim < nDim; dim++) {
      drhoM[dim] = meanVars[drhoIndex + dim];
    }
 
    // bar(grad(p))
    std::array<MFloat, nDim> dpM;
    for(MInt dim = 0; dim < nDim; dim++) {
      dpM[dim] = meanVars[dpIndex + dim];
    }
 
    // bar(grad(p)/rho)
    std::array<MFloat, nDim> dprhoM;
    for(MInt dim = 0; dim < nDim; dim++) {
      dprhoM[dim] = meanVars[dprhoIndex + dim];
    }
 
    std::array<MFloat, nDim> qmIISource;
    for(MInt dim = 0; dim < nDim; dim++) {
      // Calculate source term, starting with term 1
      qmIISource[dim] = ((fvSolver().a_slope(donorId, fvSolver().PV->P, dim)) - dpM[dim]) / rhoM
                        // term 2
                        - ((curP - pM) / (rhoM * rhoM)) * drhoM[dim]
                        // term 3
                        - (fvSolver().a_slope(donorId, fvSolver().PV->P, dim)) / curRho
                        // term 4
                        + dprhoM[dim];
    }
 
    // Store source term at output memory location
    for(MInt dim = 0; dim < nDim; dim++) {
      // Note: source terms are accumulated, thus "+=" and not "="
      sourceTerms[donorId * SysEqn::noVars() + CV::UU[0] + dim] += qmIISource[dim];
    }
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CalcSourceQmII]);
}

◆ calcSourceQmIII()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::calcSourceQmIII	(	const MFloat *const	velocity,
		MFloat *	sourceTerms
	)

overrideprivatevirtual

TODO labels:COUPLER,totest requires testing!

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 354 of file dgccacousticperturbsourcefiles.h.

                                                                                                           {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::CalcSourceQmIII]);
  TERMM(1, "requires testing");
 
  const MInt umIndex = m_meanVarsIndex[MV::UU0[0]];
 
  // Calculate source terms on all donor leaf cells that are mapped to elements
  // with nonzero filter values
  for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
    const MInt donorId = m_calcSourceDonorCells[donorIndex];
    // Create convenience pointers
    const MFloat* meanVars = &m_meanVars[donorIndex * noMeanVars()];
 
    std::array<MFloat, nDim> qmIIISource;
    std::fill_n(&qmIIISource[0], nDim, 0.0);
 
    // Calculate source term
    for(MInt dim = 0; dim < nDim; dim++) {
      const MFloat velDiff = velocity[donorId * nDim + dim] - meanVars[umIndex + dim];
 
      for(MInt i = 0; i < nDim; i++) {
        const MFloat velGrad = fvSolver().a_slope(donorId, fvSolver().PV->VV[dim], i);
        const MFloat velGradM = meanVars[m_meanVarsIndex[MV::GRADU[dim * nDim + i]]];
 
        qmIIISource[i] += velDiff * (velGrad - velGradM);
      }
 
      // Substract mean term
      qmIIISource[dim] -= meanVars[m_meanVarsIndex[MV::UGRADU[dim]]];
 
      for(MInt i = 0; i < nDim; i++) {
        const MInt gradUPos = i * nDim + dim;
        qmIIISource[dim] += meanVars[m_meanVarsIndex[MV::UU0[i]]] * meanVars[m_meanVarsIndex[MV::GRADU[gradUPos]]];
      }
    }
 
    // Store source term at output memory location
    for(MInt dim = 0; dim < nDim; dim++) {
      // Note: source terms are accumulated, thus "-=" and not "="
      sourceTerms[donorId * SysEqn::noVars() + CV::UU[0] + dim] -= qmIIISource[dim];
    }
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CalcSourceQmIII]);
}

◆ calcTimeStep()

template<MInt nDim, class FvSysEqn >

MFloat DgCcAcousticPerturb< nDim, FvSysEqn >::calcTimeStep

private

Author: Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: 2015-10-01

Returns: The next time step size (dt).

Definition at line 745 of file dgccacousticperturbsourcefiles.h.

                                                         {
  TRACE();
 
  if(m_fixedTimeStep < 0.0) {
    TERMM(1, "Fixed time step less than zero.");
  }
 
  fvSolver().forceTimeStep(m_fixedTimeStep);
  dgSolver().forceTimeStep(m_fixedTimeStep);
 
  // FIXME labels:COUPLER Return proper time step determined by both solvers
  return m_fixedTimeStep;
}

◆ cellDataSizeDlb()

template<MInt nDim, class FvSysEqn >

MInt DgCcAcousticPerturb< nDim, FvSysEqn >::cellDataSizeDlb	(	const MInt	NotUseddataId,
		const MInt	NotUsedcellId
	)

overridevirtual

Reimplemented from Coupling.

Definition at line 760 of file dgccacousticperturbsourcefiles.h.

                                                                                                  {
  TRACE();
  TERMM_IF_NOT_COND(dataId == 0, "invalid data id");
 
  // Convert to solver cell id and check
  const MInt fvCellId = fvSolver().grid().tree().grid2solver(gridCellId);
  if(fvCellId < 0) {
    return 0;
  }
 
  MInt dataSize = 0;
  // TODO labels:COUPLER Check that ids in m_calcSourceDonorCells are sorted in get/setCellDataDlb
  const MBool foundDonorCell =
      std::binary_search(m_calcSourceDonorCells.begin(), m_calcSourceDonorCells.end(), fvCellId);
  if(foundDonorCell) {
    dataSize = noMeanVars();
  }
  return dataSize;
}

◆ cellDataTypeDlb()

template<MInt nDim, class FvSysEqn >

MInt DgCcAcousticPerturb< nDim, FvSysEqn >::cellDataTypeDlb ( const MInt dataId ) const

inlineoverride

Definition at line 110 of file dgccacousticperturbsourcefiles.h.

                                                         {
    TERMM_IF_NOT_COND(dataId == 0, "invalid data id");
    return MFLOAT;
  };

◆ donorSolver()

template<MInt nDim, class FvSysEqn >

FvCartesianSolverType & DgCcAcousticPerturb< nDim, FvSysEqn >::donorSolver ( const MInt xSolverId = 0 ) const

inlineoverrideprivatevirtual

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 126 of file dgccacousticperturbsourcefiles.h.

126{ return fvSolver(xSolverId); };

◆ finalizeCouplerInit()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::finalizeCouplerInit ( )

inlineoverridevirtual

Implements Coupling.

Definition at line 94 of file dgccacousticperturbsourcefiles.h.

94{ calcTimeStep(); };

DgCcAcousticPerturb::calcTimeStep

MFloat calcTimeStep()

Return the time step size dt as determined by the coupling condition.

Definition: dgccacousticperturbsourcefiles.h:745

◆ forceTimeStep()

template<MInt nDim, class FvSysEqn >

MBool DgCcAcousticPerturb< nDim, FvSysEqn >::forceTimeStep ( ) const

inline

Definition at line 121 of file dgccacousticperturbsourcefiles.h.

121{ return true; }

◆ getCellDataDlb()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::getCellDataDlb	(	const MInt	dataId,
		const MInt	oldNoCells,
		const MInt *const	bufferIdToCellId,
		MFloat *const	data
	)

override

Definition at line 782 of file dgccacousticperturbsourcefiles.h.

                                                                             {
  TRACE();
  TERMM_IF_NOT_COND(dataId == 0, "invalid data id");
 
  const MBool donorIdsSorted = std::is_sorted(m_calcSourceDonorCells.begin(), m_calcSourceDonorCells.end());
  TERMM_IF_NOT_COND(donorIdsSorted, "donor ids not sorted");
 
  if(m_noActiveDonorCells > 0) {
    std::copy_n(&m_meanVars[0], m_noActiveDonorCells * noMeanVars(), data);
  }
}

◆ getDonorVelocityAndVorticity()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::getDonorVelocityAndVorticity	(	const std::vector< MInt > &	donorCellIds,
		MFloatScratchSpace &	p_velocity,
		MFloatScratchSpace &	p_vorticity
	)

overrideprivatevirtual

Implements CouplingDgApe< nDim, CouplingFv< nDim, FvSysEqn > >.

Definition at line 720 of file dgccacousticperturbsourcefiles.h.

                                                                                                        {
  // Load velocities of all donor leaf cells (if there are any on this domain)
  for(auto donorId : donorCellIds) {
    for(MInt varId = 0; varId < noVelocities(); varId++) {
      p_velocity(donorId, varId) = fvSolver().a_pvariable(donorId, fvSolver().PV->VV[varId]);
    }
  }
 
  // Only calculate vorticity if this domain has FV cells at all, otherwise
  // the FV solver pointer is null and a segmentation fault occurs
  // TODO labels:COUPLER,FV only compute vorticity on donor cells where it is needed?
  if(m_hasDonorCartesianSolver) {
    fvSolver().getVorticityT(&p_vorticity[0]);
  }
}

◆ init()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::init ( )

inlineoverridevirtual

Implements Coupling.

Definition at line 89 of file dgccacousticperturbsourcefiles.h.

                       {
    sanityCheck();
    BaseDg::init();
  };

◆ noCellDataDlb()

template<MInt nDim, class FvSysEqn >

MInt DgCcAcousticPerturb< nDim, FvSysEqn >::noCellDataDlb ( ) const

inlineoverridevirtual

Reimplemented from Coupling.

Definition at line 107 of file dgccacousticperturbsourcefiles.h.

                                      {
    return 1; // One (float) data field to communicate
  };

◆ noMeanVars()

template<MInt nDim, class FvSysEqn >

MInt CouplingDgApe< nDim, CouplingDonor >::noMeanVars ( ) const

inline

Definition at line 308 of file couplingdgape.h.

◆ noVelocities()

template<MInt nDim, class FvSysEqn >

static constexpr MInt CouplingDgApe< nDim, CouplingDonor >::noVelocities ( )

inlinestaticconstexpr

Definition at line 306 of file couplingdgape.h.

◆ noVorticities()

template<MInt nDim, class FvSysEqn >

static constexpr MInt CouplingDgApe< nDim, CouplingDonor >::noVorticities ( )

inlinestaticconstexpr

Definition at line 307 of file couplingdgape.h.

◆ sanityCheck()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::sanityCheck

private

Author: Miro Gondrum (refactored)

Date: 28.04.2021

Definition at line 213 of file dgccacousticperturbsourcefiles.h.

                                                      {
  TRACE();
 
  if(!fvSolver().calcSlopesAfterStep()) {
    TERMM(1,
          "Enable calcSlopesAfterStep for FV-solver for coupled simulation (else the slopes are not "
          "initialized prior to the first source term calculation and will contain garbage)");
  }
}

◆ setCellDataDlb()

template<MInt nDim, class FvSysEqn >

void DgCcAcousticPerturb< nDim, FvSysEqn >::setCellDataDlb	(	const MInt	NotUseddataId,
		const MFloat *const	NotUseddata
	)

overridevirtual

Reimplemented from Coupling.

Definition at line 799 of file dgccacousticperturbsourcefiles.h.

                                                                                                    {
  TRACE();
  TERMM_IF_NOT_COND(dataId == 0, "invalid data id");
 
  // Return if not on the right reinitialization stage
  if(m_loadBalancingReinitStage != 0) {
    return;
  }
 
  const MBool donorIdsSorted = std::is_sorted(m_calcSourceDonorCells.begin(), m_calcSourceDonorCells.end());
  TERMM_IF_NOT_COND(donorIdsSorted, "donor ids not sorted");
 
  if(m_noActiveDonorCells > 0) {
    std::copy_n(data, m_noActiveDonorCells * noMeanVars(), &m_meanVars[0]);
  }
}

Member Data Documentation

◆ m_calcProjectionError

template<MInt nDim, class FvSysEqn >

MBool CouplingDgApe< nDim, CouplingDonor >::m_calcProjectionError

Definition at line 374 of file couplingdgape.h.

◆ m_calcSourceDonorCells

template<MInt nDim, class FvSysEqn >

std::vector<MInt> CouplingDgApe< nDim, CouplingDonor >::m_calcSourceDonorCells

Definition at line 390 of file couplingdgape.h.

◆ m_checkConservation

template<MInt nDim, class FvSysEqn >

MBool CouplingDgApe< nDim, CouplingDonor >::m_checkConservation

Definition at line 395 of file couplingdgape.h.

◆ m_fixedTimeStep

template<MInt nDim, class FvSysEqn >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_fixedTimeStep

Definition at line 364 of file couplingdgape.h.

◆ m_hasDgCartesianSolver

template<MInt nDim, class FvSysEqn >

MBool CouplingDgApe< nDim, CouplingDonor >::m_hasDgCartesianSolver

Definition at line 357 of file couplingdgape.h.

◆ m_hasDonorCartesianSolver

template<MInt nDim, class FvSysEqn >

MBool CouplingDgApe< nDim, CouplingDonor >::m_hasDonorCartesianSolver

Definition at line 358 of file couplingdgape.h.

◆ m_isFirstSourceCalculation

template<MInt nDim, class FvSysEqn >

MBool CouplingDgApe< nDim, CouplingDonor >::m_isFirstSourceCalculation

Definition at line 388 of file couplingdgape.h.

◆ m_isRestart

template<MInt nDim, class FvSysEqn >

MBool CouplingDgApe< nDim, CouplingDonor >::m_isRestart

Definition at line 356 of file couplingdgape.h.

◆ m_loadBalancingReinitStage

template<MInt nDim, class FvSysEqn >

MInt DgCcAcousticPerturb< nDim, FvSysEqn >::m_loadBalancingReinitStage = -1

private

Definition at line 154 of file dgccacousticperturbsourcefiles.h.

◆ m_maxConservationError

template<MInt nDim, class FvSysEqn >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_maxConservationError

Definition at line 396 of file couplingdgape.h.

◆ m_maxL2Error

template<MInt nDim, class FvSysEqn >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_maxL2Error

Definition at line 397 of file couplingdgape.h.

◆ m_meanVars

template<MInt nDim, class FvSysEqn >

std::vector<MFloat> CouplingDgApe< nDim, CouplingDonor >::m_meanVars

Definition at line 400 of file couplingdgape.h.

◆ m_meanVarsIndex

template<MInt nDim, class FvSysEqn >

std::array<MInt, s_totalNoMeanVars> CouplingDgApe< nDim, CouplingDonor >::m_meanVarsIndex

Definition at line 426 of file couplingdgape.h.

◆ m_noActiveDonorCells

template<MInt nDim, class FvSysEqn >

MInt CouplingDgApe< nDim, CouplingDonor >::m_noActiveDonorCells

Number of 'active' donor cells, i.e. those donor leaf cells on which source terms need to be computed

Definition at line 377 of file couplingdgape.h.

◆ m_noDonorCells

template<MInt nDim, class FvSysEqn >

MInt CouplingDgApe< nDim, CouplingDonor >::m_noDonorCells

Definition at line 379 of file couplingdgape.h.

◆ m_oldPressure

template<MInt nDim, class FvSysEqn >

std::vector<MFloat> DgCcAcousticPerturb< nDim, FvSysEqn >::m_oldPressure {}

private

Definition at line 156 of file dgccacousticperturbsourcefiles.h.

◆ m_previousTime

template<MInt nDim, class FvSysEqn >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_previousTime

Definition at line 365 of file couplingdgape.h.

◆ m_timers

template<MInt nDim, class FvSysEqn >

std::array<MInt, Timers::_count> CouplingDgApe< nDim, CouplingDonor >::m_timers

Definition at line 464 of file couplingdgape.h.

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

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/COUPLER/dgccacousticperturbsourcefiles.h

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ BaseDg

◆ BaseFv

◆ CV

◆ DgCartesianSolverType

◆ FvCartesianSolverType

◆ MV

◆ ProjectionType

◆ ST

◆ SysEqn

◆ Timers

Constructor & Destructor Documentation

◆ DgCcAcousticPerturb()

◆ ~DgCcAcousticPerturb()

Member Function Documentation

◆ balancePost()

◆ balancePre()

◆ calcSourceLambLinearized()

◆ calcSourceLambNonlinear()

◆ calcSourceQc()

◆ calcSourceQe()

◆ calcSourceQmII()

◆ calcSourceQmIII()

◆ calcTimeStep()

◆ cellDataSizeDlb()

◆ cellDataTypeDlb()

◆ donorSolver()

◆ finalizeCouplerInit()

◆ forceTimeStep()

◆ getCellDataDlb()

◆ getDonorVelocityAndVorticity()

◆ init()

◆ noCellDataDlb()

◆ noMeanVars()

◆ noVelocities()

◆ noVorticities()

◆ sanityCheck()

◆ setCellDataDlb()

Member Data Documentation

◆ m_calcProjectionError

◆ m_calcSourceDonorCells

◆ m_checkConservation

◆ m_fixedTimeStep

◆ m_hasDgCartesianSolver

◆ m_hasDonorCartesianSolver

◆ m_isFirstSourceCalculation

◆ m_isRestart

◆ m_loadBalancingReinitStage

◆ m_maxConservationError

◆ m_maxL2Error

◆ m_meanVars

◆ m_meanVarsIndex

◆ m_noActiveDonorCells

◆ m_noDonorCells

◆ m_oldPressure

◆ m_previousTime

◆ m_timers