MAIA bb96820c
Multiphysics at AIA
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
maia::dg::collector::SurfaceCollector< nDim, SysEqn > Class Template Reference

Class that represents DG element collector. More...

#include <dgcartesiansurfacecollector.h>

Inheritance diagram for maia::dg::collector::SurfaceCollector< nDim, SysEqn >:
[legend]
Collaboration diagram for maia::dg::collector::SurfaceCollector< nDim, SysEqn >:
[legend]

Public Types

template<class T >
using Invalid = typename maia::dg::collector::Invalid< T >
 

Public Member Functions

constexpr SurfaceCollector ()=default
 Default c'tor does nothing. More...
 
MInt & orientation (const MInt srfcId)
 Accessor for orientation. More...
 
MInt orientation (const MInt srfcId) const
 Accessor for orientation (const version). More...
 
MInt & fineCellId (const MInt srfcId)
 Accessor for fine cell id. More...
 
MInt fineCellId (const MInt srfcId) const
 Accessor for fine cell id (const version). More...
 
MInt & internalSideId (const MInt srfcId)
 Accessor for internal side id. More...
 
MInt internalSideId (const MInt srfcId) const
 Accessor for internal side id (const version). More...
 
MInt & polyDeg (const MInt srfcId)
 Accessor for polynomial degree. More...
 
MInt polyDeg (const MInt srfcId) const
 Accessor for polynomial degree (const version). More...
 
MInt & noNodes1D (const MInt srfcId)
 Accessor for number of nodes 1D. More...
 
MInt noNodes1D (const MInt srfcId) const
 Accessor for number of nodes 1D (const version). More...
 
MInt noNodesXD (const MInt srfcId) const
 Accessor for number of nodes XD (const version). More...
 
MLong & globalId (const MInt srfcId)
 Accessor for global id. More...
 
MLong globalId (const MInt srfcId) const
 Accessor for global id (const version). More...
 
MFloat & coords (const MInt srfcId, const MInt dir)
 Accessor for coordinates. More...
 
MFloat coords (const MInt srfcId, const MInt dir) const
 Accessor for coordinates (const version). More...
 
MFloat & nodeCoords (const MInt srfcId)
 Accessor for node coordinates. More...
 
MFloat nodeCoords (const MInt srfcId) const
 Accessor for node coordinates (const version). More...
 
MFloat & flux (const MInt srfcId)
 Accessor for flux. More...
 
MFloat flux (const MInt srfcId) const
 Accessor for flux (const version). More...
 
MInt & nghbrElementIds (const MInt srfcId, const MInt side)
 Accessor for neighbor element ids. More...
 
MInt nghbrElementIds (const MInt srfcId, const MInt side) const
 Accessor for neighbor element ids (const version). More...
 
MFloat & variables (const MInt srfcId, const MInt side)
 Accessor for variables. More...
 
MFloat & variables (const MInt srfcId, const MInt side) const
 Accessor for variables (const version). More...
 
MFloat & nodeVars (const MInt srfcId, const MInt side)
 Accessor for node variables. More...
 
MFloat & nodeVars (const MInt srfcId, const MInt side) const
 Accessor for node variables (const version). More...
 
MInt maxPolyDeg () const
 Return maximum polynomial degree. More...
 
void maxPolyDeg (const MInt maxPolyDeg_)
 
MInt maxNoNodes1D () const
 Return maximum number of nodes 1D. More...
 
void maxNoNodes1D (const MInt maxNoNodes1D_)
 
MInt maxNoNodesXD () const
 Return maximum number if nodes XD. More...
 
void noNodeVars (const MInt noNodeVars_)
 
constexpr MInt noNodeVars () const
 Return number of node variables. More...
 
constexpr MInt noValuesVariables () const
 
constexpr MInt noValuesNodeVars () const
 
constexpr MInt noValuesNodeCoordinates () const
 
constexpr MInt noValuesFlux () const
 
- Public Member Functions inherited from maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >
constexpr Container ()=default
 Default c'tor does nothing. More...
 
constexpr MInt capacity () const
 Return capacity (i.e., maximum number of nodes) More...
 
void reset (const MInt capacity)
 Reset tree, re-create data structures with given capacity, and set size to zero. More...
 
void resize (const MInt capacity)
 Resize the container capacity. More...
 
constexpr MInt size () const
 Return size (i.e., currently used number of nodes) More...
 
void size (const MInt size_)
 Resize tree WITHOUT CONSIDERING ANY NODE CONSISTENCY! Use at own risk and remove ASAP... More...
 
void append (const MInt count)
 Append nodes to end of tree. More...
 
void append ()
 
void shrink (const MInt count)
 Remove nodes from end of tree. More...
 
void shrink ()
 
void copy (const T &source, const MInt begin, const MInt end, const MInt to)
 Copy nodes to another location without changing any parent/child/neighbor information. More...
 
void copy (const T &source, const MInt from, const MInt to)
 
void copy (const MInt begin, const MInt end, const MInt to)
 
void copy (const MInt from, const MInt to)
 
void move (const MInt begin, const MInt end, const MInt to)
 Move nodes to another location and update parent/child/neighbor information accordingly. More...
 
void move (const MInt from, const MInt to)
 
void swap (const MInt a, const MInt b)
 Swap two nodes and update parent/child/neighbor information accordingly. More...
 
void insert (const MInt begin, const MInt count)
 
void insert (const MInt id)
 
void erase (const MInt begin, const MInt end)
 Erase nodes in range [begin, end) and update parent/child/neighbor information. More...
 
void erase (const MInt id)
 
void removeAndShift (const MInt begin, const MInt end)
 
void removeAndShift (const MInt id)
 
void removeAndFill (const MInt begin, const MInt end)
 
void removeAndFill (const MInt id)
 
void clear ()
 Clear tree by invalidating all nodes and setting size to zero. More...
 
SurfaceCollector< nDim, SysEqn > & derived ()
 
const SurfaceCollector< nDim, SysEqn > & derived () const
 
void rawCopy (const T &source, const MInt begin, const MInt end, const MInt to)
 Copy range of nodes [begin, end) to range starting at 'to'. More...
 
void rawCopy (const T &source, const MInt from, const MInt to)
 
void deleteConnectivity (const MInt NotUsed(begin), const MInt NotUsed(end))
 
void moveConnectivity (const MInt NotUsed(begin), const MInt NotUsed(end), const MInt NotUsed(to))
 
void moveConnectivity (const MInt from, const MInt to)
 
constexpr MInt dummy () const
 

Private Types

using Base = maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >
 
template<class T >
using Storage = typename Base::template Storage< T >
 

Private Member Functions

void reset ()
 Reset SurfaceCollector, re-create data structures. More...
 
void invalidate (const MInt begin, const MInt end)
 Erase range of nodes such that they contain no sensible values anymore. More...
 
template<class Functor , class T >
void rawCopyGeneric (Functor &&c, const T &source, const MInt begin, const MInt end, const MInt destination)
 Helper function for rawCopy(). Destination may refer to beginning or end of target range. More...
 

Private Attributes

MInt m_maxPolyDeg = -1
 
MInt m_maxNoNodes1D = -1
 
MInt m_maxNoNodesXD = -1
 
MInt m_noNodeVars = -1
 
Storage< MInt > m_orientation {}
 Orientiation of face normal vector. More...
 
Storage< MInt > m_nghbrElementIds {}
 Nghbr. element ids (or -1 of no neighbor) More...
 
Storage< MInt > m_fineCellId {}
 H-refinement fine element id. More...
 
Storage< MInt > m_internalSideId {}
 Side id of the internal element. More...
 
Storage< MInt > m_polyDeg {}
 Polynomial degrees of the neighbors. More...
 
Storage< MInt > m_noNodes1D {}
 Number of nodes 1D of the neighbors. More...
 
Storage< MLong > m_globalId {}
 
Storage< MFloat > m_variables {}
 Surface variables. More...
 
Storage< MFloat > m_nodeVars {}
 Additional variables at each node. More...
 
Storage< MFloat > m_coordinates {}
 Coordinates of the surface center. More...
 
Storage< MFloat > m_nodeCoordinates {}
 Integration node coordinates. More...
 
Storage< MFloat > m_flux {}
 Store the numerical (Riemann) flux. More...
 

Friends

class maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >
 

Additional Inherited Members

- Protected Types inherited from maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >
using Storage = std::vector< T >
 
- Protected Member Functions inherited from maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >
virtual void resize ()
 
void resetStorage (const MInt n, Storage< T > &c)
 Create new container with given size and replace original one. More...
 
void resizeStorage (const MInt n, Storage< T > &c)
 Resize container with given size. More...
 
void fill_invalid (Container_ &c, const MInt begin, const MInt end, const MInt solverSize=1, const T value=Invalid< T >::value())
 
void copyData (const Container_ &source, Container_ &target, Functor &&f, const MInt begin, const MInt end, const MInt dest, const MInt solverSize=1)
 Copy [begin, end) range with given solver size from source to dest position of target. More...
 
MBool isValidId (const MInt id) const
 Return whether given id refers to a valid node (auxiliary method). More...
 

Detailed Description

template<MInt nDim, class SysEqn>
class maia::dg::collector::SurfaceCollector< nDim, SysEqn >

Definition at line 59 of file dgcartesiansurfacecollector.h.

Member Typedef Documentation

◆ Base

template<MInt nDim, class SysEqn >
using maia::dg::collector::SurfaceCollector< nDim, SysEqn >::Base = maia::container::Container<SurfaceCollector<nDim, SysEqn>, Invalid>
private

Definition at line 64 of file dgcartesiansurfacecollector.h.

◆ Invalid

template<MInt nDim, class SysEqn >
template<class T >
using maia::dg::collector::SurfaceCollector< nDim, SysEqn >::Invalid = typename maia::dg::collector::Invalid<T>

Definition at line 72 of file dgcartesiansurfacecollector.h.

◆ Storage

template<MInt nDim, class SysEqn >
template<class T >
using maia::dg::collector::SurfaceCollector< nDim, SysEqn >::Storage = typename Base::template Storage<T>
private

Definition at line 67 of file dgcartesiansurfacecollector.h.

Constructor & Destructor Documentation

◆ SurfaceCollector()

template<MInt nDim, class SysEqn >
constexpr maia::dg::collector::SurfaceCollector< nDim, SysEqn >::SurfaceCollector ( )
constexprdefault

Member Function Documentation

◆ coords() [1/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::coords ( const MInt  srfcId,
const MInt  dir 
)

Definition at line 330 of file dgcartesiansurfacecollector.h.

330 {
331// Prevent accidental compilation without support for SoA layout
332#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
333#error Missing implementation for structure-of-arrays memory layout.
334#endif
335 ENSURE_VALID_ID_ACCESSOR(srfcId);
336 ENSURE_VALID_DIR_ACCESSOR(dir);
337 return m_coordinates[srfcId * nDim + dir];
338}
maia::dg::collector::SurfaceCollector::m_coordinates
Storage< MFloat > m_coordinates
Coordinates of the surface center.
Definition: dgcartesiansurfacecollector.h:182

◆ coords() [2/2]

template<MInt nDim, class SysEqn >
MFloat maia::dg::collector::SurfaceCollector< nDim, SysEqn >::coords ( const MInt  srfcId,
const MInt  dir 
) const

Definition at line 341 of file dgcartesiansurfacecollector.h.

341 {
342// Prevent accidental compilation without support for SoA layout
343#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
344#error Missing implementation for structure-of-arrays memory layout.
345#endif
346 ENSURE_VALID_ID_ACCESSOR(srfcId);
347 ENSURE_VALID_DIR_ACCESSOR(dir);
348 return m_coordinates[srfcId * nDim + dir];
349}

◆ fineCellId() [1/2]

template<MInt nDim, class SysEqn >
MInt & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::fineCellId ( const MInt  srfcId)

Definition at line 212 of file dgcartesiansurfacecollector.h.

212 {
213// Prevent accidental compilation without support for SoA layout
214#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
215#error Missing implementation for structure-of-arrays memory layout.
216#endif
217 ENSURE_VALID_ID_ACCESSOR(srfcId);
218 return m_fineCellId[srfcId];
219}
maia::dg::collector::SurfaceCollector::m_fineCellId
Storage< MInt > m_fineCellId
H-refinement fine element id.
Definition: dgcartesiansurfacecollector.h:159

◆ fineCellId() [2/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::fineCellId ( const MInt  srfcId) const

Definition at line 222 of file dgcartesiansurfacecollector.h.

222 {
223// Prevent accidental compilation without support for SoA layout
224#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
225#error Missing implementation for structure-of-arrays memory layout.
226#endif
227 ENSURE_VALID_ID_ACCESSOR(srfcId);
228 return m_fineCellId[srfcId];
229}

◆ flux() [1/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::flux ( const MInt  srfcId)

Definition at line 376 of file dgcartesiansurfacecollector.h.

376 {
377// Prevent accidental compilation without support for SoA layout
378#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
379#error Missing implementation for structure-of-arrays memory layout.
380#endif
381 ENSURE_VALID_ID_ACCESSOR(srfcId);
382 return m_flux[srfcId * noValuesFlux()];
383}
maia::dg::collector::SurfaceCollector::m_flux
Storage< MFloat > m_flux
Store the numerical (Riemann) flux.
Definition: dgcartesiansurfacecollector.h:184

◆ flux() [2/2]

template<MInt nDim, class SysEqn >
MFloat maia::dg::collector::SurfaceCollector< nDim, SysEqn >::flux ( const MInt  srfcId) const

Definition at line 386 of file dgcartesiansurfacecollector.h.

386 {
387// Prevent accidental compilation without support for SoA layout
388#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
389#error Missing implementation for structure-of-arrays memory layout.
390#endif
391 ENSURE_VALID_ID_ACCESSOR(srfcId);
392 return m_flux[srfcId * noValuesFlux()];
393}

◆ globalId() [1/2]

template<MInt nDim, class SysEqn >
MLong & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::globalId ( const MInt  srfcId)

Definition at line 308 of file dgcartesiansurfacecollector.h.

308 {
309// Prevent accidental compilation without support for SoA layout
310#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
311#error Missing implementation for structure-of-arrays memory layout.
312#endif
313 ENSURE_VALID_ID_ACCESSOR(srfcId);
314 return m_globalId[srfcId];
315}

◆ globalId() [2/2]

template<MInt nDim, class SysEqn >
MLong maia::dg::collector::SurfaceCollector< nDim, SysEqn >::globalId ( const MInt  srfcId) const

Definition at line 318 of file dgcartesiansurfacecollector.h.

318 {
319// Prevent accidental compilation without support for SoA layout
320#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
321#error Missing implementation for structure-of-arrays memory layout.
322#endif
323 ENSURE_VALID_ID_ACCESSOR(srfcId);
324 return m_globalId[srfcId];
325}

◆ internalSideId() [1/2]

template<MInt nDim, class SysEqn >
MInt & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::internalSideId ( const MInt  srfcId)

Definition at line 234 of file dgcartesiansurfacecollector.h.

234 {
235// Prevent accidental compilation without support for SoA layout
236#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
237#error Missing implementation for structure-of-arrays memory layout.
238#endif
239 ENSURE_VALID_ID_ACCESSOR(srfcId);
240 return m_internalSideId[srfcId];
241}
maia::dg::collector::SurfaceCollector::m_internalSideId
Storage< MInt > m_internalSideId
Side id of the internal element.
Definition: dgcartesiansurfacecollector.h:160

◆ internalSideId() [2/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::internalSideId ( const MInt  srfcId) const

Definition at line 244 of file dgcartesiansurfacecollector.h.

244 {
245// Prevent accidental compilation without support for SoA layout
246#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
247#error Missing implementation for structure-of-arrays memory layout.
248#endif
249 ENSURE_VALID_ID_ACCESSOR(srfcId);
250 return m_internalSideId[srfcId];
251}

◆ invalidate()

template<MInt nDim, class SysEqn >
void maia::dg::collector::SurfaceCollector< nDim, SysEqn >::invalidate ( const MInt  begin,
const MInt  end 
)
private

Definition at line 488 of file dgcartesiansurfacecollector.h.

488 {
489// Prevent accidental compilation without support for SoA layout
490#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
491#error Missing implementation for structure-of-arrays memory layout.
492#endif
493
494 fill_invalid(m_orientation, begin, end);
495
496 fill_invalid(m_nghbrElementIds, begin, end, 2);
497
498 fill_invalid(m_fineCellId, begin, end);
499
500 fill_invalid(m_internalSideId, begin, end);
501
502 fill_invalid(m_polyDeg, begin, end);
503
504 fill_invalid(m_noNodes1D, begin, end);
505
506 fill_invalid(m_globalId, begin, end);
507
508 fill_invalid(m_variables, begin, end, 2 * noValuesVariables());
509
510 fill_invalid(m_nodeVars, begin, end, 2 * noValuesNodeVars());
511
512 fill_invalid(m_coordinates, begin, end, nDim);
513
514 fill_invalid(m_nodeCoordinates, begin, end, noValuesNodeCoordinates());
515
516 fill_invalid(m_flux, begin, end, noValuesFlux());
517}
maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >::fill_invalid
void fill_invalid(Container_ &c, const MInt begin, const MInt end, const MInt solverSize=1, const T value=Invalid< T >::value())
Definition: container.h:131
maia::dg::collector::SurfaceCollector::m_nodeCoordinates
Storage< MFloat > m_nodeCoordinates
Integration node coordinates.
Definition: dgcartesiansurfacecollector.h:183
maia::dg::collector::SurfaceCollector::m_nodeVars
Storage< MFloat > m_nodeVars
Additional variables at each node.
Definition: dgcartesiansurfacecollector.h:181
maia::dg::collector::SurfaceCollector::m_nghbrElementIds
Storage< MInt > m_nghbrElementIds
Nghbr. element ids (or -1 of no neighbor)
Definition: dgcartesiansurfacecollector.h:158
maia::dg::collector::SurfaceCollector::m_noNodes1D
Storage< MInt > m_noNodes1D
Number of nodes 1D of the neighbors.
Definition: dgcartesiansurfacecollector.h:162
maia::dg::collector::SurfaceCollector::m_polyDeg
Storage< MInt > m_polyDeg
Polynomial degrees of the neighbors.
Definition: dgcartesiansurfacecollector.h:161
maia::dg::collector::SurfaceCollector::m_orientation
Storage< MInt > m_orientation
Orientiation of face normal vector.
Definition: dgcartesiansurfacecollector.h:157
maia::dg::collector::SurfaceCollector::m_variables
Storage< MFloat > m_variables
Surface variables.
Definition: dgcartesiansurfacecollector.h:180

◆ maxNoNodes1D() [1/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::maxNoNodes1D ( ) const
inline

Definition at line 117 of file dgcartesiansurfacecollector.h.

117{ return m_maxNoNodes1D; }

◆ maxNoNodes1D() [2/2]

template<MInt nDim, class SysEqn >
void maia::dg::collector::SurfaceCollector< nDim, SysEqn >::maxNoNodes1D ( const MInt  maxNoNodes1D_)
inline

Definition at line 120 of file dgcartesiansurfacecollector.h.

120 {
121 m_maxNoNodes1D = maxNoNodes1D_;
122 m_maxNoNodesXD = ipow(m_maxNoNodes1D, nDim - 1);
123 };
ipow
MInt ipow(MInt base, MInt exp)
Integer exponent function for non-negative exponents.
Definition: functions.h:317

◆ maxNoNodesXD()

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::maxNoNodesXD ( ) const
inline

Definition at line 126 of file dgcartesiansurfacecollector.h.

126{ return m_maxNoNodesXD; }

◆ maxPolyDeg() [1/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::maxPolyDeg ( ) const
inline

Definition at line 111 of file dgcartesiansurfacecollector.h.

111{ return m_maxPolyDeg; }

◆ maxPolyDeg() [2/2]

template<MInt nDim, class SysEqn >
void maia::dg::collector::SurfaceCollector< nDim, SysEqn >::maxPolyDeg ( const MInt  maxPolyDeg_)
inline

Definition at line 114 of file dgcartesiansurfacecollector.h.

114{ m_maxPolyDeg = maxPolyDeg_; };

◆ nghbrElementIds() [1/2]

template<MInt nDim, class SysEqn >
MInt & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::nghbrElementIds ( const MInt  srfcId,
const MInt  side 
)

Definition at line 398 of file dgcartesiansurfacecollector.h.

398 {
399// Prevent accidental compilation without support for SoA layout
400#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
401#error Missing implementation for structure-of-arrays memory layout.
402#endif
403 ENSURE_VALID_ID_ACCESSOR(srfcId);
404 ENSURE_VALID_SIDE_ACCESSOR(side);
405 return m_nghbrElementIds[2 * srfcId + side];
406}

◆ nghbrElementIds() [2/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::nghbrElementIds ( const MInt  srfcId,
const MInt  side 
) const

Definition at line 409 of file dgcartesiansurfacecollector.h.

409 {
410// Prevent accidental compilation without support for SoA layout
411#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
412#error Missing implementation for structure-of-arrays memory layout.
413#endif
414 ENSURE_VALID_ID_ACCESSOR(srfcId);
415 ENSURE_VALID_SIDE_ACCESSOR(side);
416 return m_nghbrElementIds[2 * srfcId + side];
417}

◆ nodeCoords() [1/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::nodeCoords ( const MInt  srfcId)

Definition at line 354 of file dgcartesiansurfacecollector.h.

354 {
355// Prevent accidental compilation without support for SoA layout
356#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
357#error Missing implementation for structure-of-arrays memory layout.
358#endif
359 ENSURE_VALID_ID_ACCESSOR(srfcId);
360 return m_nodeCoordinates[srfcId * noValuesNodeCoordinates()];
361}

◆ nodeCoords() [2/2]

template<MInt nDim, class SysEqn >
MFloat maia::dg::collector::SurfaceCollector< nDim, SysEqn >::nodeCoords ( const MInt  srfcId) const

Definition at line 364 of file dgcartesiansurfacecollector.h.

364 {
365// Prevent accidental compilation without support for SoA layout
366#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
367#error Missing implementation for structure-of-arrays memory layout.
368#endif
369 ENSURE_VALID_ID_ACCESSOR(srfcId);
370 return m_nodeCoordinates[srfcId * noValuesNodeCoordinates()];
371}

◆ nodeVars() [1/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::nodeVars ( const MInt  srfcId,
const MInt  side 
)

Definition at line 446 of file dgcartesiansurfacecollector.h.

446 {
447// Prevent accidental compilation without support for SoA layout
448#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
449#error Missing implementation for structure-of-arrays memory layout.
450#endif
451 ENSURE_VALID_ID_ACCESSOR(srfcId);
452 ENSURE_VALID_SIDE_ACCESSOR(side);
453 return m_nodeVars[2 * noValuesNodeVars() * srfcId + side * noValuesNodeVars()];
454}

◆ nodeVars() [2/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::nodeVars ( const MInt  srfcId,
const MInt  side 
) const

Definition at line 457 of file dgcartesiansurfacecollector.h.

457 {
458// Prevent accidental compilation without support for SoA layout
459#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
460#error Missing implementation for structure-of-arrays memory layout.
461#endif
462 ENSURE_VALID_ID_ACCESSOR(srfcId);
463 ENSURE_VALID_SIDE_ACCESSOR(side);
464 return m_nodeVars[2 * noValuesNodeVars() * srfcId + side * noValuesNodeVars()];
465}

◆ noNodes1D() [1/2]

template<MInt nDim, class SysEqn >
MInt & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noNodes1D ( const MInt  srfcId)

Definition at line 277 of file dgcartesiansurfacecollector.h.

277 {
278// Prevent accidental compilation without support for SoA layout
279#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
280#error Missing implementation for structure-of-arrays memory layout.
281#endif
282 ENSURE_VALID_ID_ACCESSOR(srfcId);
283 return m_noNodes1D[srfcId];
284}

◆ noNodes1D() [2/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noNodes1D ( const MInt  srfcId) const

Definition at line 287 of file dgcartesiansurfacecollector.h.

287 {
288// Prevent accidental compilation without support for SoA layout
289#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
290#error Missing implementation for structure-of-arrays memory layout.
291#endif
292 ENSURE_VALID_ID_ACCESSOR(srfcId);
293 return m_noNodes1D[srfcId];
294}

◆ noNodesXD()

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noNodesXD ( const MInt  srfcId) const

Definition at line 297 of file dgcartesiansurfacecollector.h.

297 {
298// Prevent accidental compilation without support for SoA layout
299#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
300#error Missing implementation for structure-of-arrays memory layout.
301#endif
302 ENSURE_VALID_ID_ACCESSOR(srfcId);
303 return ipow(m_noNodes1D[srfcId], nDim - 1);
304}

◆ noNodeVars() [1/2]

template<MInt nDim, class SysEqn >
constexpr MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noNodeVars ( ) const
inlineconstexpr

Definition at line 132 of file dgcartesiansurfacecollector.h.

132{ return m_noNodeVars; }

◆ noNodeVars() [2/2]

template<MInt nDim, class SysEqn >
void maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noNodeVars ( const MInt  noNodeVars_)
inline

Definition at line 129 of file dgcartesiansurfacecollector.h.

129{ m_noNodeVars = noNodeVars_; };

◆ noValuesFlux()

template<MInt nDim, class SysEqn >
constexpr MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noValuesFlux ( ) const
inlineconstexpr

Definition at line 140 of file dgcartesiansurfacecollector.h.

140{ return maxNoNodesXD() * SysEqn::noVars(); }
maia::dg::collector::SurfaceCollector::maxNoNodesXD
MInt maxNoNodesXD() const
Return maximum number if nodes XD.
Definition: dgcartesiansurfacecollector.h:126

◆ noValuesNodeCoordinates()

template<MInt nDim, class SysEqn >
constexpr MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noValuesNodeCoordinates ( ) const
inlineconstexpr

Definition at line 138 of file dgcartesiansurfacecollector.h.

138{ return maxNoNodesXD() * nDim; }

◆ noValuesNodeVars()

template<MInt nDim, class SysEqn >
constexpr MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noValuesNodeVars ( ) const
inlineconstexpr

Definition at line 136 of file dgcartesiansurfacecollector.h.

136{ return maxNoNodesXD() * noNodeVars(); }
maia::dg::collector::SurfaceCollector::noNodeVars
constexpr MInt noNodeVars() const
Return number of node variables.
Definition: dgcartesiansurfacecollector.h:132

◆ noValuesVariables()

template<MInt nDim, class SysEqn >
constexpr MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::noValuesVariables ( ) const
inlineconstexpr

Definition at line 134 of file dgcartesiansurfacecollector.h.

134{ return maxNoNodesXD() * SysEqn::noVars(); }

◆ orientation() [1/2]

template<MInt nDim, class SysEqn >
MInt & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::orientation ( const MInt  srfcId)

Definition at line 190 of file dgcartesiansurfacecollector.h.

190 {
191// Prevent accidental compilation without support for SoA layout
192#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
193#error Missing implementation for structure-of-arrays memory layout.
194#endif
195 ENSURE_VALID_ID_ACCESSOR(srfcId);
196 return m_orientation[srfcId];
197}

◆ orientation() [2/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::orientation ( const MInt  srfcId) const

Definition at line 200 of file dgcartesiansurfacecollector.h.

200 {
201// Prevent accidental compilation without support for SoA layout
202#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
203#error Missing implementation for structure-of-arrays memory layout.
204#endif
205 ENSURE_VALID_ID_ACCESSOR(srfcId);
206 return m_orientation[srfcId];
207}

◆ polyDeg() [1/2]

template<MInt nDim, class SysEqn >
MInt & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::polyDeg ( const MInt  srfcId)

Definition at line 256 of file dgcartesiansurfacecollector.h.

256 {
257// Prevent accidental compilation without support for SoA layout
258#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
259#error Missing implementation for structure-of-arrays memory layout.
260#endif
261 ENSURE_VALID_ID_ACCESSOR(srfcId);
262 return m_polyDeg[srfcId];
263}

◆ polyDeg() [2/2]

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::polyDeg ( const MInt  srfcId) const

Definition at line 266 of file dgcartesiansurfacecollector.h.

266 {
267// Prevent accidental compilation without support for SoA layout
268#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
269#error Missing implementation for structure-of-arrays memory layout.
270#endif
271 ENSURE_VALID_ID_ACCESSOR(srfcId);
272 return m_polyDeg[srfcId];
273}

◆ rawCopyGeneric()

template<MInt nDim, class SysEqn >
template<class Functor , class T >
void maia::dg::collector::SurfaceCollector< nDim, SysEqn >::rawCopyGeneric ( Functor &&  c,
const T &  source,
const MInt  begin,
const MInt  end,
const MInt  destination 
)
private

Definition at line 523 of file dgcartesiansurfacecollector.h.

524 {
525// Prevent accidental compilation without support for SoA layout
526#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
527#error Missing implementation for structure-of-arrays memory layout.
528#endif
529
530 copyData(source.m_orientation, m_orientation, c, begin, end, destination);
531
532 copyData(source.m_nghbrElementIds, m_nghbrElementIds, c, begin, end, destination, 2);
533
534 copyData(source.m_fineCellId, m_fineCellId, c, begin, end, destination);
535
536 copyData(source.m_internalSideId, m_internalSideId, c, begin, end, destination);
537
538 copyData(source.m_polyDeg, m_polyDeg, c, begin, end, destination);
539
540 copyData(source.m_noNodes1D, m_noNodes1D, c, begin, end, destination);
541
542 copyData(source.m_globalId, m_globalId, c, begin, end, destination);
543
544 copyData(source.m_variables, m_variables, c, begin, end, destination, 2 * noValuesVariables());
545
546 copyData(source.m_nodeVars, m_nodeVars, c, begin, end, destination, 2 * noValuesNodeVars());
547
548 copyData(source.m_coordinates, m_coordinates, c, begin, end, destination, nDim);
549
550 copyData(source.m_nodeCoordinates, m_nodeCoordinates, c, begin, end, destination, noValuesNodeCoordinates());
551
552 copyData(source.m_flux, m_flux, c, begin, end, destination, noValuesFlux());
553}
maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >::copyData
void copyData(const Container_ &source, Container_ &target, Functor &&f, const MInt begin, const MInt end, const MInt dest, const MInt solverSize=1)
Copy [begin, end) range with given solver size from source to dest position of target.
Definition: container.h:138

◆ reset()

template<MInt nDim, class SysEqn >
void maia::dg::collector::SurfaceCollector< nDim, SysEqn >::reset
private

Definition at line 470 of file dgcartesiansurfacecollector.h.

470 {
471 resetStorage(1, m_orientation);
472 resetStorage(2, m_nghbrElementIds);
473 resetStorage(1, m_fineCellId);
474 resetStorage(1, m_internalSideId);
475 resetStorage(1, m_polyDeg);
476 resetStorage(1, m_noNodes1D);
477 resetStorage(1, m_globalId);
478 resetStorage(2 * noValuesVariables(), m_variables);
479 resetStorage(2 * noValuesNodeVars(), m_nodeVars);
480 resetStorage(nDim, m_coordinates);
481 resetStorage(noValuesNodeCoordinates(), m_nodeCoordinates);
482 resetStorage(noValuesFlux(), m_flux);
483}
maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >::resetStorage
void resetStorage(const MInt n, Storage< T > &c)
Create new container with given size and replace original one.
Definition: container.h:420

◆ variables() [1/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::variables ( const MInt  srfcId,
const MInt  side 
)

Definition at line 422 of file dgcartesiansurfacecollector.h.

422 {
423// Prevent accidental compilation without support for SoA layout
424#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
425#error Missing implementation for structure-of-arrays memory layout.
426#endif
427 ENSURE_VALID_ID_ACCESSOR(srfcId);
428 ENSURE_VALID_SIDE_ACCESSOR(side);
429 return m_variables[2 * noValuesVariables() * srfcId + side * noValuesVariables()];
430}

◆ variables() [2/2]

template<MInt nDim, class SysEqn >
MFloat & maia::dg::collector::SurfaceCollector< nDim, SysEqn >::variables ( const MInt  srfcId,
const MInt  side 
) const

Definition at line 433 of file dgcartesiansurfacecollector.h.

433 {
434// Prevent accidental compilation without support for SoA layout
435#ifdef DGCOLLECTOR_SOA_MEMORY_LAYOUT
436#error Missing implementation for structure-of-arrays memory layout.
437#endif
438 ENSURE_VALID_ID_ACCESSOR(srfcId);
439 ENSURE_VALID_SIDE_ACCESSOR(side);
440 return m_variables[2 * noValuesVariables() * srfcId + side * noValuesVariables()];
441}

Friends And Related Function Documentation

◆ maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >

template<MInt nDim, class SysEqn >
friend class maia::container::Container< SurfaceCollector< nDim, SysEqn >, Invalid >
friend

Definition at line 523 of file dgcartesiansurfacecollector.h.

Member Data Documentation

◆ m_coordinates

template<MInt nDim, class SysEqn >
Storage<MFloat> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_coordinates {}
private

Definition at line 182 of file dgcartesiansurfacecollector.h.

◆ m_fineCellId

template<MInt nDim, class SysEqn >
Storage<MInt> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_fineCellId {}
private

Definition at line 159 of file dgcartesiansurfacecollector.h.

◆ m_flux

template<MInt nDim, class SysEqn >
Storage<MFloat> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_flux {}
private

Definition at line 184 of file dgcartesiansurfacecollector.h.

◆ m_globalId

template<MInt nDim, class SysEqn >
Storage<MLong> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_globalId {}
private

Definition at line 178 of file dgcartesiansurfacecollector.h.

◆ m_internalSideId

template<MInt nDim, class SysEqn >
Storage<MInt> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_internalSideId {}
private

Definition at line 160 of file dgcartesiansurfacecollector.h.

◆ m_maxNoNodes1D

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_maxNoNodes1D = -1
private

Definition at line 150 of file dgcartesiansurfacecollector.h.

◆ m_maxNoNodesXD

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_maxNoNodesXD = -1
private

Definition at line 151 of file dgcartesiansurfacecollector.h.

◆ m_maxPolyDeg

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_maxPolyDeg = -1
private

Definition at line 149 of file dgcartesiansurfacecollector.h.

◆ m_nghbrElementIds

template<MInt nDim, class SysEqn >
Storage<MInt> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_nghbrElementIds {}
private

Definition at line 158 of file dgcartesiansurfacecollector.h.

◆ m_nodeCoordinates

template<MInt nDim, class SysEqn >
Storage<MFloat> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_nodeCoordinates {}
private

Definition at line 183 of file dgcartesiansurfacecollector.h.

◆ m_nodeVars

template<MInt nDim, class SysEqn >
Storage<MFloat> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_nodeVars {}
private

Definition at line 181 of file dgcartesiansurfacecollector.h.

◆ m_noNodes1D

template<MInt nDim, class SysEqn >
Storage<MInt> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_noNodes1D {}
private

Definition at line 162 of file dgcartesiansurfacecollector.h.

◆ m_noNodeVars

template<MInt nDim, class SysEqn >
MInt maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_noNodeVars = -1
private

Definition at line 154 of file dgcartesiansurfacecollector.h.

◆ m_orientation

template<MInt nDim, class SysEqn >
Storage<MInt> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_orientation {}
private

Definition at line 157 of file dgcartesiansurfacecollector.h.

◆ m_polyDeg

template<MInt nDim, class SysEqn >
Storage<MInt> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_polyDeg {}
private

Definition at line 161 of file dgcartesiansurfacecollector.h.

◆ m_variables

template<MInt nDim, class SysEqn >
Storage<MFloat> maia::dg::collector::SurfaceCollector< nDim, SysEqn >::m_variables {}
private

Definition at line 180 of file dgcartesiansurfacecollector.h.

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