maia::rb::collector::RigidBodyCollector< nDim > Class Template Reference

Class that represents DG element collector. More...

#include <rigidbodiescollector.h>

Inheritance diagram for maia::rb::collector::RigidBodyCollector< nDim >:

Collaboration diagram for maia::rb::collector::RigidBodyCollector< nDim >:

Public Types
template<class T >
using	Invalid = typename maia::rb::collector::Invalid< T >

Public Member Functions
constexpr	RigidBodyCollector ()=default
	Default c'tor does nothing. More...
MFloat &	bodyCenter (const MInt id, const MInt dim)
	Accessor for the current body center. More...
MFloat	bodyCenter (const MInt id, const MInt dim) const
	Accessor for the current body center (const) More...
MFloat &	bodyVelocity (const MInt id, const MInt dim)
	Accessor for the current body velocity. More...
MFloat	bodyVelocity (const MInt id, const MInt dim) const
	Accessor for the current body velocity (const) More...
MFloat &	bodyAcceleration (const MInt id, const MInt dim)
	Accessor for the current body acceleration. More...
MFloat	bodyAcceleration (const MInt id, const MInt dim) const
	Accessor for the current body acceleration (const) More...
MFloat &	bodyTemperature (const MInt id)
	Accessor for the body temperature. More...
MFloat	bodyTemperature (const MInt id) const
	Accessor for the body temperature (const) More...
MFloat &	bodyCenterOld (const MInt id, const MInt dim)
	Accessor for the old body center. More...
MFloat	bodyCenterOld (const MInt id, const MInt dim) const
	Accessor for the old body center (const) More...
MFloat &	bodyVelocityOld (const MInt id, const MInt dim)
	Accessor for the old body velocity. More...
MFloat	bodyVelocityOld (const MInt id, const MInt dim) const
	Accessor for the old body velocity (const) More...
MFloat &	bodyAccelerationOld (const MInt id, const MInt dim)
	Accessor for the old body acceleration. More...
MFloat	bodyAccelerationOld (const MInt id, const MInt dim) const
	Accessor for the old body acceleration (const) More...
MFloat &	bodyTemperatureOld (const MInt id)
	Accessor for the old body temperature. More...
MFloat	bodyTemperatureOld (const MInt id) const
	Accessor for the old body temperature (const) More...
MFloat &	bodyQuaternionT1B2 (const MInt id, const MInt dim)
	Accessor for the body bodyQuaternion T1B2. More...
MFloat	bodyQuaternionT1B2 (const MInt id, const MInt dim) const
	Accessor for the body bodyQuaternion T1B2 (const) More...
MFloat &	bodyQuaternionT1 (const MInt id, const MInt dim)
	Accessor for the body bodyQuaternion T1. More...
MFloat	bodyQuaternionT1 (const MInt id, const MInt dim) const
	Accessor for the body bodyQuaternion T1 (const) More...
MFloat &	angularVelocityT1 (const MInt id, const MInt dim)
	Accessor for the angular velocity T1. More...
MFloat	angularVelocityT1 (const MInt id, const MInt dim) const
	Accessor for the angular velocity T1 (const) More...
MFloat &	angularVelocityBodyT1 (const MInt id, const MInt dim)
	Accessor for the angular velocity of the body T1. More...
MFloat	angularVelocityBodyT1 (const MInt id, const MInt dim) const
	Accessor for the angular velocity of the body T1 (const) More...
MFloat &	angularVelocityT1B2 (const MInt id, const MInt dim)
	Accessor for the angular velocity T1B2. More...
MFloat	angularVelocityT1B2 (const MInt id, const MInt dim) const
	Accessor for the angular velocity T1B2 (const) More...
MFloat &	angularVelocityBodyT1B2 (const MInt id, const MInt dim)
	Accessor for the angular velocity of the body T1B2. More...
MFloat	angularVelocityBodyT1B2 (const MInt id, const MInt dim) const
	Accessor for the angular velocity of the body T1B2 (const) More...
MFloat &	angularAccelerationT1 (const MInt id, const MInt dim)
	Accessor for the angular acceleration T1. More...
MFloat	angularAccelerationT1 (const MInt id, const MInt dim) const
	Accessor for the angular acceleration T1 (const) More...
MFloat &	angularAccelerationBody (const MInt id, const MInt dim)
	Accessor for the angular acceleration. More...
MFloat	angularAccelerationBody (const MInt id, const MInt dim) const
	Accessor for the angular acceleration (const) More...
MFloat &	torqueT1 (const MInt id, const MInt dim)
	Accessor for the torque. More...
MFloat	torqueT1 (const MInt id, const MInt dim) const
	Accessor for the torque (const) More...
MFloat &	bodyForce (const MInt id, const MInt dim)
	Accessor for the body force. More...
MFloat	bodyForce (const MInt id, const MInt dim) const
	Accessor for the body force (const) More...
MFloat &	bodyHeatFlux (const MInt id)
	Accessor for the body heat flux. More...
MFloat	bodyHeatFlux (const MInt id) const
	Accessor for the body heat flux (const) More...
MFloat &	bodyDensityRatio (const MInt id)
	Accessor for the body density ratio. More...
MFloat	bodyDensityRatio (const MInt id) const
	Accessor for the body density ratio (const) More...
MFloat &	bodyInertia (const MInt id, const MInt dim)
	Accessor for the body inertia. More...
MFloat	bodyInertia (const MInt id, const MInt dim) const
	Accessor for the body inertia (const) More...
MFloat &	bodyRadius (const MInt id)
	Accessor for the body radius. More...
MFloat	bodyRadius (const MInt id) const
	Accessor for the body radius (const) More...
MFloat &	bodyRadii (const MInt id, const MInt dim)
	Accessor for the body radii. More...
MFloat	bodyRadii (const MInt id, const MInt dim) const
	Accessor for the body radii (const) More...
Status &	status (const MInt id)
	Accessor for the body status. More...
Status	status (const MInt id) const
	Accessor for the body status (const) More...
void	advanceBodies ()
	Copy the body data for time t to t-1 to prepare the next timestep. More...
Public Member Functions inherited from maia::container::Container< RigidBodyCollector< 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...
RigidBodyCollector< nDim > &	derived ()
const RigidBodyCollector< 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< RigidBodyCollector< nDim >, Invalid >
template<class T >
using	Storage = typename Base::template Storage< T >

Private Member Functions
void	reset ()
	Reset, 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
Storage< MFloat >	m_bodyCenter {}
Storage< MFloat >	m_bodyVelocity {}
Storage< MFloat >	m_bodyAcceleration {}
Storage< MFloat >	m_bodyTemperature {}
Storage< MFloat >	m_bodyCenterOld {}
Storage< MFloat >	m_bodyVelocityOld {}
Storage< MFloat >	m_bodyAccelerationOld {}
Storage< MFloat >	m_bodyTemperatureOld {}
Storage< MFloat >	m_bodyQuaternionT1B2 {}
Storage< MFloat >	m_bodyQuaternionT1 {}
Storage< MFloat >	m_angularVelocityT1 {}
Storage< MFloat >	m_angularVelocityBodyT1 {}
Storage< MFloat >	m_angularVelocityT1B2 {}
Storage< MFloat >	m_angularVelocityBodyT1B2 {}
Storage< MFloat >	m_angularAccelerationT1 {}
Storage< MFloat >	m_angularAccelerationBody {}
Storage< MFloat >	m_torqueT1 {}
Storage< MFloat >	m_bodyForce {}
Storage< MFloat >	m_bodyHeatFlux {}
Storage< MFloat >	m_bodyDensityRatio {}
Storage< MFloat >	m_bodyInertia {}
Storage< MFloat >	m_bodyRadius {}
Storage< MFloat >	m_bodyRadii {}
Storage< Status >	m_status {}

Static Private Attributes
static constexpr MInt	nRot = (nDim == 3) ? 3 : 1
static constexpr MInt	nQuat = (nDim == 3) ? 4 : 0

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

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

Definition at line 125 of file rigidbodiescollector.h.

Member Typedef Documentation

Base

template<MInt nDim>

using maia::rb::collector::RigidBodyCollector< nDim >::Base = maia::container::Container<RigidBodyCollector<nDim>, Invalid>

private

Definition at line 130 of file rigidbodiescollector.h.

Invalid

template<MInt nDim>

template<class T >

using maia::rb::collector::RigidBodyCollector< nDim >::Invalid = typename maia::rb::collector::Invalid<T>

Definition at line 138 of file rigidbodiescollector.h.

Storage

template<MInt nDim>

template<class T >

using maia::rb::collector::RigidBodyCollector< nDim >::Storage = typename Base::template Storage<T>

private

Definition at line 133 of file rigidbodiescollector.h.

Constructor & Destructor Documentation

RigidBodyCollector()

template<MInt nDim>

constexpr maia::rb::collector::RigidBodyCollector< nDim >::RigidBodyCollector ( )

constexprdefault

Member Function Documentation

advanceBodies()

template<MInt nDim>

void maia::rb::collector::RigidBodyCollector< nDim >::advanceBodies

Author

Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Definition at line 264 of file rigidbodiescollector.h.

                                             {
  m_bodyCenterOld = m_bodyCenter;
  m_bodyVelocityOld = m_bodyVelocity;
  m_bodyAccelerationOld = m_bodyAcceleration;
 
  m_bodyTemperatureOld = m_bodyTemperature;
}

angularAccelerationBody() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::angularAccelerationBody	(	const MInt	id,
		const MInt	dim
	)

Definition at line 823 of file rigidbodiescollector.h.

                                                                                       {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularAccelerationBody[id * nRot + dim];
}

angularAccelerationBody() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::angularAccelerationBody	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 834 of file rigidbodiescollector.h.

                                                                                            {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularAccelerationBody[id * nRot + dim];
}

angularAccelerationT1() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::angularAccelerationT1	(	const MInt	id,
		const MInt	dim
	)

Definition at line 846 of file rigidbodiescollector.h.

                                                                                     {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularAccelerationT1[id * nRot + dim];
}

angularAccelerationT1() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::angularAccelerationT1	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 857 of file rigidbodiescollector.h.

                                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularAccelerationT1[id * nRot + dim];
}

angularVelocityBodyT1() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityBodyT1	(	const MInt	id,
		const MInt	dim
	)

Definition at line 777 of file rigidbodiescollector.h.

                                                                                     {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityBodyT1[id * nRot + dim];
}

angularVelocityBodyT1() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityBodyT1	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 788 of file rigidbodiescollector.h.

                                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityBodyT1[id * nRot + dim];
}

angularVelocityBodyT1B2() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityBodyT1B2	(	const MInt	id,
		const MInt	dim
	)

Definition at line 800 of file rigidbodiescollector.h.

                                                                                       {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityBodyT1B2[id * nRot + dim];
}

angularVelocityBodyT1B2() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityBodyT1B2	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 811 of file rigidbodiescollector.h.

                                                                                            {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityBodyT1B2[id * nRot + dim];
}

angularVelocityT1() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityT1	(	const MInt	id,
		const MInt	dim
	)

Definition at line 731 of file rigidbodiescollector.h.

                                                                                 {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityT1[id * nRot + dim];
}

angularVelocityT1() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityT1	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 742 of file rigidbodiescollector.h.

                                                                                      {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityT1[id * nRot + dim];
}

angularVelocityT1B2() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityT1B2	(	const MInt	id,
		const MInt	dim
	)

Definition at line 754 of file rigidbodiescollector.h.

                                                                                   {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityT1B2[id * nRot + dim];
}

angularVelocityT1B2() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::angularVelocityT1B2	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 765 of file rigidbodiescollector.h.

                                                                                        {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_angularVelocityT1B2[id * nRot + dim];
}

bodyAcceleration() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyAcceleration	(	const MInt	id,
		const MInt	dim
	)

Definition at line 465 of file rigidbodiescollector.h.

                                                                                {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyAcceleration[id * nDim + dim];
}

bodyAcceleration() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyAcceleration	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 476 of file rigidbodiescollector.h.

                                                                                     {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyAcceleration[id * nDim + dim];
}

bodyAccelerationOld() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyAccelerationOld	(	const MInt	id,
		const MInt	dim
	)

Definition at line 488 of file rigidbodiescollector.h.

                                                                                   {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyAccelerationOld[id * nDim + dim];
}

bodyAccelerationOld() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyAccelerationOld	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 499 of file rigidbodiescollector.h.

                                                                                        {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyAccelerationOld[id * nDim + dim];
}

bodyCenter() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyCenter	(	const MInt	id,
		const MInt	dim
	)

Definition at line 373 of file rigidbodiescollector.h.

                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyCenter[id * nDim + dim];
}

bodyCenter() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyCenter	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 384 of file rigidbodiescollector.h.

                                                                               {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyCenter[id * nDim + dim];
}

bodyCenterOld() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyCenterOld	(	const MInt	id,
		const MInt	dim
	)

Definition at line 396 of file rigidbodiescollector.h.

                                                                             {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyCenterOld[id * nDim + dim];
}

bodyCenterOld() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyCenterOld	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 407 of file rigidbodiescollector.h.

                                                                                  {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyCenterOld[id * nDim + dim];
}

bodyDensityRatio() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyDensityRatio

(

const MInt

id

)

Definition at line 597 of file rigidbodiescollector.h.

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

bodyDensityRatio() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyDensityRatio

(

const MInt

id

)

const

Definition at line 607 of file rigidbodiescollector.h.

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

bodyForce() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyForce	(	const MInt	id,
		const MInt	dim
	)

Definition at line 511 of file rigidbodiescollector.h.

                                                                         {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyForce[id * nDim + dim];
}

bodyForce() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyForce	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 522 of file rigidbodiescollector.h.

                                                                              {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyForce[id * nDim + dim];
}

bodyHeatFlux() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyHeatFlux

(

const MInt

id

)

Definition at line 576 of file rigidbodiescollector.h.

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

bodyHeatFlux() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyHeatFlux

(

const MInt

id

)

const

Definition at line 586 of file rigidbodiescollector.h.

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

bodyInertia() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyInertia	(	const MInt	id,
		const MInt	dim
	)

Definition at line 618 of file rigidbodiescollector.h.

                                                                           {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_bodyInertia[id * nRot + dim];
}

bodyInertia() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyInertia	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 629 of file rigidbodiescollector.h.

                                                                                {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_bodyInertia[id * nRot + dim];
}

bodyQuaternionT1() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyQuaternionT1	(	const MInt	id,
		const MInt	dim
	)

Definition at line 685 of file rigidbodiescollector.h.

                                                                                {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_QUAT(dim);
  return m_bodyQuaternionT1[id * nQuat + dim];
}

bodyQuaternionT1() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyQuaternionT1	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 696 of file rigidbodiescollector.h.

                                                                                     {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_QUAT(dim);
  return m_bodyQuaternionT1[id * nQuat + dim];
}

bodyQuaternionT1B2() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyQuaternionT1B2	(	const MInt	id,
		const MInt	dim
	)

Definition at line 708 of file rigidbodiescollector.h.

                                                                                  {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_QUAT(dim);
  return m_bodyQuaternionT1B2[id * nQuat + dim];
}

bodyQuaternionT1B2() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyQuaternionT1B2	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 719 of file rigidbodiescollector.h.

                                                                                       {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_QUAT(dim);
  return m_bodyQuaternionT1B2[id * nQuat + dim];
}

bodyRadii() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyRadii	(	const MInt	id,
		const MInt	dim
	)

Definition at line 662 of file rigidbodiescollector.h.

                                                                         {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyRadii[id * nDim + dim];
}

bodyRadii() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyRadii	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 673 of file rigidbodiescollector.h.

                                                                              {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyRadii[id * nDim + dim];
}

bodyRadius() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyRadius

(

const MInt

id

)

Definition at line 641 of file rigidbodiescollector.h.

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

bodyRadius() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyRadius

(

const MInt

id

)

const

Definition at line 651 of file rigidbodiescollector.h.

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

bodyTemperature() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyTemperature

(

const MInt

id

)

Definition at line 534 of file rigidbodiescollector.h.

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

bodyTemperature() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyTemperature

(

const MInt

id

)

const

Definition at line 544 of file rigidbodiescollector.h.

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

bodyTemperatureOld() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyTemperatureOld

(

const MInt

id

)

Definition at line 555 of file rigidbodiescollector.h.

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

bodyTemperatureOld() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyTemperatureOld

(

const MInt

id

)

const

Definition at line 565 of file rigidbodiescollector.h.

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

bodyVelocity() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyVelocity	(	const MInt	id,
		const MInt	dim
	)

Definition at line 419 of file rigidbodiescollector.h.

                                                                            {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyVelocity[id * nDim + dim];
}

bodyVelocity() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyVelocity	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 430 of file rigidbodiescollector.h.

                                                                                 {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyVelocity[id * nDim + dim];
}

bodyVelocityOld() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::bodyVelocityOld	(	const MInt	id,
		const MInt	dim
	)

Definition at line 442 of file rigidbodiescollector.h.

                                                                               {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyVelocityOld[id * nDim + dim];
}

bodyVelocityOld() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::bodyVelocityOld	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 453 of file rigidbodiescollector.h.

                                                                                    {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_DIM(dim);
  return m_bodyVelocityOld[id * nDim + dim];
}

invalidate()

template<MInt nDim>

void maia::rb::collector::RigidBodyCollector< nDim >::invalidate ( const MInt  begin, const MInt  end  )

private

Definition at line 304 of file rigidbodiescollector.h.

                                                                          {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  fill_invalid(m_bodyCenter, begin, end, nDim);
  fill_invalid(m_bodyVelocity, begin, end, nDim);
  fill_invalid(m_bodyAcceleration, begin, end, nDim);
  fill_invalid(m_bodyTemperature, begin, end, 1);
  fill_invalid(m_bodyCenterOld, begin, end, nDim);
  fill_invalid(m_bodyVelocityOld, begin, end, nDim);
  fill_invalid(m_bodyAccelerationOld, begin, end, nDim);
  fill_invalid(m_bodyTemperatureOld, begin, end, 1);
  fill_invalid(m_bodyQuaternionT1B2, begin, end, nQuat);
  fill_invalid(m_bodyQuaternionT1, begin, end, nQuat);
  fill_invalid(m_angularVelocityT1, begin, end, nRot);
  fill_invalid(m_angularVelocityBodyT1, begin, end, nRot);
  fill_invalid(m_angularVelocityT1B2, begin, end, nRot);
  fill_invalid(m_angularVelocityBodyT1B2, begin, end, nRot);
  fill_invalid(m_angularAccelerationT1, begin, end, nRot);
  fill_invalid(m_angularAccelerationBody, begin, end, nRot);
  fill_invalid(m_torqueT1, begin, end, nRot);
  fill_invalid(m_bodyForce, begin, end, nDim);
  fill_invalid(m_bodyHeatFlux, begin, end, 1);
  fill_invalid(m_bodyDensityRatio, begin, end, 1);
  fill_invalid(m_bodyInertia, begin, end, nRot);
  fill_invalid(m_bodyRadius, begin, end, 1);
  fill_invalid(m_bodyRadii, begin, end, nDim);
  fill_invalid(m_status, begin, end, 1);
}

rawCopyGeneric()

template<MInt nDim>

template<class Functor , class T >

void maia::rb::collector::RigidBodyCollector< nDim >::rawCopyGeneric ( Functor &&  c, const T &  source, const MInt  begin, const MInt  end, const MInt  destination  )

private

Definition at line 339 of file rigidbodiescollector.h.

                                                                      {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  copyData(source.m_bodyCenter, m_bodyCenter, c, begin, end, destination, nDim);
  copyData(source.m_bodyVelocity, m_bodyVelocity, c, begin, end, destination, nDim);
  copyData(source.m_bodyAcceleration, m_bodyAcceleration, c, begin, end, destination, nDim);
  copyData(source.m_bodyTemperature, m_bodyTemperature, c, begin, end, destination, 1);
  copyData(source.m_bodyCenterOld, m_bodyCenterOld, c, begin, end, destination, nDim);
  copyData(source.m_bodyVelocityOld, m_bodyVelocityOld, c, begin, end, destination, nDim);
  copyData(source.m_bodyAccelerationOld, m_bodyAccelerationOld, c, begin, end, destination, nDim);
  copyData(source.m_bodyTemperatureOld, m_bodyTemperatureOld, c, begin, end, destination, 1);
  copyData(source.m_bodyQuaternionT1B2, m_bodyQuaternionT1B2, c, begin, end, destination, nQuat);
  copyData(source.m_bodyQuaternionT1, m_bodyQuaternionT1, c, begin, end, destination, nQuat);
  copyData(source.m_angularVelocityT1, m_angularVelocityT1, c, begin, end, destination, nRot);
  copyData(source.m_angularVelocityBodyT1, m_angularVelocityBodyT1, c, begin, end, destination, nRot);
  copyData(source.m_angularVelocityT1B2, m_angularVelocityT1B2, c, begin, end, destination, nRot);
  copyData(source.m_angularVelocityBodyT1B2, m_angularVelocityBodyT1B2, c, begin, end, destination, nRot);
  copyData(source.m_angularAccelerationT1, m_angularAccelerationT1, c, begin, end, destination, nRot);
  copyData(source.m_angularAccelerationBody, m_angularAccelerationBody, c, begin, end, destination, nRot);
  copyData(source.m_torqueT1, m_torqueT1, c, begin, end, destination, nRot);
  copyData(source.m_bodyForce, m_bodyForce, c, begin, end, destination, nDim);
  copyData(source.m_bodyHeatFlux, m_bodyHeatFlux, c, begin, end, destination, 1);
  copyData(source.m_bodyDensityRatio, m_bodyDensityRatio, c, begin, end, destination, 1);
  copyData(source.m_bodyInertia, m_bodyInertia, c, begin, end, destination, nRot);
  copyData(source.m_bodyRadius, m_bodyRadius, c, begin, end, destination, 1);
  copyData(source.m_bodyRadii, m_bodyRadii, c, begin, end, destination, nDim);
  copyData(source.m_status, m_status, c, begin, end, destination, 1);
}

reset()

template<MInt nDim>

void maia::rb::collector::RigidBodyCollector< nDim >::reset

private

Definition at line 275 of file rigidbodiescollector.h.

                                     {
  resetStorage(nDim, m_bodyCenter);
  resetStorage(nDim, m_bodyVelocity);
  resetStorage(nDim, m_bodyAcceleration);
  resetStorage(1, m_bodyTemperature);
  resetStorage(nDim, m_bodyCenterOld);
  resetStorage(nDim, m_bodyVelocityOld);
  resetStorage(nDim, m_bodyAccelerationOld);
  resetStorage(1, m_bodyTemperatureOld);
  resetStorage(nQuat, m_bodyQuaternionT1B2);
  resetStorage(nQuat, m_bodyQuaternionT1);
  resetStorage(nRot, m_angularVelocityT1);
  resetStorage(nRot, m_angularVelocityBodyT1);
  resetStorage(nRot, m_angularVelocityT1B2);
  resetStorage(nRot, m_angularVelocityBodyT1B2);
  resetStorage(nRot, m_angularAccelerationT1);
  resetStorage(nRot, m_angularAccelerationBody);
  resetStorage(nRot, m_torqueT1);
  resetStorage(nDim, m_bodyForce);
  resetStorage(1, m_bodyHeatFlux);
  resetStorage(1, m_bodyDensityRatio);
  resetStorage(nRot, m_bodyInertia);
  resetStorage(1, m_bodyRadius);
  resetStorage(nDim, m_bodyRadii);
  resetStorage(1, m_status);
}

status() [1/2]

template<MInt nDim>

Status & maia::rb::collector::RigidBodyCollector< nDim >::status

(

const MInt

id

)

Definition at line 892 of file rigidbodiescollector.h.

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

status() [2/2]

template<MInt nDim>

Status maia::rb::collector::RigidBodyCollector< nDim >::status

(

const MInt

id

)

const

Definition at line 902 of file rigidbodiescollector.h.

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

torqueT1() [1/2]

template<MInt nDim>

MFloat & maia::rb::collector::RigidBodyCollector< nDim >::torqueT1	(	const MInt	id,
		const MInt	dim
	)

Definition at line 869 of file rigidbodiescollector.h.

                                                                        {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_torqueT1[id * nRot + dim];
}

torqueT1() [2/2]

template<MInt nDim>

MFloat maia::rb::collector::RigidBodyCollector< nDim >::torqueT1	(	const MInt	id,
		const MInt	dim
	)		const

Definition at line 880 of file rigidbodiescollector.h.

                                                                             {
// Prevent accidental compilation without support for SoA layout
#ifdef RBCOLLECTOR_SOA_MEMORY_LAYOUT
#error Missing implementation for structure-of-arrays memory layout.
#endif
  ENSURE_VALID_ID(id);
  ENSURE_VALID_ROT(dim);
  return m_torqueT1[id * nRot + dim];
}

Friends And Related Function Documentation

maia::container::Container< RigidBodyCollector< nDim >, Invalid >

template<MInt nDim>

friend class maia::container::Container< RigidBodyCollector< nDim >, Invalid >

friend

Definition at line 119 of file rigidbodiescollector.h.

Member Data Documentation

m_angularAccelerationBody

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_angularAccelerationBody {}

private

Definition at line 242 of file rigidbodiescollector.h.

m_angularAccelerationT1

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_angularAccelerationT1 {}

private

Definition at line 241 of file rigidbodiescollector.h.

m_angularVelocityBodyT1

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_angularVelocityBodyT1 {}

private

Definition at line 237 of file rigidbodiescollector.h.

m_angularVelocityBodyT1B2

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_angularVelocityBodyT1B2 {}

private

Definition at line 239 of file rigidbodiescollector.h.

m_angularVelocityT1

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_angularVelocityT1 {}

private

Definition at line 236 of file rigidbodiescollector.h.

m_angularVelocityT1B2

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_angularVelocityT1B2 {}

private

Definition at line 238 of file rigidbodiescollector.h.

m_bodyAcceleration

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyAcceleration {}

private

Definition at line 221 of file rigidbodiescollector.h.

m_bodyAccelerationOld

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyAccelerationOld {}

private

Definition at line 228 of file rigidbodiescollector.h.

m_bodyCenter

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyCenter {}

private

Definition at line 219 of file rigidbodiescollector.h.

m_bodyCenterOld

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyCenterOld {}

private

Definition at line 226 of file rigidbodiescollector.h.

m_bodyDensityRatio

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyDensityRatio {}

private

Definition at line 249 of file rigidbodiescollector.h.

m_bodyForce

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyForce {}

private

Definition at line 246 of file rigidbodiescollector.h.

m_bodyHeatFlux

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyHeatFlux {}

private

Definition at line 247 of file rigidbodiescollector.h.

m_bodyInertia

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyInertia {}

private

Definition at line 250 of file rigidbodiescollector.h.

m_bodyQuaternionT1

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyQuaternionT1 {}

private

Definition at line 234 of file rigidbodiescollector.h.

m_bodyQuaternionT1B2

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyQuaternionT1B2 {}

private

Definition at line 233 of file rigidbodiescollector.h.

m_bodyRadii

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyRadii {}

private

Definition at line 253 of file rigidbodiescollector.h.

m_bodyRadius

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyRadius {}

private

Definition at line 252 of file rigidbodiescollector.h.

m_bodyTemperature

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyTemperature {}

private

Definition at line 223 of file rigidbodiescollector.h.

m_bodyTemperatureOld

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyTemperatureOld {}

private

Definition at line 230 of file rigidbodiescollector.h.

m_bodyVelocity

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyVelocity {}

private

Definition at line 220 of file rigidbodiescollector.h.

m_bodyVelocityOld

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_bodyVelocityOld {}

private

Definition at line 227 of file rigidbodiescollector.h.

m_status

template<MInt nDim>

Storage<Status> maia::rb::collector::RigidBodyCollector< nDim >::m_status {}

private

Definition at line 255 of file rigidbodiescollector.h.

m_torqueT1

template<MInt nDim>

Storage<MFloat> maia::rb::collector::RigidBodyCollector< nDim >::m_torqueT1 {}

private

Definition at line 244 of file rigidbodiescollector.h.

nQuat

template<MInt nDim>

constexpr MInt maia::rb::collector::RigidBodyCollector< nDim >::nQuat = (nDim == 3) ? 4 : 0

staticconstexprprivate

Definition at line 214 of file rigidbodiescollector.h.

nRot

template<MInt nDim>

constexpr MInt maia::rb::collector::RigidBodyCollector< nDim >::nRot = (nDim == 3) ? 3 : 1

staticconstexprprivate

Definition at line 213 of file rigidbodiescollector.h.

---

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

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/RB/rigidbodiescollector.h