olb::particles::access Namespace Reference

Functions
template<typename T >
Vector< T, 3 >	calcAngAcceleration3D (Vector< T, 3 > &torque, Vector< T, 3 > &momentOfInertia, const Matrix< T, 3, 3 > &rotationMatrix)
template<typename PARTICLETYPE >
constexpr bool	providesID ()
	Provides field ID.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesID (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesInvalid ()
	Provides field ID.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesInvalid (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesPosition ()
	Provides field POSITION.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesPosition (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesRadius ()
	Provides field RADIUS.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesRadius (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesDensity ()
	Provides field DENSITY.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesDensity (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesMass ()
	Provides field MASS.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesMass (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesMassOrDensity ()
	Provides field MASS or DENSITY.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesMassOrDensity (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesAngle ()
	Provides field ANGLE.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesAngle (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesVelocity ()
	Provides field VELOCITY.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesVelocity (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesAngVelocity ()
	Provides field VELOCITY.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesAngVelocity (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesForce ()
	Provides field FORCE.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesForce (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesTorque ()
	Provides field TORQUE.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesTorque (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesAdhesion ()
	Provides field ADHESION.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesAdhesion (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesMomentOfInertia ()
	Provides field MOFI.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesMomentOfInertia (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesValid ()
	Provides field INVALID.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesValid (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesDynamicsID ()
	Provides field DYNAMICS_ID.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesDynamicsID (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesActive ()
	Provides field ACTIVE.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesActive (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesComputeMotion ()
	Provides field COMPUTE_MOTION.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesComputeMotion (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesComputeContact ()
	Provides field COMPUTE_CONTACT.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesComputeContact (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesRotationMatrix ()
	Provides field ROT_MATRIX.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesRotationMatrix (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesSurface ()
	Provides group SURFACE.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesSurface (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesSmoothIndicator ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesSmoothIndicator (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesParallelization ()
	Provides group PARALLELIZATION.
template<typename T , typename PARTICLETYPE >
constexpr bool	providesParallelization (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesSpecies ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesSpecies (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesDetaching ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesDetaching (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesCORoffset ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesCORoffset (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesElongation ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesElongation (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesAccelerationStrd ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesAccelerationStrd (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesAngAccelerationStrd ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesAngAccelerationStrd (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesEnlargementForContactTreatment ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesEnlargementForContactTreatment (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesIsInContact ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesIsInContact (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	providesContactMaterial ()
template<typename T , typename PARTICLETYPE >
constexpr bool	providesContactMaterial (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	is2D ()
template<typename T , typename PARTICLETYPE >
constexpr bool	is2D (Particle< T, PARTICLETYPE > &particle)
template<typename PARTICLETYPE >
constexpr bool	is3D ()
template<typename T , typename PARTICLETYPE >
constexpr bool	is3D (Particle< T, PARTICLETYPE > &particle)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getPosition (Particle< T, PARTICLETYPE > particle)
template<bool ensureAngularBounds = false, typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	getAngle (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::matrix >	getRotationMatrix (Particle< T, PARTICLETYPE > particle)
template<unsigned dir = 2, typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getSurfaceNormal (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getVelocity (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	getAngularVelocity (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getForce (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	getTorque (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	getMomentOfInertia (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, 2 >	getAdhesion (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
bool	isValid (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
bool	isActive (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
auto	getSmoothIndicatorPtr (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
T	getRadius (Particle< T, PARTICLETYPE > &particle)
template<typename T , typename PARTICLETYPE >
T	getVolume (Particle< T, PARTICLETYPE > particle, T shapeFactor=T{1})
	Returns the volume of a particle (for subgrid the volume of a sphere/circle is multiplied by the shapeFactor), i.e., the shape factor is the volume ratio of the shape of interest to a sphere/circle.
template<typename T , typename PARTICLETYPE >
T	getDensity (Particle< T, PARTICLETYPE > particle, T shapeFactor=T{1})
template<typename T , typename PARTICLETYPE >
T	getMass (Particle< T, PARTICLETYPE > particle, T shapeFactor=T{1})
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getAccelerationStrd (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
void	setAccelerationStrd (Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > acceleration)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getAcceleration (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	getAngAcceleration (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	getAngAccelerationStrd (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
auto	getGlobalID (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
auto	getGlobalIC (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
unsigned short	getDynamicsID (Particle< T, PARTICLETYPE > &particle)
template<typename T , typename PARTICLETYPE >
bool	isDetaching (Particle< T, PARTICLETYPE > &particle)
template<typename T , typename PARTICLETYPE >
auto	getCuboidSurfaceExtent (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getCORoffset (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getElongation (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
T	getEnlargementForContact (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
unsigned	getContactMaterial (Particle< T, PARTICLETYPE > particle)
template<typename T , typename PARTICLETYPE >
void	setDensity (Particle< T, PARTICLETYPE > particle, T density, T shapeFactor=T{1})
template<typename T , typename PARTICLETYPE >
void	setMass (Particle< T, PARTICLETYPE > particle, T mass, T shapeFactor=T{1})
template<typename T , typename PARTICLETYPE >
void	setPosition (Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > position)
template<typename T , typename PARTICLETYPE >
void	setContactMaterial (Particle< T, PARTICLETYPE > particle, unsigned material)
template<typename T , typename PARTICLETYPE >
void	setAngle (Particle< T, PARTICLETYPE > particle, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > angle)
template<typename T , typename PARTICLETYPE >
void	setRotationMatrix (Particle< T, PARTICLETYPE > particle, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::matrix > rotMatrix)
template<typename T , typename PARTICLETYPE >
void	setVelocity (Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > velocity)
template<typename T , typename PARTICLETYPE >
void	setAngularVelocity (Particle< T, PARTICLETYPE > particle, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > angVelocity)
template<typename T , typename PARTICLETYPE >
void	setAngAccelerationStrd (Particle< T, PARTICLETYPE > particle, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > angAcceleration)
template<typename T , typename PARTICLETYPE >
void	setForce (Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > force)
template<typename T , typename PARTICLETYPE >
void	setTorque (Particle< T, PARTICLETYPE > particle, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > torque)
template<typename T , typename PARTICLETYPE >
void	setMomentOfInertia (Particle< T, PARTICLETYPE > particle, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > mofi)
template<typename T , typename PARTICLETYPE >
void	setAdhesion (Particle< T, PARTICLETYPE > &particle, Vector< T, 2 > adhesion)
template<typename T , typename PARTICLETYPE >
void	setInvalid (Particle< T, PARTICLETYPE > particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	setValid (Particle< T, PARTICLETYPE > particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	setActive (Particle< T, PARTICLETYPE > particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	setInactive (Particle< T, PARTICLETYPE > particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	setSmoothIndicatorPtr (Particle< T, PARTICLETYPE > particle, SmoothIndicatorF< T, T, PARTICLETYPE::d, true > *sindicator)
template<typename T , typename PARTICLETYPE >
void	setRadius (Particle< T, PARTICLETYPE > &particle, T radius)
template<typename T , typename PARTICLETYPE >
void	setGlobalID (Particle< T, PARTICLETYPE > particle, std::size_t id)
template<typename T , typename PARTICLETYPE >
void	setGlobalIC (Particle< T, PARTICLETYPE > particle, int id)
template<typename T , typename PARTICLETYPE >
void	setDynamicsID (Particle< T, PARTICLETYPE > &particle, unsigned short dynamicsID)
template<typename T , typename PARTICLETYPE >
void	setDetaching (Particle< T, PARTICLETYPE > &particle, bool value)
template<typename T , typename PARTICLETYPE >
void	setCORoffset (Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > offsetCOR)
template<typename T , typename PARTICLETYPE >
void	setElongation (Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > elongation)
template<typename T , typename PARTICLETYPE >
void	setEnlargementForContact (Particle< T, PARTICLETYPE > &particle, T value)
template<typename T , typename PARTICLETYPE >
bool	isMotionComputationEnabled (Particle< T, PARTICLETYPE > &particle)
	Check if motion is enabled.
template<typename T , typename PARTICLETYPE >
bool	isContactComputationEnabled (Particle< T, PARTICLETYPE > &particle)
	Check if contact should be regarded (specification for a single particle)
template<typename T , typename PARTICLETYPE >
bool	isContactComputationEnabled (Particle< T, PARTICLETYPE > &particleA, Particle< T, PARTICLETYPE > &particleB)
	Check if contact should be regarded (interaction of two known particles)
template<typename T , typename PARTICLETYPE >
void	enableMotionComputation (Particle< T, PARTICLETYPE > &particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	enableContactComputation (Particle< T, PARTICLETYPE > &particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	disableMotionComputation (Particle< T, PARTICLETYPE > &particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	disableContactComputation (Particle< T, PARTICLETYPE > &particle, bool value=true)
template<typename T , typename PARTICLETYPE >
void	setRestingParticle (Particle< T, PARTICLETYPE > particle)

Function Documentation

calcAngAcceleration3D()

template<typename T >

Vector< T, 3 > olb::particles::access::calcAngAcceleration3D	(	Vector< T, 3 > &	torque,
		Vector< T, 3 > &	momentOfInertia,
		const Matrix< T, 3, 3 > &	rotationMatrix )

Definition at line 45 of file dataAccessWrappers.h.

{
  T data[3][3] = {
    {momentOfInertia[0],    T {0},    T {0}},
    {   T {0}, momentOfInertia[1],    T {0}},
    {   T {0},    T {0}, momentOfInertia[2]}
  };
  Matrix<T, 3, 3>       inertiaTensor(data);
  inertiaTensor = (rotationMatrix * inertiaTensor) * (rotationMatrix.transpose());
 
  /*
   * In the following, we use the solution of a linear equation system
   * torque = inertia tensor * angular acceleration + angular velocity x (inertia tensor * angular velocity)
   * Here, we want to know the components of the angular acceleration
   * In the following, left = torque - angular velocity x (inertia tensor * angular velocity)
   */
 
  // const Vector<T,3> angularVelocity = getAngularVelocity(particle);
  // Using Euler's equation for rigid body dynamics
  // Currently not, as it leads to inaccurate results of some tests
  // Add the cross product to use Euler's equation for rigid body dynamics
  const Vector<T,3> left = torque;//- crossProduct3D(angularVelocity, (inertiaTensor * angularVelocity));
 
  const T denominator = util::pow(inertiaTensor[0][2], 2) * inertiaTensor[1][1]
    + inertiaTensor[0][0] * util::pow(inertiaTensor[1][2], 2)
    - 2 * inertiaTensor[0][1] * inertiaTensor[0][2] * inertiaTensor[1][2]
    + util::pow(inertiaTensor[0][1], 2) * inertiaTensor[2][2]
    - inertiaTensor[0][0] * inertiaTensor[1][1] * inertiaTensor[2][2];
  const T factor = T{1} / denominator;
 
  Vector<T,3> angularAcceleration;
  angularAcceleration[0] = (util::pow(inertiaTensor[1][2], 2) - inertiaTensor[1][1] * inertiaTensor[2][2]) * left[0]
    + (- inertiaTensor[0][2] * inertiaTensor[1][2] + inertiaTensor[0][1] * inertiaTensor[2][2]) * left[1]
    + (inertiaTensor[0][2] * inertiaTensor[1][1] - inertiaTensor[0][1] * inertiaTensor[1][2]) * left[2];
  angularAcceleration[1] = (- inertiaTensor[0][2] * inertiaTensor[1][2] + inertiaTensor[0][1] * inertiaTensor[2][2]) * left[0]
    + (util::pow(inertiaTensor[0][2], 2) - inertiaTensor[0][0] * inertiaTensor[2][2]) * left[1]
    + (- inertiaTensor[0][1] * inertiaTensor[0][2] + inertiaTensor[0][0] * inertiaTensor[1][2]) * left[2];
  angularAcceleration[2] = (inertiaTensor[0][2] * inertiaTensor[1][1] - inertiaTensor[0][1] * inertiaTensor[1][2]) * left[0]
    + (- inertiaTensor[0][1] * inertiaTensor[0][2] + inertiaTensor[0][0] * inertiaTensor[1][2]) * left[1]
    + (util::pow(inertiaTensor[0][1], 2) - inertiaTensor[0][0] * inertiaTensor[1][1]) * left[2];
 
  for(unsigned iDim = 0; iDim < 3; ++iDim) {
    angularAcceleration[iDim] *= factor;
  }
 
  return angularAcceleration;
}

References olb::util::pow(), and olb::Matrix< T, ROWS, COLS >::transpose().

Here is the call graph for this function:

Here is the caller graph for this function:

disableContactComputation()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::disableContactComputation	(	Particle< T, PARTICLETYPE > &	particle,
		bool	value = true )

Definition at line 1217 of file dataAccessWrappers.h.

{
  enableContactComputation(particle, !value);
}

References enableContactComputation().

Here is the call graph for this function:

disableMotionComputation()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::disableMotionComputation	(	Particle< T, PARTICLETYPE > &	particle,
		bool	value = true )

Definition at line 1211 of file dataAccessWrappers.h.

{
  enableMotionComputation(particle, !value);
}

References enableMotionComputation().

Here is the call graph for this function:

enableContactComputation()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::enableContactComputation	(	Particle< T, PARTICLETYPE > &	particle,
		bool	value = true )

Definition at line 1203 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesComputeContact<PARTICLETYPE>(), "Field DYNBEHAVIOUR:COMPUTE_CONTACT has to be provided");
  particle.template setField<DYNBEHAVIOUR, COMPUTE_CONTACT>(value);
}

References providesComputeContact().

Here is the call graph for this function:

Here is the caller graph for this function:

enableMotionComputation()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::enableMotionComputation	(	Particle< T, PARTICLETYPE > &	particle,
		bool	value = true )

Definition at line 1195 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesComputeMotion<PARTICLETYPE>(), "Field DYNBEHAVIOUR:COMPUTE_MOTION has to be provided");
  particle.template setField<DYNBEHAVIOUR, COMPUTE_MOTION>(value);
}

References providesComputeMotion().

Here is the call graph for this function:

Here is the caller graph for this function:

getAcceleration()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getAcceleration

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 742 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
 
  static_assert(providesForce<PARTICLETYPE>(), "Field FORCING:FORCE has to be provided");
  static_assert(providesMass<PARTICLETYPE>(), "Field PHYSPROPERTIES:MASS has to be provided");
 
  Vector<T,D> acceleration;
  Vector<T,D> force = getForce(particle);
  T mass = getMass(particle);
  for (unsigned iDim=0; iDim<D; ++iDim) {
    acceleration[iDim] = force[iDim] / mass;
  }
  return acceleration;
}

References getForce(), getMass(), providesForce(), and providesMass().

Here is the call graph for this function:

getAccelerationStrd()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getAccelerationStrd

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 722 of file dataAccessWrappers.h.

{
  using namespace descriptors;
 
  if(providesAccelerationStrd(particle)){
    return particle.template getField<MOBILITY,ACCELERATION_STRD>();
  }
}

References providesAccelerationStrd().

Here is the call graph for this function:

getAdhesion()

template<typename T , typename PARTICLETYPE >

Vector< T, 2 > olb::particles::access::getAdhesion

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 597 of file dataAccessWrappers.h.

{
  using namespace descriptors;
 
  static_assert(providesAdhesion<PARTICLETYPE>(), "Field FORCING:ADHESION has to be provided");
  Vector<T,2> adhesion( particle.template getField<FORCING,ADHESION>() );
  return adhesion;
}

References providesAdhesion().

Here is the call graph for this function:

getAngAcceleration()

template<typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > olb::particles::access::getAngAcceleration

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 762 of file dataAccessWrappers.h.

{
  using namespace descriptors;
 
  const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
  static_assert(providesTorque<PARTICLETYPE>(), "Field FORCING:TORQUE has to be provided");
  static_assert(providesMomentOfInertia<PARTICLETYPE>(), "Field PHYSPROPERTIES:MOFI has to be provided");
  Vector<T,Drot> angularAcceleration;
  Vector<T,Drot> torque( getTorque(particle));
  Vector<T,Drot> momentOfInertia( getMomentOfInertia(particle) );
  if constexpr (PARTICLETYPE::d == 3 && providesRotationMatrix<PARTICLETYPE>()) {
    const Matrix<T,3,3> rotationMatrix(getRotationMatrix(particle));
    angularAcceleration = calcAngAcceleration3D( torque, momentOfInertia, rotationMatrix );
  } else {
    for (unsigned iRot=0; iRot<Drot; ++iRot) {
      angularAcceleration[iRot] = torque[iRot] / momentOfInertia[iRot];
    }
  }
  return angularAcceleration;
}

References calcAngAcceleration3D(), getMomentOfInertia(), getRotationMatrix(), getTorque(), providesMomentOfInertia(), providesRotationMatrix(), and providesTorque().

Here is the call graph for this function:

getAngAccelerationStrd()

template<typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > olb::particles::access::getAngAccelerationStrd

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 785 of file dataAccessWrappers.h.

{
  using namespace descriptors;
 
  if(providesAngAccelerationStrd(particle)){
    return particle.template getField<MOBILITY,ANG_ACC_STRD>();
  }
}

References providesAngAccelerationStrd().

Here is the call graph for this function:

getAngle()

template<bool ensureAngularBounds = false, typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > olb::particles::access::getAngle

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 506 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
  static_assert(providesAngle<PARTICLETYPE>(), "Field SURFACE:ANGLE has to be provided");
  Vector<T,Drot> angle( particle.template getField<SURFACE,ANGLE>() );
  if constexpr (ensureAngularBounds){
    for (unsigned iRot=0; iRot<Drot; ++iRot) {
      angle[iRot] = util::fmod( angle[iRot], 2.*M_PI );
    }
  }
  return angle;
}

References olb::util::fmod(), M_PI, and providesAngle().

Here is the call graph for this function:

Here is the caller graph for this function:

getAngularVelocity()

template<typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > olb::particles::access::getAngularVelocity

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 556 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
  static_assert(providesAngVelocity<PARTICLETYPE>(), "Field MOBILITY:ANG_VELOCITY has to be provided");
  Vector<T,Drot> angVelocity( particle.template getField<MOBILITY,ANG_VELOCITY>() );
  return angVelocity;
}

References providesAngVelocity().

Here is the call graph for this function:

Here is the caller graph for this function:

getContactMaterial()

template<typename T , typename PARTICLETYPE >

unsigned olb::particles::access::getContactMaterial

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 906 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesContactMaterial(particle),
                "Field MECHPROPERTIES::MATERIAL has to be provided");
  return particle.template getField<MECHPROPERTIES, MATERIAL>();
}

References providesContactMaterial().

Here is the call graph for this function:

getCORoffset()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getCORoffset

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 871 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  static_assert(providesCORoffset<PARTICLETYPE>(), "Field SURFACE:COR_OFFSET has to be provided");
  Vector<T,D> offsetCOR( particle.template getField<SURFACE,COR_OFFSET>() );
  return offsetCOR;
}

References providesCORoffset().

Here is the call graph for this function:

getCuboidSurfaceExtent()

template<typename T , typename PARTICLETYPE >

auto olb::particles::access::getCuboidSurfaceExtent

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 839 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  static_assert(providesSmoothIndicator<PARTICLETYPE>(), "Field FORCING:SINDICATOR has to be provided");
  using SIndicatorType = std::conditional_t<
    D == 2,
    SmoothIndicatorCuboid2D<T,T,true>,
    SmoothIndicatorCuboid3D<T,T,true>
  >;
  //Retrieve surface indicator
  auto sIndicatorPtr = getSmoothIndicatorPtr(particle);
  auto sIndicatorCuboidPtr = static_cast<SIndicatorType*>(sIndicatorPtr);
  auto& indicatorCuboid = sIndicatorCuboidPtr->getIndicator();
  //Retrieve extent
  if constexpr(D==2){
    Vector<T,D> extent(
      indicatorCuboid.getxLength(),
      indicatorCuboid.getyLength()
    );
    return extent;
  } else {
    Vector<T,D> extent(
      indicatorCuboid.getxLength(),
      indicatorCuboid.getyLength(),
      indicatorCuboid.getzLength()
    );
    return extent;
  }
}

References getSmoothIndicatorPtr(), and providesSmoothIndicator().

Here is the call graph for this function:

getDensity()

template<typename T , typename PARTICLETYPE >

T olb::particles::access::getDensity	(	Particle< T, PARTICLETYPE >	particle,
		T	shapeFactor = T{1} )

Definition at line 686 of file dataAccessWrappers.h.

                                                                                   {1} )
{
  using namespace descriptors;
  static_assert(providesMassOrDensity(particle),
      "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
  T density;
  // Always rather use the density field than the mass field
  if constexpr(providesDensity(particle)) {
    density = particle.template getField<PHYSPROPERTIES, DENSITY>();
  }
  else {
    const T mass = particle.template getField<PHYSPROPERTIES, MASS>();
    density = mass / getVolume(particle, shapeFactor);
  }
  return density;
}

getDynamicsID()

template<typename T , typename PARTICLETYPE >

unsigned short olb::particles::access::getDynamicsID

(

Particle< T, PARTICLETYPE > &

particle

)

Definition at line 816 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesDynamicsID<PARTICLETYPE>(),
                "Field DYNBEHAVIOUR:DYNAMICS_ID has to be provided");
  unsigned short dynamicsID = particle.template getField<DYNBEHAVIOUR,DYNAMICS_ID>();
  return dynamicsID;
}

References providesDynamicsID().

Here is the call graph for this function:

Here is the caller graph for this function:

getElongation()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getElongation

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 881 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  static_assert(providesElongation<PARTICLETYPE>(), "Field SURFACE:ELONGATION has to be provided");
  Vector<T,D> elongation( particle.template getField<SURFACE,ELONGATION>() );
  return elongation;
}

References providesElongation().

Here is the call graph for this function:

Here is the caller graph for this function:

getEnlargementForContact()

template<typename T , typename PARTICLETYPE >

T olb::particles::access::getEnlargementForContact

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 892 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  if constexpr (access::providesEnlargementForContactTreatment<PARTICLETYPE>()) {
    return particle.template getField<NUMERICPROPERTIES,ENLARGEMENT_FOR_CONTACT>();
  }
  else {
    return T{0.};
  }
 
  __builtin_unreachable();
}

References providesEnlargementForContactTreatment().

Here is the call graph for this function:

Here is the caller graph for this function:

getForce()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getForce

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 566 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  static_assert(providesForce<PARTICLETYPE>(), "Field FORCING:FORCE has to be provided");
  Vector<T,D> force( particle.template getField<FORCING,FORCE>() );
  return force;
}

References providesForce().

Here is the call graph for this function:

Here is the caller graph for this function:

getGlobalIC()

template<typename T , typename PARTICLETYPE >

auto olb::particles::access::getGlobalIC

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 806 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesID<PARTICLETYPE>(), "Field PARALLELIZATION:ID has to be provided");
  auto globalIC = particle.template getField<PARALLELIZATION,IC>();
  return globalIC;
}

References providesID().

Here is the call graph for this function:

getGlobalID()

template<typename T , typename PARTICLETYPE >

auto olb::particles::access::getGlobalID

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 796 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesID<PARTICLETYPE>(), "Field PARALLELIZATION:ID has to be provided");
  auto globalID = particle.template getField<PARALLELIZATION,ID>();
  return globalID;
}

References providesID().

Here is the call graph for this function:

Here is the caller graph for this function:

getMass()

template<typename T , typename PARTICLETYPE >

T olb::particles::access::getMass	(	Particle< T, PARTICLETYPE >	particle,
		T	shapeFactor = T{1} )

Definition at line 704 of file dataAccessWrappers.h.

                                                                                {1} )
{
  using namespace descriptors;
  static_assert(providesMassOrDensity(particle),
      "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
  T mass;
  // Always rather use the mass field than the density field
  if constexpr(providesMass(particle)) {
    mass = particle.template getField<PHYSPROPERTIES, MASS>();
  }
  else {
    const T density = particle.template getField<PHYSPROPERTIES, DENSITY>();
    mass = density * getVolume(particle, shapeFactor);
  }
  return mass;
}

Here is the caller graph for this function:

getMomentOfInertia()

template<typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > olb::particles::access::getMomentOfInertia

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 586 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
  static_assert(providesMomentOfInertia<PARTICLETYPE>(), "Field PHYSPROPERTIES:MOFI has to be provided");
  Vector<T,Drot> mofi( particle.template getField<PHYSPROPERTIES,MOFI>() );
  return mofi;
}

References providesMomentOfInertia().

Here is the call graph for this function:

Here is the caller graph for this function:

getPosition()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getPosition

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 495 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  static_assert(providesPosition<PARTICLETYPE>(),
      "Field GENERAL:POSITION has to be provided");
  Vector<T,D> position( particle.template getField<GENERAL,POSITION>() );
  return position;
}

References providesPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

getRadius()

template<typename T , typename PARTICLETYPE >

T olb::particles::access::getRadius

(

Particle< T, PARTICLETYPE > &

particle

)

Definition at line 640 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  T radius;
  if constexpr (providesSmoothIndicator<PARTICLETYPE>() ) {
    radius = getSmoothIndicatorPtr(particle)->getCircumRadius();
  }
  else if constexpr ( providesRadius<PARTICLETYPE>() ) {
    radius = particle.template getField<PHYSPROPERTIES,RADIUS>();
  }
  else {
    std::cerr << "ERROR: no Field found providing radius!" << std::endl;
  }
  return radius;
}

References getSmoothIndicatorPtr(), providesRadius(), and providesSmoothIndicator().

Here is the call graph for this function:

Here is the caller graph for this function:

getRotationMatrix()

template<typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::matrix > olb::particles::access::getRotationMatrix

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 521 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  const unsigned DrotMat = utilities::dimensions::convert<PARTICLETYPE::d>::matrix;
  static_assert(providesRotationMatrix<PARTICLETYPE>(), "Field SURFACE:ROT_MATRIX has to be provided");
  Vector<T,DrotMat> rotationMatrix( particle.template getField<SURFACE,ROT_MATRIX>() );
  return rotationMatrix;
}

References providesRotationMatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

getSmoothIndicatorPtr()

template<typename T , typename PARTICLETYPE >

auto olb::particles::access::getSmoothIndicatorPtr

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 630 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesSmoothIndicator<PARTICLETYPE>(), "Field FORCING:SINDICATOR has to be provided");
  auto sIndicatorPtr = particle.template getField<SURFACE,SINDICATOR>();
  return sIndicatorPtr;
}

References providesSmoothIndicator().

Here is the call graph for this function:

Here is the caller graph for this function:

getSurfaceNormal()

template<unsigned dir = 2, typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getSurfaceNormal

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 531 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  auto rotationMatrix = getRotationMatrix( particle );
  //Note: Convention here, positively pointing towards dir (default z-dir)
  Vector<T,D> normal;
  for (unsigned iDim=0; iDim<D; ++iDim) {
    unsigned iMat = D*iDim+dir;
    normal[iDim] = rotationMatrix[iMat];
  }
  return normal;
}

References getRotationMatrix().

Here is the call graph for this function:

getTorque()

template<typename T , typename PARTICLETYPE >

Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > olb::particles::access::getTorque

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 576 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
  static_assert(providesTorque<PARTICLETYPE>(), "Field FORCING:TORQUE has to be provided");
  Vector<T,Drot> torque( particle.template getField<FORCING,TORQUE>() );
  return torque;
}

References providesTorque().

Here is the call graph for this function:

Here is the caller graph for this function:

getVelocity()

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::access::getVelocity

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 546 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  static_assert(providesVelocity<PARTICLETYPE>(), "Field MOBILITY:VELOCITY has to be provided");
  Vector<T,D> velocity( particle.template getField<MOBILITY,VELOCITY>() );
  return velocity;
}

References providesVelocity().

Here is the call graph for this function:

Here is the caller graph for this function:

getVolume()

template<typename T , typename PARTICLETYPE >

T olb::particles::access::getVolume	(	Particle< T, PARTICLETYPE >	particle,
		T	shapeFactor = T{1} )

Returns the volume of a particle (for subgrid the volume of a sphere/circle is multiplied by the shapeFactor), i.e., the shape factor is the volume ratio of the shape of interest to a sphere/circle.

Definition at line 659 of file dataAccessWrappers.h.

                                                                                  {1} )
{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  T volume;
  if constexpr(providesSurface(particle)) {
    if constexpr (D == 3) {
      volume = getSmoothIndicatorPtr(particle)->getVolume();
    }
    else {
      volume = getSmoothIndicatorPtr(particle)->getArea();
    }
  }
  else {
    const T radius = getRadius(particle);
    if constexpr(D == 3) {
      volume = (4./3.) * M_PI * util::pow(radius, D);
    }
    else {
      volume = M_PI * util::pow(radius, D);
    }
    volume *= shapeFactor;
  }
  return volume;
}

is2D() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::is2D ( )

constexpr

Definition at line 473 of file dataAccessWrappers.h.

{
  return (PARTICLETYPE::d==2);
}

Here is the caller graph for this function:

is2D() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::is2D ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 478 of file dataAccessWrappers.h.

                                                       {
  return is2D<PARTICLETYPE>();
}

References is2D().

Here is the call graph for this function:

is3D() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::is3D ( )

constexpr

Definition at line 483 of file dataAccessWrappers.h.

{
  return (PARTICLETYPE::d==3);
}

Here is the caller graph for this function:

is3D() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::is3D ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 488 of file dataAccessWrappers.h.

                                                       {
  return is3D<PARTICLETYPE>();
}

References is3D().

Here is the call graph for this function:

isActive()

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::isActive

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 618 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  bool active = true;
  if constexpr(providesActive<PARTICLETYPE>()) {
    active = particle.template getField<DYNBEHAVIOUR,ACTIVE>();
  }
  return active;
}

References providesActive().

Here is the call graph for this function:

Here is the caller graph for this function:

isContactComputationEnabled() [1/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::isContactComputationEnabled

(

Particle< T, PARTICLETYPE > &

particle

)

Check if contact should be regarded (specification for a single particle)

Definition at line 1170 of file dataAccessWrappers.h.

{
  using namespace descriptors;
 
  // if the field is not provided, return true by default
  // (meaning that the contact forces are computed and applied to the force field)
  if constexpr(!providesComputeContact<PARTICLETYPE>()) {
    return true;
  }
  else {
    return particle.template getField<DYNBEHAVIOUR,COMPUTE_CONTACT>();
  }
 
  __builtin_unreachable();
}

References providesComputeContact().

Here is the call graph for this function:

Here is the caller graph for this function:

isContactComputationEnabled() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::isContactComputationEnabled	(	Particle< T, PARTICLETYPE > &	particleA,
		Particle< T, PARTICLETYPE > &	particleB )

Check if contact should be regarded (interaction of two known particles)

Definition at line 1188 of file dataAccessWrappers.h.

{
  return (isContactComputationEnabled(particleA) || isContactComputationEnabled(particleB));
}

References isContactComputationEnabled().

Here is the call graph for this function:

isDetaching()

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::isDetaching

(

Particle< T, PARTICLETYPE > &

particle

)

Definition at line 827 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesDetaching<PARTICLETYPE>(),
                "Field DYNBEHAVIOUR:DETACHING has to be provided");
  bool detaching = particle.template getField<DYNBEHAVIOUR,DETACHING>();
    return detaching;
  }

References providesDetaching().

Here is the call graph for this function:

isMotionComputationEnabled()

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::isMotionComputationEnabled

(

Particle< T, PARTICLETYPE > &

particle

)

Check if motion is enabled.

Definition at line 1153 of file dataAccessWrappers.h.

{
  using namespace descriptors;
 
  // if the field is not provided, return true by default
  if constexpr(!providesComputeMotion<PARTICLETYPE>()) {
    return true;
  }
  else {
    return particle.template getField<DYNBEHAVIOUR,COMPUTE_MOTION>();
  }
 
  __builtin_unreachable();
}

References providesComputeMotion().

Here is the call graph for this function:

Here is the caller graph for this function:

isValid()

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::isValid

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 607 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  bool valid = true;
  if constexpr(providesValid<PARTICLETYPE>()) {
    valid = !particle.template getField<GENERAL,INVALID>();
  }
  return valid;
}

References providesValid().

Here is the call graph for this function:

Here is the caller graph for this function:

providesAccelerationStrd() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesAccelerationStrd ( )

constexpr

Definition at line 418 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<MOBILITY,ACCELERATION_STRD>();
}

Here is the caller graph for this function:

providesAccelerationStrd() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesAccelerationStrd ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 424 of file dataAccessWrappers.h.

                                                                           {
  return providesAccelerationStrd<PARTICLETYPE>();
}

References providesAccelerationStrd().

Here is the call graph for this function:

providesActive() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesActive ( )

constexpr

Provides field ACTIVE.

Definition at line 290 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<DYNBEHAVIOUR,ACTIVE>();
}

Here is the caller graph for this function:

providesActive() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesActive ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 296 of file dataAccessWrappers.h.

                                                                 {
  return providesActive<PARTICLETYPE>();
}

References providesActive().

Here is the call graph for this function:

providesAdhesion() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesAdhesion ( )

constexpr

Provides field ADHESION.

Definition at line 242 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<FORCING,ADHESION>();
}

Here is the caller graph for this function:

providesAdhesion() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesAdhesion ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 248 of file dataAccessWrappers.h.

                                                                   {
  return providesAdhesion<PARTICLETYPE>();
}

References providesAdhesion().

Here is the call graph for this function:

providesAngAccelerationStrd() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesAngAccelerationStrd ( )

constexpr

Definition at line 429 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<MOBILITY,ANG_ACC_STRD>();
}

Here is the caller graph for this function:

providesAngAccelerationStrd() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesAngAccelerationStrd ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 435 of file dataAccessWrappers.h.

                                                                              {
  return providesAngAccelerationStrd<PARTICLETYPE>();
}

References providesAngAccelerationStrd().

Here is the call graph for this function:

providesAngle() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesAngle ( )

constexpr

Provides field ANGLE.

Definition at line 182 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<SURFACE,ANGLE>();
}

Here is the caller graph for this function:

providesAngle() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesAngle ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 188 of file dataAccessWrappers.h.

                                                                {
  return providesAngle<PARTICLETYPE>();
}

References providesAngle().

Here is the call graph for this function:

providesAngVelocity() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesAngVelocity ( )

constexpr

Provides field VELOCITY.

Definition at line 206 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<MOBILITY,ANG_VELOCITY>();
}

Here is the caller graph for this function:

providesAngVelocity() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesAngVelocity ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 212 of file dataAccessWrappers.h.

                                                                      {
  return providesAngVelocity<PARTICLETYPE>();
}

References providesAngVelocity().

Here is the call graph for this function:

providesComputeContact() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesComputeContact ( )

constexpr

Provides field COMPUTE_CONTACT.

Definition at line 314 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<DYNBEHAVIOUR,COMPUTE_CONTACT>();
}

Here is the caller graph for this function:

providesComputeContact() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesComputeContact ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 320 of file dataAccessWrappers.h.

                                                                         {
  return providesComputeContact<PARTICLETYPE>();
}

References providesComputeContact().

Here is the call graph for this function:

providesComputeMotion() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesComputeMotion ( )

constexpr

Provides field COMPUTE_MOTION.

Definition at line 302 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<DYNBEHAVIOUR,COMPUTE_MOTION>();
}

Here is the caller graph for this function:

providesComputeMotion() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesComputeMotion ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 308 of file dataAccessWrappers.h.

                                                                        {
  return providesComputeMotion<PARTICLETYPE>();
}

References providesComputeMotion().

Here is the call graph for this function:

providesContactMaterial() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesContactMaterial ( )

constexpr

Definition at line 462 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<MECHPROPERTIES,MATERIAL>();
}

Here is the caller graph for this function:

providesContactMaterial() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesContactMaterial ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 468 of file dataAccessWrappers.h.

                                                                          {
  return providesContactMaterial<PARTICLETYPE>();
}

References providesContactMaterial().

Here is the call graph for this function:

providesCORoffset() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesCORoffset ( )

constexpr

Definition at line 396 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<SURFACE,COR_OFFSET>();
}

Here is the caller graph for this function:

providesCORoffset() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesCORoffset ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 402 of file dataAccessWrappers.h.

                                                                    {
  return providesCORoffset<PARTICLETYPE>();
}

References providesCORoffset().

Here is the call graph for this function:

providesDensity() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesDensity ( )

constexpr

Provides field DENSITY.

Definition at line 146 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PHYSPROPERTIES,DENSITY>();
}

Here is the caller graph for this function:

providesDensity() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesDensity ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 152 of file dataAccessWrappers.h.

                                                                  {
  return providesDensity<PARTICLETYPE>();
}

References providesDensity().

Here is the call graph for this function:

providesDetaching() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesDetaching ( )

constexpr

Definition at line 385 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<DYNBEHAVIOUR,DETACHING>();
}

Here is the caller graph for this function:

providesDetaching() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesDetaching ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 391 of file dataAccessWrappers.h.

                                                                    {
  return providesDetaching<PARTICLETYPE>();
}

References providesDetaching().

Here is the call graph for this function:

providesDynamicsID() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesDynamicsID ( )

constexpr

Provides field DYNAMICS_ID.

Definition at line 278 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<DYNBEHAVIOUR,DYNAMICS_ID>();
}

Here is the caller graph for this function:

providesDynamicsID() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesDynamicsID ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 284 of file dataAccessWrappers.h.

                                                                     {
  return providesDynamicsID<PARTICLETYPE>();
}

References providesDynamicsID().

Here is the call graph for this function:

providesElongation() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesElongation ( )

constexpr

Definition at line 407 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<SURFACE,ELONGATION>();
}

Here is the caller graph for this function:

providesElongation() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesElongation ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 413 of file dataAccessWrappers.h.

                                                                     {
  return providesElongation<PARTICLETYPE>();
}

References providesElongation().

Here is the call graph for this function:

providesEnlargementForContactTreatment() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesEnlargementForContactTreatment ( )

constexpr

Definition at line 440 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<NUMERICPROPERTIES,ENLARGEMENT_FOR_CONTACT>();
}

Here is the caller graph for this function:

providesEnlargementForContactTreatment() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesEnlargementForContactTreatment ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 446 of file dataAccessWrappers.h.

                                                                                         {
  return providesEnlargementForContactTreatment<PARTICLETYPE>();
}

References providesEnlargementForContactTreatment().

Here is the call graph for this function:

providesForce() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesForce ( )

constexpr

Provides field FORCE.

Definition at line 218 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<FORCING,FORCE>();
}

Here is the caller graph for this function:

providesForce() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesForce ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 224 of file dataAccessWrappers.h.

                                                                {
  return providesForce<PARTICLETYPE>();
}

References providesForce().

Here is the call graph for this function:

providesID() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesID ( )

constexpr

Provides field ID.

Definition at line 98 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PARALLELIZATION,ID>();
}

Here is the caller graph for this function:

providesID() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesID ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 104 of file dataAccessWrappers.h.

                                                             {
  return providesID<PARTICLETYPE>();
}

References providesID().

Here is the call graph for this function:

providesInvalid() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesInvalid ( )

constexpr

Provides field ID.

Definition at line 110 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<GENERAL,INVALID>();
}

Here is the caller graph for this function:

providesInvalid() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesInvalid ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 116 of file dataAccessWrappers.h.

                                                                  {
  return providesInvalid<PARTICLETYPE>();
}

References providesInvalid().

Here is the call graph for this function:

providesIsInContact() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesIsInContact ( )

constexpr

Definition at line 451 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<NUMERICPROPERTIES,IS_IN_CONTACT>();
}

Here is the caller graph for this function:

providesIsInContact() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesIsInContact ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 457 of file dataAccessWrappers.h.

                                                                      {
  return providesIsInContact<PARTICLETYPE>();
}

References providesIsInContact().

Here is the call graph for this function:

providesMass() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesMass ( )

constexpr

Provides field MASS.

Definition at line 158 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PHYSPROPERTIES,MASS>();
}

Here is the caller graph for this function:

providesMass() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesMass ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 164 of file dataAccessWrappers.h.

                                                               {
  return providesMass<PARTICLETYPE>();
}

References providesMass().

Here is the call graph for this function:

providesMassOrDensity() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesMassOrDensity ( )

constexpr

Provides field MASS or DENSITY.

Definition at line 170 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return providesMass<PARTICLETYPE>() || providesDensity<PARTICLETYPE>();
}

References providesDensity(), and providesMass().

Here is the call graph for this function:

Here is the caller graph for this function:

providesMassOrDensity() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesMassOrDensity ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 176 of file dataAccessWrappers.h.

                                                                        {
  return providesMassOrDensity<PARTICLETYPE>();
}

References providesMassOrDensity().

Here is the call graph for this function:

providesMomentOfInertia() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesMomentOfInertia ( )

constexpr

Provides field MOFI.

Definition at line 254 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PHYSPROPERTIES,MOFI>();
}

Here is the caller graph for this function:

providesMomentOfInertia() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesMomentOfInertia ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 260 of file dataAccessWrappers.h.

                                                                          {
  return providesMomentOfInertia<PARTICLETYPE>();
}

References providesMomentOfInertia().

Here is the call graph for this function:

providesParallelization() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesParallelization ( )

constexpr

Provides group PARALLELIZATION.

Definition at line 363 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PARALLELIZATION>();
}

Here is the caller graph for this function:

providesParallelization() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesParallelization ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 369 of file dataAccessWrappers.h.

                                                                          {
  return providesParallelization<PARTICLETYPE>();
}

References providesParallelization().

Here is the call graph for this function:

providesPosition() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesPosition ( )

constexpr

Provides field POSITION.

Definition at line 122 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<GENERAL,POSITION>();
}

Here is the caller graph for this function:

providesPosition() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesPosition ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 128 of file dataAccessWrappers.h.

                                                                   {
  return providesPosition<PARTICLETYPE>();
}

References providesPosition().

Here is the call graph for this function:

providesRadius() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesRadius ( )

constexpr

Provides field RADIUS.

Definition at line 134 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PHYSPROPERTIES,RADIUS>();
}

Here is the caller graph for this function:

providesRadius() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesRadius ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 140 of file dataAccessWrappers.h.

                                                                 {
  return providesRadius<PARTICLETYPE>();
}

References providesRadius().

Here is the call graph for this function:

providesRotationMatrix() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesRotationMatrix ( )

constexpr

Provides field ROT_MATRIX.

Definition at line 326 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<SURFACE,ROT_MATRIX>();
}

Here is the caller graph for this function:

providesRotationMatrix() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesRotationMatrix ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 332 of file dataAccessWrappers.h.

                                                                         {
  return providesRotationMatrix<PARTICLETYPE>();
}

References providesRotationMatrix().

Here is the call graph for this function:

providesSmoothIndicator() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesSmoothIndicator ( )

constexpr

Definition at line 350 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<SURFACE,SINDICATOR>();
}

Here is the caller graph for this function:

providesSmoothIndicator() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesSmoothIndicator ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 356 of file dataAccessWrappers.h.

{
  return providesSmoothIndicator<PARTICLETYPE>();
}

References providesSmoothIndicator().

Here is the call graph for this function:

providesSpecies() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesSpecies ( )

constexpr

Definition at line 374 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<PHYSPROPERTIES,SPECIES>();
}

Here is the caller graph for this function:

providesSpecies() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesSpecies ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 380 of file dataAccessWrappers.h.

                                                                  {
  return providesSpecies<PARTICLETYPE>();
}

References providesSpecies().

Here is the call graph for this function:

providesSurface() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesSurface ( )

constexpr

Provides group SURFACE.

Definition at line 338 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<SURFACE>();
}

Here is the caller graph for this function:

providesSurface() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesSurface ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 344 of file dataAccessWrappers.h.

                                                                  {
  return providesSurface<PARTICLETYPE>();
}

References providesSurface().

Here is the call graph for this function:

providesTorque() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesTorque ( )

constexpr

Provides field TORQUE.

Definition at line 230 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<FORCING,TORQUE>();
}

Here is the caller graph for this function:

providesTorque() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesTorque ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 236 of file dataAccessWrappers.h.

                                                                 {
  return providesTorque<PARTICLETYPE>();
}

References providesTorque().

Here is the call graph for this function:

providesValid() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesValid ( )

constexpr

Provides field INVALID.

Definition at line 266 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<GENERAL,INVALID>();
}

Here is the caller graph for this function:

providesValid() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesValid ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 272 of file dataAccessWrappers.h.

                                                                {
  return providesValid<PARTICLETYPE>();
}

References providesValid().

Here is the call graph for this function:

providesVelocity() [1/2]

template<typename PARTICLETYPE >

bool olb::particles::access::providesVelocity ( )

constexpr

Provides field VELOCITY.

Definition at line 194 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  return PARTICLETYPE::template providesNested<MOBILITY,VELOCITY>();
}

Here is the caller graph for this function:

providesVelocity() [2/2]

template<typename T , typename PARTICLETYPE >

bool olb::particles::access::providesVelocity ( Particle< T, PARTICLETYPE > & particle )

constexpr

Definition at line 200 of file dataAccessWrappers.h.

                                                                   {
  return providesVelocity<PARTICLETYPE>();
}

References providesVelocity().

Here is the call graph for this function:

setAccelerationStrd()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setAccelerationStrd	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, PARTICLETYPE::d >	acceleration )

Definition at line 732 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesAccelerationStrd<PARTICLETYPE>(), "Field MOBILITY:ACCELERATION has to be provided");
  if constexpr(providesAccelerationStrd(particle)) {
    particle.template setField<MOBILITY, ACCELERATION_STRD>(acceleration);
  }
}

References providesAccelerationStrd().

Here is the call graph for this function:

Here is the caller graph for this function:

setActive()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setActive	(	Particle< T, PARTICLETYPE >	particle,
		bool	value = true )

Definition at line 1061 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesActive<PARTICLETYPE>(), "Field DYNBEHAVIOUR:ACTIVE has to be provided");
  particle.template setField<DYNBEHAVIOUR,ACTIVE>( value );
}

References providesActive().

Here is the call graph for this function:

Here is the caller graph for this function:

setAdhesion()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setAdhesion	(	Particle< T, PARTICLETYPE > &	particle,
		Vector< T, 2 >	adhesion )

Definition at line 1039 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesAdhesion<PARTICLETYPE>(), "Field FORCING:ADHESION has to be provided");
  particle.template setField<FORCING,ADHESION>(adhesion);
}

References providesAdhesion().

Here is the call graph for this function:

setAngAccelerationStrd()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setAngAccelerationStrd	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	angAcceleration )

Definition at line 1001 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesAngAccelerationStrd<PARTICLETYPE>(), "Field MOBILITY:ANG_ACC_STRD has to be provided");
  particle.template setField<MOBILITY,ANG_ACC_STRD>(utilities::dimensions::convert<
                                             PARTICLETYPE::d>::serialize_rotation(angAcceleration));
}

References providesAngAccelerationStrd().

Here is the call graph for this function:

Here is the caller graph for this function:

setAngle()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setAngle	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	angle )

Definition at line 967 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesAngle<PARTICLETYPE>(), "Field SURFACE:ANGLE has to be provided");
  particle.template setField<SURFACE, ANGLE>(utilities::dimensions::convert<
                  PARTICLETYPE::d>::serialize_rotation(angle));
}

References providesAngle().

Here is the call graph for this function:

setAngularVelocity()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setAngularVelocity	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	angVelocity )

Definition at line 992 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesAngVelocity<PARTICLETYPE>(), "Field MOBILITY:ANG_VELOCITY has to be provided");
  particle.template setField<MOBILITY,ANG_VELOCITY>(utilities::dimensions::convert<
                                             PARTICLETYPE::d>::serialize_rotation(angVelocity));
}

References providesAngVelocity().

Here is the call graph for this function:

Here is the caller graph for this function:

setContactMaterial()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setContactMaterial	(	Particle< T, PARTICLETYPE >	particle,
		unsigned	material )

Definition at line 958 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesContactMaterial(particle),
      "Field MECHPROPERTIES::MATERIAL has to be provided");
  particle.template setField<MECHPROPERTIES, MATERIAL>(material);
}

References providesContactMaterial().

Here is the call graph for this function:

setCORoffset()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setCORoffset	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, PARTICLETYPE::d >	offsetCOR )

Definition at line 1128 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesCORoffset<PARTICLETYPE>(), "Field SURFACE:COR_OFFSET has to be provided");
  particle.template setField<SURFACE,COR_OFFSET>(offsetCOR);
}

References providesCORoffset().

Here is the call graph for this function:

setDensity()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setDensity	(	Particle< T, PARTICLETYPE >	particle,
		T	density,
		T	shapeFactor = T{1} )

Definition at line 917 of file dataAccessWrappers.h.

                                                                                                 {1} )
{
  using namespace descriptors;
  static_assert(providesMassOrDensity(particle),
      "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
 
  if constexpr(providesDensity(particle)) {
    particle.template setField<PHYSPROPERTIES, DENSITY>(density);
  }
  if constexpr(providesMass(particle)) {
    const T mass = density * getVolume(particle, shapeFactor);
    particle.template setField<PHYSPROPERTIES, MASS>(mass);
  }
}

Here is the caller graph for this function:

setDetaching()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setDetaching	(	Particle< T, PARTICLETYPE > &	particle,
		bool	value )

Definition at line 1119 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesDetaching<PARTICLETYPE>(),
                "Field DYNBEHAVIOUR:DETACHING has to be provided");
  particle.template setField<DYNBEHAVIOUR,DETACHING>(value);
}

References providesDetaching().

Here is the call graph for this function:

setDynamicsID()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setDynamicsID	(	Particle< T, PARTICLETYPE > &	particle,
		unsigned short	dynamicsID )

Definition at line 1110 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesDynamicsID<PARTICLETYPE>(),
                "Field DYNBEHAVIOUR:DYNAMICS_ID has to be provided");
  particle.template setField<DYNBEHAVIOUR,DYNAMICS_ID>(dynamicsID);
}

References providesDynamicsID().

Here is the call graph for this function:

setElongation()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setElongation	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, PARTICLETYPE::d >	elongation )

Definition at line 1136 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesElongation<PARTICLETYPE>(), "Field SURFACE:ELONGATION has to be provided");
  particle.template setField<SURFACE,ELONGATION>(elongation);
}

References providesElongation().

Here is the call graph for this function:

setEnlargementForContact()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setEnlargementForContact	(	Particle< T, PARTICLETYPE > &	particle,
		T	value )

Definition at line 1144 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(access::providesEnlargementForContactTreatment<PARTICLETYPE>(), "Field NUMERICPROPERTIES:ENLARGEMENT_FOR_CONTACT has to be provided");
  particle.template setField<NUMERICPROPERTIES, ENLARGEMENT_FOR_CONTACT>(value);
}

References providesEnlargementForContactTreatment().

Here is the call graph for this function:

setForce()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setForce	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, PARTICLETYPE::d >	force )

Definition at line 1012 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesForce<PARTICLETYPE>(), "Field FORCING:FORCE has to be provided");
  particle.template setField<FORCING,FORCE>(force);
}

References providesForce().

Here is the call graph for this function:

setGlobalIC()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setGlobalIC	(	Particle< T, PARTICLETYPE >	particle,
		int	id )

Definition at line 1102 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesID<PARTICLETYPE>(), "Field PARALLELIZATION:ID has to be provided");
  particle.template setField<PARALLELIZATION,IC>(id);
}

References providesID().

Here is the call graph for this function:

setGlobalID()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setGlobalID	(	Particle< T, PARTICLETYPE >	particle,
		std::size_t	id )

Definition at line 1094 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesID<PARTICLETYPE>(), "Field PARALLELIZATION:ID has to be provided");
  particle.template setField<PARALLELIZATION,ID>(id);
}

References providesID().

Here is the call graph for this function:

setInactive()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setInactive	(	Particle< T, PARTICLETYPE >	particle,
		bool	value = true )

Definition at line 1069 of file dataAccessWrappers.h.

{
  setActive(particle, !value);
}

References setActive().

Here is the call graph for this function:

Here is the caller graph for this function:

setInvalid()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setInvalid	(	Particle< T, PARTICLETYPE >	particle,
		bool	value = true )

Definition at line 1047 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesInvalid<PARTICLETYPE>(), "Field GENERAL:INVALID has to be provided");
  particle.template setField<GENERAL,INVALID>( value );
}

References providesInvalid().

Here is the call graph for this function:

Here is the caller graph for this function:

setMass()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setMass	(	Particle< T, PARTICLETYPE >	particle,
		T	mass,
		T	shapeFactor = T{1} )

Definition at line 933 of file dataAccessWrappers.h.

                                                                                           {1} )
{
  using namespace descriptors;
  static_assert(providesMassOrDensity(particle),
      "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
 
  if constexpr(providesMass(particle)) {
    particle.template setField<PHYSPROPERTIES, MASS>(mass);
  }
  if constexpr(providesDensity(particle)){
    const T density = mass / getVolume(particle, shapeFactor);
    particle.template setField<PHYSPROPERTIES, DENSITY>(density);
  }
}

setMomentOfInertia()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setMomentOfInertia	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	mofi )

Definition at line 1029 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesMomentOfInertia<PARTICLETYPE>(), "Field PHYSPROPERTIES:MOFI has to be provided");
  particle.template setField<PHYSPROPERTIES,MOFI>(utilities::dimensions::convert<
                                              PARTICLETYPE::d>::serialize_rotation(mofi));
}

References providesMomentOfInertia().

Here is the call graph for this function:

setPosition()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setPosition	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, PARTICLETYPE::d >	position )

Definition at line 949 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesPosition(particle),
      "Field GENERAL:POSITION has to be provided");
  particle.template setField<GENERAL, POSITION>(position);
}

References providesPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

setRadius()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setRadius	(	Particle< T, PARTICLETYPE > &	particle,
		T	radius )

Definition at line 1086 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesRadius<PARTICLETYPE>(), "Field PHYSPROPERTIES:RADIUS has to be provided");
  particle.template setField<PHYSPROPERTIES,RADIUS>(radius);
}

References providesRadius().

Here is the call graph for this function:

setRestingParticle()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setRestingParticle

(

Particle< T, PARTICLETYPE >

particle

)

Definition at line 1223 of file dataAccessWrappers.h.

{
  if constexpr(providesVelocity(particle)){
      setVelocity(particle, Vector<T,PARTICLETYPE::d>(0.));
  }
 
  if constexpr(providesAccelerationStrd(particle)){
      setAccelerationStrd(particle, Vector<T,PARTICLETYPE::d>(0.));
  }
 
 
  if constexpr(providesAngVelocity(particle)){
      setAngularVelocity(particle, Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>(0.));
  }
 
  if constexpr(providesAngAccelerationStrd(particle)){
      setAngAccelerationStrd(particle, Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>(0.));
  }
}

References providesAccelerationStrd(), providesAngAccelerationStrd(), providesAngVelocity(), providesVelocity(), setAccelerationStrd(), setAngAccelerationStrd(), setAngularVelocity(), and setVelocity().

Here is the call graph for this function:

Here is the caller graph for this function:

setRotationMatrix()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setRotationMatrix	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::matrix >	rotMatrix )

Definition at line 976 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesRotationMatrix<PARTICLETYPE>(), "Field SURFACE:ROT_MATRIX has to be provided");
  particle.template setField<SURFACE,ROT_MATRIX>(rotMatrix);
}

References providesRotationMatrix().

Here is the call graph for this function:

setSmoothIndicatorPtr()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setSmoothIndicatorPtr	(	Particle< T, PARTICLETYPE >	particle,
		SmoothIndicatorF< T, T, PARTICLETYPE::d, true > *	sindicator )

Definition at line 1076 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesSmoothIndicator<PARTICLETYPE>(), "Field FORCING:SINDICATOR has to be provided");
  particle.template setField<SURFACE,SINDICATOR>(sindicator);
}

References providesSmoothIndicator().

Here is the call graph for this function:

setTorque()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setTorque	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	torque )

Definition at line 1020 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesTorque<PARTICLETYPE>(), "Field FORCING:TORQUE has to be provided");
  particle.template setField<FORCING,TORQUE>(utilities::dimensions::convert<
                                             PARTICLETYPE::d>::serialize_rotation(torque));
}

References providesTorque().

Here is the call graph for this function:

setValid()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setValid	(	Particle< T, PARTICLETYPE >	particle,
		bool	value = true )

Definition at line 1055 of file dataAccessWrappers.h.

{
  setInvalid(particle, !value);
}

References setInvalid().

Here is the call graph for this function:

setVelocity()

template<typename T , typename PARTICLETYPE >

void olb::particles::access::setVelocity	(	Particle< T, PARTICLETYPE >	particle,
		Vector< T, PARTICLETYPE::d >	velocity )

Definition at line 984 of file dataAccessWrappers.h.

{
  using namespace descriptors;
  static_assert(providesVelocity<PARTICLETYPE>(), "Field MOBILITY:VELOCITY has to be provided");
  particle.template setField<MOBILITY,VELOCITY>(velocity);
}

References providesVelocity().

Here is the call graph for this function:

Here is the caller graph for this function: