Class that represents FV surface collector. More...

#include <fvcartesiansurfacecollector.h>

Inheritance diagram for maia::fv::surface_collector::FvSurfaceCollector< nDim >:

Collaboration diagram for maia::fv::surface_collector::FvSurfaceCollector< nDim >:

Public Types
template<class T >
using	Invalid = typename maia::fv::surface_collector::Invalid< T >

Public Member Functions
constexpr	FvSurfaceCollector ()=default
	Default c'tor does nothing. More...

void	checkVariables ()
	Print data size variables. More...

MInt &	bndryCndId (const MInt id)
	Accessor for bndryCndId. More...

MInt	bndryCndId (const MInt id) const
	Accessor for bndryCndId (const version). More...

MInt &	orientation (const MInt id)
	Accessor for orientation. More...

MInt	orientation (const MInt id) const
	Accessor for orientation (const version). More...

MFloat &	factor (const MInt id, const MInt varId)
	Accessor for factor. More...

MFloat	factor (const MInt id, const MInt varId) const
	Accessor for factor (const version). More...

MFloat &	area (const MInt id)
	Accessor for area. More...

MFloat	area (const MInt id) const
	Accessor for area (const version). More...

MFloat &	coordinate (const MInt id, const MInt dir)
	Accessor for coordinate. More...

MFloat	coordinate (const MInt id, const MInt dir) const
	Accessor for coordinate (const version). More...

MFloat &	deltaX (const MInt id, const MInt varId)
	Accessor for deltaX. More...

MFloat	deltaX (const MInt id, const MInt varId) const
	Accessor for deltaX (const version). More...

MInt &	nghbrCellId (const MInt id, const MInt dir)
	Accessor for nghbrCellId. More...

MInt	nghbrCellId (const MInt id, const MInt dir) const
	Accessor for nghbrCellId (const version). More...

MFloat &	variable (const MInt id, const MInt dir, const MInt varId)
	Accessor for variable. More...

MFloat	variable (const MInt id, const MInt dir, const MInt varId) const
	Accessor for variable (const version). More...

MFloat &	upwindCoefficient (const MInt id)
	Accessor for upwind coefficient. More...

MFloat	upwindCoefficient (const MInt id) const
	Accessor for upwind coefficient (const version). More...

MFloat &	surfaceCoefficient (const MInt id, const MInt dimCoefficient)
	Accessor for surfaceCoefficient. More...

MFloat	surfaceCoefficient (const MInt id, const MInt dimCoefficient) const
	Accessor for surfaceCoefficient (const version). More...

MFloat &	flux (const MInt id, const MInt fVarId)
	Accessor for flux. More...

MFloat	flux (const MInt id, const MInt fVarId) const
	Accessor for flux (const version). More...

void	setNoSpecies (const MInt noSpecies_)
	Set number of species and update number of variables. More...

void	setNoMaxSrfcs (const MInt noMaxSrfcs_)
	Set number of maximum surfaces and update number of variables. More...

void	setNoVariables (const MInt noVariables_)
	Set number of variables and update number of variables. More...

void	setNoFVariables (const MInt noFVariables_)
	Set number of flux variables. More...

void	setNoSurfaceCoefficients (const MInt noSurfaceCoefficients_)
	Set number of surface coefficients and update number of surface coefficients. More...

void	setSolverType (const MInt solverType)
	Set solver type. More...

constexpr MInt	noSpecies () const
	Return number of species. More...

constexpr MInt	noMaxSrfcs () const
	Return number of maximum surfaces. More...

constexpr MInt	noVariables () const
	Return number of variables. More...

constexpr MInt	noFVariables () const
	Return number of flux variables. More...

constexpr MInt	noSurfaceCoefficients () const
	Return number of surface coefficients. More...

constexpr SolverType	solverType () const
	Return solver type. More...

Public Member Functions inherited from maia::container::Container< FvSurfaceCollector< 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...

FvSurfaceCollector< nDim > &	derived ()

const FvSurfaceCollector< 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

Private Types
using	Base = maia::container::Container< FvSurfaceCollector< nDim >, Invalid >

template<class T >
using	Storage = typename Base::template Storage< T >

Private Member Functions
void	reset ()
	Reset tree, re-create data structures with given capacity, and set size to zero. More...

void	resize () override
	Reset tree, re-create data structures with given capacity, and set size to zero. 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_noSpecies = -1
	Number of species (not being used) More...

MInt	m_noMaxSrfcs = -1

MInt	m_noVariables = -1

MInt	m_noFVariables = -1

MInt	m_noSurfaceCoefficients = -1

MInt	m_solverType = -1

Storage< MInt >	m_bndryCndId {}

Storage< MInt >	m_orientation {}

Storage< MFloat >	m_factor {}

Storage< MFloat >	m_area {}

Storage< MFloat >	m_coordinates {}

Storage< MFloat >	m_deltaX {}

Storage< MInt >	m_nghbrCellIds {}

Storage< MFloat >	m_variables {}

Storage< MFloat >	m_upwindCoefficent {}

Storage< MFloat >	m_flux {}

Storage< MFloat >	m_surfaceCoefficients {}

Friends
class	maia::container::Container< FvSurfaceCollector< nDim >, Invalid >

Additional Inherited Members
Protected Types inherited from maia::container::Container< FvSurfaceCollector< nDim >, Invalid >
using	Storage = std::vector< T >

Protected Member Functions inherited from maia::container::Container< FvSurfaceCollector< 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::surface_collector::FvSurfaceCollector< nDim >

Definition at line 122 of file fvcartesiansurfacecollector.h.

Member Typedef Documentation

◆ Base

template<MInt nDim>

using maia::fv::surface_collector::FvSurfaceCollector< nDim >::Base = maia::container::Container<FvSurfaceCollector<nDim>, Invalid>

private

Definition at line 127 of file fvcartesiansurfacecollector.h.

◆ Invalid

template<MInt nDim>

template<class T >

using maia::fv::surface_collector::FvSurfaceCollector< nDim >::Invalid = typename maia::fv::surface_collector::Invalid<T>

Definition at line 137 of file fvcartesiansurfacecollector.h.

◆ Storage

template<MInt nDim>

template<class T >

using maia::fv::surface_collector::FvSurfaceCollector< nDim >::Storage = typename Base::template Storage<T>

private

Definition at line 131 of file fvcartesiansurfacecollector.h.

Constructor & Destructor Documentation

◆ FvSurfaceCollector()

template<MInt nDim>

constexpr maia::fv::surface_collector::FvSurfaceCollector< nDim >::FvSurfaceCollector ( )

constexprdefault

Member Function Documentation

◆ area() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::area ( const MInt id )

Definition at line 367 of file fvcartesiansurfacecollector.h.

                                                    {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_area[id];
}

◆ area() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::area ( const MInt id ) const

Definition at line 377 of file fvcartesiansurfacecollector.h.

                                                         {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_area[id];
}

◆ bndryCndId() [1/2]

template<MInt nDim>

MInt & FvSurfaceCollector< nDim >::bndryCndId ( const MInt id )

Definition at line 302 of file fvcartesiansurfacecollector.h.

                                                        {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_bndryCndId[id];
}

◆ bndryCndId() [2/2]

template<MInt nDim>

MInt FvSurfaceCollector< nDim >::bndryCndId ( const MInt id ) const

Definition at line 312 of file fvcartesiansurfacecollector.h.

                                                             {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_bndryCndId[id];
}

◆ checkVariables()

template<MInt nDim>

void FvSurfaceCollector< nDim >::checkVariables

Definition at line 254 of file fvcartesiansurfacecollector.h.

                                              {
  std::cerr << "@FvSurfaceCollector: noVariables() = " << noVariables() << ", noFVariables() = " << noFVariables()
            << ", noSurfaceCoefficients() = " << noSurfaceCoefficients() << ", m_noMaxSrfcs = " << noMaxSrfcs()
            << std::endl;
}

◆ coordinate() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::coordinate	(	const MInt	id,
		const MInt	dir
	)

Definition at line 388 of file fvcartesiansurfacecollector.h.

                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_COORDINATE_DIR_ACCESSOR(dir);
  return m_coordinates[id * nDim + dir];
}

◆ coordinate() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::coordinate	(	const MInt	id,
		const MInt	dir
	)		const

Definition at line 399 of file fvcartesiansurfacecollector.h.

                                                                               {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_COORDINATE_DIR_ACCESSOR(dir);
  return m_coordinates[id * nDim + dir];
}

◆ deltaX() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::deltaX	(	const MInt	id,
		const MInt	varId
	)

Definition at line 411 of file fvcartesiansurfacecollector.h.

                                                                        {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
  return m_deltaX[id * 2 * nDim + varId];
}

◆ deltaX() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::deltaX	(	const MInt	id,
		const MInt	varId
	)		const

Definition at line 422 of file fvcartesiansurfacecollector.h.

                                                                             {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
  return m_deltaX[id * 2 * nDim + varId];
}

◆ factor() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::factor	(	const MInt	id,
		const MInt	varId
	)

Definition at line 344 of file fvcartesiansurfacecollector.h.

                                                                        {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
  return m_factor[id * 2 + varId];
}

◆ factor() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::factor	(	const MInt	id,
		const MInt	varId
	)		const

Definition at line 355 of file fvcartesiansurfacecollector.h.

                                                                             {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
  return m_factor[id * 2 + varId];
}

◆ flux() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::flux	(	const MInt	id,
		const MInt	fVarId
	)

Definition at line 526 of file fvcartesiansurfacecollector.h.

                                                                       {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_FLUX_VARIABLE_ID_ACCESSOR(varId);
  return m_flux[id * noFVariables() + fVarId];
}

◆ flux() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::flux	(	const MInt	id,
		const MInt	fVarId
	)		const

Definition at line 537 of file fvcartesiansurfacecollector.h.

                                                                            {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_FLUX_VARIABLE_ID_ACCESSOR(varId);
  return m_flux[id * noFVariables() + fVarId];
}

◆ invalidate()

template<MInt nDim>

void FvSurfaceCollector< nDim >::invalidate	(	const MInt	begin,
		const MInt	end
	)

private

Definition at line 584 of file fvcartesiansurfacecollector.h.

                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
 
  // bndryCndId
  fill_invalid(m_bndryCndId, begin, end, 1, -1);
  // orientation
  fill_invalid(m_orientation, begin, end, 1, -1);
  // factors
  fill_invalid(m_factor, begin, end, 2);
  // area
  fill_invalid(m_area, begin, end);
  // coordinates
  fill_invalid(m_coordinates, begin, end, nDim);
  // deltaX
  fill_invalid(m_deltaX, begin, end, 2 * nDim);
  // nghbrCellIds
  fill_invalid(m_nghbrCellIds, begin, end, 2, -1);
  // variables
  fill_invalid(m_variables, begin, end, 2 * noVariables());
  // upwindCoefficient
  fill_invalid(m_upwindCoefficent, begin, end);
  // surfaceCoefficients
  fill_invalid(m_surfaceCoefficients, begin, end, noSurfaceCoefficients());
  // flux
  fill_invalid(m_flux, begin, end, noFVariables());
}

◆ nghbrCellId() [1/2]

template<MInt nDim>

MInt & FvSurfaceCollector< nDim >::nghbrCellId	(	const MInt	id,
		const MInt	dir
	)

Definition at line 434 of file fvcartesiansurfacecollector.h.

                                                                         {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_COORDINATE_DIR_ACCESSOR(dir);
  return m_nghbrCellIds[id * 2 + dir];
}

◆ nghbrCellId() [2/2]

template<MInt nDim>

MInt FvSurfaceCollector< nDim >::nghbrCellId	(	const MInt	id,
		const MInt	dir
	)		const

Definition at line 445 of file fvcartesiansurfacecollector.h.

                                                                              {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_COORDINATE_DIR_ACCESSOR(dir);
  return m_nghbrCellIds[id * 2 + dir];
}

◆ noFVariables()

template<MInt nDim>

constexpr MInt maia::fv::surface_collector::FvSurfaceCollector< nDim >::noFVariables ( ) const

inlineconstexpr

Definition at line 202 of file fvcartesiansurfacecollector.h.

202{ return m_noFVariables; }

maia::fv::surface_collector::FvSurfaceCollector::m_noFVariables

MInt m_noFVariables

Definition: fvcartesiansurfacecollector.h:229

◆ noMaxSrfcs()

template<MInt nDim>

constexpr MInt maia::fv::surface_collector::FvSurfaceCollector< nDim >::noMaxSrfcs ( ) const

inlineconstexpr

Definition at line 196 of file fvcartesiansurfacecollector.h.

196{ return m_noMaxSrfcs; }

maia::fv::surface_collector::FvSurfaceCollector::m_noMaxSrfcs

MInt m_noMaxSrfcs

Definition: fvcartesiansurfacecollector.h:223

◆ noSpecies()

template<MInt nDim>

constexpr MInt maia::fv::surface_collector::FvSurfaceCollector< nDim >::noSpecies ( ) const

inlineconstexpr

Definition at line 193 of file fvcartesiansurfacecollector.h.

193{ return m_noSpecies; }

maia::fv::surface_collector::FvSurfaceCollector::m_noSpecies

MInt m_noSpecies

Number of species (not being used)

Definition: fvcartesiansurfacecollector.h:220

◆ noSurfaceCoefficients()

template<MInt nDim>

constexpr MInt maia::fv::surface_collector::FvSurfaceCollector< nDim >::noSurfaceCoefficients ( ) const

inlineconstexpr

Definition at line 205 of file fvcartesiansurfacecollector.h.

205{ return m_noSurfaceCoefficients; }

maia::fv::surface_collector::FvSurfaceCollector::m_noSurfaceCoefficients

MInt m_noSurfaceCoefficients

Definition: fvcartesiansurfacecollector.h:232

◆ noVariables()

template<MInt nDim>

constexpr MInt maia::fv::surface_collector::FvSurfaceCollector< nDim >::noVariables ( ) const

inlineconstexpr

Definition at line 199 of file fvcartesiansurfacecollector.h.

199{ return m_noVariables; }

maia::fv::surface_collector::FvSurfaceCollector::m_noVariables

MInt m_noVariables

Definition: fvcartesiansurfacecollector.h:226

◆ orientation() [1/2]

template<MInt nDim>

MInt & FvSurfaceCollector< nDim >::orientation ( const MInt id )

Definition at line 323 of file fvcartesiansurfacecollector.h.

                                                         {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_orientation[id];
}

◆ orientation() [2/2]

template<MInt nDim>

MInt FvSurfaceCollector< nDim >::orientation ( const MInt id ) const

Definition at line 333 of file fvcartesiansurfacecollector.h.

                                                              {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_orientation[id];
}

◆ rawCopyGeneric()

template<MInt nDim>

template<class Functor , class T >

void FvSurfaceCollector< nDim >::rawCopyGeneric	(	Functor &&	c,
		const T &	source,
		const MInt	begin,
		const MInt	end,
		const MInt	destination
	)

private

Definition at line 617 of file fvcartesiansurfacecollector.h.

                                                                      {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
 
  // bndryCndId
  copyData(source.m_bndryCndId, m_bndryCndId, c, begin, end, destination);
  // orientation
  copyData(source.m_orientation, m_orientation, c, begin, end, destination);
  // factors
  copyData(source.m_factor, m_factor, c, begin, end, destination, 2);
  // area
  copyData(source.m_area, m_area, c, begin, end, destination);
  // coordinates
  copyData(source.m_coordinates, m_coordinates, c, begin, end, destination, nDim);
  // deltaX
  copyData(source.m_deltaX, m_deltaX, c, begin, end, destination, 2 * nDim);
  // nghbrCellIds
  copyData(source.m_nghbrCellIds, m_nghbrCellIds, c, begin, end, destination, 2);
  // variables
  copyData(source.m_variables, m_variables, c, begin, end, destination, 2 * noVariables());
  // upwindCoefficient
  copyData(source.m_upwindCoefficent, m_upwindCoefficent, c, begin, end, destination);
  // surfaceCoefficients
  copyData(source.m_surfaceCoefficients, m_surfaceCoefficients, c, begin, end, destination, noSurfaceCoefficients());
  // flux
  copyData(source.m_flux, m_flux, c, begin, end, destination, noFVariables());
}

◆ reset()

template<MInt nDim>

void FvSurfaceCollector< nDim >::reset

private

Definition at line 263 of file fvcartesiansurfacecollector.h.

                                     {
  resetStorage(1, m_bndryCndId);
  resetStorage(1, m_orientation);
  resetStorage(2, m_factor);
  resetStorage(1, m_area);
  resetStorage(nDim, m_coordinates);
  resetStorage(2 * nDim, m_deltaX);
  resetStorage(2, m_nghbrCellIds);
  resetStorage(2 * noVariables(), m_variables);
  resetStorage(1, m_upwindCoefficent);
  resetStorage(noSurfaceCoefficients(), m_surfaceCoefficients);
  resetStorage(noFVariables(), m_flux);
}

◆ resize()

template<MInt nDim>

void FvSurfaceCollector< nDim >::resize

overrideprivatevirtual

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

Definition at line 280 of file fvcartesiansurfacecollector.h.

                                      {
  resizeStorage(1, m_bndryCndId);
  resizeStorage(1, m_orientation);
  resizeStorage(2, m_factor);
  resizeStorage(1, m_area);
  resizeStorage(nDim, m_coordinates);
  resizeStorage(2 * nDim, m_deltaX);
  resizeStorage(2, m_nghbrCellIds);
  resizeStorage(2 * noVariables(), m_variables);
  resizeStorage(1, m_upwindCoefficent);
  resizeStorage(noSurfaceCoefficients(), m_surfaceCoefficients);
  resizeStorage(noFVariables(), m_flux);
}

◆ setNoFVariables()

template<MInt nDim>

void FvSurfaceCollector< nDim >::setNoFVariables ( const MInt noFVariables_ )

Definition at line 566 of file fvcartesiansurfacecollector.h.

                                                                       {
  m_noFVariables = noFVariables_;
}

◆ setNoMaxSrfcs()

template<MInt nDim>

void FvSurfaceCollector< nDim >::setNoMaxSrfcs ( const MInt noMaxSrfcs_ )

Definition at line 554 of file fvcartesiansurfacecollector.h.

                                                                   {
  m_noMaxSrfcs = noMaxSrfcs_;
}

◆ setNoSpecies()

template<MInt nDim>

void FvSurfaceCollector< nDim >::setNoSpecies ( const MInt noSpecies_ )

Definition at line 548 of file fvcartesiansurfacecollector.h.

                                                                 {
  m_noSpecies = noSpecies_;
}

◆ setNoSurfaceCoefficients()

template<MInt nDim>

void FvSurfaceCollector< nDim >::setNoSurfaceCoefficients ( const MInt noSurfaceCoefficients_ )

Definition at line 572 of file fvcartesiansurfacecollector.h.

                                                                                         {
  m_noSurfaceCoefficients = noSurfaceCoefficients_;
}

◆ setNoVariables()

template<MInt nDim>

void FvSurfaceCollector< nDim >::setNoVariables ( const MInt noVariables_ )

Definition at line 560 of file fvcartesiansurfacecollector.h.

                                                                     {
  m_noVariables = noVariables_;
}

◆ setSolverType()

template<MInt nDim>

void FvSurfaceCollector< nDim >::setSolverType ( const MInt solverType )

Definition at line 578 of file fvcartesiansurfacecollector.h.

                                                                  {
  m_solverType = solverType;
}

◆ solverType()

template<MInt nDim>

constexpr SolverType maia::fv::surface_collector::FvSurfaceCollector< nDim >::solverType ( ) const

inlineconstexpr

Definition at line 208 of file fvcartesiansurfacecollector.h.

208{ return (SolverType)m_solverType; }

SolverType

Definition: enums.h:22

◆ surfaceCoefficient() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::surfaceCoefficient	(	const MInt	id,
		const MInt	dimCoefficient
	)

Definition at line 503 of file fvcartesiansurfacecollector.h.

                                                                                             {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_SURFACE_COEFFICIENT_ID_ACCESSOR(dimCoefficient);
  return m_surfaceCoefficients[id * noSurfaceCoefficients() + dimCoefficient];
}

◆ surfaceCoefficient() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::surfaceCoefficient	(	const MInt	id,
		const MInt	dimCoefficient
	)		const

Definition at line 514 of file fvcartesiansurfacecollector.h.

                                                                                                  {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_SURFACE_COEFFICIENT_ID_ACCESSOR(dimCoefficient);
  return m_surfaceCoefficients[id * noSurfaceCoefficients() + dimCoefficient];
}

◆ upwindCoefficient() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::upwindCoefficient ( const MInt id )

Definition at line 482 of file fvcartesiansurfacecollector.h.

                                                                 {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_upwindCoefficent[id];
}

◆ upwindCoefficient() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::upwindCoefficient ( const MInt id ) const

Definition at line 492 of file fvcartesiansurfacecollector.h.

                                                                      {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  return m_upwindCoefficent[id];
}

◆ variable() [1/2]

template<MInt nDim>

MFloat & FvSurfaceCollector< nDim >::variable	(	const MInt	id,
		const MInt	dir,
		const MInt	varId
	)

Definition at line 457 of file fvcartesiansurfacecollector.h.

                                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_DIR_ACCESSOR(dir);
  ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
  return m_variables[(id * 2 + dir) * noVariables() + varId];
}

◆ variable() [2/2]

template<MInt nDim>

MFloat FvSurfaceCollector< nDim >::variable	(	const MInt	id,
		const MInt	dir,
		const MInt	varId
	)		const

Definition at line 469 of file fvcartesiansurfacecollector.h.

                                                                                               {
// Prevent accidental compilation without support for SoA layout
#ifdef FVSURFACECOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID_ACCESSOR(id);
  ENSURE_VALID_DIR_ACCESSOR(dir);
  ENSURE_VALID_VARIABLE_ID_ACCESSOR(varId);
  return m_variables[(id * 2 + dir) * noVariables() + varId];
}