Container for sponge elements. More...

#include <dgcartesiansponge.h>

Collaboration diagram for DgSponge< nDim, SysEqn >:

Public Member Functions
MPI_Comm	mpiComm () const
	Return the MPI communicator used by the corresponding solver. More...

MInt	domainId () const
	Return the domain id of the corresponding solver. More...

MInt	noDomains () const
	Return the number of domains of the corresponding solver. More...

	DgSponge (const MInt solverId, const MPI_Comm comm)
	Constructor accepts solver id and MPI communicator. More...

void	init (const MInt maxPolyDeg, Grid grid_, ElementCollector elements_, SurfaceCollector surfaces_, std::vector< BC > boundaryConditions, SysEqn *sysEqn, const MPI_Comm comm)
	Sets attributes so that sponge can access necessary components in solver. Checks sponge boundary condition ids. Creates sponge elements. More...

void	calcSourceTerms ()
	Calculates the sponge terms, that can be considered as an addition source terms for each node and adds them to the time derivative of the conservative variables. More...

MInt	noSpongeElements () const

MInt	elementId (const MInt seId) const

MInt	spongeElementId (const MInt eId) const
	Return sponge element id for given element id. If none exists, return -1. More...

MFloat	spongeEta (const MInt seId, const MInt pos)

Private Types
using	BC = typename DgBoundaryConditionFactory< nDim, SysEqn >::ReturnType

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

using	SpongeElementCollector = maia::dg::collector::SpongeElementCollector< nDim, SysEqn >

using	SpongeLayerType = DgSpongeLayer< nDim >

using	ElementCollector = maia::dg::collector::ElementCollector< nDim, SysEqn >

using	SurfaceCollector = maia::dg::collector::SurfaceCollector< nDim, SysEqn >

Private Member Functions
void	checkSpongeBoundaryConditions () const
	Check whether boundary conditions specified to have a sponge exist. More...

void	initSpongeElements ()
	Initialisation of SpongeLayer. Calculation of spongeEta. Sponge is an additional Sourceoperator: DelL: du/dt + L(u) = DelL(u) More...

void	initSpongeLayer (SpongeLayerType &spongeLayer, const BC &boundaryCondition)
	Determines boundary plane. More...

void	exchangeSpongeLayers (std::vector< SpongeLayerType > &spongeLayers)
	Exchange sponge layers between all domains. More...

void	calcSpongeEtaForAllNodes (const MInt seId, const std::vector< SpongeLayerType > &spongeLayers)
	Calculation of SpongeEta for all nodes of one DG-Element. More...

MFloat	distance (const SpongeLayerType &spongeLayer, const MFloat *otherPoint) const
	Calculates the distance between a point and a boundary plane. The distance is signed, i.e., it is positive if the point is inside. More...

MBool	pointInsideSpongeLayer (const SpongeLayerType &spongeLayer, const MFloat *otherPoint, MFloat &diff) const
	Returns true if point is inside sponge layer. Calculates difference between thickness of sponge layer and distance of point to boundary plane. More...

Private Attributes
const MInt	m_solverId = -1

MPI_Comm	m_mpiComm = MPI_COMM_NULL

MInt	m_domainId = -1

MInt	m_noDomains = -1

Grid *	m_grid = nullptr

MInt	m_maxPolyDeg = -1

ElementCollector *	m_elements = nullptr

std::vector< BC > *	m_boundaryConditions = nullptr

SurfaceCollector *	m_surfaces = nullptr

SysEqn *	m_sysEqn = nullptr

SpongeElementCollector	m_spongeElements

Detailed Description

template<MInt nDim, class SysEqn>
class DgSponge< nDim, SysEqn >

Author: Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 8th, 2015

Definition at line 59 of file dgcartesiansponge.h.

Member Typedef Documentation

◆ BC

template<MInt nDim, class SysEqn >

using DgSponge< nDim, SysEqn >::BC = typename DgBoundaryConditionFactory<nDim, SysEqn>::ReturnType

private

Definition at line 60 of file dgcartesiansponge.h.

◆ ElementCollector

template<MInt nDim, class SysEqn >

using DgSponge< nDim, SysEqn >::ElementCollector = maia::dg::collector::ElementCollector<nDim, SysEqn>

private

Definition at line 64 of file dgcartesiansponge.h.

◆ Grid

template<MInt nDim, class SysEqn >

using DgSponge< nDim, SysEqn >::Grid = typename maia::grid::Proxy<nDim>

private

Definition at line 61 of file dgcartesiansponge.h.

◆ SpongeElementCollector

template<MInt nDim, class SysEqn >

using DgSponge< nDim, SysEqn >::SpongeElementCollector = maia::dg::collector::SpongeElementCollector<nDim, SysEqn>

private

Definition at line 62 of file dgcartesiansponge.h.

◆ SpongeLayerType

template<MInt nDim, class SysEqn >

using DgSponge< nDim, SysEqn >::SpongeLayerType = DgSpongeLayer<nDim>

private

Definition at line 63 of file dgcartesiansponge.h.

◆ SurfaceCollector

template<MInt nDim, class SysEqn >

using DgSponge< nDim, SysEqn >::SurfaceCollector = maia::dg::collector::SurfaceCollector<nDim, SysEqn>

private

Definition at line 65 of file dgcartesiansponge.h.

Constructor & Destructor Documentation

◆ DgSponge()

template<MInt nDim, class SysEqn >

DgSponge< nDim, SysEqn >::DgSponge	(	const MInt	solverId,
		const MPI_Comm	comm
	)

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

Date: 2015-08-31

Parameters

[in]	solverId	The id of the corresponding solver.
[in]	comm	The MPI communicator to use.

Definition at line 133 of file dgcartesiansponge.h.

                                                                         : m_solverId(solverId), m_mpiComm(comm) {
  TRACE();
}

Member Function Documentation

◆ calcSourceTerms()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::calcSourceTerms

Author: Vitali Pauz v.pau.nosp@m.z@ai.nosp@m.a.rwt.nosp@m.h-aa.nosp@m.chen..nosp@m.de

Date: April 4th, 2014

Definition at line 593 of file dgcartesiansponge.h.

                                             {
  TRACE();
 
  // const MInt* polyDeg = &m_elements->polyDeg(0);
  const MInt* noNodes1D = &m_elements->noNodes1D(0);
  const MInt maxDataBlockSize = m_elements->maxNoNodesXD() * SysEqn::noVars();
 
  std::vector<MFloat> spongeSources(maxDataBlockSize);
 
#ifdef _OPENMP
#pragma omp parallel for firstprivate(spongeSources)
#endif
  for(MInt seId = 0; seId < noSpongeElements(); seId++) {
    const MInt eId = m_spongeElements.elementId(seId);
    const MInt dataBlockSize = m_elements->noNodesXD(eId) * SysEqn::noVars();
    m_sysEqn->calcSpongeSource(&m_elements->nodeVars(eId),
                               &m_elements->variables(eId),
                               noNodes1D[eId],
                               &m_spongeElements.spongeEta(seId),
                               &spongeSources[0]);
    MFloat* const rhs = &m_elements->rightHandSide(eId);
    for(MInt dataId = 0; dataId < dataBlockSize; dataId++) {
      rhs[dataId] += spongeSources[dataId];
    }
  }
}

◆ calcSpongeEtaForAllNodes()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::calcSpongeEtaForAllNodes	(	const MInt	seId,
		const std::vector< SpongeLayerType > &	spongeLayers
	)

private

Author: Vitali Pauz v.pau.nosp@m.z@ai.nosp@m.a.rwt.nosp@m.h-aa.nosp@m.chen..nosp@m.de

Date: April 4th, 2014

Definition at line 628 of file dgcartesiansponge.h.

                                                                                                      {
  TRACE();
 
  const MInt eId = m_spongeElements.elementId(seId);
  const MInt noNodes1D = m_elements->noNodes1D(eId);
  const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
 
  MFloatTensor nodeCoordinates(&m_elements->nodeCoordinates(eId), noNodes1D, noNodes1D, noNodes1D3, nDim);
 
  MFloatTensor sEta(&m_spongeElements.spongeEta(seId), noNodes1D, noNodes1D, noNodes1D3);
  std::fill_n(&sEta(0, 0, 0), sEta.size(), 0.0);
 
  for(MInt i = 0; i < noNodes1D; i++) {
    for(MInt j = 0; j < noNodes1D; j++) {
      for(MInt k = 0; k < noNodes1D3; k++) {
        for(size_t s = 0; s < spongeLayers.size(); s++) {
          MFloat diff = 0.0;
          if(pointInsideSpongeLayer(spongeLayers[s], &nodeCoordinates(i, j, k, 0), diff)) {
            const MFloat eta = POW2(diff / spongeLayers[s].m_thickness);
            sEta(i, j, k) = std::max(sEta(i, j, k), eta);
          }
        }
      }
    }
  }
}

◆ checkSpongeBoundaryConditions()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::checkSpongeBoundaryConditions

private

Author: Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 20th, 2015

Definition at line 233 of file dgcartesiansponge.h.

◆ distance()

template<MInt nDim, class SysEqn >

MFloat DgSponge< nDim, SysEqn >::distance	(	const SpongeLayerType &	spongeLayer,
		const MFloat *	point
	)		const

private

Author: Sven Berger, Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 21st, 2015

Definition at line 665 of file dgcartesiansponge.h.

                                                                                                     {
  // 0=x, 1=y, 2=z
  const MInt orientation = (spongeLayer.m_orientation - spongeLayer.m_orientation % 2) / 2;
  // 1=inside in positive direction, -1=inside in negative direction
  const MInt direction = 2 * (spongeLayer.m_orientation % 2) - 1;
 
  return direction * (point[orientation] - spongeLayer.m_offset);
}

◆ domainId()

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::domainId ( ) const

inline

Definition at line 72 of file dgcartesiansponge.h.

72{ return m_domainId; }

DgSponge::m_domainId

MInt m_domainId

Definition: dgcartesiansponge.h:99

◆ elementId()

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::elementId ( const MInt seId ) const

inline

Definition at line 82 of file dgcartesiansponge.h.

82{ return m_spongeElements.elementId(seId); }

◆ exchangeSpongeLayers()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::exchangeSpongeLayers ( std::vector< SpongeLayerType > & spongeLayers )

private

Author: Sven Berger, Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 21st, 2015

Definition at line 495 of file dgcartesiansponge.h.

                                                                                          {
  TRACE();
 
  // Exchange sponge layer ids
 
  // Set up communication buffer
  const MInt noSpongeBcs = spongeLayers.size();
  ScratchSpace<MChar> whichSpongeLayers(noDomains(), noSpongeBcs, AT_, "whichSpongeLayers");
 
  // For each sponge BC id, store if it has surfaces on current domain
  for(MInt i = 0; i < noSpongeBcs; i++) {
    const MInt spongeBcId = spongeLayers[i].m_bcId;
    whichSpongeLayers(domainId(), i) =
        std::find_if(m_boundaryConditions->begin(),
                     m_boundaryConditions->end(),
                     [spongeBcId](const BC& bc) { return bc->id() == spongeBcId && bc->count() > 0; })
        != m_boundaryConditions->end();
  }
 
  // Exchange with all domains
  MPI_Allgather(MPI_IN_PLACE, noSpongeBcs, maia::type_traits<MChar>::mpiType(), &whichSpongeLayers(0, 0), noSpongeBcs,
                maia::type_traits<MChar>::mpiType(), mpiComm(), AT_, "MPI_IN_PLACE", "whichSpongeLayers(0");
 
  // Exchange boundary planes and thicknesses
 
  // One broadcast per sponge BC:
  // 1.) If whichSpongeLayerRecv is false, nothing has to be done.
  // 2.) If whichSpongeLayerRecv is true, make sure that domains with higher id
  // do not broadcast.
  // 3.) Prepare and perform broadcast.
  // Iterating through whichSpongeLayer is equivalent to iterating through
  // all domains and sponge BCs
  for(MInt i = 0; i < noDomains(); i++) {
    for(MInt j = 0; j < noSpongeBcs; j++) {
      // Step 1
      if(!whichSpongeLayers(i, j)) {
        continue;
      }
 
      // Step 2
      for(MInt k = i + 1; k < noDomains(); k++) {
        whichSpongeLayers(k, j) = false;
      }
 
      // Step 3
      const MInt spongeBcId = spongeLayers[j].m_bcId;
      SpongeLayerType& spongeLayer =
          *std::find_if(spongeLayers.begin(), spongeLayers.end(),
                        [spongeBcId](const SpongeLayerType& sl) { return sl.m_bcId == spongeBcId; });
      MPI_Bcast(&spongeLayer.m_orientation, 1, maia::type_traits<MInt>::mpiType(), i, mpiComm(), AT_,
                "spongeLayer.m_orientation");
      MPI_Bcast(&spongeLayer.m_offset, 1, maia::type_traits<MFloat>::mpiType(), i, mpiComm(), AT_,
                "spongeLayer.m_offset");
      MPI_Allreduce(MPI_IN_PLACE, &spongeLayer.m_minCoord[0], nDim, maia::type_traits<MFloat>::mpiType(), MPI_MIN,
                    mpiComm(), AT_, "MPI_IN_PLACE", "spongeLayer.m_minCoord[0]");
      MPI_Allreduce(MPI_IN_PLACE, &spongeLayer.m_maxCoord[0], nDim, maia::type_traits<MFloat>::mpiType(), MPI_MAX,
                    mpiComm(), AT_, "MPI_IN_PLACE", "spongeLayer.m_maxCoord[0]");
    }
  }
}

◆ init()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::init	(	const MInt	maxPolyDeg,
		Grid *	grid_,
		ElementCollector *	elements_,
		SurfaceCollector *	surfaces_,
		std::vector< BC > *	boundaryConditions,
		SysEqn *	sysEqn,
		const MPI_Comm	comm
	)

Author: Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 8th, 2015

Parameters

[in]	solverId
[in]	maxPolyDeg
[in]	grid
[in]	elements
[in]	surfaces
[in]	boundaryConditions
[in]	sysEqn

Definition at line 154 of file dgcartesiansponge.h.

                                                       {
  TRACE();
 
  m_mpiComm = comm;
  // Determine domain id and number of domains
  MPI_Comm_rank(mpiComm(), &m_domainId);
  MPI_Comm_size(mpiComm(), &m_noDomains);
 
  m_maxPolyDeg = maxPolyDeg;
  m_grid = grid_;
  m_elements = elements_;
  m_surfaces = surfaces_;
  m_boundaryConditions = boundaryConditions;
  m_sysEqn = sysEqn;
 
  // Make sure that all BCs marked as spongeBCs are actually present in
  // simulation setup (sanity check)
  checkSpongeBoundaryConditions();
 
  // Intialize a sponge element for each DG element affected by a sponge layer
  initSpongeElements();
}

◆ initSpongeElements()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::initSpongeElements

private

DelL = spongeSigma * spongeEta * DeltaStates spongeSigma = heuristical value (approx 0.5) spongeEta = (x_sp / L_sp)^2 L_sp = spongeLayerThickness x_sp = distance of a point to the inner spongeLayer DeltaStages = state_infinity - state_current

Literature: Hartmann Diss. eq. 3.58

Author: Vitali Pauz v.pau.nosp@m.z@ai.nosp@m.a.rwt.nosp@m.h-aa.nosp@m.chen..nosp@m.de, Sven Berger, Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 20th, 2015

Definition at line 287 of file dgcartesiansponge.h.

◆ initSpongeLayer()

template<MInt nDim, class SysEqn >

void DgSponge< nDim, SysEqn >::initSpongeLayer	(	SpongeLayerType &	spongeLayer,
		const BC &	boundaryCondition
	)

private

Author: Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 20th, 2015

Definition at line 422 of file dgcartesiansponge.h.

                                                                                                      {
  TRACE();
 
  const MInt firstSrfcId = boundaryCondition->begin();
  const MFloat* srfcCoord = &m_surfaces->coords(firstSrfcId, 0);
 
  // Store orientation
  MInt orientation = m_surfaces->orientation(firstSrfcId);
  MInt direction = m_surfaces->internalSideId(firstSrfcId);
  spongeLayer.m_orientation = 2 * orientation + direction;
 
  // Correct orientation of the boundary condition manually
  // used for the direct-hybrid testcase of a acoustically
  // exicted flame
  if(spongeLayer.m_bcId == 200) {
    orientation = 0;
    direction = 0;
    spongeLayer.m_orientation = 0;
  }
  if(spongeLayer.m_bcId == 201) {
    orientation = 1;
    direction = 1;
    spongeLayer.m_orientation = 3;
  }
  if(spongeLayer.m_bcId == 202) {
    orientation = 1;
    direction = 1;
    spongeLayer.m_orientation = 3;
  }
  if(spongeLayer.m_bcId == 203) {
    orientation = 0;
    direction = 1;
    spongeLayer.m_orientation = 1;
  }
 
  // Store offset (distance to origin)
  spongeLayer.m_offset = srfcCoord[orientation];
 
  // Determine minimum and maximum coordinates
  std::fill_n(&spongeLayer.m_minCoord[0], nDim, std::numeric_limits<MFloat>::max());
  spongeLayer.m_minCoord[orientation] = srfcCoord[orientation];
  std::fill_n(&spongeLayer.m_maxCoord[0], nDim, -std::numeric_limits<MFloat>::max());
  spongeLayer.m_maxCoord[orientation] = srfcCoord[orientation];
 
  // Determine minimum and maximum extent of boundary by checking each surface
  for(MInt i = boundaryCondition->begin(); i < boundaryCondition->end(); i++) {
    const MFloat* srfcCenter = &m_surfaces->coords(i, 0);
    const MInt internalSideId = m_surfaces->internalSideId(i);
    // FIXME labels:DG,toenhance Boundary surfaces with two neighbor elements should not exist. For
    // now, they are simply skipped.
    if(internalSideId == -1) {
      continue;
    }
    const MInt eId = m_surfaces->nghbrElementIds(i, internalSideId);
    const MInt cellId = m_elements->cellId(eId);
    const MFloat halfCellLength = m_grid->halfCellLength(cellId);
    for(MInt j = 0; j < nDim; j++) {
      if(j != orientation) {
        spongeLayer.m_minCoord[j] = std::min(spongeLayer.m_minCoord[j], srfcCenter[j] - halfCellLength);
        spongeLayer.m_maxCoord[j] = std::max(spongeLayer.m_maxCoord[j], srfcCenter[j] + halfCellLength);
      }
    }
  }
}

◆ mpiComm()

template<MInt nDim, class SysEqn >

MPI_Comm DgSponge< nDim, SysEqn >::mpiComm ( ) const

inline

Definition at line 70 of file dgcartesiansponge.h.

70{ return m_mpiComm; }

◆ noDomains()

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::noDomains ( ) const

inline

Definition at line 74 of file dgcartesiansponge.h.

74{ return m_noDomains; }

◆ noSpongeElements()

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::noSpongeElements ( ) const

inline

Definition at line 81 of file dgcartesiansponge.h.

81{ return m_spongeElements.size(); }

maia::container::Container::size

constexpr MInt size() const

Return size (i.e., currently used number of nodes)

Definition: container.h:89

◆ pointInsideSpongeLayer()

template<MInt nDim, class SysEqn >

MBool DgSponge< nDim, SysEqn >::pointInsideSpongeLayer	(	const SpongeLayerType &	spongeLayer,
		const MFloat *	point,
		MFloat &	diff
	)		const

private

Author: Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 21st, 2015

Definition at line 684 of file dgcartesiansponge.h.

                                                                         {
  // distance to boundary plane
  MFloat dist = distance(spongeLayer, point);
  if(dist < 0.0) {
    return false;
  }
  diff = spongeLayer.m_thickness - dist;
  if(diff < 0.0) {
    return false;
  }
 
  // within min and max coordinates
  for(MInt i = 0; i < nDim; i++) {
    const MInt orientation = (spongeLayer.m_orientation - spongeLayer.m_orientation % 2) / 2;
    if(orientation == i) {
      continue;
    }
 
    if(point[i] < spongeLayer.m_minCoord[i] || point[i] > spongeLayer.m_maxCoord[i]) {
      return false;
    }
  }
 
  return true;
}

◆ spongeElementId()

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::spongeElementId ( const MInt eId ) const

Author: Hans Yu hans..nosp@m.yu@r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date: April 2nd, 2015

Definition at line 569 of file dgcartesiansponge.h.

                                                                 {
  const MInt* const begin = &m_spongeElements.elementId(0);
  const MInt* const end = &m_spongeElements.elementId(0) + noSpongeElements();
  const MInt* const low = std::lower_bound(begin, end, eId);
 
  // Return not found if std::lower_bound does not find anything
  if(low == end || *low != eId) {
    return -1;
  }
 
  // Otherwise return found sponge element id
  return std::distance(begin, low);
}

◆ spongeEta()

template<MInt nDim, class SysEqn >

MFloat DgSponge< nDim, SysEqn >::spongeEta	(	const MInt	seId,
		const MInt	pos
	)

inline

Definition at line 84 of file dgcartesiansponge.h.

84{ return m_spongeElements.spongeEta(seId, pos); }

Member Data Documentation

◆ m_boundaryConditions

template<MInt nDim, class SysEqn >

std::vector<BC>* DgSponge< nDim, SysEqn >::m_boundaryConditions = nullptr

private

Definition at line 112 of file dgcartesiansponge.h.

◆ m_domainId

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::m_domainId = -1

private

Definition at line 99 of file dgcartesiansponge.h.

◆ m_elements

template<MInt nDim, class SysEqn >

ElementCollector* DgSponge< nDim, SysEqn >::m_elements = nullptr

private

Definition at line 109 of file dgcartesiansponge.h.

◆ m_grid

template<MInt nDim, class SysEqn >

Grid* DgSponge< nDim, SysEqn >::m_grid = nullptr

private

Definition at line 103 of file dgcartesiansponge.h.

◆ m_maxPolyDeg

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::m_maxPolyDeg = -1

private

Definition at line 106 of file dgcartesiansponge.h.

◆ m_mpiComm

template<MInt nDim, class SysEqn >

MPI_Comm DgSponge< nDim, SysEqn >::m_mpiComm = MPI_COMM_NULL

private

Definition at line 98 of file dgcartesiansponge.h.

◆ m_noDomains

template<MInt nDim, class SysEqn >

MInt DgSponge< nDim, SysEqn >::m_noDomains = -1

private

Definition at line 100 of file dgcartesiansponge.h.

◆ m_solverId

template<MInt nDim, class SysEqn >

const MInt DgSponge< nDim, SysEqn >::m_solverId = -1

private

Definition at line 97 of file dgcartesiansponge.h.

◆ m_spongeElements

template<MInt nDim, class SysEqn >

SpongeElementCollector DgSponge< nDim, SysEqn >::m_spongeElements

private

Definition at line 121 of file dgcartesiansponge.h.

◆ m_surfaces

template<MInt nDim, class SysEqn >

SurfaceCollector* DgSponge< nDim, SysEqn >::m_surfaces = nullptr

private

Definition at line 115 of file dgcartesiansponge.h.

◆ m_sysEqn

template<MInt nDim, class SysEqn >

SysEqn* DgSponge< nDim, SysEqn >::m_sysEqn = nullptr

private

Definition at line 118 of file dgcartesiansponge.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/DG/dgcartesiansponge.h

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BC

◆ ElementCollector

◆ Grid

◆ SpongeElementCollector

◆ SpongeLayerType

◆ SurfaceCollector

Constructor & Destructor Documentation

◆ DgSponge()

Member Function Documentation

◆ calcSourceTerms()

◆ calcSpongeEtaForAllNodes()

◆ checkSpongeBoundaryConditions()

◆ distance()

◆ domainId()

◆ elementId()

◆ exchangeSpongeLayers()

◆ init()

◆ initSpongeElements()

◆ initSpongeLayer()

◆ mpiComm()

◆ noDomains()

◆ noSpongeElements()

◆ pointInsideSpongeLayer()

◆ spongeElementId()

◆ spongeEta()

Member Data Documentation

◆ m_boundaryConditions

◆ m_domainId

◆ m_elements

◆ m_grid

◆ m_maxPolyDeg

◆ m_mpiComm

◆ m_noDomains

◆ m_solverId

◆ m_spongeElements

◆ m_surfaces

◆ m_sysEqn