CouplingDgApe< nDim, CouplingDonor > Class Template Reference

Intermediate class for coupling DG solver with APE sysEqn. More...

#include <couplingdgape.h>

Inheritance diagram for CouplingDgApe< nDim, CouplingDonor >:

Collaboration diagram for CouplingDgApe< nDim, CouplingDonor >:

Classes
struct	ST
struct	Timers

Public Types
using	Base = Coupling
using	BaseDonor = CouplingDonor
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 CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >
using	solverType = DgCartesianSolver< nDim, DgSysEqnAcousticPerturb< nDim > >
using	CV = typename SysEqn::CV

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

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

Protected Member Functions
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 Coupling
MFloat	returnLoadRecord () const
MFloat	returnIdleRecord () const

Protected Attributes
MBool	m_isRestart = false
	Store whether this is a restart (in case special treatment is necessary) More...
MBool	m_hasDgCartesianSolver = false
	Store whether this domain has DG cells/elements. More...
MBool	m_hasDonorCartesianSolver = false
	Store whether this domain has Cartesian donor solver cells. More...
MInt	m_maxNoNodesXD = -1
	Maximum number of nodes of an element (corresponding to maxPolyDeg) More...
MFloat	m_fixedTimeStep = -1.0
	Fixed time step to use. More...
MFloat	m_previousTime
	Previous time for the calculation of time derivatives. More...
MInt	m_previousTimeStep = -1
	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 = false
	Store whether the sources on the donor grid should be saved as well. More...
MInt	m_saveSourceTermsInterval = -1
	Interval at which source term data should be saved to disk. More...
MBool	m_calcProjectionError = false
	Calculate the L2 error of the Galerkin projection. More...
MInt	m_noActiveDonorCells = -1
MInt	m_noDonorCells = -1
	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 = true
	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 = 1.0
	Factor by which the source terms are multiplied. More...
MBool	m_checkConservation = false
	Check if each Galerkin projection is conservative. More...
MFloat	m_maxConservationError = -1.0
	Maximum conservation error. More...
MFloat	m_maxL2Error = -1.0
	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 = 0
	Number of modes to cut using the low-pass source term. More...
MBool	m_useLowPassFilter = false
	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 = false
	Apply source filter on donor cells or on DG elements after projection. More...
MBool	m_saveSourceTermFilter = false
	Store whether filter values should be written to a file at initialization. More...
MBool	m_projectionFilter = false
	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 CouplingDg< nDim, DgSysEqnAcousticPerturb< nDim > >
solverType *	m_dgSolver

Static Protected Attributes
static const MInt	s_totalNoMeanVars = MV::totalNoMeanVars
static const std::array< MString, ST::totalNoSourceTerms >	s_sourceTermNames
	Hold indices for source terms. More...

Private Member Functions
void	neededMeanVarsForSourceTerm (const MInt sourceTerm, std::vector< MInt > &meanVars) const
	Return the needed mean variables for a given source term. More...

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

Detailed Description

template<MInt nDim, class CouplingDonor>
class CouplingDgApe< nDim, CouplingDonor >

Author

Miro Gondrum (refactored stuff of Ansgar Niemoeller)

Date

22.02.2021

Definition at line 214 of file couplingdgape.h.

Member Typedef Documentation

Base

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::Base = Coupling

Definition at line 217 of file couplingdgape.h.

BaseDg

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::BaseDg = CouplingDg<nDim, DgSysEqnAcousticPerturb<nDim> >

Definition at line 226 of file couplingdgape.h.

BaseDonor

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::BaseDonor = CouplingDonor

Definition at line 221 of file couplingdgape.h.

DgCartesianSolverType

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::DgCartesianSolverType = typename BaseDg::solverType

Definition at line 227 of file couplingdgape.h.

DonorSolverType

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::DonorSolverType = typename BaseDonor::solverType

Definition at line 222 of file couplingdgape.h.

MV

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::MV = MeanVariables<nDim>

Definition at line 241 of file couplingdgape.h.

ProjectionType

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::ProjectionType = DgGalerkinProjection<nDim>

Definition at line 225 of file couplingdgape.h.

SysEqn

template<MInt nDim, class CouplingDonor >

using CouplingDgApe< nDim, CouplingDonor >::SysEqn = DgSysEqnAcousticPerturb<nDim>

Definition at line 224 of file couplingdgape.h.

Constructor & Destructor Documentation

CouplingDgApe()

template<MInt nDim, class CouplingDonor >

CouplingDgApe< nDim, CouplingDonor >::CouplingDgApe	(	const MInt	couplingId,
		DgCartesianSolverType *	dg,
		DonorSolverType *	ds
	)

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]

solver_

A reference to the DG solver in which this coupling class is used.

Definition at line 500 of file couplingdgape.h.

  : Coupling(couplingId),
    BaseDonor(couplingId, ds),
    CouplingDg<nDim, SysEqn>(couplingId, dg),
    m_sourceTermFilter(dg->solverId()) {
  TRACE();
 
  // Ensure consistency in arguments
  static_assert(MV::totalNoMeanVars == s_totalNoMeanVars, "Total number of mean vars is inconsistent");
 
  initTimers();
 
  RECORD_TIMER_STOP(m_timers[Timers::Constructor]);
}

~CouplingDgApe()

template<MInt nDim, class CouplingDonor >

virtual CouplingDgApe< nDim, CouplingDonor >::~CouplingDgApe ( )

virtualdefault

Member Function Documentation

applyStoredSources()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::applyStoredSources ( const MFloat  time )

protected

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 1439 of file couplingdgape.h.

                                                                                      {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::ApplyStoredSources]);
 
  const MInt dataSize = m_maxNoNodesXD * SysEqn::noVars();
 
  // Note: moved this into the DG solver applyExternalSource to remove the dependency
  // on the simulation time in this function, this way the external sources can be computed once in
  // the preCouple step before starting the first RK stage!
  // Source term ramp up factor (linear in time)
  /* const MFloat rampUpFactor */
  /*     = (m_useSourceRampUp) */
  /*           ? maia::filter::slope::linear(startTime(), */
  /*                                        startTime() + m_sourceRampUpTime, time) */
  /*           : 1.0; */
 
  const MInt noSourceElements = m_calcSourceElements.size();
  // Add source terms from persistent storage to right-hand side of all
  // elements with both nonzero filter values and donor cells.
  maia::parallelFor(0, noSourceElements, [&](MInt elementIndex) {
    const MInt elementId = m_calcSourceElements[elementIndex];
    const MInt noNodes1D = elements().polyDeg(elementId) + 1;
    const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
    MFloatTensor r(externalSource() + elementId * dataSize, noNodes1D, noNodes1D, noNodes1D3, SysEqn::noVars());
    MFloatTensor s(&m_sourceTerms[0] + elementIndex * dataSize, noNodes1D, noNodes1D, noNodes1D3, SysEqn::noVars());
 
    // Add source terms to all equations
    for(MInt i = 0; i < noNodes1D; i++) {
      for(MInt j = 0; j < noNodes1D; j++) {
        for(MInt k = 0; k < noNodes1D3; k++) {
          for(MInt l = 0; l < SysEqn::noVars(); l++) {
            r(i, j, k, l) += m_sourceFactor * s(i, j, k, l);
          }
        }
      }
    }
  });
 
  RECORD_TIMER_STOP(m_timers[Timers::ApplyStoredSources]);
}

calcInitialCondition()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::calcInitialCondition ( const MFloat  time )

protected

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]

time

Current simulation time for time-dependent ICs

Definition at line 549 of file couplingdgape.h.

                                                                                        {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::InitialCondition]);
 
  // Load mean quantities from disk into node variables
  loadMeanQuantities();
 
  RECORD_TIMER_STOP(m_timers[Timers::InitialCondition]);
}

calcSourceLambLinearized()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::calcSourceLambLinearized ( const MFloat *const  velocity, const MFloat *const  vorticity, MFloat *  sourceTerms  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

calcSourceLambNonlinear()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::calcSourceLambNonlinear ( const MFloat *const  velocity, const MFloat *const  vorticity, MFloat *const  sourceTerms  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

calcSourceQc()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::calcSourceQc ( const MFloat *const  velocity, MFloat *const  sourceTerms, const MFloat  time, const MInt  timeStep  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

calcSourceQe()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::calcSourceQe ( const MFloat *const  velocity, const MFloat  time, MFloat *const  sourceTerms  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

calcSourceQmII()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::calcSourceQmII ( const MFloat *const  velocity, MFloat *const  sourceTerms  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

calcSourceQmIII()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::calcSourceQmIII ( const MFloat *const  velocity, MFloat *  sourceTerms  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

checkProperties()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::checkProperties ( )

inlinefinaloverrideprotectedvirtual

Implements Coupling.

Definition at line 348 of file couplingdgape.h.

{};

cleanUp()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::cleanUp ( )

inlinefinaloverridevirtual

Implements Coupling.

Definition at line 259 of file couplingdgape.h.

{};

donorSolver()

template<MInt nDim, class CouplingDonor >

virtual DonorSolverType & CouplingDgApe< nDim, CouplingDonor >::donorSolver ( const MInt  solverId = 0 ) const

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

finalizeSubCoupleInit()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::finalizeSubCoupleInit ( MInt  )

inlinefinaloverridevirtual

Implements Coupling.

Definition at line 254 of file couplingdgape.h.

{};

getCouplingTimings()

template<MInt nDim, class CouplingDonor >

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

inlineoverride

Definition at line 261 of file couplingdgape.h.

                                                                                                         {
    const MString namePrefix = "c" + std::to_string(this->couplerId()) + "_";
 
    timings.emplace_back(namePrefix + "loadCouplerApe", returnLoadRecord());
    timings.emplace_back(namePrefix + "idleCouplerApe", returnIdleRecord());
 
#ifdef MAIA_TIMER_FUNCTION
    timings.emplace_back(namePrefix + "preCouple", RETURN_TIMER_TIME(m_timers[Timers::PreCouple]));
 
    if(allTimings) {
      // Full set of timings
      timings.emplace_back(namePrefix + "storeSources", RETURN_TIMER_TIME(m_timers[Timers::StoreSources]));
      timings.emplace_back(namePrefix + "calcSources", RETURN_TIMER_TIME(m_timers[Timers::CalcSources]));
      timings.emplace_back(namePrefix + "projectSourceTerms", RETURN_TIMER_TIME(m_timers[Timers::ProjectSourceTerms]));
 
      timings.emplace_back(namePrefix + "applyStoredSources", RETURN_TIMER_TIME(m_timers[Timers::ApplyStoredSources]));
    } else {
      // Reduced/essential set of timings
      timings.emplace_back(namePrefix + "projectSourceTerms", RETURN_TIMER_TIME(m_timers[Timers::ProjectSourceTerms]));
    }
#endif
  };

getDomainDecompositionInformation()

template<MInt nDim, class CouplingDonor >

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

inlinefinaloverride

Definition at line 284 of file couplingdgape.h.

                                                                                                       {
    const MString namePrefix = "c" + std::to_string(this->couplerId()) + "_";
 
    const MInt noCoupledDgElements = m_calcSourceElements.size();
    const MInt noCoupledDonorCells = m_calcSourceDonorCells.size();
 
    domainInfo.emplace_back(namePrefix + "noCoupledDgElements", noCoupledDgElements);
    domainInfo.emplace_back(namePrefix + "noCoupledDonorCells", noCoupledDonorCells);
  };

getDonorVelocityAndVorticity()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::getDonorVelocityAndVorticity ( const std::vector< MInt > &  donorCellIds, MFloatScratchSpace &  p_velocity, MFloatScratchSpace &  p_vorticity  )

protectedpure virtual

Implemented in DgCcAcousticPerturb< nDim, FvSysEqn >, and LbDgApe< nDim, nDist, SysEqn >.

init()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::init ( )

inlineoverridevirtual

Implements Coupling.

Definition at line 249 of file couplingdgape.h.

                       {
    readProperties();
    initCoupler();
    initData();
  };

initCoupler()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::initCoupler

protected

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

This also allocates memory for local storage of mean variables and source terms.

Definition at line 566 of file couplingdgape.h.

                                                     {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::Init]);
 
  m_hasDgCartesianSolver = dgSolver().isActive();
  if(!m_hasDgCartesianSolver) {
    TERMM_IF_NOT_COND(noElements() == 0, "inactive DG solver should have no elements");
  }
 
  // Determine the total number of donor cells on this domain, i.e., total number of donor cells on
  // this domain
  m_noDonorCells = donorSolver().noInternalCells();
  if(m_noDonorCells < 0) { // Reset if donorSolver is inactive
    m_noDonorCells = 0;
  }
  m_hasDonorCartesianSolver = (m_noDonorCells > 0);
  TERMM_IF_NOT_COND(m_hasDonorCartesianSolver == donorSolver().isActive(), "Donor solver status error");
 
  // Calculate maximum number of nodes
  m_maxNoNodesXD = (m_hasDgCartesianSolver) ? ipow(maxPolyDeg() + 1, nDim) : -1;
 
  // Initialize the Galerkin projection(s) and determine the information needed
  // to perform the Galerkin projection for all elements that have donor cells
  initProjection();
 
  // Allocate persistent storage for the source filter values. The maximum
  // polynomial degree is used here to be consisent with the memory allocation
  // in the solver.
  m_filter.resize(std::max(noElements() * m_maxNoNodesXD, 0));
  // Storage for donor cell filter
  m_filterDonor.resize(m_noDonorCells);
 
  // Allocate storage for element ids for which coupling source terms need to be
  // computed
  m_calcSourceElements.reserve(noElements());
 
  // Calculate source filter values and store element ids on which source terms
  // need to be computed, i.e. elements that have nonzero filter value(s) AND
  // also have donor cell(s)
  initSourceFilter();
 
  // Save filter values to file
  if(m_saveSourceTermFilter) {
    saveFilterValues();
    saveFilterValuesDonor();
  }
 
  // Allocate persistent storage for the source terms of all elements for which
  // coupling source terms need to be computed. The maximum polynomial degree is
  // used here to be consistent with the memory allocation in the solver.
  m_sourceTerms.resize(std::max(static_cast<MInt>(m_calcSourceElements.size()) * m_maxNoNodesXD * SysEqn::noVars(), 0));
 
  // Determine the set of donor cells on which source terms need to be computed
  std::set<MInt> calcSourceDonorCells;
  for(MInt elementId : m_calcSourceElements) {
    calcSourceDonorCells.insert(m_elementDonorMap[elementId].begin(), m_elementDonorMap[elementId].end());
  }
  // Number of 'active' donor cells
  m_noActiveDonorCells = calcSourceDonorCells.size();
  if(!m_hasDgCartesianSolver) {
    TERMM_IF_COND(m_noActiveDonorCells > 0, "Inactive DG solver cannot have active donor cells.");
  }
 
  // Store 'active' donor cell ids in m_calcSourceDonorCells
  m_calcSourceDonorCells.resize(m_noActiveDonorCells);
  m_calcSourceDonorCells.assign(calcSourceDonorCells.begin(), calcSourceDonorCells.end());
 
  // Allocate persistent storage for the mean variables of the donor cells
  m_meanVars.resize(m_noActiveDonorCells * noMeanVars());
 
  if(m_noCutModesLowPass > 0 && m_hasDgCartesianSolver) {
    // Temporarily create interpolation objects
 
    // Check for SBP Mode
    const MInt defaultSbpMode = 0;
    const MInt sbpMode = Context::getSolverProperty("sbpMode", solverId(), AT_, &defaultSbpMode);
 
    // Determine SBP Operator
    const MString defaultSbpOperator = "";
    const MString sbpOperator =
        Context::getSolverProperty<MString>("sbpOperator", solverId(), AT_, &defaultSbpOperator);
 
    // Determine initial number of nodes
    MInt initNoNodes1D = -1;
    initNoNodes1D = Context::getSolverProperty<MInt>("initNoNodes", solverId(), AT_, &initNoNodes1D);
 
    // Determine DG integration method (same as in dgsolver.cpp)
    const MString defaultDgIntegrationMethod = "DG_INTEGRATE_GAUSS";
    const MInt dgIntegrationMethod = string2enum(
        Context::getSolverProperty<MString>("dgIntegrationMethod", solverId(), AT_, &defaultDgIntegrationMethod));
 
    // Determine DG polynomial type (same as in dgsolver.cpp)
    const MString defaultDgPolynomialType = "DG_POLY_LEGENDRE";
    const MInt dgPolynomialType =
        string2enum(Context::getSolverProperty<MString>("dgPolynomialType", solverId(), AT_, &defaultDgPolynomialType));
 
    // Convert integers to enums
    auto polyType = static_cast<DgPolynomialType>(dgPolynomialType);
    auto intMethod = static_cast<DgIntegrationMethod>(dgIntegrationMethod);
 
    // Create & init interpolation objects
    std::vector<DgInterpolation> interpolation(maxPolyDeg() + 1);
    for(MInt i = std::max(0, minPolyDeg() - m_noCutModesLowPass); i < maxPolyDeg() + 1; i++) {
      const MInt noNodes1D = sbpMode ? initNoNodes1D : (i + 1);
      interpolation[i].init(i, polyType, noNodes1D, intMethod, sbpMode, sbpOperator);
    }
 
    // Create & store Vandermonde matrices
 
    // Create
    m_vdmLowPass.clear();
    m_vdmLowPass.resize(maxPolyDeg() + 1 - m_noCutModesLowPass);
 
    // Create matrices
    for(MInt polyDeg = std::max(0, minPolyDeg() - m_noCutModesLowPass);
        polyDeg < maxPolyDeg() + 1 - m_noCutModesLowPass;
        polyDeg++) {
      const MInt noNodesIn = polyDeg + 1;
      const MInt noNodesOut = polyDeg + 1 + m_noCutModesLowPass;
      m_vdmLowPass[polyDeg].resize(noNodesOut, noNodesIn);
      const DgInterpolation& interpIn = interpolation[polyDeg];
      const DgInterpolation& interpOut = interpolation[polyDeg + m_noCutModesLowPass];
      maia::dg::interpolation::calcPolynomialInterpolationMatrix(noNodesIn,
                                                                 &interpIn.m_nodes[0],
                                                                 noNodesOut,
                                                                 &interpOut.m_nodes[0],
                                                                 &interpIn.m_wBary[0],
                                                                 &m_vdmLowPass[polyDeg][0]);
    }
  } else {
    m_vdmLowPass.clear();
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::Init]);
}

initData()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::initData

protected

Note: not included anymore in initCoupler() since not required, e.g., during balancing.

Definition at line 710 of file couplingdgape.h.

                                                  {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::Init]);
 
  if(dgSolver().m_restart) {
    // Load mean vars for source term calculation at a restart
    const MFloat time = dgSolver().time();
    // TODO labels:COUPLER,DG,toremove @ansgar_unified is dt already set?
    // const MFloat dt = dgSolver().m_dt;
    // initRestart(time, dt);
    // initRestart(time, -1.0);
    initRestart(time, m_fixedTimeStep); // NOTE: use prescribed fixed time step
  } else {
    // Load DG node variables and mean vars for source term calculation
    calcInitialCondition(-1.0);
    RECORD_TIMER_STOP(m_timers[Timers::Init]);
 
    // Apply the initial conditions of the solver (again) to allow overwriting node variables set
    // by the coupling
    if(m_hasDgCartesianSolver) {
      RECORD_TIMER_START(dgSolver().m_timers[maia::dg::Timers_::RunInit]);
      RECORD_TIMER_START(dgSolver().m_timers[maia::dg::Timers_::InitData]);
      dgSolver().initialCondition();
      RECORD_TIMER_STOP(dgSolver().m_timers[maia::dg::Timers_::InitData]);
      RECORD_TIMER_STOP(dgSolver().m_timers[maia::dg::Timers_::RunInit]);
    }
 
    RECORD_TIMER_START(m_timers[Timers::Init]);
 
    // Update node variables at surfaces in the solver and perform extension
    if(m_hasDgCartesianSolver && SysEqn::noNodeVars() > 0) {
      dgSolver().updateNodeVariables();
      dgSolver().extendNodeVariables();
    }
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::Init]);
}

initProjection()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::initProjection

protected

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-07-16

Initializes the required Galerkin projections for spatial coupling and determines all information needed to perform the Galerkin projection for all elements that have a mapping.

Definition at line 758 of file couplingdgape.h.

                                                        {
  TRACE();
 
  if(!m_hasDgCartesianSolver) {
    // Clear member variables if DG solver is not active
    m_projection.clear();
    m_elementDonorMap.clear();
    m_elementDonorLevels.clear();
    m_elementDonorPos.clear();
    return;
  }
 
  // Create map from donor-cells to dg-elements
  std::vector<std::vector<MInt>> elementGridMap(noElements());
 
  for(MInt elementId = 0; elementId < noElements(); elementId++) {
    const MInt cellId = elements().cellId(elementId);
    const MInt gridCellId = dgSolver().grid().tree().solver2grid(cellId);
 
    elementGridMap[elementId].clear();
    // Get all leaf-cells of the donor-solver that are mapped to the global cell of the current
    // dg-element
    dgSolver().grid().raw().createLeafCellMapping(donorSolver().solverId(), gridCellId, elementGridMap[elementId]);
  }
 
  // Initialize the required Galerkin projections needed for spatial coupling
  {
    m_projection.clear();
    m_projection.reserve(maxPolyDeg() + 1);
 
    // Determine the number of refinement levels of the donor grid
    MInt noLevels = 1;
    if(m_hasDonorCartesianSolver) {
      noLevels = donorSolver().grid().maxLevel() - donorSolver().grid().minLevel() + 1;
    }
 
    m_log << "Initialize Galerkin projections for " << noLevels << " levels." << std::endl;
 
    // Dummy projections such that m_projection can be accessed by polyDeg
    for(MInt i = 0; i < std::max(0, minPolyDeg() - m_noCutModesLowPass); i++) {
      m_projection.push_back(ProjectionType());
    }
 
    // Initialize projection for each used polynomial degree
    for(MInt i = std::max(0, minPolyDeg() - m_noCutModesLowPass); i <= maxPolyDeg(); i++) {
      m_log << "Initialize Galerkin projection (p = " << i << ")... ";
      m_projection.push_back(ProjectionType(i, noLevels, dgSolver().grid().lengthLevel0(), dgSolver().solverId()));
      m_log << "done" << std::endl;
    }
  }
 
  m_elementDonorMap.resize(noElements());
  m_elementDonorLevels.resize(noElements());
  m_elementDonorPos.resize(noElements());
 
  // Determine information needed to apply the Galerkin projection
  for(MInt elementId = 0; elementId < noElements(); elementId++) {
    const MInt polyDeg = elements().polyDeg(elementId);
 
    // Clear any previous projection information for this element
    m_elementDonorMap[elementId].clear();
    m_elementDonorLevels[elementId].clear();
    m_elementDonorPos[elementId].clear();
 
    // Check if element has mapped donor cells and skip iteration otherwise
    if(elementGridMap[elementId].empty()) {
      continue;
    }
 
    const MInt noMappedLeafCells = elementGridMap[elementId].size();
    MIntScratchSpace donorCellLevels(noMappedLeafCells, AT_, "donorCellLevels");
    MFloatScratchSpace donorCellCoordinates(noMappedLeafCells, nDim, AT_, "donorCellCoordinates");
 
    // Information on target element
    const MInt targetCellId = elements().cellId(elementId);
    const MInt targetLevel = dgSolver().grid().tree().level(targetCellId);
    const MFloat halfCellLength = 0.5 * dgSolver().grid().cellLengthAtLevel(targetLevel);
    const MFloat* targetElementCenter = &dgSolver().grid().tree().coordinate(targetCellId, 0);
 
    // Check if element is inside projection filter box (excluding filter)
    if(m_projectionFilter) {
      MBool hasProjection = false;
      for(MInt dimId = 0; dimId < nDim; dimId++) {
        const MFloat coord = targetElementCenter[dimId];
        if(coord + halfCellLength < m_projectionFilterBox[dimId]
           || coord - halfCellLength > m_projectionFilterBox[nDim + dimId]) {
          hasProjection = true;
          break;
        }
      }
      if(!hasProjection) {
        continue;
      }
    }
 
    MInt noDonorCells = 0;
    // Loop over all mapped donor leaf-cells
    for(MInt i = 0; i < noMappedLeafCells; i++) {
      const MInt donorGridCellId = elementGridMap[elementId][i];
      const MInt donorCellId = donorSolver().grid().tree().grid2solver(donorGridCellId);
 
      if(donorCellId < 0) {
        TERMM(1, "Error in mapped donor leaf cells.");
      }
 
      // Store donor cell id in element donor map
      m_elementDonorMap[elementId].push_back(donorCellId);
      // Store the corresponding refinement level of the donor cell
      donorCellLevels[noDonorCells] = donorSolver().grid().tree().level(donorCellId);
 
      // Get original cell center coordinates
      // NOTE: For all donor cells (i.e. also for boundary and cut cells) the
      // original cell position is needed to establish the projection
      // information. There is no special treatment of cut cells at the
      // moment, for now they are treated as if they were normal cells.
      for(MInt d = 0; d < nDim; d++) {
        donorCellCoordinates(noDonorCells, d) = donorSolver().grid().tree().coordinate(donorCellId, d);
      }
 
      noDonorCells++;
    }
 
    if(noDonorCells == 0) {
      TERMM(1, "Donor cells for element (elementId=" + std::to_string(elementId)
                   + ") not found, but elementGridMap[elementId] "
                     "with elementGridMap[elementId].size()="
                   + std::to_string(elementGridMap[elementId].size()) + " contains mapped donor cells.");
    }
 
    // Allocate storage for the projection information of this element
    m_elementDonorLevels[elementId].resize(noDonorCells);
    m_elementDonorPos[elementId].resize(noDonorCells);
 
    // Check for one-to-multiple mapping and continue if so (there is no projection information to
    // compute)
    if(noDonorCells == 1) {
      const MInt donorCellId = m_elementDonorMap[elementId][0];
      const MInt donorLevel = donorSolver().grid().tree().level(donorCellId);
      if(targetLevel > donorLevel) {
        m_elementDonorLevels[elementId][0] = donorLevel - targetLevel;
        m_elementDonorPos[elementId][0] = -1;
        continue;
      }
    }
 
    // Compute and store the projection information for this element (this includes non-mapped
    // volumes)
    m_projection[polyDeg].calcProjectionInformation(noDonorCells, &donorCellLevels[0], &donorCellCoordinates[0],
                                                    targetLevel, targetElementCenter, m_elementDonorPos[elementId],
                                                    m_elementDonorLevels[elementId]);
  }
}

initRestart()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::initRestart ( const MFloat  time, const MFloat  dt  )

protected

Author

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

Parameters

[in]	time	Simulation time at time of restart.
[in]	dt	Previous time step size before restart.

Definition at line 918 of file couplingdgape.h.

                                                                                       {
  TRACE();
 
  // Store that this is a restart
  m_isRestart = true;
 
  // Calculate previous time for use in Qe source term
  m_previousTime = time - dt;
 
  RECORD_TIMER_START(m_timers[Timers::InitialCondition]);
  // Only load mean data for source term calculation since node variables are already read from the
  // nodevars-file
  loadMeanQuantities(true);
  RECORD_TIMER_STOP(m_timers[Timers::InitialCondition]);
}

initSourceFilter()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::initSourceFilter

protected

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-07-04

Definition at line 940 of file couplingdgape.h.

                                                          {
  TRACE();
 
  // Make sure that the element list is empty
  m_calcSourceElements.clear();
 
  if(!m_hasDgCartesianSolver) {
    m_filter.clear();
    m_elementInsideBody.clear();
    return;
  }
 
  const MInt filterOffset = m_maxNoNodesXD;
 
  // Temporary storage before permanent allocation with exact size
  MBoolScratchSpace hasNonZeroFilter(noElements(), AT_, "hasNonZeroFilter");
  std::fill(hasNonZeroFilter.begin(), hasNonZeroFilter.end(), false);
 
  // Reset inside body marker for all elements
  m_elementInsideBody.resize(noElements());
  std::fill(m_elementInsideBody.begin(), m_elementInsideBody.end(), 0);
 
  MInt noInsideElements = 0;
 
  for(MInt elementId = 0; elementId < noElements(); elementId++) {
    const MInt noNodes1D = elements().polyDeg(elementId) + 1;
    const MInt noNodesXD = ipow(noNodes1D, nDim);
 
    // Pointer to coordinates of source term
    const MFloat* const coordinates = &elements().nodeCoordinates(elementId);
 
    // Pointer to filter values of current element
    MFloat* const elementFilter = &m_filter[elementId * filterOffset];
 
    // Calculate filter values for all node coordinates of the element
    m_sourceTermFilter.filter(coordinates, noNodesXD, elementFilter);
 
    // Set filter values to zero if element is excluded via projection filter box
    // @ansgar_mb TODO labels:COUPLER,DG make this a function?
    if(m_projectionFilter) {
      MBool hasProjection = false;
      for(MInt dimId = 0; dimId < nDim; dimId++) {
        const MFloat coord = coordinates[dimId];
        if(coord < m_projectionFilterBox[dimId] || coord > m_projectionFilterBox[nDim + dimId]) {
          hasProjection = true;
          break;
        }
      }
      if(!hasProjection) {
        std::fill_n(elementFilter, noNodesXD, 0.0);
      }
    }
 
    // Check if any filter value is nonzero (above epsilon), i.e. source terms need to be
    // computed for this element
    hasNonZeroFilter[elementId] =
        std::any_of(elementFilter, elementFilter + noNodesXD, [](MFloat filter) { return filter > MFloatEps; });
 
    // @ansgar TODO labels:COUPLER fix this, what about geometries that are not inside the source region -> mean
    // vars (see loadMeanQuantities)?
    if(hasNonZeroFilter[elementId] && m_elementDonorMap[elementId].empty()) {
      m_elementInsideBody[elementId] = 1;
 
      // Reset filter
      hasNonZeroFilter[elementId] = false;
      std::fill_n(elementFilter, noNodesXD, 0.0);
 
      noInsideElements++;
      std::cerr << "Element " << std::to_string(elementId)
                << " has nonzero filter value(s), but there are no donor "
                   "cells mapped to this element. It will be considered to be inside the geometry."
                << std::endl;
      TERMM(1, "TODO check! (element has nonzero filter but no donor cells)");
    }
  }
 
  MPI_Allreduce(MPI_IN_PLACE, &noInsideElements, 1, maia::type_traits<MInt>::mpiType(), MPI_SUM, dgSolver().mpiComm(),
                AT_, "MPI_IN_PLACE", "noInsideElements");
  if(noInsideElements > 0) {
    m_log << "WARNING: Number of DG elements considered to be inside the geometry: " << noInsideElements << std::endl;
    if(dgSolver().domainId() == 0) {
      std::cerr << "WARNING: Number of DG elements considered to be inside the geometry: " << noInsideElements
                << std::endl;
    }
  }
 
  // Permanently store elements with non-zero filter
  const MInt noNonZeroElements = std::count(hasNonZeroFilter.begin(), hasNonZeroFilter.end(), true);
  m_calcSourceElements.resize(noNonZeroElements);
 
  // Store element id if source terms need to be computed, i.e. there is at
  // least one nonzero filter value AND there are donor cells mapped to this
  // element.
  for(MInt elementId = 0, nonZeroElementId = 0; elementId < noElements(); elementId++) {
    if(hasNonZeroFilter[elementId]) {
      if(!m_elementDonorMap[elementId].empty()) {
        m_calcSourceElements[nonZeroElementId] = elementId;
        nonZeroElementId++;
      } else {
        TERMM(1, "Element " + std::to_string(elementId)
                     + " has nonzero filter value(s), but there are no donor "
                       "cells mapped to this element. Go fix the source term "
                       "filter in your property file.");
      }
    }
  }
 
  // Compute spatial filter values on donor cells
  if(m_hasDonorCartesianSolver) {
    for(MInt i = 0; i < m_noDonorCells; i++) {
      const MFloat* const coordinates = &donorSolver().a_coordinate(i, 0);
      MFloat* const cellFilter = &m_filterDonor[i];
 
      m_sourceTermFilter.filter(coordinates, 1, cellFilter);
    }
  }
}

initTimers()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::initTimers

protected

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 1063 of file couplingdgape.h.

                                                    {
  TRACE();
 
  // Create timer group & timer for solver, and start the timer
  NEW_TIMER_GROUP_NOCREATE(m_timers[Timers::TimerGroup],
                           "CouplingDgApe (solverId = " + std::to_string(solverId()) + ")");
  NEW_TIMER_NOCREATE(m_timers[Timers::Class], "total object lifetime", m_timers[Timers::TimerGroup]);
  RECORD_TIMER_START(m_timers[Timers::Class]);
 
  // Create & start constructor timer
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Constructor], "Constructor", m_timers[Timers::Class]);
  RECORD_TIMER_START(m_timers[Timers::Constructor]);
 
  // Create regular solver-wide timers
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Init], "init", m_timers[Timers::Class]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::InitialCondition], "calcInitialCondition", m_timers[Timers::Class]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadMeanQuantities], "loadMeanQuantities",
                         m_timers[Timers::InitialCondition]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::PreCouple], "PreCouple", m_timers[Timers::Class]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::StoreSources], "storeSources", m_timers[Timers::PreCouple]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadInstantaneous], "loadInstantaneousQuantities",
                         m_timers[Timers::StoreSources]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CalcSources], "calcSources", m_timers[Timers::StoreSources]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CalcSourceLamb], "calcSourceLamb", m_timers[Timers::CalcSources]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CalcSourceQmII], "calcSourceQmII", m_timers[Timers::CalcSources]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CalcSourceQmIII], "calcSourceQmIII", m_timers[Timers::CalcSources]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CalcSourceQe], "calcSourceQe", m_timers[Timers::CalcSources]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CalcSourceQc], "calcSourceQc", m_timers[Timers::CalcSources]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ProjectSourceTerms], "projectSourceTerms", m_timers[Timers::StoreSources]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ApplyStoredSources], "applyStoredSources", m_timers[Timers::PreCouple]);
 
  // Create accumulated timers that monitor selected subsystems
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Accumulated], "selected accumulated timers", m_timers[Timers::Class]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::LoadCouplingData], "loadCouplingData", m_timers[Timers::Accumulated]);
}

loadCouplingData()

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::loadCouplingData ( const MString &  filename, const MString &  name_, const MInt  stride, MFloat *  data  )

protected

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]	filename	File name to open.
[in]	name_	Attribute 'name' of variable to read.
[in]	stride	Store data with given stride.
[out]	data	Pointer to memory where read data should be stored.

Definition at line 1113 of file couplingdgape.h.

                                                                         {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::Accumulated]);
  RECORD_TIMER_START(m_timers[Timers::LoadCouplingData]);
 
  using namespace maia::parallel_io;
  ParallelIo file(filename, PIO_READ, dgSolver().grid().raw().mpiComm());
 
  MString datasetName;
  MString variableName;
  MBool foundVariable = false;
  // Get the names of all datasets in the file
  std::vector<MString> datasets = file.getDatasetNames();
  // Loop over all datasets and check if it has the right 'name' attribute
  for(auto&& dataset : datasets) {
    if(file.hasAttribute("name", dataset)) {
      file.getAttribute(&variableName, "name", dataset);
      if(variableName == name_) {
        datasetName = dataset;
        foundVariable = true;
        break;
      }
    }
  }
  // Read if variable was found in file
  if(foundVariable) {
    ParallelIo::size_type count = 0;
    ParallelIo::size_type start = 0;
 
    if(m_hasDonorCartesianSolver) {
      count = donorSolver().noInternalCells();
      start = donorSolver().domainOffset(donorSolver().domainId());
    }
 
    file.setOffset(count, start);
    file.readArray(data, datasetName, stride);
 
    const MInt noInternalCells = donorSolver().noInternalCells();
    performUnitConversion(variableName, noInternalCells, stride, data);
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::LoadCouplingData]);
  RECORD_TIMER_STOP(m_timers[Timers::Accumulated]);
  return foundVariable;
}

loadMeanQuantities()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::loadMeanQuantities ( const MBool  skipNodeVars = false )

protected

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 1167 of file couplingdgape.h.

                                                                                    {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::LoadMeanQuantities]);
 
  // Get the default node variables for regions without LES
  std::array<MFloat, SysEqn::noNodeVars()> defaultNodeVars;
  sysEqn().getDefaultNodeVars(&defaultNodeVars[0]);
 
  // Get the default node variables for regions inside a LES geometry
  std::array<MFloat, SysEqn::noNodeVars()> defaultNodeVarsBody;
  sysEqn().getDefaultNodeVarsBody(&defaultNodeVarsBody[0]);
 
  // Skip loading of the mean file (e.g. when doing a scaling and there is no useful mean file to be loaded)
  MBool skipLoadMeanFile = false;
  skipLoadMeanFile = Context::getSolverProperty<MBool>("skipLoadMeanFile", solverId(), AT_, &skipLoadMeanFile);
 
  // Load mean data for node variables, apply the projection and store results
  // in nodeVars
  if(!skipNodeVars && !skipLoadMeanFile) {
    m_log << "Coupling condition: loading node vars from mean file." << std::endl;
    MFloatScratchSpace data(std::max(m_noDonorCells, 1), SysEqn::noNodeVars(), AT_, "data");
    // Load mean velocity data (data is stored with stride SysEqn::noNodeVars())
    std::vector<MInt> undefinedNodeVarIds; // nodeVarNames that are not available in mean file
    for(MInt varId = 0; varId < SysEqn::noNodeVars(); varId++) {
      if(!loadCouplingData(m_meanDataFileName, MV::nodeVarNames[varId], SysEqn::noNodeVars(), &data(0, varId))) {
        // Variable name was not found in mean file
        undefinedNodeVarIds.push_back(varId);
      }
    }
 
    // Sanity check whether all data is available
    if(!undefinedNodeVarIds.empty()) {
      std::stringstream ss;
      ss << "Warning: Following dataset/s with attribute 'name' have not been found in file '" << m_meanDataFileName
         << "': ";
      for(MInt i : undefinedNodeVarIds) {
        ss << MV::nodeVarNames[i] << ", ";
      }
      ss << std::endl << "Those dataset/s have to be specified by the initial condition.";
      // Note: Here is only a warning called, since it might make sense not
      // providing some of the data through the mean file. For example the speed
      // of sound is not provided by the LB solver but set by the initial
      // condition as constant.
      // TERMM(1, ss.str());
      m_log << ss.str() << std::endl;
    }
 
    // Disable low-pass filter for node vars
    const MBool previousLowPassFilterState = m_useLowPassFilter;
    m_useLowPassFilter = false;
 
#ifdef _OPENMP
#pragma omp parallel for
#endif
    // Project data to elements and store in nodeVars
    for(MInt elementId = 0; elementId < noElements(); elementId++) {
      const MInt noDonorCells = m_elementDonorMap[elementId].size();
      const MInt noNonMappedCells = m_elementDonorPos[elementId].size() - noDonorCells;
 
      // FIXME labels:COUPLER @ansgar this is not correct for a general case where there are bodies
      // in the donor-solver that are located outside the source region as DG-elements inside these
      // objects are not identified to be inside a body!
      if((m_elementInsideBody[elementId] == 0) && noNonMappedCells == 0) {
        projectToElement(elementId, SysEqn::noNodeVars(), &data[0], &defaultNodeVars[0],
                         &elements().nodeVars(elementId));
      } else {
        projectToElement(elementId, SysEqn::noNodeVars(), &data[0], &defaultNodeVarsBody[0],
                         &elements().nodeVars(elementId));
      }
    }
 
    // Enable low-pass filter again after interpolation of node vars
    m_useLowPassFilter = previousLowPassFilterState;
  } else {
    m_log << "Coupling condition: skipped loading node vars from mean file." << std::endl;
  }
 
  // Load mean data for source term calculation on donor grid
  if(!skipLoadMeanFile) {
    MFloatScratchSpace meanVars(std::max(m_noDonorCells, 1), noMeanVars(), AT_, "meanVars");
    m_log << "Coupling condition noMeanVars: " << noMeanVars() << std::endl;
    // Load mean variables data (stored with stride noMeanVars() in meanVars)
    std::vector<MInt> undefinedMeanVarIds; // meanVarNames that are not available in mean file
    for(MInt varId = 0; varId < noMeanVars(); varId++) {
      m_log << "Load coupling data: " << varId << " " << MV::names[m_activeMeanVars[varId]] << std::endl;
      if(!loadCouplingData(m_meanDataFileName, MV::names[m_activeMeanVars[varId]], noMeanVars(), &meanVars[varId])) {
        // Variable name was not found in mean file
        undefinedMeanVarIds.push_back(varId);
      }
    }
 
    // Sanity check whether all data is available
    if(!undefinedMeanVarIds.empty()) {
      std::stringstream ss;
      ss << "Warning: Following dataset/s with attribute 'name' have not been found in file '" << m_meanDataFileName
         << "': ";
      for(MInt i : undefinedMeanVarIds) {
        ss << MV::names[m_activeMeanVars[i]] << ", ";
      }
      ss << std::endl;
      TERMM(1, ss.str());
    }
 
    // Store the mean variables data of all donor leaf cells that are mapped to
    // elements that need to calculate coupling source terms in m_meanVars
    for(MInt donorIndex = 0; donorIndex < m_noActiveDonorCells; donorIndex++) {
      const MInt donorId = m_calcSourceDonorCells[donorIndex];
      std::copy_n(&meanVars(donorId, 0), noMeanVars(), &m_meanVars[donorIndex * noMeanVars()]);
    }
  } else {
    m_log << "Coupling condition: skip loading mean vars, set to zero instead." << std::endl;
    std::fill(m_meanVars.begin(), m_meanVars.end(), 0.0);
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::LoadMeanQuantities]);
}

neededMeanVarsForSourceTerm()

template<MInt nDim, class CouplingDonor >

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

private

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-07-30

Parameters

[in]	sourceTerm	The id of the requestest source term.
[out]	meanVars	Vector of needed mean variable ids.

Definition at line 1978 of file couplingdgape.h.

                                                                                                      {
  TRACE();
 
  meanVars.clear();
  switch(sourceTerm) {
    case ST::Q_mI:
      // Mean Lamb vector
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::LAMB0[i]);
      }
      break;
    case ST::Q_mI_linear:
      // Mean velocities
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::UU0[i]);
      }
      // Mean vorticities
      for(MInt i = 0; i < noVorticities(); i++) {
        meanVars.push_back(MV::VORT0[i]);
      }
      break;
    case ST::Q_mII:
      // Mean density and pressure
      meanVars.push_back(MV::RHO0);
      meanVars.push_back(MV::P0);
      // Mean gradient of rho
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DRHO[i]);
      }
      // Mean gradient of p
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DP[i]);
      }
      // Mean of (gradient of p divided by rho)
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::GRADPRHO[i]);
      }
      break;
    case ST::Q_mIII:
      // Mean velocities
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::UU0[i]);
      }
      // Mean velocity gradients
      for(MInt i = 0; i < nDim * nDim; i++) {
        meanVars.push_back(MV::GRADU[i]);
      }
      // Sum of products of velocity components with corresponding velocity gradients
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::UGRADU[i]);
      }
      break;
    case ST::Q_e:
      meanVars.push_back(MV::RHO0);
      meanVars.push_back(MV::P0);
      meanVars.push_back(MV::C0);
      // Mean velocities
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::UU0[i]);
      }
      // Mean gradient of c
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DC0[i]);
      }
      // Components of divergence of u
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DU[i]);
      }
      // Mean gradient of rho
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DRHO[i]);
      }
      // Mean gradient of p
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DP[i]);
      }
      break;
    case ST::Q_c:
      // Mean density, pressure, and speed of sound
      meanVars.push_back(MV::RHO0);
      meanVars.push_back(MV::P0);
      meanVars.push_back(MV::C0);
      // Mean velocities
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::UU0[i]);
      }
      // Components of divergence of u
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DU[i]);
      }
      // Mean gradient of rho
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::DRHO[i]);
      }
      // Mean gradient of rho*div(u)
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::RHODIVU[i]);
      }
      // Mean gradient of u*grad(rho)
      for(MInt i = 0; i < nDim; i++) {
        meanVars.push_back(MV::UGRADRHO[i]);
      }
      break;
    default:
      TERMM(1, "Source term '" + s_sourceTermNames[sourceTerm] + "' not implemented yet.");
      break;
  }
}

noCouplingTimers()

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::noCouplingTimers ( const MBool  allTimings ) const

inlineoverride

Definition at line 293 of file couplingdgape.h.

                                                               {
#ifdef MAIA_TIMER_FUNCTION
    if(allTimings) {
      return 7;
    } else {
      return 4;
    }
#else
    return 2;
#endif
  };

noMeanVars()

template<MInt nDim, class CouplingDonor >

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

inline

Definition at line 308 of file couplingdgape.h.

noVelocities()

template<MInt nDim, class CouplingDonor >

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

inlinestaticconstexpr

Definition at line 306 of file couplingdgape.h.

noVorticities()

template<MInt nDim, class CouplingDonor >

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

inlinestaticconstexpr

Definition at line 307 of file couplingdgape.h.

performUnitConversion()

template<MInt nDim, class CouplingDonor >

virtual void CouplingDgApe< nDim, CouplingDonor >::performUnitConversion ( const MString &  , const  MInt, const  MInt, MFloat *    )

inlineprotectedvirtual

Reimplemented in LbDgApe< nDim, nDist, SysEqn >.

Definition at line 331 of file couplingdgape.h.

                                               {};

postCouple()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::postCouple ( MInt  )

inlinefinaloverridevirtual

Implements Coupling.

Definition at line 258 of file couplingdgape.h.

{};

preCouple()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::preCouple ( MInt  )

finalvirtual

Implements Coupling.

Definition at line 519 of file couplingdgape.h.

                                                       {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::PreCouple]);
 
  const MInt timeStep = (m_hasDgCartesianSolver) ? dgSolver().getCurrentTimeStep() : -1;
  const MFloat time = (m_hasDgCartesianSolver) ? dgSolver().time() : -1.0;
 
  if(m_hasDgCartesianSolver && timeStep == m_previousTimeStep) {
    TERMM(1, "Error: preCouple already called for this time step.");
  }
 
  // Calculate source terms
  storeSources(time, timeStep);
  // Add stored source terms to the external source buffer of the DG solver
  applyStoredSources(time);
  // Update time step
  m_previousTimeStep = timeStep;
 
  RECORD_TIMER_STOP(m_timers[Timers::PreCouple]);
}

projectToElement()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::projectToElement ( const MInt  elementId, const MInt  noVars, const MFloat *  data, const MFloat *  defaultValues, MFloat *  target  )

protected

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-07-16

Parameters

[in]	elementId	The id of the element to perform the projection onto.
[in]	noVar	Number of variables to project.
[in]	data	Donor field(s).
[in]	defaultValues	Default values to use if there is no donor cell.
[out]	target	Target field containing the projected variables.

The variables in data need to be stored as: [u1, v1, w1, u2, v2, w2, ...]

Definition at line 1297 of file couplingdgape.h.

                                                                                                       {
  TRACE();
  const MInt polyDeg = elements().polyDeg(elementId);
  const MInt noNodesXD = ipow(polyDeg + 1, nDim);
  const MInt noDonorCells = m_elementDonorMap[elementId].size();
  // Number of non-mapped cells/volumes
  const MInt noNonMappedCells = m_elementDonorPos[elementId].size() - noDonorCells;
 
  // Check if more than one donor cell
  if(noDonorCells > 1) {
    // Apply the Galerkin projection
    if(!m_useLowPassFilter || m_noCutModesLowPass == 0) {
      m_projection[polyDeg].apply(noDonorCells, noNonMappedCells, &m_elementDonorMap[elementId][0],
                                  &m_elementDonorLevels[elementId][0], &m_elementDonorPos[elementId][0], &data[0],
                                  defaultValues, noVars, target);
    } else {
      MFloatScratchSpace tmp(noNodesXD * noVars, AT_, "tmp");
      m_projection[polyDeg - m_noCutModesLowPass].apply(
          noDonorCells, noNonMappedCells, &m_elementDonorMap[elementId][0], &m_elementDonorLevels[elementId][0],
          &m_elementDonorPos[elementId][0], &data[0], defaultValues, noVars, &tmp[0]);
      maia::dg::interpolation::interpolateNodes<nDim>(&tmp[0],
                                                      &m_vdmLowPass[polyDeg - m_noCutModesLowPass][0],
                                                      polyDeg + 1 - m_noCutModesLowPass,
                                                      polyDeg + 1,
                                                      noVars,
                                                      target);
    }
 
    if(m_checkConservation || m_calcProjectionError) {
      if(noNonMappedCells > 0) {
        TERMM(1, "Fix conservation/projection error comp. for the case with non-mapped cells");
      }
 
      const MInt cellId = elements().cellId(elementId);
      const MFloat targetLength = dgSolver().grid().cellLengthAtCell(cellId);
      MFloatScratchSpace errors(noVars, AT_, "errors");
 
      // Check if the projection is conservative
      if(m_checkConservation) {
        m_projection[polyDeg].calcConservationError(noDonorCells, &m_elementDonorMap[elementId][0],
                                                    &m_elementDonorLevels[elementId][0], &data[0], noVars, targetLength,
                                                    target, &errors[0]);
 
        const MFloat maxError = *(std::max_element(errors.begin(), errors.end()));
        m_maxConservationError = std::max(m_maxConservationError, maxError);
      }
 
      // Calculate the projection error
      if(m_calcProjectionError) {
        m_projection[polyDeg].calcL2Error(noDonorCells, &m_elementDonorMap[elementId][0],
                                          &m_elementDonorLevels[elementId][0], &m_elementDonorPos[elementId][0],
                                          &data[0], noVars, targetLength, target, &errors[0]);
 
        // Calculate maximum error
        const MFloat maxError = *(std::max_element(errors.begin(), errors.end()));
        m_maxL2Error = std::max(m_maxL2Error, maxError);
      }
    }
  } else if(noDonorCells == 1) {
    // One-to-one mapping
    MFloatTensor targetF(target, noNodesXD, noVars);
 
    // Store donor cell variables in all element nodes
    const MInt donorCellId = m_elementDonorMap[elementId][0];
    const MInt offset = donorCellId * noVars;
    for(MInt i = 0; i < noNodesXD; i++) {
      for(MInt v = 0; v < noVars; v++) {
        targetF(i, v) = data[offset + v];
      }
    }
  } else {
    // No mapped cell: use default value(s)
    MFloatTensor targetF(target, noNodesXD, noVars);
    for(MInt i = 0; i < noNodesXD; i++) {
      for(MInt v = 0; v < noVars; v++) {
        targetF(i, v) = defaultValues[v];
      }
    }
  }
}

readProperties()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::readProperties ( )

finaloverrideprotectedvirtual

Author

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

Date

2015-10-02

Implements Coupling.

saveFilterValues()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::saveFilterValues

protected

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-12-03

Definition at line 1384 of file couplingdgape.h.

                                                          {
  TRACE();
 
  m_log << "Saving file with filter values ... ";
 
  if(!m_hasDgCartesianSolver) {
    return;
  }
 
  const std::vector<MString> filterVarName{"sourcefilter:" + m_sourceTermFilter.name()};
  saveNodalData("sourcefilter", 1, filterVarName, &m_filter[0]);
 
  m_log << "done" << std::endl;
}

saveFilterValuesDonor()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::saveFilterValuesDonor

protected

Definition at line 1401 of file couplingdgape.h.

                                                               {
  TRACE();
  m_log << "Saving file with filter values on donor cells... ";
 
  if(!m_hasDonorCartesianSolver) {
    return;
  }
 
  std::stringstream fileName;
  fileName << donorSolver().outputDir() << "sourcefilterDonor" << ParallelIo::fileExt();
 
  using namespace maia::parallel_io;
  ParallelIo parallelIo(fileName.str(), PIO_REPLACE, donorSolver().mpiComm());
 
  const MInt localNoCells = m_noDonorCells;
  // Determine offset and global number of cells
  ParallelIo::size_type offset = 0;
  ParallelIo::size_type globalNoCells = 0;
  parallelIo.calcOffset(localNoCells, &offset, &globalNoCells, donorSolver().mpiComm());
 
  // Set attributes
  parallelIo.setAttribute(globalNoCells, "noCells");
  parallelIo.setAttribute(donorSolver().grid().gridInputFileName(), "gridFile");
  parallelIo.setAttribute(donorSolver().solverId(), "solverId");
 
  const MString name_ = "sourcefilter:" + m_sourceTermFilter.name();
  parallelIo.defineArray(PIO_FLOAT, name_, globalNoCells);
  parallelIo.setOffset(localNoCells, offset);
  parallelIo.writeArray(&m_filterDonor[0], name_);
 
  m_log << "done" << std::endl;
}

saveSourceTermsDonorGrid()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::saveSourceTermsDonorGrid ( const MInt  timeStep, const MFloat *const  data  )

protected

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-12-03

Parameters

[in]	timeStep	Current time step.
[in]	data	Pointer to source term data on donor grid.

Definition at line 1634 of file couplingdgape.h.

                                                                                                               {
  TRACE();
  CHECK_TIMERS_IO();
 
  if(!m_hasDonorCartesianSolver) {
    return;
  }
 
  const MInt noVariables = SysEqn::noVars();
 
  std::stringstream fileName;
  fileName << donorSolver().outputDir() << "sourceTermsDonorGrid_" << std::setw(8) << std::setfill('0') << timeStep
           << ParallelIo::fileExt();
 
  // Define source term names
  std::vector<MString> sourceTermNames(noVariables);
  if constexpr(nDim == 2) {
    sourceTermNames = std::vector<MString>{"source_u", "source_v", "source_p"};
  } else {
    sourceTermNames = std::vector<MString>{"source_u", "source_v", "source_w", "source_p"};
  }
 
  // Create data out object to save data to disk
  using namespace maia::parallel_io;
  ParallelIo parallelIo(fileName.str(), PIO_REPLACE, donorSolver().mpiComm());
 
  const MInt localNoCells = m_noDonorCells;
  // Determine offset and global number of cells
  ParallelIo::size_type offset = 0;
  ParallelIo::size_type globalNoCells = 0;
  parallelIo.calcOffset(localNoCells, &offset, &globalNoCells, donorSolver().mpiComm());
 
  // Set attributes
  parallelIo.setAttribute(globalNoCells, "noCells");
  parallelIo.setAttribute(donorSolver().grid().gridInputFileName(), "gridFile");
  parallelIo.setAttribute(donorSolver().solverId(), "solverId");
 
  // Define arrays in file
  for(MInt i = 0; i < noVariables; i++) {
    const MString name_ = "variables" + std::to_string(i);
    parallelIo.defineArray(PIO_FLOAT, name_, globalNoCells);
    parallelIo.setAttribute(sourceTermNames[i], "name", name_);
  }
 
  parallelIo.setOffset(localNoCells, offset);
 
  // Write source term data to file
  for(MInt i = 0; i < noVariables; i++) {
    const MString name_ = "variables" + std::to_string(i);
    parallelIo.writeArray(&data[i], name_, noVariables);
  }
}

saveSourceTermsTargetGrid()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::saveSourceTermsTargetGrid ( const MInt  timeStep )

protected

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-12-03

Parameters

[in]

timeStep

Current time step.

Definition at line 1694 of file couplingdgape.h.

                                                                                      {
  TRACE();
  CHECK_TIMERS_IO();
 
  const MInt noVariables = SysEqn::noVars();
  const MInt dataSize = m_maxNoNodesXD * noVariables;
 
  // Buffer for source terms on all elements to write to file
  ScratchSpace<MFloat> sourceTerms(noElements(), dataSize, AT_, "sourceTerms");
 
  // Copy source terms to buffer
  const MInt noSourceElements = m_calcSourceElements.size();
  for(MInt eId = 0; eId < noSourceElements; eId++) {
    const MInt elementId = m_calcSourceElements[eId];
    const MInt noNodesXD = ipow(elements().polyDeg(elementId) + 1, nDim);
 
    // Set source and destination pointers
    MFloat* const dest = &sourceTerms[elementId * dataSize];
    const MFloat* const src = &m_sourceTerms[eId * dataSize];
 
    // Copy all source terms of this element
    std::copy_n(src, noNodesXD * noVariables, dest);
  }
 
  std::stringstream fileNameBase;
  fileNameBase << "sourceTerms_" << std::setw(8) << std::setfill('0') << timeStep;
 
  // Define source term names
  std::vector<MString> sourceTermNames(noVariables);
  if constexpr(nDim == 2) {
    sourceTermNames = std::vector<MString>{"source_u", "source_v", "source_p"};
  } else {
    sourceTermNames = std::vector<MString>{"source_u", "source_v", "source_w", "source_p"};
  }
 
  // Save source terms to file
  saveNodalData(fileNameBase.str(), noVariables, sourceTermNames, &sourceTerms[0]);
}

startLoadTimer()

template<MInt nDim, class CouplingDonor >

void Coupling::startLoadTimer ( const MString &  name ) const

inline

Definition at line 148 of file coupling.h.

                                                        {
    maia::dlb::g_dlbTimerController.startLoadTimer(m_dlbTimerId, name);
  }

stopLoadTimer()

template<MInt nDim, class CouplingDonor >

void Coupling::stopLoadTimer ( const MString &  name ) const

inline

Definition at line 152 of file coupling.h.

                                                       {
    maia::dlb::g_dlbTimerController.stopLoadTimer(m_dlbTimerId, name);
  }

storeSources()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::storeSources ( const MFloat  time, const MInt  timeStep  )

protected

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]	time	Current simulation time.
[in]	timeStep	Current simulation time step.

The purpose of this method is to calculate the sources only once per time step, and not once per Runge-Kutta step.

Definition at line 1492 of file couplingdgape.h.

                                                                                            {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::StoreSources]);
 
  // Storage for velocities and vorticities of the donor cells
  MFloatScratchSpace velocity(std::max(m_noDonorCells, 1), noVelocities(), AT_, "velocity");
  MFloatScratchSpace vorticity(std::max(m_noDonorCells, 1), noVorticities(), AT_, "vorticity");
 
  // Load all needed coupling data here
  // NOTE: for now (Q_mI and Q_mI_linear) the velocities and the vorticities are
  // needed for both source terms so there is no check yet which variables are
  // actually needed, but this will change in the future.
  RECORD_TIMER_START(m_timers[Timers::LoadInstantaneous]);
  getDonorVelocityAndVorticity(m_calcSourceDonorCells, velocity, vorticity);
  RECORD_TIMER_STOP(m_timers[Timers::LoadInstantaneous]);
 
  // Source terms on donor cells (i.e. all source terms summed up)
  MFloatScratchSpace sourceTerms(std::max(m_noDonorCells, 1), SysEqn::noVars(), AT_, "sourceTerms");
  std::fill(sourceTerms.begin(), sourceTerms.end(), 0.0);
 
  RECORD_TIMER_START(m_timers[Timers::CalcSources]);
  // Compute all source terms and accumulate to get the total source terms
  for(auto&& sourceTerm : m_activeSourceTerms) {
    switch(sourceTerm) {
      case ST::Q_mI:
        // Perturbed Lamb vector
        calcSourceLambNonlinear(&velocity[0], &vorticity[0], &sourceTerms(0, 0));
        break;
      case ST::Q_mI_linear:
        // Linearized Lamb vector
        calcSourceLambLinearized(&velocity[0], &vorticity[0], &sourceTerms(0, 0));
        break;
      case ST::Q_mII:
        // Pressure linearization
        calcSourceQmII(&velocity[0], &sourceTerms(0, 0));
        break;
      case ST::Q_mIII:
        calcSourceQmIII(&velocity[0], &sourceTerms(0, 0));
        break;
      case ST::Q_e:
        // Perturbed energy
        calcSourceQe(&velocity[0], time, &sourceTerms(0, 0));
        break;
      case ST::Q_c:
        calcSourceQc(&velocity[0], &sourceTerms(0, 0), time, timeStep);
        break;
      default:
        TERMM(1, "Source term '" + s_sourceTermNames[sourceTerm] + "' not implemented.");
        break;
    }
  }
  RECORD_TIMER_STOP(m_timers[Timers::CalcSources]);
 
  // Set flag to indicate that the source terms have already been calculated at least once
  m_isFirstSourceCalculation = false;
 
  // Store source terms on donor grid
  if(m_saveSourceTermsInterval > 0 && timeStep % m_saveSourceTermsInterval == 0 && m_saveSourceTermsDonorGrid) {
    stopLoadTimer(AT_);
    maia::dlb::g_dlbTimerController.disableAllDlbTimers();
 
    saveSourceTermsDonorGrid(timeStep, &sourceTerms[0]);
 
    maia::dlb::g_dlbTimerController.enableAllDlbTimers();
    startLoadTimer(AT_);
  }
 
  // TODO labels:COUPLER save filtered or unfiltered sources on donor grid?
  if(m_applySourceFilterDonor) {
    // Apply spatial filter to source terms on donor cells
    const MInt noVars = SysEqn::noVars();
    for(MInt i = 0; i < m_noDonorCells; i++) {
      const MFloat filter = m_filterDonor[i];
      for(MInt j = 0; j < noVars; j++) {
        sourceTerms[i * noVars + j] *= filter;
      }
    }
  }
 
  // Default source terms (NaN): only needed for the call to projectToElement()
  // but this should never be used/needed as an element without mapped LES cells
  // should not do anything here.
  /* const MFloat nan_value = std::numeric_limits<MFloat>::quiet_NaN(); */
  /* const std::array<MFloat, MAX_SPACE_DIMENSIONS + 1> defaultSourceTerms = { */
  /*     {nan_value, nan_value, nan_value, nan_value}}; */
  // Note: changed to 0 since non-mapped cells can now appear in the projection information that
  // will use these values
  const std::array<MFloat, MAX_SPACE_DIMENSIONS + 1> defaultSourceTerms = {{0.0, 0.0, 0.0, 0.0}};
 
  // Project accumulated source terms on elements and apply the spatial filter
  RECORD_TIMER_START(m_timers[Timers::ProjectSourceTerms]);
  const MInt noSourceElements = m_calcSourceElements.size();
  const MInt sourceOffset = m_maxNoNodesXD * SysEqn::noVars();
 
  maia::parallelFor(0, noSourceElements, [&](MInt elementIndex) {
    const MInt elementId = m_calcSourceElements[elementIndex];
    const MInt noNodes1D = elements().polyDeg(elementId) + 1;
    const MInt noNodesXD = ipow(noNodes1D, nDim);
    const MInt elementOffset = elementIndex * sourceOffset;
 
    MFloatTensor elementSourceTerms(&m_sourceTerms[elementOffset], noNodesXD, SysEqn::noVars());
    MFloatTensor filter(&m_filter[elementId * m_maxNoNodesXD], noNodesXD);
 
    // Project source terms on element
    projectToElement(elementId, SysEqn::noVars(), &sourceTerms[0], &defaultSourceTerms[0], &elementSourceTerms[0]);
 
    // Apply spatial filter on element (if not already applied on donor cells)
    if(!m_applySourceFilterDonor) {
      for(MInt i = 0; i < noNodesXD; i++) {
        for(MInt v = 0; v < SysEqn::noVars(); v++) {
          elementSourceTerms(i, v) *= filter(i);
        }
      }
    }
  });
  RECORD_TIMER_STOP(m_timers[Timers::ProjectSourceTerms]);
 
  // Store previous time for calculating dp/dt in the Qe source term
  m_previousTime = time;
 
  // Store source terms on target grid
  if(m_saveSourceTermsInterval > 0 && timeStep % m_saveSourceTermsInterval == 0) {
    stopLoadTimer(AT_);
    maia::dlb::g_dlbTimerController.disableAllDlbTimers();
 
    saveSourceTermsTargetGrid(timeStep);
 
    maia::dlb::g_dlbTimerController.enableAllDlbTimers();
    startLoadTimer(AT_);
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::StoreSources]);
}

subCouple()

template<MInt nDim, class CouplingDonor >

void CouplingDgApe< nDim, CouplingDonor >::subCouple ( MInt  , MInt  , std::vector< MBool > &    )

inlinefinaloverridevirtual

Implements Coupling.

Definition at line 257 of file couplingdgape.h.

{};

Member Data Documentation

m_activeMeanVars

template<MInt nDim, class CouplingDonor >

std::vector<MInt> CouplingDgApe< nDim, CouplingDonor >::m_activeMeanVars {}

protected

Definition at line 369 of file couplingdgape.h.

m_activeSourceTerms

template<MInt nDim, class CouplingDonor >

std::vector<MInt> CouplingDgApe< nDim, CouplingDonor >::m_activeSourceTerms {}

protected

Definition at line 371 of file couplingdgape.h.

m_applySourceFilterDonor

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_applySourceFilterDonor = false

protected

Definition at line 413 of file couplingdgape.h.

m_calcProjectionError

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_calcProjectionError = false

protected

Definition at line 374 of file couplingdgape.h.

m_calcSourceDonorCells

template<MInt nDim, class CouplingDonor >

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

protected

Definition at line 390 of file couplingdgape.h.

m_calcSourceElements

template<MInt nDim, class CouplingDonor >

std::vector<MInt> CouplingDgApe< nDim, CouplingDonor >::m_calcSourceElements {}

protected

Definition at line 391 of file couplingdgape.h.

m_checkConservation

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_checkConservation = false

protected

Definition at line 395 of file couplingdgape.h.

m_elementDonorLevels

template<MInt nDim, class CouplingDonor >

std::vector<std::vector<MInt> > CouplingDgApe< nDim, CouplingDonor >::m_elementDonorLevels = {}

protected

Definition at line 380 of file couplingdgape.h.

m_elementDonorMap

template<MInt nDim, class CouplingDonor >

std::vector<std::vector<MInt> > CouplingDgApe< nDim, CouplingDonor >::m_elementDonorMap = {}

protected

Definition at line 381 of file couplingdgape.h.

m_elementDonorPos

template<MInt nDim, class CouplingDonor >

std::vector<std::vector<MInt> > CouplingDgApe< nDim, CouplingDonor >::m_elementDonorPos = {}

protected

Definition at line 382 of file couplingdgape.h.

m_elementInsideBody

template<MInt nDim, class CouplingDonor >

std::vector<MInt> CouplingDgApe< nDim, CouplingDonor >::m_elementInsideBody {}

protected

Definition at line 403 of file couplingdgape.h.

m_filter

template<MInt nDim, class CouplingDonor >

std::vector<MFloat> CouplingDgApe< nDim, CouplingDonor >::m_filter {}

protected

Definition at line 408 of file couplingdgape.h.

m_filterDonor

template<MInt nDim, class CouplingDonor >

std::vector<MFloat> CouplingDgApe< nDim, CouplingDonor >::m_filterDonor {}

protected

Definition at line 409 of file couplingdgape.h.

m_fixedTimeStep

template<MInt nDim, class CouplingDonor >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_fixedTimeStep = -1.0

protected

Definition at line 364 of file couplingdgape.h.

m_hasDgCartesianSolver

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_hasDgCartesianSolver = false

protected

Definition at line 357 of file couplingdgape.h.

m_hasDonorCartesianSolver

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_hasDonorCartesianSolver = false

protected

Definition at line 358 of file couplingdgape.h.

m_isFirstSourceCalculation

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_isFirstSourceCalculation = true

protected

Definition at line 388 of file couplingdgape.h.

m_isRestart

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_isRestart = false

protected

Definition at line 356 of file couplingdgape.h.

m_maxConservationError

template<MInt nDim, class CouplingDonor >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_maxConservationError = -1.0

protected

Definition at line 396 of file couplingdgape.h.

m_maxL2Error

template<MInt nDim, class CouplingDonor >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_maxL2Error = -1.0

protected

Definition at line 397 of file couplingdgape.h.

m_maxNoNodesXD

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::m_maxNoNodesXD = -1

protected

Definition at line 360 of file couplingdgape.h.

m_meanDataFileName

template<MInt nDim, class CouplingDonor >

MString CouplingDgApe< nDim, CouplingDonor >::m_meanDataFileName {}

protected

Definition at line 370 of file couplingdgape.h.

m_meanVars

template<MInt nDim, class CouplingDonor >

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

protected

Definition at line 400 of file couplingdgape.h.

m_meanVarsIndex

template<MInt nDim, class CouplingDonor >

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

protected

Definition at line 426 of file couplingdgape.h.

m_noActiveDonorCells

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::m_noActiveDonorCells = -1

protected

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_noCutModesLowPass

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::m_noCutModesLowPass = 0

protected

Definition at line 410 of file couplingdgape.h.

m_noDonorCells

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::m_noDonorCells = -1

protected

Definition at line 379 of file couplingdgape.h.

m_previousTime

template<MInt nDim, class CouplingDonor >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_previousTime

protected

Initial value:

=
      std::numeric_limits<MFloat>::quiet_NaN()

Definition at line 365 of file couplingdgape.h.

m_previousTimeStep

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::m_previousTimeStep = -1

protected

Definition at line 367 of file couplingdgape.h.

m_projection

template<MInt nDim, class CouplingDonor >

std::vector<ProjectionType> CouplingDgApe< nDim, CouplingDonor >::m_projection {}

protected

Definition at line 385 of file couplingdgape.h.

m_projectionFilter

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_projectionFilter = false

protected

Definition at line 416 of file couplingdgape.h.

m_projectionFilterBox

template<MInt nDim, class CouplingDonor >

std::vector<MFloat> CouplingDgApe< nDim, CouplingDonor >::m_projectionFilterBox {}

protected

Definition at line 417 of file couplingdgape.h.

m_saveSourceTermFilter

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_saveSourceTermFilter = false

protected

Definition at line 414 of file couplingdgape.h.

m_saveSourceTermsDonorGrid

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_saveSourceTermsDonorGrid = false

protected

Definition at line 372 of file couplingdgape.h.

m_saveSourceTermsInterval

template<MInt nDim, class CouplingDonor >

MInt CouplingDgApe< nDim, CouplingDonor >::m_saveSourceTermsInterval = -1

protected

Definition at line 373 of file couplingdgape.h.

m_sourceFactor

template<MInt nDim, class CouplingDonor >

MFloat CouplingDgApe< nDim, CouplingDonor >::m_sourceFactor = 1.0

protected

Definition at line 392 of file couplingdgape.h.

m_sourceTermFilter

template<MInt nDim, class CouplingDonor >

Filter<nDim> CouplingDgApe< nDim, CouplingDonor >::m_sourceTermFilter

protected

Definition at line 407 of file couplingdgape.h.

m_sourceTerms

template<MInt nDim, class CouplingDonor >

std::vector<MFloat> CouplingDgApe< nDim, CouplingDonor >::m_sourceTerms {}

protected

Definition at line 389 of file couplingdgape.h.

m_timers

template<MInt nDim, class CouplingDonor >

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

protected

Definition at line 464 of file couplingdgape.h.

m_useLowPassFilter

template<MInt nDim, class CouplingDonor >

MBool CouplingDgApe< nDim, CouplingDonor >::m_useLowPassFilter = false

protected

Definition at line 411 of file couplingdgape.h.

m_vdmLowPass

template<MInt nDim, class CouplingDonor >

std::vector<MFloatTensor> CouplingDgApe< nDim, CouplingDonor >::m_vdmLowPass {}

protected

Definition at line 412 of file couplingdgape.h.

s_sourceTermNames

template<MInt nDim, class CouplingDonor >

const std::array< MString, CouplingDgApe< nDim, CouplingDonor >::ST::totalNoSourceTerms > CouplingDgApe< nDim, CouplingDonor >::s_sourceTermNames

staticprotected

Initial value:

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

Source term names corresponding to ST

Definition at line 430 of file couplingdgape.h.

s_totalNoMeanVars

template<MInt nDim, class CouplingDonor >

const MInt CouplingDgApe< nDim, CouplingDonor >::s_totalNoMeanVars = MV::totalNoMeanVars

staticprotected

Definition at line 422 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/couplingdgape.h