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

Class that represents FV cell collector. More...

#include <fvcartesiancellcollector.h>

Inheritance diagram for maia::fv::collector::FvCellCollector< nDim >:
[legend]
Collaboration diagram for maia::fv::collector::FvCellCollector< nDim >:
[legend]

Public Types

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

Public Member Functions

void setFvCollectorType (const MInt mode)
 Set the fv-collector type. More...
 
void setFvTimeStepType (const MInt mode)
 
constexpr MBool hasCellCenterMeanMolarWeight () const
 
constexpr MBool hasCellCenterGamma () const
 
constexpr MBool hasReactionRates () const
 
constexpr MBool hasReactionRatesBackup () const
 
constexpr MBool hasPsi () const
 
constexpr MBool isEEGas () const
 
constexpr MBool hasLocalTS () const
 
constexpr MBool hasDualTS () const
 
constexpr FvCellCollector ()=default
 Default c'tor does nothing. More...
 
MFloat & oldVariable (const MInt id, const MInt varId)
 Accessor for oldVariables. More...
 
MFloat oldVariable (const MInt id, const MInt varId) const
 Accessor for oldVariables (const version). More...
 
MFloat & variable (const MInt id, const MInt dim)
 Accessor for variables. More...
 
MFloat variable (const MInt id, const MInt dim) const
 Accessor for variables (const version). More...
 
MFloat & pvariable (const MInt id, const MInt dim)
 Accessor for pvariable. More...
 
MFloat pvariable (const MInt id, const MInt dim) const
 Accessor for pvariable (const version). More...
 
MFloat & avariable (const MInt id, const MInt dim)
 Accessor for additional variables. More...
 
MFloat avariable (const MInt id, const MInt dim) const
 Accessor for additional variables (const version). More...
 
MFloat & rightHandSide (const MInt id, const MInt varId)
 Accessor for right hand side. More...
 
MFloat rightHandSide (const MInt id, const MInt varId) const
 Accessor for right hand side (const version). More...
 
MFloat & slope (const MInt id, const MInt dimVar, const MInt dimDir)
 Accessor for slopes. More...
 
MFloat slope (const MInt id, const MInt dimVar, const MInt dimDir) const
 Accessor for slopes (const version). More...
 
MInt & bndryCellId (const MInt id)
 Accessor for bndryCellIds. More...
 
MInt bndryCellId (const MInt id) const
 Accessor for bndryCellIds (const version). More...
 
MInt & noRcnstrctnNghbrIds (const MInt id)
 Accessor for noRcnstrctnNghbrIds. More...
 
MInt noRcnstrctnNghbrIds (const MInt id) const
 Accessor for noRcnstrctnNghbrIds (const version). More...
 
MInt & rcnstrctnNghbrId (const MInt id, const MInt dimRecNghbr)
 Accessor for rcnstrctnNghbrId. More...
 
MInt rcnstrctnNghbrId (const MInt id, const MInt dimRecNghbr) const
 Accessor for rcnstrctnNghbrId (const version). More...
 
MInt & reconstructionData (const MInt id)
 Accessor for reconstructionData. More...
 
MInt reconstructionData (const MInt id) const
 Accessor for reconstructionData (const version). More...
 
void nghbrInterface (const MInt id, const MInt dir, const MInt state)
 Accessor for nghbrInterface. More...
 
MInt nghbrInterface (const MInt id, const MInt dir) const
 Accessor for rcnstrctnNghbrId (const version). More...
 
MFloat & reactionRate (const MInt id, const MInt dimReaction)
 Accessor for reaction rates. More...
 
MFloat reactionRate (const MInt id, const MInt dimReaction) const
 Accessor for reaction rates (const version). More...
 
MFloat & reactionRateBackup (const MInt id, const MInt dimReaction)
 Accessor for reaction rates backup. More...
 
MFloat reactionRateBackup (const MInt id, const MInt dimReaction) const
 Accessor for reaction rates backup (const version). More...
 
MFloat & psi (const MInt id)
 Accessor for psi. More...
 
MFloat psi (const MInt id) const
 Accessor for psi(const version). More...
 
MFloat & implicitCoefficient (const MInt id, const MInt dimCoefficient)
 Accessor for implicit coefficient. More...
 
MFloat implicitCoefficient (const MInt id, const MInt dimCoefficient) const
 Accessor for implicit coefficient (const version). More...
 
MFloat & speciesReactionRate (const MInt id, const MInt speciesIndex)
 Accessor for species reaction rates. More...
 
MFloat speciesReactionRate (const MInt id, const MInt speciesIndex) const
 Accessor for species reaction rates (const version). More...
 
MFloat & cellCenterMeanMolarWeight (const MInt id)
 Accessor for species reaction rates. More...
 
MFloat cellCenterMeanMolarWeight (const MInt id) const
 Accessor for species reaction rates (const version). More...
 
MFloat & cellCenterGamma (const MInt id)
 Accessor for species reaction rates. More...
 
MFloat cellCenterGamma (const MInt id) const
 Accessor for species reaction rates (const version). More...
 
MFloat & dt1Variable (const MInt id, const MInt dim)
 Accessor for dt1Variable. More...
 
MFloat dt1Variable (const MInt id, const MInt dim) const
 Accessor for dt1Variable (const version). More...
 
MFloat & dt2Variable (const MInt id, const MInt dim)
 Accessor for dt2Variable. More...
 
MFloat dt2Variable (const MInt id, const MInt dim) const
 Accessor for dt2Variable (const version). More...
 
MFloat & localTimeStep (const MInt id)
 Accessor for local timestep. More...
 
MFloat localTimeStep (const MInt id) const
 Accessor for local timestep (const version). More...
 
MFloat & fluidFraction (const MInt id)
 
const MFloat & fluidFraction (const MInt id) const
 
MFloat & spongeFactor (const MInt id)
 Accessor for spongeFactor. More...
 
MFloat spongeFactor (const MInt id) const
 Accessor for spongeFactor (const version). More...
 
MFloat & spongeFactorStart (const MInt id)
 Accessor for spongeFactorStart. More...
 
MFloat spongeFactorStart (const MInt id) const
 Accessor for spongeFactorStart (const version). More...
 
MInt & spongeBndryId (const MInt id, const MInt dimDir)
 Accessor for spongeBndryId. More...
 
MInt spongeBndryId (const MInt id, const MInt dimDir) const
 Accessor for spongeBndryId (const version). More...
 
MFloat & coordinate (const MInt id, const MInt dim)
 Accessor for coordinates. More...
 
MFloat coordinate (const MInt id, const MInt dim) const
 Accessor for coordinates (const version). More...
 
MInt & level (const MInt cellId)
 Accessor for level. More...
 
MInt level (const MInt cellId) const
 Accessor for level (const version). More...
 
MFloat & cellVolume (const MInt cellId)
 Accessor for cell volume. More...
 
MFloat cellVolume (const MInt cellId) const
 Accessor for cell volume (const version). More...
 
MFloat & FcellVolume (const MInt cellId)
 Accessor for inverse cell volume. More...
 
MFloat FcellVolume (const MInt cellId) const
 Accessor for inverse cell volume (const version). More...
 
MFloat & tau (const MInt id, const MInt varId)
 Accessor for coarse cell correction (tau). More...
 
MFloat tau (const MInt id, const MInt varId) const
 Accessor for coarse cell correction (tau) (const version). More...
 
MFloat & restrictedRHS (const MInt id, const MInt varId)
 Accessor for restricted RHS for multilevel computation. More...
 
MFloat restrictedRHS (const MInt id, const MInt varId) const
 Accessor for restricted RHS for multilevel computation (const version). More...
 
MFloat & restrictedVar (const MInt id, const MInt varId)
 Accessor for variables after restriction during multigrid computations. More...
 
MFloat restrictedVar (const MInt id, const MInt varId) const
 Accessor for variables after restriction during multigrid computations (const version). More...
 
MFloat & storedSlope (const MInt id, const MInt dimVar, const MInt dimDir)
 Accessor for stored slopes. More...
 
MFloat storedSlope (const MInt id, const MInt dimVar, const MInt dimDir) const
 Accessor for stored slopes (const version). More...
 
BitsetType::reference hasProperty (const MInt id, const FvCell p)
 Accessor for properties. More...
 
MBool hasProperty (const MInt id, const FvCell p) const
 Accessor for properties (const version). More...
 
void resetProperties (const MInt id)
 Reset all properties. More...
 
BitsetType & properties (const MInt id)
 Accessor for properties. More...
 
void setNoCVariables (const MInt noCVariables_, const MInt noSpecies_)
 Set number of species and update number of variables. More...
 
void setNoPVariables (const MInt noPVariables_)
 Update number of primitive variables. More...
 
void setNoFVariables (const MInt noFVariables_)
 Update number of flux variables. More...
 
void setNoAVariables (const MInt noAVariables_)
 Update number of additional variables. More...
 
constexpr MInt noSpecies () const
 Return number of species. More...
 
MInt isMultilevel (const MBool isMultilevel_)
 Allow activation of multilevel calculations. More...
 
constexpr MInt isMultilevel () const
 Return whether multilevel is active or not. More...
 
constexpr MInt noCVariables () const
 Return number of conservative variables. More...
 
constexpr MInt noPVariables () const
 Return number of primitive variables. More...
 
constexpr MInt noFVariables () const
 Return number of flux variables. More...
 
constexpr MInt noAVariables () const
 Return number of additional variables. More...
 
constexpr MInt noRecNghbrs () const
 Return max number of reconstruction nghbrs. More...
 
constexpr MInt noReactionRates () const
 Return max number of reaction rates. More...
 
constexpr MInt noImplicitCoefficients () const
 Return max number of implicit coefficients. More...
 
- Public Member Functions inherited from maia::container::Container< FvCellCollector< nDim >, 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...
 
FvCellCollector< nDim > & derived ()
 
const FvCellCollector< nDim > & 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
 

Static Public Member Functions

static constexpr MInt noProperties ()
 Return number of properties defined for each node. More...
 

Private Types

using Base = maia::container::Container< FvCellCollector< nDim >, Invalid >
 
template<class T >
using Storage = typename Base::template Storage< T >
 
using BitsetType = maia::fv::cell::BitsetType
 

Private Member Functions

void reset ()
 Reset tree, re-create data structures with given capacity, and set size to zero. More...
 
void resize () override
 TODO doc. 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

MBool m_hasCellCenterMeanMolarWeight = false
 
MBool m_hasReactionRates = false
 
MBool m_hasReactionRatesBackup = false
 
MBool m_hasPsi = false
 
MBool m_isEEGas = false
 
MBool m_hasCellCenterGamma = false
 
MBool m_hasLocalTS = false
 
MBool m_hasDualTS = false
 
MInt m_noCVariables = 2 + nDim
 Number of variables. More...
 
MInt m_noPVariables = 2 + nDim
 
MInt m_noFVariables = 2 + nDim
 
MInt m_noAVariables = 0
 
MInt m_noSpecies = 0
 Number of species. More...
 
MBool m_isMultilevel = false
 Is multilevel computation activated. More...
 
MInt m_noRecNghbrs = IPOW3[nDim] + nDim
 Max number of reconstruction neighbors. More...
 
MInt m_noReactionRates = 1
 Max number of reaction rates. More...
 
MInt m_noImplicitCoefficients = 2 * nDim
 Max number of implicit coefficients. More...
 
Storage< MFloat > m_oldVariables {}
 
Storage< MFloat > m_variables {}
 
Storage< MFloat > m_avariables {}
 
Storage< MFloat > m_rightHandSide {}
 
Storage< MFloat > m_slopes {}
 
Storage< MFloat > m_pvariables {}
 
Storage< MInt > m_bndryCellIds {}
 
Storage< MInt > m_noRcnstrctnNghbrIds {}
 
Storage< MInt > m_rcnstrctnNghbrIds {}
 
Storage< MInt > m_reconstructionData {}
 
Storage< M16X2bit< false > > m_nghbrInterface {}
 
Storage< MFloat > m_reactionRates {}
 
Storage< MFloat > m_reactionRatesBackup {}
 
Storage< MFloat > m_psi {}
 
Storage< MFloat > m_implicitCoefficients {}
 
Storage< MFloat > m_speciesReactionRates {}
 
Storage< MFloat > m_cellCenterMeanMolarWeight {}
 
Storage< MFloat > m_cellCenterGamma {}
 
Storage< MFloat > m_dt1Variables {}
 
Storage< MFloat > m_dt2Variables {}
 
Storage< MFloat > m_localTimeStep_ {}
 Storage of cell-local time-steps for dual time stepping: More...
 
Storage< MFloat > m_spongeFactor {}
 
Storage< MFloat > m_spongeFactorStart {}
 
Storage< MInt > m_spongeBndryIds {}
 
Storage< MFloat > m_coordinates {}
 
Storage< MInt > m_levels {}
 
Storage< BitsetType > m_properties {}
 
Storage< MFloat > m_cellVolumes {}
 
Storage< MFloat > m_FcellVolumes {}
 
Storage< MFloat > m_tau {}
 
Storage< MFloat > m_restrictedRHS {}
 
Storage< MFloat > m_restrictedVars {}
 
Storage< MFloat > m_storedSlopes {}
 

Friends

class maia::container::Container< FvCellCollector< nDim >, Invalid >
 

Additional Inherited Members

- Protected Types inherited from maia::container::Container< FvCellCollector< nDim >, Invalid >
using Storage = std::vector< T >
 
- Protected Member Functions inherited from maia::container::Container< FvCellCollector< nDim >, 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 maia::fv::collector::FvCellCollector< nDim >

Definition at line 184 of file fvcartesiancellcollector.h.

Member Typedef Documentation

◆ Base

template<MInt nDim>
using maia::fv::collector::FvCellCollector< nDim >::Base = maia::container::Container<FvCellCollector<nDim>, Invalid>
private

Definition at line 189 of file fvcartesiancellcollector.h.

◆ BitsetType

template<MInt nDim>
using maia::fv::collector::FvCellCollector< nDim >::BitsetType = maia::fv::cell::BitsetType
private

Definition at line 194 of file fvcartesiancellcollector.h.

◆ Invalid

template<MInt nDim>
template<class T >
using maia::fv::collector::FvCellCollector< nDim >::Invalid = typename maia::fv::collector::Invalid<T>

Definition at line 212 of file fvcartesiancellcollector.h.

◆ Storage

template<MInt nDim>
template<class T >
using maia::fv::collector::FvCellCollector< nDim >::Storage = typename Base::template Storage<T>
private

Definition at line 193 of file fvcartesiancellcollector.h.

Constructor & Destructor Documentation

◆ FvCellCollector()

template<MInt nDim>
constexpr maia::fv::collector::FvCellCollector< nDim >::FvCellCollector ( )
constexprdefault

Member Function Documentation

◆ avariable() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::avariable ( const MInt  id,
const MInt  dim 
)

Definition at line 692 of file fvcartesiancellcollector.h.

692 {
693// Prevent accidental compilation without support for SoA layout
694#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
695#error Missing implementation for structure-of-arrays memory layout.
696#endif
697 ENSURE_VALID_ID_ACCESSOR(id);
698 ENSURE_VALID_AVARIABLE_ID_ACCESSOR(varId);
699 return m_avariables[id * noAVariables() + varId];
700}
maia::fv::collector::FvCellCollector::noAVariables
constexpr MInt noAVariables() const
Return number of additional variables.
Definition: fvcartesiancellcollector.h:362

◆ avariable() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::avariable ( const MInt  id,
const MInt  dim 
) const

Definition at line 703 of file fvcartesiancellcollector.h.

703 {
704// Prevent accidental compilation without support for SoA layout
705#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
706#error Missing implementation for structure-of-arrays memory layout.
707#endif
708 ENSURE_VALID_ID_ACCESSOR(id);
709 ENSURE_VALID_AVARIABLE_ID_ACCESSOR(varId);
710 return m_avariables[id * noAVariables() + varId];
711}

◆ bndryCellId() [1/2]

template<MInt nDim>
MInt & maia::fv::collector::FvCellCollector< nDim >::bndryCellId ( const MInt  id)

Definition at line 763 of file fvcartesiancellcollector.h.

763 {
764// Prevent accidental compilation without support for SoA layout
765#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
766#error Missing implementation for structure-of-arrays memory layout.
767#endif
768 ENSURE_VALID_ID_ACCESSOR(id);
769 return m_bndryCellIds[id];
770}
id
MInt id
Definition: maiatypes.h:71

◆ bndryCellId() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::bndryCellId ( const MInt  id) const

Definition at line 773 of file fvcartesiancellcollector.h.

773 {
774// Prevent accidental compilation without support for SoA layout
775#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
776#error Missing implementation for structure-of-arrays memory layout.
777#endif
778 ENSURE_VALID_ID_ACCESSOR(id);
779 return m_bndryCellIds[id];
780}

◆ cellCenterGamma() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::cellCenterGamma ( const MInt  id)

Definition at line 1008 of file fvcartesiancellcollector.h.

1008 {
1009// Prevent accidental compilation without support for SoA layout
1010#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1011#error Missing implementation for structure-of-arrays memory layout.
1012#endif
1013 ENSURE_VALID_ID_ACCESSOR(id);
1014 return m_cellCenterGamma[id];
1015}

◆ cellCenterGamma() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::cellCenterGamma ( const MInt  id) const

Definition at line 1019 of file fvcartesiancellcollector.h.

1019 {
1020// Prevent accidental compilation without support for SoA layout
1021#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1022#error Missing implementation for structure-of-arrays memory layout.
1023#endif
1024 ENSURE_VALID_ID_ACCESSOR(id);
1025 return m_cellCenterGamma[id];
1026}

◆ cellCenterMeanMolarWeight() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::cellCenterMeanMolarWeight ( const MInt  id)

Definition at line 986 of file fvcartesiancellcollector.h.

986 {
987// Prevent accidental compilation without support for SoA layout
988#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
989#error Missing implementation for structure-of-arrays memory layout.
990#endif
991 ENSURE_VALID_ID_ACCESSOR(id);
992 return m_cellCenterMeanMolarWeight[id];
993}

◆ cellCenterMeanMolarWeight() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::cellCenterMeanMolarWeight ( const MInt  id) const

Definition at line 997 of file fvcartesiancellcollector.h.

997 {
998// Prevent accidental compilation without support for SoA layout
999#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1000#error Missing implementation for structure-of-arrays memory layout.
1001#endif
1002 ENSURE_VALID_ID_ACCESSOR(id);
1003 return m_cellCenterMeanMolarWeight[id];
1004}

◆ cellVolume() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::cellVolume ( const MInt  cellId)

Definition at line 1197 of file fvcartesiancellcollector.h.

1197 {
1198 ENSURE_VALID_ID_ACCESSOR(id);
1199 return m_cellVolumes[id];
1200}

◆ cellVolume() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::cellVolume ( const MInt  cellId) const

Definition at line 1203 of file fvcartesiancellcollector.h.

1203 {
1204 ENSURE_VALID_ID_ACCESSOR(id);
1205 return m_cellVolumes[id];
1206}

◆ coordinate() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::coordinate ( const MInt  id,
const MInt  dim 
)

Definition at line 1161 of file fvcartesiancellcollector.h.

1161 {
1162// Prevent accidental compilation without support for SoA layout
1163#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1164#error Missing implementation for structure-of-arrays memory layout.
1165#endif
1166 ENSURE_VALID_ID_ACCESSOR(id);
1167 ENSURE_VALID_COORDINATE_DIR_ACCESSOR(dir);
1168 return m_coordinates[id * nDim + dir];
1169}

◆ coordinate() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::coordinate ( const MInt  id,
const MInt  dim 
) const

Definition at line 1172 of file fvcartesiancellcollector.h.

1172 {
1173// Prevent accidental compilation without support for SoA layout
1174#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1175#error Missing implementation for structure-of-arrays memory layout.
1176#endif
1177 ENSURE_VALID_ID_ACCESSOR(id);
1178 ENSURE_VALID_COORDINATE_DIR_ACCESSOR(dir);
1179 return m_coordinates[id * nDim + dir];
1180}

◆ dt1Variable() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::dt1Variable ( const MInt  id,
const MInt  dim 
)

Definition at line 1030 of file fvcartesiancellcollector.h.

1030 {
1031// Prevent accidental compilation without support for SoA layout
1032#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1033#error Missing implementation for structure-of-arrays memory layout.
1034#endif
1035 ENSURE_VALID_ID_ACCESSOR(id);
1036 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1037 return m_dt1Variables[id * noCVariables() + varId];
1038}
maia::fv::collector::FvCellCollector::noCVariables
constexpr MInt noCVariables() const
Return number of conservative variables.
Definition: fvcartesiancellcollector.h:353

◆ dt1Variable() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::dt1Variable ( const MInt  id,
const MInt  dim 
) const

Definition at line 1041 of file fvcartesiancellcollector.h.

1041 {
1042// Prevent accidental compilation without support for SoA layout
1043#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1044#error Missing implementation for structure-of-arrays memory layout.
1045#endif
1046 ENSURE_VALID_ID_ACCESSOR(id);
1047 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1048 return m_dt1Variables[id * noCVariables() + varId];
1049}

◆ dt2Variable() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::dt2Variable ( const MInt  id,
const MInt  dim 
)

Definition at line 1053 of file fvcartesiancellcollector.h.

1053 {
1054// Prevent accidental compilation without support for SoA layout
1055#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1056#error Missing implementation for structure-of-arrays memory layout.
1057#endif
1058 ENSURE_VALID_ID_ACCESSOR(id);
1059 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1060 return m_dt2Variables[id * noCVariables() + varId];
1061}

◆ dt2Variable() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::dt2Variable ( const MInt  id,
const MInt  dim 
) const

Definition at line 1064 of file fvcartesiancellcollector.h.

1064 {
1065// Prevent accidental compilation without support for SoA layout
1066#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1067#error Missing implementation for structure-of-arrays memory layout.
1068#endif
1069 ENSURE_VALID_ID_ACCESSOR(id);
1070 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1071 return m_dt2Variables[id * noCVariables() + varId];
1072}

◆ FcellVolume() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::FcellVolume ( const MInt  cellId)

Definition at line 1210 of file fvcartesiancellcollector.h.

1210 {
1211 ENSURE_VALID_ID_ACCESSOR(id);
1212 return m_FcellVolumes[id];
1213}

◆ FcellVolume() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::FcellVolume ( const MInt  cellId) const

Definition at line 1216 of file fvcartesiancellcollector.h.

1216 {
1217 ENSURE_VALID_ID_ACCESSOR(id);
1218 return m_FcellVolumes[id];
1219}

◆ fluidFraction() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::fluidFraction ( const MInt  id)

◆ fluidFraction() [2/2]

template<MInt nDim>
const MFloat & maia::fv::collector::FvCellCollector< nDim >::fluidFraction ( const MInt  id) const

◆ hasCellCenterGamma()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasCellCenterGamma ( ) const
inlineconstexpr

Definition at line 202 of file fvcartesiancellcollector.h.

202{ return m_hasCellCenterGamma; }

◆ hasCellCenterMeanMolarWeight()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasCellCenterMeanMolarWeight ( ) const
inlineconstexpr

Definition at line 201 of file fvcartesiancellcollector.h.

201{ return m_hasCellCenterMeanMolarWeight; }

◆ hasDualTS()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasDualTS ( ) const
inlineconstexpr

Definition at line 208 of file fvcartesiancellcollector.h.

208{ return m_hasDualTS; }

◆ hasLocalTS()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasLocalTS ( ) const
inlineconstexpr

Definition at line 207 of file fvcartesiancellcollector.h.

207{ return m_hasLocalTS; }

◆ hasProperty() [1/2]

template<MInt nDim>
FvCellCollector< nDim >::BitsetType::reference maia::fv::collector::FvCellCollector< nDim >::hasProperty ( const MInt  id,
const FvCell  p 
)

Definition at line 1223 of file fvcartesiancellcollector.h.

1223 {
1224 ENSURE_VALID_ID_ACCESSOR(id);
1225 ENSURE_VALID_PROPERTY_ACCESSOR(p);
1226 return m_properties[id][maia::fv::cell::p(p)];
1227}
maia::fv::cell::p
constexpr std::underlying_type< FvCell >::type p(const FvCell property)
Converts property name to underlying integer value.
Definition: fvcartesiancellproperties.h:58

◆ hasProperty() [2/2]

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::hasProperty ( const MInt  id,
const FvCell  p 
) const

Definition at line 1230 of file fvcartesiancellcollector.h.

1230 {
1231 ENSURE_VALID_ID_ACCESSOR(id);
1232 ENSURE_VALID_PROPERTY_ACCESSOR(p);
1233 return m_properties[id][maia::fv::cell::p(p)];
1234}

◆ hasPsi()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasPsi ( ) const
inlineconstexpr

Definition at line 205 of file fvcartesiancellcollector.h.

205{ return m_hasPsi; }

◆ hasReactionRates()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasReactionRates ( ) const
inlineconstexpr

Definition at line 203 of file fvcartesiancellcollector.h.

203{ return m_hasReactionRates; }

◆ hasReactionRatesBackup()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::hasReactionRatesBackup ( ) const
inlineconstexpr

Definition at line 204 of file fvcartesiancellcollector.h.

204{ return m_hasReactionRatesBackup; }

◆ implicitCoefficient() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::implicitCoefficient ( const MInt  id,
const MInt  dimCoefficient 
)

Definition at line 939 of file fvcartesiancellcollector.h.

939 {
940// Prevent accidental compilation without support for SoA layout
941#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
942#error Missing implementation for structure-of-arrays memory layout.
943#endif
944 ENSURE_VALID_ID_ACCESSOR(id);
945 ENSURE_VALID_IMPLICIT_COEFFICIENT_ID_ACCESSOR(dimCoefficient);
946 return m_implicitCoefficients[id * noImplicitCoefficients() + dimCoefficient];
947}
maia::fv::collector::FvCellCollector::noImplicitCoefficients
constexpr MInt noImplicitCoefficients() const
Return max number of implicit coefficients.
Definition: fvcartesiancellcollector.h:371

◆ implicitCoefficient() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::implicitCoefficient ( const MInt  id,
const MInt  dimCoefficient 
) const

Definition at line 950 of file fvcartesiancellcollector.h.

950 {
951// Prevent accidental compilation without support for SoA layout
952#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
953#error Missing implementation for structure-of-arrays memory layout.
954#endif
955 ENSURE_VALID_ID_ACCESSOR(id);
956 ENSURE_VALID_IMPLICIT_COEFFICIENT_ID_ACCESSOR(dimCoefficient);
957 return m_implicitCoefficients[id * noImplicitCoefficients() + dimCoefficient];
958}

◆ invalidate()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::invalidate ( const MInt  begin,
const MInt  end 
)
private

Definition at line 1381 of file fvcartesiancellcollector.h.

1381 {
1382// Prevent accidental compilation without support for SoA layout
1383#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1384#error Missing implementation for structure-of-arrays memory layout.
1385#endif
1386
1387 // oldVariables
1388 fill_invalid(m_oldVariables, begin, end, noCVariables());
1389 // variables
1390 fill_invalid(m_variables, begin, end, noCVariables());
1391 // pvariables
1392 fill_invalid(m_pvariables, begin, end, noPVariables());
1393 // right hand side
1394 fill_invalid(m_rightHandSide, begin, end, noFVariables());
1395 // slopes
1396 fill_invalid(m_slopes, begin, end, noPVariables() * nDim);
1397 // bndry cell ids, -1 as "invalid" value
1398 // mapping -1: internal, -2: ghost cell
1399 fill_invalid(m_bndryCellIds, begin, end, 1, -1);
1400 // noRcnstrctnNghbrIds
1401 fill_invalid(m_noRcnstrctnNghbrIds, begin, end);
1402 // rcnstrctnNghbrId
1403 fill_invalid(m_rcnstrctnNghbrIds, begin, end, noRecNghbrs());
1404 // m_reconstructionData
1405 fill_invalid(m_reconstructionData, begin, end);
1406 // nghbrInterface
1407 fill_invalid(m_nghbrInterface, begin, end);
1408
1409 // reactionRates
1410 if(hasReactionRates()) fill_invalid(m_reactionRates, begin, end, noReactionRates());
1411 if(hasReactionRatesBackup()) fill_invalid(m_reactionRatesBackup, begin, end, noReactionRates());
1412 // psi
1413 if(hasPsi()) fill_invalid(m_psi, begin, end);
1414 // speciesReactionRates
1415 if(hasReactionRates()) fill_invalid(m_speciesReactionRates, begin, end, noSpecies());
1416 if(hasCellCenterMeanMolarWeight()) fill_invalid(m_cellCenterMeanMolarWeight, begin, end);
1417 if(hasCellCenterGamma()) fill_invalid(m_cellCenterGamma, begin, end);
1418
1419 // implicit coefficients
1420 if(isEEGas()) fill_invalid(m_implicitCoefficients, begin, end, noImplicitCoefficients());
1421 // additional variables
1422 fill_invalid(m_avariables, begin, end, noAVariables());
1423
1424 if(hasDualTS()) {
1425 // dt1Variables
1426 fill_invalid(m_dt1Variables, begin, end, noCVariables());
1427 // dt2Variables
1428 fill_invalid(m_dt2Variables, begin, end, noCVariables());
1429 fill_invalid(m_localTimeStep_, begin, end);
1430 } else if(hasLocalTS()) {
1431 fill_invalid(m_localTimeStep_, begin, end);
1432 }
1433
1434 // spongeFactor
1435 fill_invalid(m_spongeFactor, begin, end);
1436 // spongeFactorStart
1437 fill_invalid(m_spongeFactorStart, begin, end);
1438 // spongeBndryIds
1439 fill_invalid(m_spongeBndryIds, begin, end, nDim);
1440
1441 // Properties
1442 fill_invalid(m_properties, begin, end);
1443 // Coordinates
1444 fill_invalid(m_coordinates, begin * nDim, end * nDim);
1445
1446 // Level
1447 fill_invalid(m_levels, begin, end);
1448
1449 // Cell volume
1450 fill_invalid(m_cellVolumes, begin, end);
1451 // Inverse cell volume
1452 fill_invalid(m_FcellVolumes, begin, end);
1453
1454 // Multilevel-related data
1455 if(isMultilevel()) {
1456 // Coarse grid correction
1457 fill_invalid(m_tau, begin, end, noCVariables());
1458 // Restricted RHS
1459 fill_invalid(m_restrictedRHS, begin, end, noCVariables());
1460 // Variables after restriction
1461 fill_invalid(m_restrictedVars, begin, end, noCVariables());
1462 // Temporarily stored slopes
1463 fill_invalid(m_storedSlopes, begin, end, noPVariables() * nDim);
1464 }
1465}
maia::container::Container< FvCellCollector< nDim >, 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::fv::collector::FvCellCollector::hasCellCenterMeanMolarWeight
constexpr MBool hasCellCenterMeanMolarWeight() const
Definition: fvcartesiancellcollector.h:201
maia::fv::collector::FvCellCollector::isMultilevel
constexpr MInt isMultilevel() const
Return whether multilevel is active or not.
Definition: fvcartesiancellcollector.h:350
maia::fv::collector::FvCellCollector::noPVariables
constexpr MInt noPVariables() const
Return number of primitive variables.
Definition: fvcartesiancellcollector.h:356
maia::fv::collector::FvCellCollector::m_nghbrInterface
Storage< M16X2bit< false > > m_nghbrInterface
Definition: fvcartesiancellcollector.h:427
maia::fv::collector::FvCellCollector::noReactionRates
constexpr MInt noReactionRates() const
Return max number of reaction rates.
Definition: fvcartesiancellcollector.h:368
maia::fv::collector::FvCellCollector::noRecNghbrs
constexpr MInt noRecNghbrs() const
Return max number of reconstruction nghbrs.
Definition: fvcartesiancellcollector.h:365
maia::fv::collector::FvCellCollector::noFVariables
constexpr MInt noFVariables() const
Return number of flux variables.
Definition: fvcartesiancellcollector.h:359
maia::fv::collector::FvCellCollector::m_localTimeStep_
Storage< MFloat > m_localTimeStep_
Storage of cell-local time-steps for dual time stepping:
Definition: fvcartesiancellcollector.h:438
maia::fv::collector::FvCellCollector::noSpecies
constexpr MInt noSpecies() const
Return number of species.
Definition: fvcartesiancellcollector.h:344

◆ isEEGas()

template<MInt nDim>
constexpr MBool maia::fv::collector::FvCellCollector< nDim >::isEEGas ( ) const
inlineconstexpr

Definition at line 206 of file fvcartesiancellcollector.h.

206{ return m_isEEGas; }

◆ isMultilevel() [1/2]

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::isMultilevel ( ) const
inlineconstexpr

Definition at line 350 of file fvcartesiancellcollector.h.

350{ return m_isMultilevel; }
maia::fv::collector::FvCellCollector::m_isMultilevel
MBool m_isMultilevel
Is multilevel computation activated.
Definition: fvcartesiancellcollector.h:405

◆ isMultilevel() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::isMultilevel ( const MBool  isMultilevel_)

Activate or deactivate multilevel-relevant storage.

Definition at line 1373 of file fvcartesiancellcollector.h.

1373 {
1374 const MInt oldIsMultilevel = m_isMultilevel;
1375 m_isMultilevel = isMultilevel_;
1376 return oldIsMultilevel;
1377}
MInt
int32_t MInt
Definition: maiatypes.h:62

◆ level() [1/2]

template<MInt nDim>
MInt & maia::fv::collector::FvCellCollector< nDim >::level ( const MInt  cellId)

Definition at line 1184 of file fvcartesiancellcollector.h.

1184 {
1185 ENSURE_VALID_ID_ACCESSOR(id);
1186 return m_levels[id];
1187}

◆ level() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::level ( const MInt  cellId) const

Definition at line 1190 of file fvcartesiancellcollector.h.

1190 {
1191 ENSURE_VALID_ID_ACCESSOR(id);
1192 return m_levels[id];
1193}

◆ localTimeStep() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::localTimeStep ( const MInt  id)

Definition at line 1086 of file fvcartesiancellcollector.h.

1086 {
1087#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1088#error Missing implementation for structure-of-arrays memory layout.
1089#endif
1090 ENSURE_VALID_ID_ACCESSOR(id);
1091 return m_localTimeStep_[id];
1092}

◆ localTimeStep() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::localTimeStep ( const MInt  id) const

Definition at line 1076 of file fvcartesiancellcollector.h.

1076 {
1077#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1078#error Missing implementation for structure-of-arrays memory layout.
1079#endif
1080 ENSURE_VALID_ID_ACCESSOR(id);
1081 return m_localTimeStep_[id];
1082}

◆ nghbrInterface() [1/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::nghbrInterface ( const MInt  id,
const MInt  dir 
) const

Definition at line 860 of file fvcartesiancellcollector.h.

860 {
861// Prevent accidental compilation without support for SoA layout
862#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
863#error Missing implementation for structure-of-arrays memory layout.
864#endif
865 ENSURE_VALID_ID_ACCESSOR(id);
866 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dir / 2);
867 return m_nghbrInterface[id].get(dir);
868}

◆ nghbrInterface() [2/2]

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::nghbrInterface ( const MInt  id,
const MInt  dir,
const MInt  state 
)

Definition at line 849 of file fvcartesiancellcollector.h.

849 {
850// Prevent accidental compilation without support for SoA layout
851#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
852#error Missing implementation for structure-of-arrays memory layout.
853#endif
854 ENSURE_VALID_ID_ACCESSOR(id);
855 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dir / 2);
856 m_nghbrInterface[id].set(dir, state);
857}

◆ noAVariables()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noAVariables ( ) const
inlineconstexpr

Definition at line 362 of file fvcartesiancellcollector.h.

362{ return m_noAVariables; }

◆ noCVariables()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noCVariables ( ) const
inlineconstexpr

Definition at line 353 of file fvcartesiancellcollector.h.

353{ return m_noCVariables; }

◆ noFVariables()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noFVariables ( ) const
inlineconstexpr

Definition at line 359 of file fvcartesiancellcollector.h.

359{ return m_noFVariables; }

◆ noImplicitCoefficients()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noImplicitCoefficients ( ) const
inlineconstexpr

Definition at line 371 of file fvcartesiancellcollector.h.

371{ return m_noImplicitCoefficients; }
maia::fv::collector::FvCellCollector::m_noImplicitCoefficients
MInt m_noImplicitCoefficients
Max number of implicit coefficients.
Definition: fvcartesiancellcollector.h:414

◆ noProperties()

template<MInt nDim>
static constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noProperties ( )
inlinestaticconstexpr

Definition at line 374 of file fvcartesiancellcollector.h.

374{ return maia::fv::cell::p(FvCell::NumProperties); }

◆ noPVariables()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noPVariables ( ) const
inlineconstexpr

Definition at line 356 of file fvcartesiancellcollector.h.

356{ return m_noPVariables; }

◆ noRcnstrctnNghbrIds() [1/2]

template<MInt nDim>
MInt & maia::fv::collector::FvCellCollector< nDim >::noRcnstrctnNghbrIds ( const MInt  id)

Definition at line 784 of file fvcartesiancellcollector.h.

784 {
785// Prevent accidental compilation without support for SoA layout
786#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
787#error Missing implementation for structure-of-arrays memory layout.
788#endif
789 ENSURE_VALID_ID_ACCESSOR(id);
790 return m_noRcnstrctnNghbrIds[id];
791}

◆ noRcnstrctnNghbrIds() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::noRcnstrctnNghbrIds ( const MInt  id) const

Definition at line 794 of file fvcartesiancellcollector.h.

794 {
795// Prevent accidental compilation without support for SoA layout
796#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
797#error Missing implementation for structure-of-arrays memory layout.
798#endif
799 ENSURE_VALID_ID_ACCESSOR(id);
800 return m_noRcnstrctnNghbrIds[id];
801}

◆ noReactionRates()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noReactionRates ( ) const
inlineconstexpr

Definition at line 368 of file fvcartesiancellcollector.h.

368{ return m_noReactionRates; }
maia::fv::collector::FvCellCollector::m_noReactionRates
MInt m_noReactionRates
Max number of reaction rates.
Definition: fvcartesiancellcollector.h:411

◆ noRecNghbrs()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noRecNghbrs ( ) const
inlineconstexpr

Definition at line 365 of file fvcartesiancellcollector.h.

365{ return m_noRecNghbrs; }
maia::fv::collector::FvCellCollector::m_noRecNghbrs
MInt m_noRecNghbrs
Max number of reconstruction neighbors.
Definition: fvcartesiancellcollector.h:408

◆ noSpecies()

template<MInt nDim>
constexpr MInt maia::fv::collector::FvCellCollector< nDim >::noSpecies ( ) const
inlineconstexpr

Definition at line 344 of file fvcartesiancellcollector.h.

344{ return m_noSpecies; }

◆ oldVariable() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::oldVariable ( const MInt  id,
const MInt  varId 
)

Definition at line 623 of file fvcartesiancellcollector.h.

623 {
624// Prevent accidental compilation without support for SoA layout
625#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
626#error Missing implementation for structure-of-arrays memory layout.
627#endif
628 ENSURE_VALID_ID_ACCESSOR(id);
629 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
630 return m_oldVariables[id * noCVariables() + varId];
631}

◆ oldVariable() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::oldVariable ( const MInt  id,
const MInt  varId 
) const

Definition at line 634 of file fvcartesiancellcollector.h.

634 {
635// Prevent accidental compilation without support for SoA layout
636#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
637#error Missing implementation for structure-of-arrays memory layout.
638#endif
639 ENSURE_VALID_ID_ACCESSOR(id);
640 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
641 return m_oldVariables[id * noCVariables() + varId];
642}

◆ properties()

template<MInt nDim>
BitsetType & maia::fv::collector::FvCellCollector< nDim >::properties ( const MInt  id)

Definition at line 1243 of file fvcartesiancellcollector.h.

1243 {
1244 ENSURE_VALID_ID_ACCESSOR(id);
1245 return m_properties[id];
1246}

◆ psi() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::psi ( const MInt  id)

Definition at line 918 of file fvcartesiancellcollector.h.

918 {
919// Prevent accidental compilation without support for SoA layout
920#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
921#error Missing implementation for structure-of-arrays memory layout.
922#endif
923 ENSURE_VALID_ID_ACCESSOR(id);
924 return m_psi[id];
925}

◆ psi() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::psi ( const MInt  id) const

Definition at line 928 of file fvcartesiancellcollector.h.

928 {
929// Prevent accidental compilation without support for SoA layout
930#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
931#error Missing implementation for structure-of-arrays memory layout.
932#endif
933 ENSURE_VALID_ID_ACCESSOR(id);
934 return m_psi[id];
935}

◆ pvariable() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::pvariable ( const MInt  id,
const MInt  dim 
)

Definition at line 669 of file fvcartesiancellcollector.h.

669 {
670// Prevent accidental compilation without support for SoA layout
671#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
672#error Missing implementation for structure-of-arrays memory layout.
673#endif
674 ENSURE_VALID_ID_ACCESSOR(id);
675 ENSURE_VALID_PVARIABLE_ID_ACCESSOR(varId);
676 return m_pvariables[id * noPVariables() + varId];
677}

◆ pvariable() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::pvariable ( const MInt  id,
const MInt  dim 
) const

Definition at line 680 of file fvcartesiancellcollector.h.

680 {
681// Prevent accidental compilation without support for SoA layout
682#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
683#error Missing implementation for structure-of-arrays memory layout.
684#endif
685 ENSURE_VALID_ID_ACCESSOR(id);
686 ENSURE_VALID_PVARIABLE_ID_ACCESSOR(varId);
687 return m_pvariables[id * noPVariables() + varId];
688}

◆ rawCopyGeneric()

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

Definition at line 1471 of file fvcartesiancellcollector.h.

1472 {
1473// Prevent accidental compilation without support for SoA layout
1474#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1475#error Missing implementation for structure-of-arrays memory layout.
1476#endif
1477
1478 // oldVariables
1479 copyData(source.m_oldVariables, m_oldVariables, c, begin, end, destination, noCVariables());
1480 // variables
1481 copyData(source.m_variables, m_variables, c, begin, end, destination, noCVariables());
1482 // pvariables
1483 copyData(source.m_pvariables, m_pvariables, c, begin, end, destination, noPVariables());
1484 // right hand side
1485 copyData(source.m_rightHandSide, m_rightHandSide, c, begin, end, destination, noFVariables());
1486 // slopes
1487 copyData(source.m_slopes, m_slopes, c, begin, end, destination, noPVariables() * nDim);
1488 // bndryCellIds
1489 copyData(source.m_bndryCellIds, m_bndryCellIds, c, begin, end, destination);
1490 // noRcnstrctnNghbrIds
1491 copyData(source.m_noRcnstrctnNghbrIds, m_noRcnstrctnNghbrIds, c, begin, end, destination);
1492 // rcnstrctnNghbrId
1493 copyData(source.m_rcnstrctnNghbrIds, m_rcnstrctnNghbrIds, c, begin, end, destination, noRecNghbrs());
1494 // reconstructionData
1495 copyData(source.m_reconstructionData, m_reconstructionData, c, begin, end, destination);
1496 // nghbrInterface
1497 copyData(source.m_nghbrInterface, m_nghbrInterface, c, begin, end, destination);
1498 // reactionRate
1499 if(hasReactionRates())
1500 copyData(source.m_reactionRates, m_reactionRates, c, begin, end, destination, noReactionRates());
1501 if(hasReactionRatesBackup())
1502 copyData(source.m_reactionRatesBackup, m_reactionRatesBackup, c, begin, end, destination, noReactionRates());
1503 // psi
1504 if(hasPsi()) copyData(source.m_psi, m_psi, c, begin, end, destination);
1505 // speciesReactionRate
1506 if(hasReactionRates())
1507 copyData(source.m_speciesReactionRates, m_speciesReactionRates, c, begin, end, destination, noSpecies());
1508 if(hasCellCenterMeanMolarWeight())
1509 copyData(source.m_cellCenterMeanMolarWeight, m_cellCenterMeanMolarWeight, c, begin, end, destination);
1510 if(hasCellCenterGamma()) copyData(source.m_cellCenterGamma, m_cellCenterGamma, c, begin, end, destination);
1511
1512 // implicit coefficient
1513 if(isEEGas())
1514 copyData(source.m_implicitCoefficients, m_implicitCoefficients, c, begin, end, destination,
1515 noImplicitCoefficients());
1516
1517 // additional variables
1518 copyData(source.m_avariables, m_avariables, c, begin, end, destination, noAVariables());
1519
1520 if(hasDualTS()) {
1521 // dt1Variables
1522 copyData(source.m_dt1Variables, m_dt1Variables, c, begin, end, destination, noCVariables());
1523 // dt2Variables
1524 copyData(source.m_dt2Variables, m_dt2Variables, c, begin, end, destination, noCVariables());
1525 copyData(source.m_localTimeStep_, m_localTimeStep_, c, begin, end, destination);
1526 } else if(hasLocalTS()) {
1527 copyData(source.m_localTimeStep_, m_localTimeStep_, c, begin, end, destination);
1528 }
1529
1530 // spongeFactor
1531 copyData(source.m_spongeFactor, m_spongeFactor, c, begin, end, destination);
1532 // spongeFactorStart
1533 copyData(source.m_spongeFactorStart, m_spongeFactorStart, c, begin, end, destination);
1534 // spongeBbndryIds
1535 copyData(source.m_spongeBndryIds, m_spongeBndryIds, c, begin, end, destination, nDim);
1536 // Coordinates
1537 copyData(source.m_coordinates, m_coordinates, c, begin, end, destination, nDim);
1538
1539 // Properties
1540 copyData(source.m_properties, m_properties, c, begin, end, destination);
1541
1542 // Level
1543 copyData(source.m_levels, m_levels, c, begin, end, destination);
1544
1545 // Cell volume
1546 copyData(source.m_cellVolumes, m_cellVolumes, c, begin, end, destination);
1547
1548 // Inverse cell volume
1549 copyData(source.m_FcellVolumes, m_FcellVolumes, c, begin, end, destination);
1550
1551 // Multilevel-related data
1552 if(isMultilevel()) {
1553 // Coarse grid correction
1554 copyData(source.m_tau, m_tau, c, begin, end, destination, noCVariables());
1555 // Restricted RHS
1556 copyData(source.m_restrictedRHS, m_restrictedRHS, c, begin, end, destination, noCVariables());
1557 // Variables after restriction
1558 copyData(source.m_restrictedVars, m_restrictedVars, c, begin, end, destination, noCVariables());
1559 // Temporarly stored slopes
1560 copyData(source.m_storedSlopes, m_storedSlopes, c, begin, end, destination, noPVariables() * nDim);
1561 }
1562}
maia::container::Container< FvCellCollector< nDim >, 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

◆ rcnstrctnNghbrId() [1/2]

template<MInt nDim>
MInt & maia::fv::collector::FvCellCollector< nDim >::rcnstrctnNghbrId ( const MInt  id,
const MInt  dimRecNghbr 
)

Definition at line 805 of file fvcartesiancellcollector.h.

805 {
806// Prevent accidental compilation without support for SoA layout
807#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
808#error Missing implementation for structure-of-arrays memory layout.
809#endif
810 ENSURE_VALID_ID_ACCESSOR(id);
811 ENSURE_VALID_RECNGHBR_ID_ACCESSOR(dimRecNghbr);
812 return m_rcnstrctnNghbrIds[id * noRecNghbrs() + dimRecNghbr];
813}

◆ rcnstrctnNghbrId() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::rcnstrctnNghbrId ( const MInt  id,
const MInt  dimRecNghbr 
) const

Definition at line 816 of file fvcartesiancellcollector.h.

816 {
817// Prevent accidental compilation without support for SoA layout
818#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
819#error Missing implementation for structure-of-arrays memory layout.
820#endif
821 ENSURE_VALID_ID_ACCESSOR(id);
822 ENSURE_VALID_RECNGHBR_ID_ACCESSOR(dimRecNghbr);
823 return m_rcnstrctnNghbrIds[id * noRecNghbrs() + dimRecNghbr];
824}

◆ reactionRate() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::reactionRate ( const MInt  id,
const MInt  dimReaction 
)

Definition at line 872 of file fvcartesiancellcollector.h.

872 {
873// Prevent accidental compilation without support for SoA layout
874#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
875#error Missing implementation for structure-of-arrays memory layout.
876#endif
877 ENSURE_VALID_ID_ACCESSOR(id);
878 ENSURE_VALID_REACTION_ID_ACCESSOR(dimReaction);
879 return m_reactionRates[id * noReactionRates() + dimReaction];
880}

◆ reactionRate() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::reactionRate ( const MInt  id,
const MInt  dimReaction 
) const

Definition at line 883 of file fvcartesiancellcollector.h.

883 {
884// Prevent accidental compilation without support for SoA layout
885#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
886#error Missing implementation for structure-of-arrays memory layout.
887#endif
888 ENSURE_VALID_ID_ACCESSOR(id);
889 ENSURE_VALID_REACTION_ID_ACCESSOR(dimReaction);
890 return m_reactionRates[id * noReactionRates() + dimReaction];
891}

◆ reactionRateBackup() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::reactionRateBackup ( const MInt  id,
const MInt  dimReaction 
)

Definition at line 895 of file fvcartesiancellcollector.h.

895 {
896// Prevent accidental compilation without support for SoA layout
897#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
898#error Missing implementation for structure-of-arrays memory layout.
899#endif
900 ENSURE_VALID_ID_ACCESSOR(id);
901 ENSURE_VALID_REACTION_ID_ACCESSOR(dimReaction);
902 return m_reactionRatesBackup[id * noReactionRates() + dimReaction];
903}

◆ reactionRateBackup() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::reactionRateBackup ( const MInt  id,
const MInt  dimReaction 
) const

Definition at line 906 of file fvcartesiancellcollector.h.

906 {
907// Prevent accidental compilation without support for SoA layout
908#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
909#error Missing implementation for structure-of-arrays memory layout.
910#endif
911 ENSURE_VALID_ID_ACCESSOR(id);
912 ENSURE_VALID_REACTION_ID_ACCESSOR(dimReaction);
913 return m_reactionRatesBackup[id * noReactionRates() + dimReaction];
914}

◆ reconstructionData() [1/2]

template<MInt nDim>
MInt & maia::fv::collector::FvCellCollector< nDim >::reconstructionData ( const MInt  id)

Definition at line 828 of file fvcartesiancellcollector.h.

828 {
829// Prevent accidental compilation without support for SoA layout
830#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
831#error Missing implementation for structure-of-arrays memory layout.
832#endif
833 ENSURE_VALID_ID_ACCESSOR(id);
834 return m_reconstructionData[id];
835}

◆ reconstructionData() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::reconstructionData ( const MInt  id) const

Definition at line 838 of file fvcartesiancellcollector.h.

838 {
839// Prevent accidental compilation without support for SoA layout
840#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
841#error Missing implementation for structure-of-arrays memory layout.
842#endif
843 ENSURE_VALID_ID_ACCESSOR(id);
844 return m_reconstructionData[id];
845}

◆ reset()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::reset
private

Definition at line 458 of file fvcartesiancellcollector.h.

458 {
459 resetStorage(noCVariables(), m_oldVariables);
460 resetStorage(noCVariables(), m_variables);
461 resetStorage(noFVariables(), m_rightHandSide);
462 resetStorage(noPVariables() * nDim, m_slopes);
463 resetStorage(noPVariables(), m_pvariables);
464 resetStorage(1, m_bndryCellIds);
465 resetStorage(1, m_noRcnstrctnNghbrIds);
466 resetStorage(noRecNghbrs(), m_rcnstrctnNghbrIds);
467 resetStorage(1, m_reconstructionData);
468 resetStorage(1, m_nghbrInterface);
469 if(hasReactionRates()) resetStorage(noReactionRates(), m_reactionRates);
470 if(hasReactionRates()) resetStorage(noSpecies(), m_speciesReactionRates);
471 if(hasReactionRatesBackup()) resetStorage(noReactionRates(), m_reactionRatesBackup);
472 if(hasPsi()) resetStorage(1, m_psi);
473 if(hasCellCenterMeanMolarWeight()) resetStorage(1, m_cellCenterMeanMolarWeight);
474 if(hasCellCenterGamma()) resetStorage(1, m_cellCenterGamma);
475 if(isEEGas()) resetStorage(noImplicitCoefficients(), m_implicitCoefficients);
476 resetStorage(noAVariables(), m_avariables);
477 if(hasDualTS()) {
478 resetStorage(noCVariables(), m_dt1Variables);
479 resetStorage(noCVariables(), m_dt2Variables);
480 resetStorage(1, m_localTimeStep_);
481 } else if(hasLocalTS()) {
482 resetStorage(1, m_localTimeStep_);
483 }
484 resetStorage(1, m_spongeFactor);
485 resetStorage(1, m_spongeFactorStart);
486 resetStorage(nDim, m_spongeBndryIds);
487 resetStorage(nDim, m_coordinates);
488 resetStorage(1, m_levels);
489 resetStorage(1, m_properties);
490 resetStorage(1, m_cellVolumes);
491 resetStorage(1, m_FcellVolumes);
492
493 // Initialize multilevel storage only if using more than one grid level
494 if(isMultilevel()) {
495 resetStorage(noCVariables(), m_tau);
496 resetStorage(noCVariables(), m_restrictedRHS);
497 resetStorage(noCVariables(), m_restrictedVars);
498 resetStorage(noCVariables() * nDim, m_storedSlopes);
499 }
500}
maia::container::Container< FvCellCollector< nDim >, Invalid >::resetStorage
void resetStorage(const MInt n, Storage< T > &c)
Create new container with given size and replace original one.
Definition: container.h:420

◆ resetProperties()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::resetProperties ( const MInt  id)

Definition at line 1237 of file fvcartesiancellcollector.h.

1237 {
1238 ENSURE_VALID_ID_ACCESSOR(id);
1239 m_properties[id].reset();
1240}

◆ resize()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::resize
overrideprivatevirtual

Reimplemented from maia::container::Container< FvCellCollector< nDim >, Invalid >.

Definition at line 504 of file fvcartesiancellcollector.h.

504 {
505 resizeStorage(noCVariables(), m_oldVariables);
506 resizeStorage(noCVariables(), m_variables);
507 resizeStorage(noFVariables(), m_rightHandSide);
508 resizeStorage(noPVariables() * nDim, m_slopes);
509 resizeStorage(noPVariables(), m_pvariables);
510 resizeStorage(1, m_bndryCellIds);
511 resizeStorage(1, m_noRcnstrctnNghbrIds);
512 resizeStorage(noRecNghbrs(), m_rcnstrctnNghbrIds);
513 resizeStorage(1, m_reconstructionData);
514 if(hasReactionRates()) resizeStorage(noReactionRates(), m_reactionRates);
515 if(hasReactionRates()) resizeStorage(noSpecies(), m_speciesReactionRates);
516 if(hasReactionRatesBackup()) resizeStorage(noReactionRates(), m_reactionRatesBackup);
517 if(hasPsi()) resizeStorage(1, m_psi);
518 if(hasCellCenterMeanMolarWeight()) resizeStorage(1, m_cellCenterMeanMolarWeight);
519 if(hasCellCenterGamma()) resizeStorage(1, m_cellCenterGamma);
520 if(isEEGas()) resizeStorage(noImplicitCoefficients(), m_implicitCoefficients);
521 resizeStorage(noAVariables(), m_avariables);
522
523 if(hasDualTS()) {
524 resizeStorage(noCVariables(), m_dt1Variables);
525 resizeStorage(noCVariables(), m_dt2Variables);
526 resizeStorage(1, m_localTimeStep_);
527 } else if(hasLocalTS()) {
528 resizeStorage(1, m_localTimeStep_);
529 }
530
531 resizeStorage(1, m_spongeFactor);
532 resizeStorage(1, m_spongeFactorStart);
533 resizeStorage(nDim, m_spongeBndryIds);
534 resizeStorage(nDim, m_coordinates);
535 resizeStorage(1, m_levels);
536 resizeStorage(1, m_properties);
537 resizeStorage(1, m_cellVolumes);
538 resizeStorage(1, m_FcellVolumes);
539
540 // Initialize multilevel storage only if using more than one grid level
541 if(isMultilevel()) {
542 resizeStorage(noCVariables(), m_tau);
543 resizeStorage(noCVariables(), m_restrictedRHS);
544 resizeStorage(noCVariables(), m_restrictedVars);
545 resizeStorage(noCVariables() * nDim, m_storedSlopes);
546 }
547}
maia::container::Container< FvCellCollector< nDim >, Invalid >::resizeStorage
void resizeStorage(const MInt n, Storage< T > &c)
Resize container with given size.
Definition: container.h:436

◆ restrictedRHS() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::restrictedRHS ( const MInt  id,
const MInt  varId 
)

Definition at line 1273 of file fvcartesiancellcollector.h.

1273 {
1274// Prevent accidental compilation without support for SoA layout
1275#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1276#error Missing implementation for structure-of-arrays memory layout.
1277#endif
1278 ENSURE_VALID_ID_ACCESSOR(id);
1279 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1280 return m_restrictedRHS[id * noCVariables() + varId];
1281}

◆ restrictedRHS() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::restrictedRHS ( const MInt  id,
const MInt  varId 
) const

Definition at line 1284 of file fvcartesiancellcollector.h.

1284 {
1285// Prevent accidental compilation without support for SoA layout
1286#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1287#error Missing implementation for structure-of-arrays memory layout.
1288#endif
1289 ENSURE_VALID_ID_ACCESSOR(id);
1290 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1291 return m_restrictedRHS[id * noCVariables() + varId];
1292}

◆ restrictedVar() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::restrictedVar ( const MInt  id,
const MInt  varId 
)

Definition at line 1296 of file fvcartesiancellcollector.h.

1296 {
1297// Prevent accidental compilation without support for SoA layout
1298#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1299#error Missing implementation for structure-of-arrays memory layout.
1300#endif
1301 ENSURE_VALID_ID_ACCESSOR(id);
1302 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1303 return m_restrictedVars[id * noCVariables() + varId];
1304}

◆ restrictedVar() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::restrictedVar ( const MInt  id,
const MInt  varId 
) const

Definition at line 1307 of file fvcartesiancellcollector.h.

1307 {
1308// Prevent accidental compilation without support for SoA layout
1309#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1310#error Missing implementation for structure-of-arrays memory layout.
1311#endif
1312 ENSURE_VALID_ID_ACCESSOR(id);
1313 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1314 return m_restrictedVars[id * noCVariables() + varId];
1315}

◆ rightHandSide() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::rightHandSide ( const MInt  id,
const MInt  varId 
)

Definition at line 715 of file fvcartesiancellcollector.h.

715 {
716// Prevent accidental compilation without support for SoA layout
717#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
718#error Missing implementation for structure-of-arrays memory layout.
719#endif
720 ENSURE_VALID_ID_ACCESSOR(id);
721 ENSURE_VALID_FVARIABLE_ID_ACCESSOR(varId);
722 return m_rightHandSide[id * noFVariables() + varId];
723}

◆ rightHandSide() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::rightHandSide ( const MInt  id,
const MInt  varId 
) const

Definition at line 726 of file fvcartesiancellcollector.h.

726 {
727// Prevent accidental compilation without support for SoA layout
728#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
729#error Missing implementation for structure-of-arrays memory layout.
730#endif
731 ENSURE_VALID_ID_ACCESSOR(id);
732 ENSURE_VALID_FVARIABLE_ID_ACCESSOR(varId);
733 return m_rightHandSide[id * noFVariables() + varId];
734}

◆ setFvCollectorType()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::setFvCollectorType ( const MInt  mode)

Definition at line 552 of file fvcartesiancellcollector.h.

552 {
553 ASSERT(mode >= 0, "");
554 switch(mode) {
555 case 0: {
556 m_hasCellCenterMeanMolarWeight = false;
557 m_hasCellCenterGamma = false;
558 m_hasReactionRates = false;
559 m_hasReactionRatesBackup = false;
560 m_hasPsi = false;
561 m_isEEGas = false;
562 break;
563 }
564 case 1: // detailedChemistry:
565 {
566 m_hasCellCenterMeanMolarWeight = true;
567 m_hasCellCenterGamma = true;
568 m_hasReactionRates = true;
569 m_hasReactionRatesBackup = false;
570 m_hasPsi = false;
571 m_isEEGas = false;
572 break;
573 }
574 case 2: { // combustion without detailedChemisty
575 m_hasCellCenterMeanMolarWeight = false;
576 m_hasCellCenterGamma = false;
577 m_hasReactionRates = true;
578 m_hasReactionRatesBackup = true;
579 m_hasPsi = true;
580 m_isEEGas = false;
581 break;
582 }
583 case 3: { // EEGas
584 m_hasCellCenterMeanMolarWeight = false;
585 m_hasCellCenterGamma = false;
586 m_hasReactionRates = false;
587 m_hasReactionRatesBackup = false;
588 m_hasPsi = false;
589 m_isEEGas = true;
590 break;
591 }
592 default: {
593 mTerm(1, AT_, "Unknown fvCollector Type!");
594 }
595 }
596}
mTerm
void mTerm(const MInt errorCode, const MString &location, const MString &message)
Definition: functions.cpp:29

◆ setFvTimeStepType()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::setFvTimeStepType ( const MInt  mode)

Definition at line 598 of file fvcartesiancellcollector.h.

598 {
599 ASSERT(mode >= 0, "");
600 switch(mode) {
601 case 0: {
602 // default: global single time-step
603 break;
604 }
605 case 1: {
606 // local time-step with standart RK
607 m_hasLocalTS = true;
608 break;
609 }
610 case 2: {
611 // dual time-stepping with local TS
612 m_hasDualTS = true;
613 break;
614 }
615 default: {
616 mTerm(1, AT_, "Unknown fvTimeStepType!");
617 }
618 }
619}

◆ setNoAVariables()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::setNoAVariables ( const MInt  noAVariables_)

Definition at line 1366 of file fvcartesiancellcollector.h.

1366 {
1367 m_noAVariables = noAVariables_;
1368 return;
1369}

◆ setNoCVariables()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::setNoCVariables ( const MInt  noCVariables_,
const MInt  noSpecies_ 
)

Definition at line 1344 of file fvcartesiancellcollector.h.

1344 {
1345 m_noSpecies = noSpecies_;
1346 m_noCVariables = noCVariables_;
1347 return;
1348}

◆ setNoFVariables()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::setNoFVariables ( const MInt  noFVariables_)

Definition at line 1359 of file fvcartesiancellcollector.h.

1359 {
1360 m_noFVariables = noFVariables_;
1361 return;
1362}

◆ setNoPVariables()

template<MInt nDim>
void maia::fv::collector::FvCellCollector< nDim >::setNoPVariables ( const MInt  noPVariables_)

Definition at line 1352 of file fvcartesiancellcollector.h.

1352 {
1353 m_noPVariables = noPVariables_;
1354 return;
1355}

◆ slope() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::slope ( const MInt  id,
const MInt  dimVar,
const MInt  dimDir 
)

Definition at line 738 of file fvcartesiancellcollector.h.

738 {
739// Prevent accidental compilation without support for SoA layout
740#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
741#error Missing implementation for structure-of-arrays memory layout.
742#endif
743 ENSURE_VALID_ID_ACCESSOR(id);
744 ENSURE_VALID_PVARIABLE_ID_ACCESSOR(dimVar);
745 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dimDir);
746 return m_slopes[id * noPVariables() * nDim + dimVar * nDim + dimDir];
747}

◆ slope() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::slope ( const MInt  id,
const MInt  dimVar,
const MInt  dimDir 
) const

Definition at line 750 of file fvcartesiancellcollector.h.

750 {
751// Prevent accidental compilation without support for SoA layout
752#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
753#error Missing implementation for structure-of-arrays memory layout.
754#endif
755 ENSURE_VALID_ID_ACCESSOR(id);
756 ENSURE_VALID_PVARIABLE_ID_ACCESSOR(dimVar);
757 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dimDir);
758 return m_slopes[id * noPVariables() * nDim + dimVar * nDim + dimDir];
759}

◆ speciesReactionRate() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::speciesReactionRate ( const MInt  id,
const MInt  speciesIndex 
)

Definition at line 962 of file fvcartesiancellcollector.h.

962 {
963// Prevent accidental compilation without support for SoA layout
964#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
965#error Missing implementation for structure-of-arrays memory layout.
966#endif
967 ENSURE_VALID_ID_ACCESSOR(id);
968 ENSURE_VALID_REACTION_ID_ACCESSOR(speciesIndex);
969 return m_speciesReactionRates[id * noSpecies() + speciesIndex];
970}

◆ speciesReactionRate() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::speciesReactionRate ( const MInt  id,
const MInt  speciesIndex 
) const

Definition at line 974 of file fvcartesiancellcollector.h.

974 {
975// Prevent accidental compilation without support for SoA layout
976#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
977#error Missing implementation for structure-of-arrays memory layout.
978#endif
979 ENSURE_VALID_ID_ACCESSOR(id);
980 ENSURE_VALID_REACTION_ID_ACCESSOR(speciesIndex);
981 return m_speciesReactionRates[id * noSpecies() + speciesIndex];
982}

◆ spongeBndryId() [1/2]

template<MInt nDim>
MInt & maia::fv::collector::FvCellCollector< nDim >::spongeBndryId ( const MInt  id,
const MInt  dimDir 
)

Definition at line 1138 of file fvcartesiancellcollector.h.

1138 {
1139// Prevent accidental compilation without support for SoA layout
1140#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1141#error Missing implementation for structure-of-arrays memory layout.
1142#endif
1143 ENSURE_VALID_ID_ACCESSOR(id);
1144 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dimDir);
1145 return m_spongeBndryIds[id * nDim + dimDir];
1146}

◆ spongeBndryId() [2/2]

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::spongeBndryId ( const MInt  id,
const MInt  dimDir 
) const

Definition at line 1149 of file fvcartesiancellcollector.h.

1149 {
1150// Prevent accidental compilation without support for SoA layout
1151#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1152#error Missing implementation for structure-of-arrays memory layout.
1153#endif
1154 ENSURE_VALID_ID_ACCESSOR(id);
1155 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dimDir);
1156 return m_spongeBndryIds[id * nDim + dimDir];
1157}

◆ spongeFactor() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::spongeFactor ( const MInt  id)

Definition at line 1096 of file fvcartesiancellcollector.h.

1096 {
1097// Prevent accidental compilation without support for SoA layout
1098#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1099#error Missing implementation for structure-of-arrays memory layout.
1100#endif
1101 ENSURE_VALID_ID_ACCESSOR(id);
1102 return m_spongeFactor[id];
1103}

◆ spongeFactor() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::spongeFactor ( const MInt  id) const

Definition at line 1106 of file fvcartesiancellcollector.h.

1106 {
1107// Prevent accidental compilation without support for SoA layout
1108#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1109#error Missing implementation for structure-of-arrays memory layout.
1110#endif
1111 ENSURE_VALID_ID_ACCESSOR(id);
1112 return m_spongeFactor[id];
1113}

◆ spongeFactorStart() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::spongeFactorStart ( const MInt  id)

Definition at line 1117 of file fvcartesiancellcollector.h.

1117 {
1118// Prevent accidental compilation without support for SoA layout
1119#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1120#error Missing implementation for structure-of-arrays memory layout.
1121#endif
1122 ENSURE_VALID_ID_ACCESSOR(id);
1123 return m_spongeFactorStart[id];
1124}

◆ spongeFactorStart() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::spongeFactorStart ( const MInt  id) const

Definition at line 1127 of file fvcartesiancellcollector.h.

1127 {
1128// Prevent accidental compilation without support for SoA layout
1129#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1130#error Missing implementation for structure-of-arrays memory layout.
1131#endif
1132 ENSURE_VALID_ID_ACCESSOR(id);
1133 return m_spongeFactorStart[id];
1134}

◆ storedSlope() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::storedSlope ( const MInt  id,
const MInt  dimVar,
const MInt  dimDir 
)

Definition at line 1319 of file fvcartesiancellcollector.h.

1319 {
1320// Prevent accidental compilation without support for SoA layout
1321#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1322#error Missing implementation for structure-of-arrays memory layout.
1323#endif
1324 ENSURE_VALID_ID_ACCESSOR(id);
1325 ENSURE_VALID_PVARIABLE_ID_ACCESSOR(dimVar);
1326 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dimDir);
1327 return m_storedSlopes[id * noPVariables() * nDim + dimVar * nDim + dimDir];
1328}

◆ storedSlope() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::storedSlope ( const MInt  id,
const MInt  dimVar,
const MInt  dimDir 
) const

Definition at line 1331 of file fvcartesiancellcollector.h.

1331 {
1332// Prevent accidental compilation without support for SoA layout
1333#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1334#error Missing implementation for structure-of-arrays memory layout.
1335#endif
1336 ENSURE_VALID_ID_ACCESSOR(id);
1337 ENSURE_VALID_PVARIABLE_ID_ACCESSOR(dimVar);
1338 ENSURE_VALID_DIRECTION_ID_ACCESSOR(dimDir);
1339 return m_storedSlopes[id * noPVariables() * nDim + dimVar * nDim + dimDir];
1340}

◆ tau() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::tau ( const MInt  id,
const MInt  varId 
)

Definition at line 1250 of file fvcartesiancellcollector.h.

1250 {
1251// Prevent accidental compilation without support for SoA layout
1252#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1253#error Missing implementation for structure-of-arrays memory layout.
1254#endif
1255 ENSURE_VALID_ID_ACCESSOR(id);
1256 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1257 return m_tau[id * noCVariables() + varId];
1258}

◆ tau() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::tau ( const MInt  id,
const MInt  varId 
) const

Definition at line 1261 of file fvcartesiancellcollector.h.

1261 {
1262// Prevent accidental compilation without support for SoA layout
1263#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
1264#error Missing implementation for structure-of-arrays memory layout.
1265#endif
1266 ENSURE_VALID_ID_ACCESSOR(id);
1267 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
1268 return m_tau[id * noCVariables() + varId];
1269}

◆ variable() [1/2]

template<MInt nDim>
MFloat & maia::fv::collector::FvCellCollector< nDim >::variable ( const MInt  id,
const MInt  dim 
)

Definition at line 646 of file fvcartesiancellcollector.h.

646 {
647// Prevent accidental compilation without support for SoA layout
648#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
649#error Missing implementation for structure-of-arrays memory layout.
650#endif
651 ENSURE_VALID_ID_ACCESSOR(id);
652 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
653 return m_variables[id * noCVariables() + varId];
654}

◆ variable() [2/2]

template<MInt nDim>
MFloat maia::fv::collector::FvCellCollector< nDim >::variable ( const MInt  id,
const MInt  dim 
) const

Definition at line 657 of file fvcartesiancellcollector.h.

657 {
658// Prevent accidental compilation without support for SoA layout
659#ifdef FVCELLCOLLECTOR_SOA_MEMORY_LAYOUT
660#error Missing implementation for structure-of-arrays memory layout.
661#endif
662 ENSURE_VALID_ID_ACCESSOR(id);
663 ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
664 return m_variables[id * noCVariables() + varId];
665}

Friends And Related Function Documentation

◆ maia::container::Container< FvCellCollector< nDim >, Invalid >

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

Definition at line 178 of file fvcartesiancellcollector.h.

Member Data Documentation

◆ m_avariables

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_avariables {}
private

Definition at line 419 of file fvcartesiancellcollector.h.

◆ m_bndryCellIds

template<MInt nDim>
Storage<MInt> maia::fv::collector::FvCellCollector< nDim >::m_bndryCellIds {}
private

Definition at line 423 of file fvcartesiancellcollector.h.

◆ m_cellCenterGamma

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_cellCenterGamma {}
private

Definition at line 434 of file fvcartesiancellcollector.h.

◆ m_cellCenterMeanMolarWeight

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_cellCenterMeanMolarWeight {}
private

Definition at line 433 of file fvcartesiancellcollector.h.

◆ m_cellVolumes

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_cellVolumes {}
private

Definition at line 445 of file fvcartesiancellcollector.h.

◆ m_coordinates

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_coordinates {}
private

Definition at line 442 of file fvcartesiancellcollector.h.

◆ m_dt1Variables

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_dt1Variables {}
private

Definition at line 435 of file fvcartesiancellcollector.h.

◆ m_dt2Variables

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_dt2Variables {}
private

Definition at line 436 of file fvcartesiancellcollector.h.

◆ m_FcellVolumes

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_FcellVolumes {}
private

Definition at line 446 of file fvcartesiancellcollector.h.

◆ m_hasCellCenterGamma

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasCellCenterGamma = false
private

Definition at line 383 of file fvcartesiancellcollector.h.

◆ m_hasCellCenterMeanMolarWeight

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasCellCenterMeanMolarWeight = false
private

Definition at line 378 of file fvcartesiancellcollector.h.

◆ m_hasDualTS

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasDualTS = false
private

Definition at line 385 of file fvcartesiancellcollector.h.

◆ m_hasLocalTS

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasLocalTS = false
private

Definition at line 384 of file fvcartesiancellcollector.h.

◆ m_hasPsi

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasPsi = false
private

Definition at line 381 of file fvcartesiancellcollector.h.

◆ m_hasReactionRates

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasReactionRates = false
private

Definition at line 379 of file fvcartesiancellcollector.h.

◆ m_hasReactionRatesBackup

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_hasReactionRatesBackup = false
private

Definition at line 380 of file fvcartesiancellcollector.h.

◆ m_implicitCoefficients

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_implicitCoefficients {}
private

Definition at line 431 of file fvcartesiancellcollector.h.

◆ m_isEEGas

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_isEEGas = false
private

Definition at line 382 of file fvcartesiancellcollector.h.

◆ m_isMultilevel

template<MInt nDim>
MBool maia::fv::collector::FvCellCollector< nDim >::m_isMultilevel = false
private

Definition at line 405 of file fvcartesiancellcollector.h.

◆ m_levels

template<MInt nDim>
Storage<MInt> maia::fv::collector::FvCellCollector< nDim >::m_levels {}
private

Definition at line 443 of file fvcartesiancellcollector.h.

◆ m_localTimeStep_

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_localTimeStep_ {}
private

Definition at line 438 of file fvcartesiancellcollector.h.

◆ m_nghbrInterface

template<MInt nDim>
Storage<M16X2bit<false> > maia::fv::collector::FvCellCollector< nDim >::m_nghbrInterface {}
private

Definition at line 427 of file fvcartesiancellcollector.h.

◆ m_noAVariables

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noAVariables = 0
private

Definition at line 399 of file fvcartesiancellcollector.h.

◆ m_noCVariables

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noCVariables = 2 + nDim
private

Definition at line 396 of file fvcartesiancellcollector.h.

◆ m_noFVariables

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noFVariables = 2 + nDim
private

Definition at line 398 of file fvcartesiancellcollector.h.

◆ m_noImplicitCoefficients

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noImplicitCoefficients = 2 * nDim
private

Definition at line 414 of file fvcartesiancellcollector.h.

◆ m_noPVariables

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noPVariables = 2 + nDim
private

Definition at line 397 of file fvcartesiancellcollector.h.

◆ m_noRcnstrctnNghbrIds

template<MInt nDim>
Storage<MInt> maia::fv::collector::FvCellCollector< nDim >::m_noRcnstrctnNghbrIds {}
private

Definition at line 424 of file fvcartesiancellcollector.h.

◆ m_noReactionRates

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noReactionRates = 1
private

Definition at line 411 of file fvcartesiancellcollector.h.

◆ m_noRecNghbrs

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noRecNghbrs = IPOW3[nDim] + nDim
private

Definition at line 408 of file fvcartesiancellcollector.h.

◆ m_noSpecies

template<MInt nDim>
MInt maia::fv::collector::FvCellCollector< nDim >::m_noSpecies = 0
private

Definition at line 402 of file fvcartesiancellcollector.h.

◆ m_oldVariables

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_oldVariables {}
private

Definition at line 417 of file fvcartesiancellcollector.h.

◆ m_properties

template<MInt nDim>
Storage<BitsetType> maia::fv::collector::FvCellCollector< nDim >::m_properties {}
private

Definition at line 444 of file fvcartesiancellcollector.h.

◆ m_psi

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_psi {}
private

Definition at line 430 of file fvcartesiancellcollector.h.

◆ m_pvariables

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_pvariables {}
private

Definition at line 422 of file fvcartesiancellcollector.h.

◆ m_rcnstrctnNghbrIds

template<MInt nDim>
Storage<MInt> maia::fv::collector::FvCellCollector< nDim >::m_rcnstrctnNghbrIds {}
private

Definition at line 425 of file fvcartesiancellcollector.h.

◆ m_reactionRates

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_reactionRates {}
private

Definition at line 428 of file fvcartesiancellcollector.h.

◆ m_reactionRatesBackup

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_reactionRatesBackup {}
private

Definition at line 429 of file fvcartesiancellcollector.h.

◆ m_reconstructionData

template<MInt nDim>
Storage<MInt> maia::fv::collector::FvCellCollector< nDim >::m_reconstructionData {}
private

Definition at line 426 of file fvcartesiancellcollector.h.

◆ m_restrictedRHS

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_restrictedRHS {}
private

Definition at line 450 of file fvcartesiancellcollector.h.

◆ m_restrictedVars

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_restrictedVars {}
private

Definition at line 451 of file fvcartesiancellcollector.h.

◆ m_rightHandSide

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_rightHandSide {}
private

Definition at line 420 of file fvcartesiancellcollector.h.

◆ m_slopes

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_slopes {}
private

Definition at line 421 of file fvcartesiancellcollector.h.

◆ m_speciesReactionRates

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_speciesReactionRates {}
private

Definition at line 432 of file fvcartesiancellcollector.h.

◆ m_spongeBndryIds

template<MInt nDim>
Storage<MInt> maia::fv::collector::FvCellCollector< nDim >::m_spongeBndryIds {}
private

Definition at line 441 of file fvcartesiancellcollector.h.

◆ m_spongeFactor

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_spongeFactor {}
private

Definition at line 439 of file fvcartesiancellcollector.h.

◆ m_spongeFactorStart

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_spongeFactorStart {}
private

Definition at line 440 of file fvcartesiancellcollector.h.

◆ m_storedSlopes

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_storedSlopes {}
private

Definition at line 452 of file fvcartesiancellcollector.h.

◆ m_tau

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_tau {}
private

Definition at line 449 of file fvcartesiancellcollector.h.

◆ m_variables

template<MInt nDim>
Storage<MFloat> maia::fv::collector::FvCellCollector< nDim >::m_variables {}
private

Definition at line 418 of file fvcartesiancellcollector.h.

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