DgBcAcousticPerturbRBC< nDim > Class Template Reference

#include <dgcartesianbcacousticperturbrbc.h>

Inheritance diagram for DgBcAcousticPerturbRBC< nDim >:

Collaboration diagram for DgBcAcousticPerturbRBC< nDim >:

Classes
struct	Timers

Public Types
using	Base = DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >
Public Types inherited from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >
using	SysEqn = DgSysEqnAcousticPerturb< nDim >
using	SolverType = DgCartesianSolver< nDim, SysEqn >
using	ElementCollector = maia::dg::collector::ElementCollector< nDim, SysEqn >
using	HElementCollector = maia::dg::collector::HElementCollector< nDim, SysEqn >
using	SurfaceCollector = maia::dg::collector::SurfaceCollector< nDim, SysEqn >

Public Member Functions
	DgBcAcousticPerturbRBC (SolverType &solver_, MInt bcId)
	~DgBcAcousticPerturbRBC ()
MString	name () const override
	Returns name of boundary condition. More...
void	init () override
	Initialize RBC. More...
void	initTimers ()
	Initialize all timers and start the class timer. More...
void	apply (const MFloat time) override
	Apply RBC. More...
void	applyAtSurface (const MInt surfaceId, const MFloat NotUsed(time))
	Calculate boundary surface flux. More...
void	calcFlux (const MFloat *nodeVars, const MFloat *q, const MInt noNodes1D, MFloat *flux_) const
	Calculates the physical fluxes in all directions for all integration points in an element. More...
void	calcRiemann (const MFloat *nodeVarsL, const MFloat *nodeVarsR, const MFloat *stateL, const MFloat *stateR, const MInt noNodes1D, const MInt dirId, MFloat *flux_) const
	Calculates the numerical flux at a surface given two states. More...
void	calcSource (const MFloat *nodeVars, const MFloat *u, const MInt noNodes1D, const MFloat t, const MFloat *x, MFloat *src) const
	Calculates the source terms of the RBC system. More...
MInt	noRestartVars () const override
MInt	getLocalNoNodes () const override
	Return local number of nodes. More...
MString	restartVarName (const MInt id_) const override
	Return name of restart variable. More...
void	setRestartVariable (const MInt id_, const MFloat *const data) override
	Copy restart variable data to boundary conditon. More...
void	getRestartVariable (const MInt id_, MFloat *const data) const override
	Copy restart variable data to pointer. More...
MInt	noBcElements () const override
MBool	hasBcElement (const MInt elementId) const override
	Check if there is a boundary condition element associated with the given element. More...
MInt	noCellDataDlb () const override
	Dynamic load balancing. More...
MInt	cellDataTypeDlb (const MInt NotUsed(dataId)) const override
MInt	cellDataSizeDlb (const MInt dataId, const MInt cellId) const override
	Solution data size for given cell and data id. More...
void	getCellDataDlb (const MInt dataId, MFloat *const data) const override
void	setCellDataDlb (const MInt dataId, const MFloat *const data) override
Public Member Functions inherited from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >
virtual	~DgBoundaryCondition ()
	Destructor must be virtual. More...
void	init (const MInt begin_, const MInt end_)
	Init method to initialize boundary condition for range of surfaces. More...
virtual void	apply (const MFloat time)=0
	Apply method to apply boundary condition. More...
virtual MString	name () const=0
	Returns name of boundary condition. More...
	DgBoundaryCondition (SolverType &solver_, MInt bcId)
	Constructor saves arguments to member variables. More...
MInt	id () const
	Return boundary condition if of this boundary condition. More...
MInt	begin () const
	Return index of first surface. More...
MInt	end () const
	Return index of one-past-last surface. More...
MInt	count () const
	Return number of boundary surfaces. More...
virtual MInt	noRestartVars () const
virtual MInt	getLocalNoNodes () const
	Return local number of nodes. More...
virtual MString	restartVarName (const MInt NotUsed(id)) const
	Return name of restart variable. More...
virtual void	setRestartVariable (const MInt NotUsed(id), const MFloat *const NotUsed(data))
	Copy restart variable data from pointer to boundary condition class. More...
virtual void	getRestartVariable (const MInt NotUsed(id), MFloat *const NotUsed(data)) const
	Copy restart variable data from boundary condition class to pointer. More...
virtual MInt	noBcElements () const
virtual MBool	hasBcElement (const MInt NotUsed(elementId)) const
virtual MInt	noCellDataDlb () const
virtual MInt	cellDataTypeDlb (const MInt NotUsed(dataId)) const
virtual MInt	cellDataSizeDlb (const MInt NotUsed(dataId), const MInt NotUsed(cellId)) const
virtual void	getCellDataDlb (const MInt NotUsed(dataId), MFloat *const NotUsed(data)) const
virtual void	getCellDataDlb (const MInt NotUsed(dataId), MInt *const NotUsed(data)) const
virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MFloat *const NotUsed(data))
virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MInt *const NotUsed(data))

Private Types
using	ElementCollector = maia::dg::collector::ElementCollector< nDim, SysEqn >
using	HElementCollector = maia::dg::collector::HElementCollector< nDim, SysEqn >
using	SurfaceCollector = maia::dg::collector::SurfaceCollector< nDim, SysEqn >

Private Member Functions
void	calcFlux1D (const MFloat *nodeVars, const MFloat *q, const MInt noNodes1D, const MInt dirId, MFloat *flux_) const
	Calculates the physical fluxes in direction 'dirId' on a surface. More...
void	calcElementNodeVars ()
	Calculate node variables of rb-elements. More...
void	calcSurfaceNodeVars ()
	Calculate node variables of rb-surfaces. More...
void	calcNodeVars (const MFloat *pos, const MFloat *nodeVarsAPE, MFloat *nodeVars)
	Calculate RBC node variables at a given position. More...

Private Attributes
ElementCollector	m_rbElements
std::vector< MInt >	m_rbElementId
std::vector< MInt >	m_rbSurfaceId
std::vector< MInt >	m_elementId
std::vector< MInt >	m_surfaceId
SurfaceCollector	m_rbSurfaces
std::vector< std::pair< MInt, MInt > >	m_addBndrySrfcIds
HElementCollector	m_hRbElements
MFloat **	m_rbSolution = nullptr
MInt	m_internalDataSize = -1
MInt	m_rkStage = -1
std::array< MFloat, MAX_SPACE_DIMENSIONS >	m_rbcReferencePos {}
MBool	m_isInitialized = false
std::array< MInt, Timers::_count >	m_timers

Static Private Attributes
static const constexpr MInt	s_noNodeVars = nDim + 2

Additional Inherited Members
Protected Member Functions inherited from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >
SolverType &	solver ()
	Return reference to solver. More...
SysEqn &	sysEqn ()
	Return reference to SysEqn object. More...
MFloat *	flux (const MInt i)
	Return pointer to surface flux. More...
ElementCollector &	elements ()
	Return reference to elements. More...
MInt	getElementByCellId (const MInt cellId) const
	Return element id corresponding to given cell id. More...
HElementCollector &	helements ()
	Return reference to h-elements. More...
SurfaceCollector &	surfaces ()
	Return reference to surfaces. More...
MBool	isMpiSurface (const MInt id_) const
	Return true if surface is a MPI surface. More...
MBool	needHElementForCell (const MInt cellId)
	Return if h-element is needed for given cell. More...
MInt	getHElementId (const MInt elementId)
	Return h-element id for an element. More...
const DgInterpolation &	interpolation (const MInt polyDeg, const MInt noNodes1D) const
	Return interpolation. More...
MInt	integrationMethod () const
	Return integration method. More...
MInt	timeIntegrationScheme () const
	Return time integration scheme. More...
MInt	maxPolyDeg () const
	Return maximum polynomial degree. More...
MInt	maxNoNodes1D () const
	Return maximum number of nodes. More...
MFloat	dt () const
	Return current time step size. More...
MBool	isRestart () const
	Return if a restart is performed. More...
void	subTimeStepRk (const MFloat dt_, const MInt stage, const MInt totalSize, const MFloat *const rhs, MFloat *const variables, MFloat *const timeIntStorage)
	Access to time integration method. More...
void	calcVolumeIntegral (const MInt noElements, ElementCollector &elem, F &fluxFct)
void	resetBuffer (const MInt totalSize, MFloat *const buffer)
void	applyJacobian (const MInt noElements, ElementCollector &elem)
void	calcSourceTerms (const MFloat t, const MInt noElements, ElementCollector &elem, F &sourceFct)
void	calcSurfaceIntegral (const MInt begin_, const MInt end_, ElementCollector &elem, SurfaceCollector &surf, HElementCollector &helem, const MInt noHElements)
void	calcRegularSurfaceFlux (const MInt begin_, const MInt end_, SurfaceCollector &surf, F &riemannFct)

Detailed Description

template<MInt nDim>
class DgBcAcousticPerturbRBC< nDim >

Definition at line 14 of file dgcartesianbcacousticperturbrbc.h.

Member Typedef Documentation

Base

template<MInt nDim>

using DgBcAcousticPerturbRBC< nDim >::Base = DgBoundaryCondition<nDim, DgSysEqnAcousticPerturb<nDim> >

Definition at line 17 of file dgcartesianbcacousticperturbrbc.h.

ElementCollector

template<MInt nDim>

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

private

Definition at line 120 of file dgcartesianbcacousticperturbrbc.h.

HElementCollector

template<MInt nDim>

using DgBcAcousticPerturbRBC< nDim >::HElementCollector = maia::dg::collector::HElementCollector<nDim, SysEqn>

private

Definition at line 121 of file dgcartesianbcacousticperturbrbc.h.

SurfaceCollector

template<MInt nDim>

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

private

Definition at line 122 of file dgcartesianbcacousticperturbrbc.h.

Constructor & Destructor Documentation

DgBcAcousticPerturbRBC()

template<MInt nDim>

DgBcAcousticPerturbRBC< nDim >::DgBcAcousticPerturbRBC ( SolverType &  solver_, MInt  bcId  )

inline

Definition at line 49 of file dgcartesianbcacousticperturbrbc.h.

                                                         : Base(solver_, bcId) {
    // Create timers
    // @ansgar TODO labels:DG,TIMERS this creates new timers every time DLB is performed and new RBCs are created
    initTimers();
  }

~DgBcAcousticPerturbRBC()

template<MInt nDim>

DgBcAcousticPerturbRBC< nDim >::~DgBcAcousticPerturbRBC ( )

inline

Definition at line 54 of file dgcartesianbcacousticperturbrbc.h.

                            {
    // Free allocated memory
    mDeallocate(m_rbSolution);
    // Stop the class timer
    RECORD_TIMER_STOP(m_timers[Timers::Class]);
  }

Member Function Documentation

apply()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::apply ( const MFloat  time )

overridevirtual

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

2015-12-13

0. Initialize:

• Calculate RBC node variables for rb-elements and rb-surfaces.
• Copy APE initial condition to rb-elements.

Copy APE surface variables to rb-surfaces.

1. Prolong RBC solution to boundary surfaces and copy to corresponding rb-surfaces (both sides).
2. Solve RBC system.
3. Compute APE boundary surface flux with prolonged RBC solution as outer state.

Implements DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 480 of file dgcartesianbcacousticperturbrbc.h.

                                                          {
  using namespace maia::dg::interpolation;
  TRACE();
 
  // Nothing to be done if there are no RBC elements
  if(m_rbElements.size() == 0) {
    return;
  }
 
  RECORD_TIMER_START(m_timers[Timers::Apply]);
 
  // 0. Initialize node variables and set initial condition if not already done
  const MInt* const noNodes = &m_rbElements.noNodes1D(0);
  if(!m_isInitialized) {
    RECORD_TIMER_START(m_timers[Timers::InitializeVars]);
 
    // Set initial condition (same as for APE)
    if(!isRestart()) {
      for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
        const MInt eId = m_elementId[rbId];
        const MInt noNodes1D = noNodes[rbId];
        const MInt noNodesXD = ipow(noNodes1D, nDim);
        const MInt dataSize = noNodesXD * Base::SysEqn::noVars();
 
        // Copy element variables to rb-element
        std::copy_n(&elements().variables(eId), dataSize, &m_rbElements.variables(rbId));
      }
    }
 
    // Copy APE nodeVars to outer state of boundary surfaces
    for(MInt srfcId = begin(); srfcId < end(); srfcId++) {
      const MInt noNodes1D = surfaces().noNodes1D(srfcId);
      const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
      const MInt noNodesXD = noNodes1D * noNodes1D3;
      const MInt internalSide = surfaces().internalSideId(srfcId);
      const MInt outerSide = (internalSide + 1) % 2;
 
      // Copy node vars to outer surface state
      std::copy_n(&surfaces().nodeVars(srfcId, internalSide),
                  noNodesXD * Base::SysEqn::noNodeVars(),
                  &surfaces().nodeVars(srfcId, outerSide));
    }
 
    // Also copy APE node vars to outer state of additional boundary surfaces
    const MInt noAddBcIds = m_addBndrySrfcIds.size();
    for(MInt sId = 0; sId < noAddBcIds; sId++) {
      const MInt rbSrfcId = m_addBndrySrfcIds[sId].first;
      const MInt srfcId = m_surfaceId[rbSrfcId];
 
      const MInt noNodes1D = surfaces().noNodes1D(srfcId);
      const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
      const MInt noNodesXD = noNodes1D * noNodes1D3;
      const MInt internalSide = surfaces().internalSideId(srfcId);
      const MInt outerSide = (internalSide + 1) % 2;
 
      // Copy node vars to outer surface state
      std::copy_n(&surfaces().nodeVars(srfcId, internalSide),
                  noNodesXD * Base::SysEqn::noNodeVars(),
                  &surfaces().nodeVars(srfcId, outerSide));
    }
 
    // Calculate RBC node variables
    calcElementNodeVars();
    calcSurfaceNodeVars();
 
    // Set initial Runge Kutta stage
    m_rkStage = 0;
 
    m_isInitialized = true;
 
    RECORD_TIMER_STOP(m_timers[Timers::InitializeVars]);
  }
 
  // 1. Copy surface variables to rb-surfaces for surface flux computation
  // For boundary surfaces: variables are later overwritten with prolonged
  // rb-solutions
  RECORD_TIMER_START(m_timers[Timers::CopySurfaceVars]);
 
  for(MInt rbSId = 0; rbSId < m_rbSurfaces.size(); rbSId++) {
    const MInt sId = m_surfaceId[rbSId];
 
    const MInt noNodesXD = ipow(maxNoNodes1D(), nDim - 1);
    const MInt dataSize = noNodesXD * Base::SysEqn::noVars();
 
    std::copy_n(&surfaces().variables(sId, 0), dataSize, &m_rbSurfaces.variables(rbSId, 0));
    std::copy_n(&surfaces().variables(sId, 1), dataSize, &m_rbSurfaces.variables(rbSId, 1));
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::CopySurfaceVars]);
 
  // 2.1 Prolong RBC solution to boundary surfaces
  RECORD_TIMER_START(m_timers[Timers::Prolong]);
 
  for(MInt srfcId = begin(); srfcId < end(); srfcId++) {
    // Get corresponding rb-element id for boundary surface
    const MInt rbId = m_rbElementId[srfcId - begin()];
 
    const MInt polyDeg = m_rbElements.polyDeg(rbId);
    const MInt noNodes1D = m_rbElements.noNodes1D(rbId);
    const MInt orientation = surfaces().orientation(srfcId);
    const MInt internalSide = surfaces().internalSideId(srfcId);
    const MInt outerSide = (internalSide + 1) % 2;
    const MInt dir = 2 * orientation + outerSide;
 
    // Prolong to outer state of boundary surface
    MFloat* src = &m_rbElements.variables(rbId);
    MFloat* dest = &surfaces().variables(srfcId, outerSide);
 
    if(integrationMethod() == DG_INTEGRATE_GAUSS) {
      prolongToFaceGauss<nDim, Base::SysEqn::noVars()>(src, dir, noNodes1D,
                                                       &interpolation(polyDeg, noNodes1D).m_LFace[0][0],
                                                       &interpolation(polyDeg, noNodes1D).m_LFace[1][0], dest);
    } else if(integrationMethod() == DG_INTEGRATE_GAUSS_LOBATTO) {
      prolongToFaceGaussLobatto<nDim, Base::SysEqn::noVars()>(src, dir, noNodes1D, dest);
    }
 
    const MInt rbSId = m_rbSurfaceId[srfcId - begin()];
    const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
    const MInt noNodesXD = noNodes1D * noNodes1D3;
    const MInt dataSize = noNodesXD * Base::SysEqn::noVars();
 
    // Copy prolonged rbc solution to rb boundary surfaces
    std::copy_n(dest, dataSize, &m_rbSurfaces.variables(rbSId, 0));
    std::copy_n(dest, dataSize, &m_rbSurfaces.variables(rbSId, 1));
  }
 
  // 2.2 Prolong RBC solution to additional boundary surfaces
  const MInt noAddBcIds = m_addBndrySrfcIds.size();
  for(MInt srfcId = 0; srfcId < noAddBcIds; srfcId++) {
    const MInt rbSrfcId = m_addBndrySrfcIds[srfcId].first;
    const MInt rbId = m_addBndrySrfcIds[srfcId].second;
 
    const MInt polyDeg = m_rbElements.polyDeg(rbId);
    const MInt noNodes1D = m_rbElements.noNodes1D(rbId);
    const MInt orientation = m_rbSurfaces.orientation(rbSrfcId);
    const MInt internalSide = m_rbSurfaces.internalSideId(rbSrfcId);
    const MInt outerSide = (internalSide + 1) % 2;
    const MInt dir = 2 * orientation + outerSide;
 
    // Prolong to left state of boundary surface
    MFloat* src = &m_rbElements.variables(rbId);
    MFloat* dest = &m_rbSurfaces.variables(rbSrfcId, 0);
 
    if(integrationMethod() == DG_INTEGRATE_GAUSS) {
      prolongToFaceGauss<nDim, Base::SysEqn::noVars()>(src, dir, noNodes1D,
                                                       &interpolation(polyDeg, noNodes1D).m_LFace[0][0],
                                                       &interpolation(polyDeg, noNodes1D).m_LFace[1][0], dest);
    } else if(integrationMethod() == DG_INTEGRATE_GAUSS_LOBATTO) {
      prolongToFaceGaussLobatto<nDim, Base::SysEqn::noVars()>(src, dir, noNodes1D, dest);
    }
 
    const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
    const MInt dataSize = noNodes1D * noNodes1D3 * Base::SysEqn::noVars();
 
    // Copy prolonged left state to right state
    std::copy_n(&m_rbSurfaces.variables(rbSrfcId, 0), dataSize, &m_rbSurfaces.variables(rbSrfcId, 1));
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::Prolong]);
 
  // 3. Solve RBC system
  RECORD_TIMER_START(m_timers[Timers::TimeDeriv]);
 
  // Reset rbc-rhs
  resetBuffer(m_internalDataSize, &m_rbElements.rightHandSide(0));
 
  // Store rbc-solution and copy element variables to rb-elements for flux
  // computation
  for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
    const MInt eId = m_elementId[rbId];
    const MInt noNodes1D = noNodes[rbId];
    const MInt noNodesXD = ipow(noNodes1D, nDim);
    const MInt dataSize = noNodesXD * Base::SysEqn::noVars();
 
    // Store rb-element variables in m_rbSolution
    std::copy_n(&m_rbElements.variables(rbId), dataSize, m_rbSolution[rbId]);
 
    // Copy element variables to rb-element
    std::copy_n(&elements().variables(eId), dataSize, &m_rbElements.variables(rbId));
  }
 
  // Calculate volume integral (with APE variables)
  calcVolumeIntegral(m_rbElements.size(), m_rbElements, *this);
 
  // Calculate surface fluxes
  // Inner fluxes are computed with the APE variables on the surfaces
  // Boundary fluxes use the prolonged rbc solutions for both the left and right
  // state
  calcRegularSurfaceFlux(0, m_rbSurfaces.size(), m_rbSurfaces, *this);
 
  // Calculate surface integral
  calcSurfaceIntegral(0, m_rbElements.size(), m_rbElements, m_rbSurfaces, m_hRbElements, m_hRbElements.size());
 
  // Apply jacobian
  applyJacobian(m_rbElements.size(), m_rbElements);
 
  // Calculate source terms
  calcSourceTerms(time, m_rbElements.size(), m_rbElements, *this);
 
  // Copy rbc-solutions back to rb-elements for time integration
  for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
    const MInt noNodes1D = noNodes[rbId];
    const MInt noNodesXD = ipow(noNodes1D, nDim);
    const MInt dataSize = noNodesXD * Base::SysEqn::noVars();
 
    std::copy_n(m_rbSolution[rbId], dataSize, &m_rbElements.variables(rbId));
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::TimeDeriv]);
 
  // Perform rk substep
  RECORD_TIMER_START(m_timers[Timers::RungeKuttaStep]);
  subTimeStepRk(dt(), m_rkStage, m_internalDataSize, &m_rbElements.rightHandSide(0), &m_rbElements.variables(0),
                &m_rbElements.timeIntStorage(0));
 
  // Define the number of Rk-steps according to the Scheme being used
  if(timeIntegrationScheme() == DG_TIMEINTEGRATION_CARPENTER_4_5) {
    m_rkStage = (m_rkStage + 1) % 5;
  } else if(timeIntegrationScheme() == DG_TIMEINTEGRATION_TOULORGEC_4_8) {
    m_rkStage = (m_rkStage + 1) % 8;
  } else if(timeIntegrationScheme() == DG_TIMEINTEGRATION_NIEGEMANN_4_14) {
    m_rkStage = (m_rkStage + 1) % 14;
  } else if(timeIntegrationScheme() == DG_TIMEINTEGRATION_NIEGEMANN_4_13) {
    m_rkStage = (m_rkStage + 1) % 13;
  } else if(timeIntegrationScheme() == DG_TIMEINTEGRATION_TOULORGEC_3_7) {
    m_rkStage = (m_rkStage + 1) % 7;
  } else if(timeIntegrationScheme() == DG_TIMEINTEGRATION_TOULORGEF_4_8) {
    m_rkStage = (m_rkStage + 1) % 8;
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::RungeKuttaStep]);
 
  // 4. Apply boundary condition
  RECORD_TIMER_START(m_timers[Timers::ApplyAtSurface]);
  maia::dg::bc::loop(&DgBcAcousticPerturbRBC::applyAtSurface, this, begin(), end(), time);
  RECORD_TIMER_STOP(m_timers[Timers::ApplyAtSurface]);
 
  RECORD_TIMER_STOP(m_timers[Timers::Apply]);
}

applyAtSurface()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::applyAtSurface	(	const MInt	surfaceId,
		const MFloat	NotUsedtime
	)

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

2015-12-13

Definition at line 726 of file dgcartesianbcacousticperturbrbc.h.

                                                                                                  {
  // TRACE();
 
  MFloat* nodeVarsL = &surfaces().nodeVars(surfaceId, 0);
  MFloat* nodeVarsR = &surfaces().nodeVars(surfaceId, 1);
  MFloat* stateL = &surfaces().variables(surfaceId, 0);
  MFloat* stateR = &surfaces().variables(surfaceId, 1);
  const MInt noNodes1D = surfaces().noNodes1D(surfaceId);
  const MInt dirId = surfaces().orientation(surfaceId);
 
  // The boundary state contains the prolonged rbc-solution and the same node
  // variables as the inner state
  MFloat* f = flux(surfaceId);
  sysEqn().calcRiemann(nodeVarsL, nodeVarsR, stateL, stateR, noNodes1D, dirId, f);
}

calcElementNodeVars()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcElementNodeVars

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

2015-12-13

Calculate all node variables on the rb-elements using the node variables on the 'normal' elements.

Definition at line 942 of file dgcartesianbcacousticperturbrbc.h.

                                                       {
  TRACE();
 
  // Loop over rb-elements
  for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
    const MInt eId = m_elementId[rbId]; // Corresponding element id
    const MInt noNodesXD = m_rbElements.noNodesXD(rbId);
    const MFloat* coordinates = &m_rbElements.nodeCoordinates(rbId);
 
    for(MInt pId = 0; pId < noNodesXD; pId++) {
      calcNodeVars(&coordinates[pId * nDim],
                   &elements().nodeVars(eId) + pId * Base::SysEqn::noNodeVars(),
                   &m_rbElements.nodeVars(rbId) + pId * s_noNodeVars);
    }
  }
}

calcFlux()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcFlux	(	const MFloat *	nodeVars,
		const MFloat *	q,
		const MInt	noNodes1D,
		MFloat *	flux_
	)		const

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

2015-12-13

Note: for argument description, see DgSysEqnAcousticPerturb::calcFlux.

Definition at line 751 of file dgcartesianbcacousticperturbrbc.h.

                                                                 {
  // TRACE();
 
  const MInt noVars = Base::SysEqn::noVars();
  const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
  const MFloatTensor U(const_cast<MFloat*>(q), noNodes1D, noNodes1D, noNodes1D3, noVars);
  const MFloatTensor coeff(const_cast<MFloat*>(nodeVars), noNodes1D, noNodes1D, noNodes1D3, s_noNodeVars);
 
  MFloatTensor f(flux_, noNodes1D, noNodes1D, noNodes1D3, nDim, noVars);
 
  // The following flux equations are calculated here (if 2D, consider all
  // z-components to be zero and sin(theta)=1):
  // vg: speed of wave propagation
  // theta, phi: angles in cylindrical coordinates
 
  // Flux in x-direction:
  // f1 = vg*sin(theta)*cos(phi)
  // f_x(CV[u]) = f1*u
  // f_x(CV[v]) = f1*v
  // f_x(CV[w]) = f1*w
  // f_x(CV[p]) = f1*p
 
  // Flux in y-direction:
  // f2 = vg*sin(theta)*sin(phi)
  // f_y(CV[u]) = f2*u
  // f_y(CV[v]) = f2*v
  // f_y(CV[w]) = f2*w
  // f_y(CV[p]) = f2*p
 
  // Flux in z-direction:
  // f3 = vg*cos(theta)
  // f_z(CV[u]) = f3*u
  // f_z(CV[v]) = f3*v
  // f_z(CV[w]) = f3*w
  // f_z(CV[p]) = f3*p
 
  for(MInt i = 0; i < noNodes1D; i++) {
    for(MInt j = 0; j < noNodes1D; j++) {
      for(MInt k = 0; k < noNodes1D3; k++) {
        for(MInt d = 0; d < nDim; d++) {
          for(MInt var = 0; var < noVars; var++) {
            f(i, j, k, d, var) = coeff(i, j, k, d) * U(i, j, k, var);
          }
        }
      }
    }
  }
}

calcFlux1D()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcFlux1D ( const MFloat *  nodeVars, const MFloat *  q, const MInt  noNodes1D, const MInt  dirId, MFloat *  flux_  ) 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

2015-12-13

The flux is obtained by the projection of the speed of wave propagation on the given direction multiplied with the variables. Note: for argument description, see DgSysEqnAcousticPerturb::calcFlux1D.

Definition at line 813 of file dgcartesianbcacousticperturbrbc.h.

                                                                                     {
  // TRACE();
 
  const MInt noVars = Base::SysEqn::noVars();
  const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
  const MFloatTensor U(const_cast<MFloat*>(q), noNodes1D, noNodes1D3, noVars);
  const MFloatTensor coeff(const_cast<MFloat*>(nodeVars), noNodes1D, noNodes1D3, s_noNodeVars);
  MFloatTensor f(flux_, noNodes1D, noNodes1D3, noVars);
 
  for(MInt i = 0; i < noNodes1D; i++) {
    for(MInt j = 0; j < noNodes1D3; j++) {
      for(MInt var = 0; var < noVars; var++) {
        f(i, j, var) = coeff(i, j, dirId) * U(i, j, var);
      }
    }
  }
}

calcNodeVars()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcNodeVars ( const MFloat *  pos, const MFloat *  nodeVarsAPE, MFloat *  nodeVars  )

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

2015-12-13

The 'nDim + 2' RBC node variables are computed at a given position with the corresponding mean velocities. The first nDim node variables contain the projection of the speed of wave propagation from the acoustic source region onto the Cartesian coordinate directions. These are the needed coefficients for the flux computations in the corresponding directions. At position 'nDim + 1' the speed of wave propagation is stored, which is needed for the Riemann solver. The last entry contains the source term coefficient which is given by the ratio of the speed of wave propagation and the distance to the reference position (2D: with factor of 1/2).

Parameters

[in]	pos	position where to calculate the node variables.
[in]	nodeVarsAPE	node variables of the APE-system at given position.
[out]	nodeVars	computed RBC node variables.

Definition at line 1011 of file dgcartesianbcacousticperturbrbc.h.

                                                                                                              {
  // Mean speed of sound
  const MFloat c = nodeVarsAPE[Base::SysEqn::CV::C0];
 
  IF_CONSTEXPR(nDim == 2) { // 2D
    const MFloat x = pos[0];
    const MFloat y = pos[1];
 
    const MFloat x0 = m_rbcReferencePos[0];
    const MFloat y0 = m_rbcReferencePos[1];
 
    // Inverse distance of given position and reference position
    const MFloat rInv = 1.0 / sqrt(POW2(x - x0) + POW2(y - y0));
 
    // Orientation of given position with respect to the reference position
    const MFloat cosPhi = (x - x0) * rInv;
    const MFloat sinPhi = (y - y0) * rInv;
 
    // Mean velocities
    const MFloat u0 = nodeVarsAPE[Base::SysEqn::CV::U0];
    const MFloat v0 = nodeVarsAPE[Base::SysEqn::CV::V0];
 
    // Speed of wave propagation
    //
    // v_g = u0 * cos(phi) + v0 * sin(phi)
    //       + sqrt(c^2 - (-u0 * sin(phi) + v0 * cos(phi))^2)
    //
    // c: mean sound speed
    // u0, v0: mean velocities
    // phi: angle between given position and reference position
    //
    // Reference: see 3D case
    const MFloat vg = u0 * cosPhi + v0 * sinPhi + sqrt(POW2(c) - POW2(-u0 * sinPhi + v0 * cosPhi));
 
    // Projection of speed of wave propagation in both Cartesian coordinate
    // directions (coefficients for flux computation)
    nodeVars[0] = vg * cosPhi;
    nodeVars[1] = vg * sinPhi;
 
    // Speed of wave propagation (needed in calcRiemann)
    nodeVars[2] = vg;
 
    // Source term coefficient
    nodeVars[3] = 0.5 * vg * rInv;
  }
  else { // 3D
    const MFloat x = pos[0];
    const MFloat y = pos[1];
    const MFloat z = pos[2];
 
    const MFloat x0 = m_rbcReferencePos[0];
    const MFloat y0 = m_rbcReferencePos[1];
    const MFloat z0 = m_rbcReferencePos[2];
 
    // Inverse distance of given position and reference position
    const MFloat rInv = 1.0 / sqrt(POW2(x - x0) + POW2(y - y0) + POW2(z - z0));
 
    // Inverse distance in x-y-plane of given position and reference position
    const MFloat r2Inv = 1.0 / sqrt(POW2(x - x0) + POW2(y - y0));
 
    // Orientation of given position with respect to the reference position
    // (spherical coordinates (r, theta, phi))
    const MFloat cosPhi = (x - x0) * r2Inv;
    const MFloat sinPhi = (y - y0) * r2Inv;
    const MFloat cosTheta = (z - z0) * rInv;
    const MFloat sinTheta = sqrt(1 - POW2(cosTheta));
 
    // Mean velocities
    const MFloat u0 = nodeVarsAPE[Base::SysEqn::CV::UU0[0]];
    const MFloat v0 = nodeVarsAPE[Base::SysEqn::CV::UU0[1]];
    const MFloat w0 = nodeVarsAPE[Base::SysEqn::CV::UU0[2]];
 
    // Speed of wave propagation in radial direction
    const MFloat u_er = u0 * sinTheta * cosPhi + v0 * sinTheta * sinPhi + w0 * cosTheta;
 
    // Speed of wave propagation in theta direction
    const MFloat u_et = u0 * cosTheta * cosPhi + v0 * cosTheta * sinPhi + w0 * (-sinTheta);
 
    // Speed of wave propagation in phi direction
    const MFloat u_ep = u0 * (-sinPhi) + v0 * cosPhi;
 
    // Speed of wave propagation
    //
    // v_g = u_m*e_r + sqrt(c^2 - (u_m*e_t)^2 - (u_m*e_p)^2)
    //
    // u_m: mean flow velocity vector u_m = [u0, v0, w0]'
    // e_r: unit vector in radial direction
    //      e_r = [sin(phi)*cos(theta), sin(theta)*sin(phi), cos(theta)]'
    // e_t: unit vector in theta direction
    //      e_t = [cos(theta)*cos(phi), cos(theta)*sin(phi), -sin(theta)]'
    // e_p: unit vector in phi direction
    //      e_p = [-sin(phi), cos(phi), 0]'
    // c: mean sound speed
    //
    // Reference: C .Bogey, C. Bailly; Three-dimensional non-reflective boundary
    // conditions for acoustic simulations: far field formulation and validation
    // test cases, Eqns. (1) and (2)
    const MFloat vg = u_er + sqrt(POW2(c) - POW2(u_et) - POW2(u_ep));
 
    // Projection of speed of wave propagation in all Cartesian coordinate
    // directions (coefficients for flux computation)
    nodeVars[0] = vg * sinTheta * cosPhi;
    nodeVars[1] = vg * sinTheta * sinPhi;
    nodeVars[2] = vg * cosTheta;
 
    // Speed of wave propagation (needed in calcRiemann)
    nodeVars[3] = vg;
 
    // Source term coefficient
    nodeVars[4] = vg * rInv;
  }
}

calcRiemann()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcRiemann	(	const MFloat *	nodeVarsL,
		const MFloat *	nodeVarsR,
		const MFloat *	stateL,
		const MFloat *	stateR,
		const MInt	noNodes1D,
		const MInt	dirId,
		MFloat *	flux_
	)		const

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

2015-12-13

The numerical flux is calculated using the local Lax-Friedrichs flux scheme. Note: for argument description, see DgSysEqnAcousticPerturb::calcRiemann.

Definition at line 879 of file dgcartesianbcacousticperturbrbc.h.

                                                                    {
  // TRACE();
 
  const MInt noVars = Base::SysEqn::noVars();
  const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
  const MFloatTensor uL(const_cast<MFloat*>(stateL), noNodes1D, noNodes1D3, noVars);
  const MFloatTensor uR(const_cast<MFloat*>(stateR), noNodes1D, noNodes1D3, noVars);
 
#ifndef _OPENMP
  MFloatScratchSpace maxLambda(noNodes1D, noNodes1D3, AT_, "maxLambda");
#else
  MFloatTensor maxLambda(noNodes1D, noNodes1D3);
#endif
 
  // Left and right node variables
  const MFloatTensor cL(const_cast<MFloat*>(nodeVarsL), noNodes1D, noNodes1D3, s_noNodeVars);
  const MFloatTensor cR(const_cast<MFloat*>(nodeVarsR), noNodes1D, noNodes1D3, s_noNodeVars);
 
  // Calculate maximum eigenvalue from speed of sound propagation
  for(MInt i = 0; i < noNodes1D; i++) {
    for(MInt j = 0; j < noNodes1D3; j++) {
      maxLambda(i, j) = std::max(fabs(cL(i, j, nDim)), fabs(cR(i, j, nDim)));
    }
  }
 
#ifndef _OPENMP
  MFloatScratchSpace fluxL(noNodes1D, noNodes1D3, noVars, AT_, "fluxL");
  MFloatScratchSpace fluxR(noNodes1D, noNodes1D3, noVars, AT_, "fluxR");
#else
  MFloatTensor fluxL(noNodes1D, noNodes1D3, noVars);
  MFloatTensor fluxR(noNodes1D, noNodes1D3, noVars);
#endif
 
  // Calculate flux from left and right state
  calcFlux1D(nodeVarsL, stateL, noNodes1D, dirId, &fluxL[0]);
  calcFlux1D(nodeVarsR, stateR, noNodes1D, dirId, &fluxR[0]);
 
  // Solve Riemann problem
  MFloatTensor riemann(flux_, noNodes1D, noNodes1D3, noVars);
  for(MInt i = 0; i < noNodes1D; i++) {
    for(MInt j = 0; j < noNodes1D3; j++) {
      for(MInt n = 0; n < noVars; n++) {
        riemann(i, j, n) = 0.5 * ((fluxL(i, j, n) + fluxR(i, j, n)) - maxLambda(i, j) * (uR(i, j, n) - uL(i, j, n)));
      }
    }
  }
}

calcSource()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcSource	(	const MFloat *	nodeVars,
		const MFloat *	u,
		const MInt	noNodes1D,
		const MFloat	t,
		const MFloat *	x,
		MFloat *	src
	)		const

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

2015-12-13

The RBC source terms are given by: 2D: S = vg/(2*r)*U 3D: S = vg/r*U Note: for argument description, see DgSysEqnAcousticPerturb::calcSource.

Definition at line 843 of file dgcartesianbcacousticperturbrbc.h.

                                                                 {
  // TRACE();
 
  const MInt noVars = Base::SysEqn::noVars();
 
  const MInt noNodes1D3 = (nDim == 3) ? noNodes1D : 1;
  MFloatTensor s(src, noNodes1D, noNodes1D, noNodes1D3, noVars);
 
  const MFloatTensor U(const_cast<MFloat*>(u), noNodes1D, noNodes1D, noNodes1D3, noVars);
  const MFloatTensor coeff(const_cast<MFloat*>(nodeVars), noNodes1D, noNodes1D, noNodes1D3, nDim + 2);
 
  for(MInt i = 0; i < noNodes1D; i++) {
    for(MInt j = 0; j < noNodes1D; j++) {
      for(MInt k = 0; k < noNodes1D3; k++) {
        for(MInt var = 0; var < noVars; var++) {
          s(i, j, k, var) = coeff(i, j, k, nDim + 1) * U(i, j, k, var);
        }
      }
    }
  }
}

calcSurfaceNodeVars()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::calcSurfaceNodeVars

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

2015-12-13

Calculate all node variables on the rb-surfaces using the node variables on the 'normal' surfaces.

Definition at line 968 of file dgcartesianbcacousticperturbrbc.h.

                                                       {
  TRACE();
 
  // Loop over rb-surfaces
  for(MInt rbSId = 0; rbSId < m_rbSurfaces.size(); rbSId++) {
    const MInt sId = m_surfaceId[rbSId];
    const MFloat* coordinates = &m_rbSurfaces.nodeCoords(rbSId);
    const MInt noNodesXD = m_rbSurfaces.noNodesXD(rbSId);
 
    for(MInt pId = 0; pId < noNodesXD; pId++) {
      calcNodeVars(&coordinates[pId * nDim],
                   &((&surfaces().nodeVars(sId, 0))[pId * Base::SysEqn::noNodeVars()]),
                   &((&m_rbSurfaces.nodeVars(rbSId, 0))[pId * s_noNodeVars]));
 
      calcNodeVars(&coordinates[pId * nDim],
                   &((&surfaces().nodeVars(sId, 1))[pId * Base::SysEqn::noNodeVars()]),
                   &((&m_rbSurfaces.nodeVars(rbSId, 1))[pId * s_noNodeVars]));
    }
  }
}

cellDataSizeDlb()

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::cellDataSizeDlb ( const MInt  dataId, const MInt  cellId  ) const

override

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

Definition at line 1221 of file dgcartesianbcacousticperturbrbc.h.

                                                                                             {
  TRACE();
 
  // Only the variables need to be considered
  if(dataId < 0 || dataId > Base::SysEqn::noVars()) {
    TERMM(1, "Invalid dataId.");
  }
 
  // Get element id and find corresponding RB-element (if there is one)
  const MInt elementId = getElementByCellId(cellId);
  auto rbElemIt = std::find(m_elementId.begin(), m_elementId.end(), elementId);
 
  MInt dataSize = 0;
  if(rbElemIt != m_elementId.end()) {
    // Compute rb-element id
    const MInt rbId = std::distance(m_elementId.begin(), rbElemIt);
    const MInt noNodesXD = m_rbElements.noNodesXD(rbId);
 
    dataSize = noNodesXD;
  }
 
  return dataSize;
}

cellDataTypeDlb()

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::cellDataTypeDlb ( const MInt   NotUseddataId ) const

inlineoverridevirtual

Reimplemented from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 98 of file dgcartesianbcacousticperturbrbc.h.

                                                                  {
    return MFLOAT; // Note: assumes there are not MInt to communicate
  }

getCellDataDlb()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::getCellDataDlb ( const MInt  dataId, MFloat *const  data  ) const

inlineoverride

Definition at line 106 of file dgcartesianbcacousticperturbrbc.h.

{ getRestartVariable(dataId, data); }

getLocalNoNodes()

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::getLocalNoNodes

overridevirtual

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

Reimplemented from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 1130 of file dgcartesianbcacousticperturbrbc.h.

                                                         {
  TRACE();
 
  MInt localNoNodes = 0;
  for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
    const MInt noNodesXD = m_rbElements.noNodesXD(rbId);
 
    localNoNodes += noNodesXD;
  }
 
  return localNoNodes;
}

getRestartVariable()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::getRestartVariable ( const MInt  id_, MFloat *const  data  ) const

override

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

Parameters

[in]	id_	Variable id.
[in]	data	Pointer to store restart variable data.

Definition at line 1197 of file dgcartesianbcacousticperturbrbc.h.

                                                                                              {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::GetRestartVars]);
 
  // Copy variables to data buffer (in ascending cell/element id order)
  MInt offset = 0;
  for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
    const MInt noNodesXD = m_rbElements.noNodesXD(rbId);
 
    for(MInt n = 0; n < noNodesXD; n++) {
      data[offset + n] = m_rbElements.variables(rbId, n * Base::SysEqn::noVars() + id_);
    }
 
    offset += noNodesXD;
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::GetRestartVars]);
}

hasBcElement()

template<MInt nDim>

MBool DgBcAcousticPerturbRBC< nDim >::hasBcElement ( const MInt  elementId ) const

override

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

Definition at line 1250 of file dgcartesianbcacousticperturbrbc.h.

                                                                           {
  TRACE();
 
  return std::find(m_elementId.begin(), m_elementId.end(), elementId) != m_elementId.end();
}

init()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::init

overridevirtual

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

2015-12-13

1. Create rb-elements for all elements along the boundary.
2. Create needed h-rb-elements.
3. Create rb-surfaces for all rb-elements.
4. Initialize h-rb-elements and create missing h-refined surfaces.

Reimplemented from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 209 of file dgcartesianbcacousticperturbrbc.h.

initTimers()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::initTimers

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-01-24

Definition at line 438 of file dgcartesianbcacousticperturbrbc.h.

                                              {
  TRACE();
 
  // Create timer group & timer for solver, and start the timer
  NEW_TIMER_GROUP_NOCREATE(m_timers[Timers::TimerGroup],
                           "DgBcAcousticPerturbRBC (solverId = " + std::to_string(solver().solverId())
                               + ", bcId = " + std::to_string(id()) + ")");
  NEW_TIMER_NOCREATE(m_timers[Timers::Class], "total object lifetime", m_timers[Timers::TimerGroup]);
  RECORD_TIMER_START(m_timers[Timers::Class]);
 
  // 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::Apply], "apply", m_timers[Timers::Class]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::InitializeVars], "initializeVars", m_timers[Timers::Apply]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::CopySurfaceVars], "copySurfaceVars", m_timers[Timers::Apply]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::Prolong], "prolong", m_timers[Timers::Apply]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::TimeDeriv], "timeDeriv", m_timers[Timers::Apply]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::RungeKuttaStep], "RungeKuttaStep", m_timers[Timers::Apply]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::ApplyAtSurface], "applyAtSurface", m_timers[Timers::Apply]);
 
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::SetRestartVars], "setRestartVars", m_timers[Timers::Class]);
  NEW_SUB_TIMER_NOCREATE(m_timers[Timers::GetRestartVars], "getRestartVars", m_timers[Timers::Class]);
}

name()

template<MInt nDim>

MString DgBcAcousticPerturbRBC< nDim >::name ( ) const

inlineoverridevirtual

Implements DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 61 of file dgcartesianbcacousticperturbrbc.h.

{ return "radiation boundary condition"; }

noBcElements()

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::noBcElements ( ) const

inlineoverridevirtual

Reimplemented from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 90 of file dgcartesianbcacousticperturbrbc.h.

{ return m_rbElements.size(); };

noCellDataDlb()

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::noCellDataDlb ( ) const

inlineoverridevirtual

Reimplemented from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 95 of file dgcartesianbcacousticperturbrbc.h.

{ return noRestartVars(); }

noRestartVars()

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::noRestartVars ( ) const

inlineoverridevirtual

Return number of restart variables that need to be stored/loaded. If a derived class does not need additional restart variables, it may omit an implementation.

Reimplemented from DgBoundaryCondition< nDim, DgSysEqnAcousticPerturb< nDim > >.

Definition at line 84 of file dgcartesianbcacousticperturbrbc.h.

{ return Base::SysEqn::noVars(); };

restartVarName()

template<MInt nDim>

MString DgBcAcousticPerturbRBC< nDim >::restartVarName ( const MInt  id_ ) const

override

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

Parameters

[in]

id_

Requested variable id.

Definition at line 1151 of file dgcartesianbcacousticperturbrbc.h.

                                                                         {
  TRACE();
 
  std::stringstream varName;
  varName << "bc" << id() << "_" << Base::SysEqn::consVarNames(id_);
 
  return varName.str();
}

setCellDataDlb()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::setCellDataDlb ( const MInt  dataId, const MFloat *const  data  )

inlineoverride

Definition at line 109 of file dgcartesianbcacousticperturbrbc.h.

{ setRestartVariable(dataId, data); }

setRestartVariable()

template<MInt nDim>

void DgBcAcousticPerturbRBC< nDim >::setRestartVariable ( const MInt  id_, const MFloat *const  data  )

override

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

Parameters

[in]	id_	Variable id.
[in]	data	Pointer to restart variable data.

Definition at line 1169 of file dgcartesianbcacousticperturbrbc.h.

                                                                                              {
  TRACE();
  RECORD_TIMER_START(m_timers[Timers::SetRestartVars]);
 
  // Copy variables to rb elements (in ascending cell/element id order)
  MInt offset = 0;
  for(MInt rbId = 0; rbId < m_rbElements.size(); rbId++) {
    const MInt noNodesXD = m_rbElements.noNodesXD(rbId);
    MFloat* const vars = &m_rbElements.variables(rbId);
    for(MInt n = 0; n < noNodesXD; n++) {
      vars[n * Base::SysEqn::noVars() + id_] = data[offset + n];
    }
 
    offset += noNodesXD;
  }
 
  RECORD_TIMER_STOP(m_timers[Timers::SetRestartVars]);
}

Member Data Documentation

m_addBndrySrfcIds

template<MInt nDim>

std::vector<std::pair<MInt, MInt> > DgBcAcousticPerturbRBC< nDim >::m_addBndrySrfcIds

private

Definition at line 144 of file dgcartesianbcacousticperturbrbc.h.

m_elementId

template<MInt nDim>

std::vector<MInt> DgBcAcousticPerturbRBC< nDim >::m_elementId

private

Definition at line 134 of file dgcartesianbcacousticperturbrbc.h.

m_hRbElements

template<MInt nDim>

HElementCollector DgBcAcousticPerturbRBC< nDim >::m_hRbElements

private

Definition at line 148 of file dgcartesianbcacousticperturbrbc.h.

m_internalDataSize

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::m_internalDataSize = -1

private

Definition at line 154 of file dgcartesianbcacousticperturbrbc.h.

m_isInitialized

template<MInt nDim>

MBool DgBcAcousticPerturbRBC< nDim >::m_isInitialized = false

private

Definition at line 163 of file dgcartesianbcacousticperturbrbc.h.

m_rbcReferencePos

template<MInt nDim>

std::array<MFloat, MAX_SPACE_DIMENSIONS> DgBcAcousticPerturbRBC< nDim >::m_rbcReferencePos {}

private

Definition at line 160 of file dgcartesianbcacousticperturbrbc.h.

m_rbElementId

template<MInt nDim>

std::vector<MInt> DgBcAcousticPerturbRBC< nDim >::m_rbElementId

private

Definition at line 129 of file dgcartesianbcacousticperturbrbc.h.

m_rbElements

template<MInt nDim>

ElementCollector DgBcAcousticPerturbRBC< nDim >::m_rbElements

private

Definition at line 126 of file dgcartesianbcacousticperturbrbc.h.

m_rbSolution

template<MInt nDim>

MFloat** DgBcAcousticPerturbRBC< nDim >::m_rbSolution = nullptr

private

Definition at line 151 of file dgcartesianbcacousticperturbrbc.h.

m_rbSurfaceId

template<MInt nDim>

std::vector<MInt> DgBcAcousticPerturbRBC< nDim >::m_rbSurfaceId

private

Definition at line 131 of file dgcartesianbcacousticperturbrbc.h.

m_rbSurfaces

template<MInt nDim>

SurfaceCollector DgBcAcousticPerturbRBC< nDim >::m_rbSurfaces

private

Definition at line 140 of file dgcartesianbcacousticperturbrbc.h.

m_rkStage

template<MInt nDim>

MInt DgBcAcousticPerturbRBC< nDim >::m_rkStage = -1

private

Definition at line 157 of file dgcartesianbcacousticperturbrbc.h.

m_surfaceId

template<MInt nDim>

std::vector<MInt> DgBcAcousticPerturbRBC< nDim >::m_surfaceId

private

Definition at line 136 of file dgcartesianbcacousticperturbrbc.h.

m_timers

template<MInt nDim>

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

private

Definition at line 191 of file dgcartesianbcacousticperturbrbc.h.

s_noNodeVars

template<MInt nDim>

const constexpr MInt DgBcAcousticPerturbRBC< nDim >::s_noNodeVars = nDim + 2

staticconstexprprivate

Definition at line 166 of file dgcartesianbcacousticperturbrbc.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/dgcartesianbcacousticperturbrbc.h