OpenLB 1.7
Loading...
Searching...
No Matches
Functions
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 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.

47{
48 T data[3][3] = {
49 {momentOfInertia[0], T {0}, T {0}},
50 { T {0}, momentOfInertia[1], T {0}},
51 { T {0}, T {0}, momentOfInertia[2]}
52 };
53 Matrix<T, 3, 3> inertiaTensor(data);
54 inertiaTensor = (rotationMatrix * inertiaTensor) * (rotationMatrix.transpose());
55
56 /*
57 * In the following, we use the solution of a linear equation system
58 * torque = inertia tensor * angular acceleration + angular velocity x (inertia tensor * angular velocity)
59 * Here, we want to know the components of the angular acceleration
60 * In the following, left = torque - angular velocity x (inertia tensor * angular velocity)
61 */
62
63 // const Vector<T,3> angularVelocity = getAngularVelocity(particle);
64 // Using Euler's equation for rigid body dynamics
65 // Currently not, as it leads to inaccurate results of some tests
66 // Add the cross product to use Euler's equation for rigid body dynamics
67 const Vector<T,3> left = torque;//- crossProduct3D(angularVelocity, (inertiaTensor * angularVelocity));
68
69 const T denominator = util::pow(inertiaTensor[0][2], 2) * inertiaTensor[1][1]
70 + inertiaTensor[0][0] * util::pow(inertiaTensor[1][2], 2)
71 - 2 * inertiaTensor[0][1] * inertiaTensor[0][2] * inertiaTensor[1][2]
72 + util::pow(inertiaTensor[0][1], 2) * inertiaTensor[2][2]
73 - inertiaTensor[0][0] * inertiaTensor[1][1] * inertiaTensor[2][2];
74 const T factor = T{1} / denominator;
75
76 Vector<T,3> angularAcceleration;
77 angularAcceleration[0] = (util::pow(inertiaTensor[1][2], 2) - inertiaTensor[1][1] * inertiaTensor[2][2]) * left[0]
78 + (- inertiaTensor[0][2] * inertiaTensor[1][2] + inertiaTensor[0][1] * inertiaTensor[2][2]) * left[1]
79 + (inertiaTensor[0][2] * inertiaTensor[1][1] - inertiaTensor[0][1] * inertiaTensor[1][2]) * left[2];
80 angularAcceleration[1] = (- inertiaTensor[0][2] * inertiaTensor[1][2] + inertiaTensor[0][1] * inertiaTensor[2][2]) * left[0]
81 + (util::pow(inertiaTensor[0][2], 2) - inertiaTensor[0][0] * inertiaTensor[2][2]) * left[1]
82 + (- inertiaTensor[0][1] * inertiaTensor[0][2] + inertiaTensor[0][0] * inertiaTensor[1][2]) * left[2];
83 angularAcceleration[2] = (inertiaTensor[0][2] * inertiaTensor[1][1] - inertiaTensor[0][1] * inertiaTensor[1][2]) * left[0]
84 + (- inertiaTensor[0][1] * inertiaTensor[0][2] + inertiaTensor[0][0] * inertiaTensor[1][2]) * left[1]
85 + (util::pow(inertiaTensor[0][1], 2) - inertiaTensor[0][0] * inertiaTensor[1][1]) * left[2];
86
87 for(unsigned iDim = 0; iDim < 3; ++iDim) {
88 angularAcceleration[iDim] *= factor;
89 }
90
91 return angularAcceleration;
92}
olb::Matrix::transpose
constexpr Matrix< T, COLS, ROWS > transpose() const
Definition matrix.h:125

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 1206 of file dataAccessWrappers.h.

1207{
1208 enableContactComputation(particle, !value);
1209}
olb::particles::access::enableContactComputation
void enableContactComputation(Particle< T, PARTICLETYPE > &particle, bool value=true)
Definition dataAccessWrappers.h:1192

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 1200 of file dataAccessWrappers.h.

1201{
1202 enableMotionComputation(particle, !value);
1203}
olb::particles::access::enableMotionComputation
void enableMotionComputation(Particle< T, PARTICLETYPE > &particle, bool value=true)
Definition dataAccessWrappers.h:1184

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 1192 of file dataAccessWrappers.h.

1193{
1194 using namespace descriptors;
1195 static_assert(providesComputeContact<PARTICLETYPE>(), "Field DYNBEHAVIOUR:COMPUTE_CONTACT has to be provided");
1196 particle.template setField<DYNBEHAVIOUR, COMPUTE_CONTACT>(value);
1197}
+ 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 1184 of file dataAccessWrappers.h.

1185{
1186 using namespace descriptors;
1187 static_assert(providesComputeMotion<PARTICLETYPE>(), "Field DYNBEHAVIOUR:COMPUTE_MOTION has to be provided");
1188 particle.template setField<DYNBEHAVIOUR, COMPUTE_MOTION>(value);
1189}
+ 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 731 of file dataAccessWrappers.h.

732{
733 using namespace descriptors;
734 constexpr unsigned D = PARTICLETYPE::d;
735
736 static_assert(providesForce<PARTICLETYPE>(), "Field FORCING:FORCE has to be provided");
737 static_assert(providesMass<PARTICLETYPE>(), "Field PHYSPROPERTIES:MASS has to be provided");
738
739 Vector<T,D> acceleration;
740 Vector<T,D> force = getForce(particle);
741 T mass = getMass(particle);
742 for (unsigned iDim=0; iDim<D; ++iDim) {
743 acceleration[iDim] = force[iDim] / mass;
744 }
745 return acceleration;
746}
olb::Vector
Plain old scalar vector.
Definition vector.h:47
olb::particles::access::getForce
Vector< T, PARTICLETYPE::d > getForce(Particle< T, PARTICLETYPE > particle)
Definition dataAccessWrappers.h:555
olb::particles::access::getMass
T getMass(Particle< T, PARTICLETYPE > particle, T shapeFactor=T{1})
Definition dataAccessWrappers.h:693

References getForce(), and getMass().

+ 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 711 of file dataAccessWrappers.h.

712{
713 using namespace descriptors;
714
715 if(providesAccelerationStrd(particle)){
716 return particle.template getField<MOBILITY,ACCELERATION_STRD>();
717 }
718}
olb::particles::access::providesAccelerationStrd
constexpr bool providesAccelerationStrd()
Definition dataAccessWrappers.h:418

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 586 of file dataAccessWrappers.h.

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

◆ 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 751 of file dataAccessWrappers.h.

753{
754 using namespace descriptors;
755
756 const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
757 static_assert(providesTorque<PARTICLETYPE>(), "Field FORCING:TORQUE has to be provided");
758 static_assert(providesMomentOfInertia<PARTICLETYPE>(), "Field PHYSPROPERTIES:MOFI has to be provided");
759 Vector<T,Drot> angularAcceleration;
760 Vector<T,Drot> torque( getTorque(particle));
761 Vector<T,Drot> momentOfInertia( getMomentOfInertia(particle) );
762 if constexpr (PARTICLETYPE::d == 3 && providesRotationMatrix<PARTICLETYPE>()) {
763 const Matrix<T,3,3> rotationMatrix(getRotationMatrix(particle));
764 angularAcceleration = calcAngAcceleration3D( torque, momentOfInertia, rotationMatrix );
765 } else {
766 for (unsigned iRot=0; iRot<Drot; ++iRot) {
767 angularAcceleration[iRot] = torque[iRot] / momentOfInertia[iRot];
768 }
769 }
770 return angularAcceleration;
771}
olb::Matrix
Matrix with a defined number of ROWS and columns (COLS)
Definition matrix.h:31
olb::particles::access::getRotationMatrix
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::matrix > getRotationMatrix(Particle< T, PARTICLETYPE > particle)
Definition dataAccessWrappers.h:510
olb::particles::access::getMomentOfInertia
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > getMomentOfInertia(Particle< T, PARTICLETYPE > particle)
Definition dataAccessWrappers.h:575
olb::particles::access::calcAngAcceleration3D
Vector< T, 3 > calcAngAcceleration3D(Vector< T, 3 > &torque, Vector< T, 3 > &momentOfInertia, const Matrix< T, 3, 3 > &rotationMatrix)
Definition dataAccessWrappers.h:45
olb::particles::access::getTorque
Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > getTorque(Particle< T, PARTICLETYPE > particle)
Definition dataAccessWrappers.h:565
olb::utilities::dimensions::convert
Converts dimensions by deriving from given cartesian dimension D.
Definition dimensionConverter.h:43

References calcAngAcceleration3D(), getMomentOfInertia(), getRotationMatrix(), and getTorque().

+ 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 774 of file dataAccessWrappers.h.

775{
776 using namespace descriptors;
777
778 if(providesAngAccelerationStrd(particle)){
779 return particle.template getField<MOBILITY,ANG_ACC_STRD>();
780 }
781}
olb::particles::access::providesAngAccelerationStrd
constexpr bool providesAngAccelerationStrd()
Definition dataAccessWrappers.h:429

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 495 of file dataAccessWrappers.h.

496{
497 using namespace descriptors;
498 const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
499 static_assert(providesAngle<PARTICLETYPE>(), "Field SURFACE:ANGLE has to be provided");
500 Vector<T,Drot> angle( particle.template getField<SURFACE,ANGLE>() );
501 if constexpr (ensureAngularBounds){
502 for (unsigned iRot=0; iRot<Drot; ++iRot) {
503 angle[iRot] = util::fmod( angle[iRot], 2.*M_PI );
504 }
505 }
506 return angle;
507}
M_PI
#define M_PI
Definition analyticalF.hh:43

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

+ 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 545 of file dataAccessWrappers.h.

546{
547 using namespace descriptors;
548 const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
549 static_assert(providesAngVelocity<PARTICLETYPE>(), "Field MOBILITY:ANG_VELOCITY has to be provided");
550 Vector<T,Drot> angVelocity( particle.template getField<MOBILITY,ANG_VELOCITY>() );
551 return angVelocity;
552}
+ 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 895 of file dataAccessWrappers.h.

896{
897 using namespace descriptors;
898 static_assert(providesContactMaterial(particle),
899 "Field MECHPROPERTIES::MATERIAL has to be provided");
900 return particle.template getField<MECHPROPERTIES, MATERIAL>();
901}
olb::particles::access::providesContactMaterial
constexpr bool providesContactMaterial()
Definition dataAccessWrappers.h:451

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 860 of file dataAccessWrappers.h.

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

◆ getCuboidSurfaceExtent()

template<typename T , typename PARTICLETYPE >
auto olb::particles::access::getCuboidSurfaceExtent ( Particle< T, PARTICLETYPE > particle)

Definition at line 828 of file dataAccessWrappers.h.

829{
830 using namespace descriptors;
831 constexpr unsigned D = PARTICLETYPE::d;
832 static_assert(providesSmoothIndicator<PARTICLETYPE>(), "Field FORCING:SINDICATOR has to be provided");
833 using SIndicatorType = std::conditional_t<
834 D == 2,
835 SmoothIndicatorCuboid2D<T,T,true>,
836 SmoothIndicatorCuboid3D<T,T,true>
837 >;
838 //Retrieve surface indicator
839 auto sIndicatorPtr = getSmoothIndicatorPtr(particle);
840 auto sIndicatorCuboidPtr = static_cast<SIndicatorType*>(sIndicatorPtr);
841 auto& indicatorCuboid = sIndicatorCuboidPtr->getIndicator();
842 //Retrieve extent
843 if constexpr(D==2){
844 Vector<T,D> extent(
845 indicatorCuboid.getxLength(),
846 indicatorCuboid.getyLength()
847 );
848 return extent;
849 } else {
850 Vector<T,D> extent(
851 indicatorCuboid.getxLength(),
852 indicatorCuboid.getyLength(),
853 indicatorCuboid.getzLength()
854 );
855 return extent;
856 }
857}
olb::SmoothIndicatorCuboid2D
implements a smooth cuboid in 2D with an _epsilon sector.
Definition smoothIndicatorF2D.h:52
olb::SmoothIndicatorCuboid3D
implements a smooth particle cuboid in 3D with an _epsilon sector.
Definition smoothIndicatorF3D.h:43
olb::particles::access::getSmoothIndicatorPtr
auto getSmoothIndicatorPtr(Particle< T, PARTICLETYPE > particle)
Definition dataAccessWrappers.h:619

References getSmoothIndicatorPtr().

+ 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 675 of file dataAccessWrappers.h.

675 {1} )
676{
677 using namespace descriptors;
678 static_assert(providesMassOrDensity(particle),
679 "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
680 T density;
681 // Always rather use the density field than the mass field
682 if constexpr(providesDensity(particle)) {
683 density = particle.template getField<PHYSPROPERTIES, DENSITY>();
684 }
685 else {
686 const T mass = particle.template getField<PHYSPROPERTIES, MASS>();
687 density = mass / getVolume(particle, shapeFactor);
688 }
689 return density;
690}

◆ getDynamicsID()

template<typename T , typename PARTICLETYPE >
unsigned short olb::particles::access::getDynamicsID ( Particle< T, PARTICLETYPE > & particle)

Definition at line 805 of file dataAccessWrappers.h.

806{
807 using namespace descriptors;
808 static_assert(providesDynamicsID<PARTICLETYPE>(),
809 "Field DYNBEHAVIOUR:DYNAMICS_ID has to be provided");
810 unsigned short dynamicsID = particle.template getField<DYNBEHAVIOUR,DYNAMICS_ID>();
811 return dynamicsID;
812}
+ 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 870 of file dataAccessWrappers.h.

871{
872 using namespace descriptors;
873 constexpr unsigned D = PARTICLETYPE::d;
874 static_assert(providesElongation<PARTICLETYPE>(), "Field SURFACE:ELONGATION has to be provided");
875 Vector<T,D> elongation( particle.template getField<SURFACE,ELONGATION>() );
876 return elongation;
877}
+ 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 881 of file dataAccessWrappers.h.

882{
883 using namespace descriptors;
884 if constexpr (access::providesEnlargementForContactTreatment<PARTICLETYPE>()) {
885 return particle.template getField<NUMERICPROPERTIES,ENLARGEMENT_FOR_CONTACT>();
886 }
887 else {
888 return T{0.};
889 }
890
891 __builtin_unreachable();
892}
+ 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 555 of file dataAccessWrappers.h.

556{
557 using namespace descriptors;
558 constexpr unsigned D = PARTICLETYPE::d;
559 static_assert(providesForce<PARTICLETYPE>(), "Field FORCING:FORCE has to be provided");
560 Vector<T,D> force( particle.template getField<FORCING,FORCE>() );
561 return force;
562}
+ 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 795 of file dataAccessWrappers.h.

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

◆ getGlobalID()

template<typename T , typename PARTICLETYPE >
auto olb::particles::access::getGlobalID ( Particle< T, PARTICLETYPE > particle)

Definition at line 785 of file dataAccessWrappers.h.

786{
787 using namespace descriptors;
788 static_assert(providesID<PARTICLETYPE>(), "Field PARALLELIZATION:ID has to be provided");
789 auto globalID = particle.template getField<PARALLELIZATION,ID>();
790 return globalID;
791}
+ 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 693 of file dataAccessWrappers.h.

693 {1} )
694{
695 using namespace descriptors;
696 static_assert(providesMassOrDensity(particle),
697 "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
698 T mass;
699 // Always rather use the mass field than the density field
700 if constexpr(providesMass(particle)) {
701 mass = particle.template getField<PHYSPROPERTIES, MASS>();
702 }
703 else {
704 const T density = particle.template getField<PHYSPROPERTIES, DENSITY>();
705 mass = density * getVolume(particle, shapeFactor);
706 }
707 return mass;
708}
+ 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 575 of file dataAccessWrappers.h.

576{
577 using namespace descriptors;
578 const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
579 static_assert(providesMomentOfInertia<PARTICLETYPE>(), "Field PHYSPROPERTIES:MOFI has to be provided");
580 Vector<T,Drot> mofi( particle.template getField<PHYSPROPERTIES,MOFI>() );
581 return mofi;
582}
+ 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 484 of file dataAccessWrappers.h.

485{
486 using namespace descriptors;
487 constexpr unsigned D = PARTICLETYPE::d;
488 static_assert(providesPosition<PARTICLETYPE>(),
489 "Field GENERAL:POSITION has to be provided");
490 Vector<T,D> position( particle.template getField<GENERAL,POSITION>() );
491 return position;
492}
+ 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 629 of file dataAccessWrappers.h.

630{
631 using namespace descriptors;
632 T radius;
633 if constexpr (providesSmoothIndicator<PARTICLETYPE>() ) {
634 radius = getSmoothIndicatorPtr(particle)->getCircumRadius();
635 }
636 else if constexpr ( providesRadius<PARTICLETYPE>() ) {
637 radius = particle.template getField<PHYSPROPERTIES,RADIUS>();
638 }
639 else {
640 std::cerr << "ERROR: no Field found providing radius!" << std::endl;
641 }
642 return radius;
643}

References getSmoothIndicatorPtr().

+ 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 510 of file dataAccessWrappers.h.

511{
512 using namespace descriptors;
513 const unsigned DrotMat = utilities::dimensions::convert<PARTICLETYPE::d>::matrix;
514 static_assert(providesRotationMatrix<PARTICLETYPE>(), "Field SURFACE:ROT_MATRIX has to be provided");
515 Vector<T,DrotMat> rotationMatrix( particle.template getField<SURFACE,ROT_MATRIX>() );
516 return rotationMatrix;
517}
+ 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 619 of file dataAccessWrappers.h.

620{
621 using namespace descriptors;
622 static_assert(providesSmoothIndicator<PARTICLETYPE>(), "Field FORCING:SINDICATOR has to be provided");
623 auto sIndicatorPtr = particle.template getField<SURFACE,SINDICATOR>();
624 return sIndicatorPtr;
625}
+ 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 520 of file dataAccessWrappers.h.

521{
522 using namespace descriptors;
523 constexpr unsigned D = PARTICLETYPE::d;
524 auto rotationMatrix = getRotationMatrix( particle );
525 //Note: Convention here, positively pointing towards dir (default z-dir)
526 Vector<T,D> normal;
527 for (unsigned iDim=0; iDim<D; ++iDim) {
528 unsigned iMat = D*iDim+dir;
529 normal[iDim] = rotationMatrix[iMat];
530 }
531 return normal;
532}

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 565 of file dataAccessWrappers.h.

566{
567 using namespace descriptors;
568 const unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
569 static_assert(providesTorque<PARTICLETYPE>(), "Field FORCING:TORQUE has to be provided");
570 Vector<T,Drot> torque( particle.template getField<FORCING,TORQUE>() );
571 return torque;
572}
+ 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 535 of file dataAccessWrappers.h.

536{
537 using namespace descriptors;
538 constexpr unsigned D = PARTICLETYPE::d;
539 static_assert(providesVelocity<PARTICLETYPE>(), "Field MOBILITY:VELOCITY has to be provided");
540 Vector<T,D> velocity( particle.template getField<MOBILITY,VELOCITY>() );
541 return velocity;
542}
+ 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 648 of file dataAccessWrappers.h.

648 {1} )
649{
650 using namespace descriptors;
651 constexpr unsigned D = PARTICLETYPE::d;
652 T volume;
653 if constexpr(providesSurface(particle)) {
654 if constexpr (D == 3) {
655 volume = getSmoothIndicatorPtr(particle)->getVolume();
656 }
657 else {
658 volume = getSmoothIndicatorPtr(particle)->getArea();
659 }
660 }
661 else {
662 const T radius = getRadius(particle);
663 if constexpr(D == 3) {
664 volume = (4./3.) * M_PI * util::pow(radius, D);
665 }
666 else {
667 volume = M_PI * util::pow(radius, D);
668 }
669 volume *= shapeFactor;
670 }
671 return volume;
672}
olb::particles::access::getRadius
T getRadius(Particle< T, PARTICLETYPE > &particle)
Definition dataAccessWrappers.h:629

◆ is2D() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::is2D ( )
constexpr

Definition at line 462 of file dataAccessWrappers.h.

463{
464 return (PARTICLETYPE::d==2);
465}

◆ is2D() [2/2]

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

Definition at line 467 of file dataAccessWrappers.h.

467 {
468 return is2D<PARTICLETYPE>();
469}

◆ is3D() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::is3D ( )
constexpr

Definition at line 472 of file dataAccessWrappers.h.

473{
474 return (PARTICLETYPE::d==3);
475}

◆ is3D() [2/2]

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

Definition at line 477 of file dataAccessWrappers.h.

477 {
478 return is3D<PARTICLETYPE>();
479}

◆ isActive()

template<typename T , typename PARTICLETYPE >
bool olb::particles::access::isActive ( Particle< T, PARTICLETYPE > particle)

Definition at line 607 of file dataAccessWrappers.h.

608{
609 using namespace descriptors;
610 bool active = true;
611 if constexpr(providesActive<PARTICLETYPE>()) {
612 active = particle.template getField<DYNBEHAVIOUR,ACTIVE>();
613 }
614 return active;
615}
+ 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 1159 of file dataAccessWrappers.h.

1160{
1161 using namespace descriptors;
1162
1163 // if the field is not provided, return true by default
1164 // (meaning that the contact forces are computed and applied to the force field)
1165 if constexpr(!providesComputeContact<PARTICLETYPE>()) {
1166 return true;
1167 }
1168 else {
1169 return particle.template getField<DYNBEHAVIOUR,COMPUTE_CONTACT>();
1170 }
1171
1172 __builtin_unreachable();
1173}
+ 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 1177 of file dataAccessWrappers.h.

1179{
1180 return (isContactComputationEnabled(particleA) || isContactComputationEnabled(particleB));
1181}
olb::particles::access::isContactComputationEnabled
bool isContactComputationEnabled(Particle< T, PARTICLETYPE > &particle)
Check if contact should be regarded (specification for a single particle)
Definition dataAccessWrappers.h:1159

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 816 of file dataAccessWrappers.h.

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

◆ isMotionComputationEnabled()

template<typename T , typename PARTICLETYPE >
bool olb::particles::access::isMotionComputationEnabled ( Particle< T, PARTICLETYPE > & particle)

Check if motion is enabled.

Definition at line 1142 of file dataAccessWrappers.h.

1143{
1144 using namespace descriptors;
1145
1146 // if the field is not provided, return true by default
1147 if constexpr(!providesComputeMotion<PARTICLETYPE>()) {
1148 return true;
1149 }
1150 else {
1151 return particle.template getField<DYNBEHAVIOUR,COMPUTE_MOTION>();
1152 }
1153
1154 __builtin_unreachable();
1155}
+ 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 596 of file dataAccessWrappers.h.

597{
598 using namespace descriptors;
599 bool valid = true;
600 if constexpr(providesValid<PARTICLETYPE>()) {
601 valid = !particle.template getField<GENERAL,INVALID>();
602 }
603 return valid;
604}
+ Here is the caller graph for this function:

◆ providesAccelerationStrd() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesAccelerationStrd ( )
constexpr

Definition at line 418 of file dataAccessWrappers.h.

419{
420 using namespace descriptors;
421 return PARTICLETYPE::template providesNested<MOBILITY,ACCELERATION_STRD>();
422}
+ Here is the caller graph for this function:

◆ providesAccelerationStrd() [2/2]

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

Definition at line 424 of file dataAccessWrappers.h.

424 {
425 return providesAccelerationStrd<PARTICLETYPE>();
426}

◆ providesActive() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesActive ( )
constexpr

Provides field ACTIVE.

Definition at line 290 of file dataAccessWrappers.h.

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

◆ providesActive() [2/2]

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

Definition at line 296 of file dataAccessWrappers.h.

296 {
297 return providesActive<PARTICLETYPE>();
298}

◆ providesAdhesion() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesAdhesion ( )
constexpr

Provides field ADHESION.

Definition at line 242 of file dataAccessWrappers.h.

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

◆ providesAdhesion() [2/2]

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

Definition at line 248 of file dataAccessWrappers.h.

248 {
249 return providesAdhesion<PARTICLETYPE>();
250}

◆ providesAngAccelerationStrd() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesAngAccelerationStrd ( )
constexpr

Definition at line 429 of file dataAccessWrappers.h.

430{
431 using namespace descriptors;
432 return PARTICLETYPE::template providesNested<MOBILITY,ANG_ACC_STRD>();
433}
+ Here is the caller graph for this function:

◆ providesAngAccelerationStrd() [2/2]

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

Definition at line 435 of file dataAccessWrappers.h.

435 {
436 return providesAngAccelerationStrd<PARTICLETYPE>();
437}

◆ providesAngle() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesAngle ( )
constexpr

Provides field ANGLE.

Definition at line 182 of file dataAccessWrappers.h.

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

◆ providesAngle() [2/2]

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

Definition at line 188 of file dataAccessWrappers.h.

188 {
189 return providesAngle<PARTICLETYPE>();
190}

◆ providesAngVelocity() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesAngVelocity ( )
constexpr

Provides field VELOCITY.

Definition at line 206 of file dataAccessWrappers.h.

207{
208 using namespace descriptors;
209 return PARTICLETYPE::template providesNested<MOBILITY,ANG_VELOCITY>();
210}
+ Here is the caller graph for this function:

◆ providesAngVelocity() [2/2]

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

Definition at line 212 of file dataAccessWrappers.h.

212 {
213 return providesAngVelocity<PARTICLETYPE>();
214}

◆ providesComputeContact() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesComputeContact ( )
constexpr

Provides field COMPUTE_CONTACT.

Definition at line 314 of file dataAccessWrappers.h.

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

◆ providesComputeContact() [2/2]

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

Definition at line 320 of file dataAccessWrappers.h.

320 {
321 return providesComputeContact<PARTICLETYPE>();
322}

◆ providesComputeMotion() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesComputeMotion ( )
constexpr

Provides field COMPUTE_MOTION.

Definition at line 302 of file dataAccessWrappers.h.

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

◆ providesComputeMotion() [2/2]

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

Definition at line 308 of file dataAccessWrappers.h.

308 {
309 return providesComputeMotion<PARTICLETYPE>();
310}

◆ providesContactMaterial() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesContactMaterial ( )
constexpr

Definition at line 451 of file dataAccessWrappers.h.

452{
453 using namespace descriptors;
454 return PARTICLETYPE::template providesNested<MECHPROPERTIES,MATERIAL>();
455}
+ Here is the caller graph for this function:

◆ providesContactMaterial() [2/2]

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

Definition at line 457 of file dataAccessWrappers.h.

457 {
458 return providesContactMaterial<PARTICLETYPE>();
459}

◆ providesCORoffset() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesCORoffset ( )
constexpr

Definition at line 396 of file dataAccessWrappers.h.

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

◆ providesCORoffset() [2/2]

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

Definition at line 402 of file dataAccessWrappers.h.

402 {
403 return providesCORoffset<PARTICLETYPE>();
404}

◆ providesDensity() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesDensity ( )
constexpr

Provides field DENSITY.

Definition at line 146 of file dataAccessWrappers.h.

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

◆ providesDensity() [2/2]

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

Definition at line 152 of file dataAccessWrappers.h.

152 {
153 return providesDensity<PARTICLETYPE>();
154}

◆ providesDetaching() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesDetaching ( )
constexpr

Definition at line 385 of file dataAccessWrappers.h.

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

◆ providesDetaching() [2/2]

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

Definition at line 391 of file dataAccessWrappers.h.

391 {
392 return providesDetaching<PARTICLETYPE>();
393}

◆ providesDynamicsID() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesDynamicsID ( )
constexpr

Provides field DYNAMICS_ID.

Definition at line 278 of file dataAccessWrappers.h.

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

◆ providesDynamicsID() [2/2]

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

Definition at line 284 of file dataAccessWrappers.h.

284 {
285 return providesDynamicsID<PARTICLETYPE>();
286}

◆ providesElongation() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesElongation ( )
constexpr

Definition at line 407 of file dataAccessWrappers.h.

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

◆ providesElongation() [2/2]

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

Definition at line 413 of file dataAccessWrappers.h.

413 {
414 return providesElongation<PARTICLETYPE>();
415}

◆ providesEnlargementForContactTreatment() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesEnlargementForContactTreatment ( )
constexpr

Definition at line 440 of file dataAccessWrappers.h.

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

◆ providesEnlargementForContactTreatment() [2/2]

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

Definition at line 446 of file dataAccessWrappers.h.

446 {
447 return providesEnlargementForContactTreatment<PARTICLETYPE>();
448}

◆ providesForce() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesForce ( )
constexpr

Provides field FORCE.

Definition at line 218 of file dataAccessWrappers.h.

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

◆ providesForce() [2/2]

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

Definition at line 224 of file dataAccessWrappers.h.

224 {
225 return providesForce<PARTICLETYPE>();
226}

◆ providesID() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesID ( )
constexpr

Provides field ID.

Definition at line 98 of file dataAccessWrappers.h.

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

◆ providesID() [2/2]

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

Definition at line 104 of file dataAccessWrappers.h.

104 {
105 return providesID<PARTICLETYPE>();
106}

◆ providesInvalid() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesInvalid ( )
constexpr

Provides field ID.

Definition at line 110 of file dataAccessWrappers.h.

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

◆ providesInvalid() [2/2]

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

Definition at line 116 of file dataAccessWrappers.h.

116 {
117 return providesInvalid<PARTICLETYPE>();
118}

◆ providesMass() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesMass ( )
constexpr

Provides field MASS.

Definition at line 158 of file dataAccessWrappers.h.

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

◆ providesMass() [2/2]

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

Definition at line 164 of file dataAccessWrappers.h.

164 {
165 return providesMass<PARTICLETYPE>();
166}

◆ providesMassOrDensity() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesMassOrDensity ( )
constexpr

Provides field MASS or DENSITY.

Definition at line 170 of file dataAccessWrappers.h.

171{
172 using namespace descriptors;
173 return providesMass<PARTICLETYPE>() || providesDensity<PARTICLETYPE>();
174}

◆ providesMassOrDensity() [2/2]

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

Definition at line 176 of file dataAccessWrappers.h.

176 {
177 return providesMassOrDensity<PARTICLETYPE>();
178}

◆ providesMomentOfInertia() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesMomentOfInertia ( )
constexpr

Provides field MOFI.

Definition at line 254 of file dataAccessWrappers.h.

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

◆ providesMomentOfInertia() [2/2]

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

Definition at line 260 of file dataAccessWrappers.h.

260 {
261 return providesMomentOfInertia<PARTICLETYPE>();
262}

◆ providesParallelization() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesParallelization ( )
constexpr

Provides group PARALLELIZATION.

Definition at line 363 of file dataAccessWrappers.h.

364{
365 using namespace descriptors;
366 return PARTICLETYPE::template providesNested<PARALLELIZATION>();
367}
+ Here is the caller graph for this function:

◆ providesParallelization() [2/2]

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

Definition at line 369 of file dataAccessWrappers.h.

369 {
370 return providesParallelization<PARTICLETYPE>();
371}

◆ providesPosition() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesPosition ( )
constexpr

Provides field POSITION.

Definition at line 122 of file dataAccessWrappers.h.

123{
124 using namespace descriptors;
125 return PARTICLETYPE::template providesNested<GENERAL,POSITION>();
126}
+ Here is the caller graph for this function:

◆ providesPosition() [2/2]

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

Definition at line 128 of file dataAccessWrappers.h.

128 {
129 return providesPosition<PARTICLETYPE>();
130}

◆ providesRadius() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesRadius ( )
constexpr

Provides field RADIUS.

Definition at line 134 of file dataAccessWrappers.h.

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

◆ providesRadius() [2/2]

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

Definition at line 140 of file dataAccessWrappers.h.

140 {
141 return providesRadius<PARTICLETYPE>();
142}

◆ providesRotationMatrix() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesRotationMatrix ( )
constexpr

Provides field ROT_MATRIX.

Definition at line 326 of file dataAccessWrappers.h.

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

◆ providesRotationMatrix() [2/2]

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

Definition at line 332 of file dataAccessWrappers.h.

332 {
333 return providesRotationMatrix<PARTICLETYPE>();
334}

◆ providesSmoothIndicator() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesSmoothIndicator ( )
constexpr

Definition at line 350 of file dataAccessWrappers.h.

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

◆ providesSmoothIndicator() [2/2]

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

Definition at line 356 of file dataAccessWrappers.h.

357{
358 return providesSmoothIndicator<PARTICLETYPE>();
359}

◆ providesSpecies() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesSpecies ( )
constexpr

Definition at line 374 of file dataAccessWrappers.h.

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

◆ providesSpecies() [2/2]

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

Definition at line 380 of file dataAccessWrappers.h.

380 {
381 return providesSpecies<PARTICLETYPE>();
382}

◆ providesSurface() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesSurface ( )
constexpr

Provides group SURFACE.

Definition at line 338 of file dataAccessWrappers.h.

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

◆ providesSurface() [2/2]

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

Definition at line 344 of file dataAccessWrappers.h.

344 {
345 return providesSurface<PARTICLETYPE>();
346}

◆ providesTorque() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesTorque ( )
constexpr

Provides field TORQUE.

Definition at line 230 of file dataAccessWrappers.h.

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

◆ providesTorque() [2/2]

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

Definition at line 236 of file dataAccessWrappers.h.

236 {
237 return providesTorque<PARTICLETYPE>();
238}

◆ providesValid() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesValid ( )
constexpr

Provides field INVALID.

Definition at line 266 of file dataAccessWrappers.h.

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

◆ providesValid() [2/2]

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

Definition at line 272 of file dataAccessWrappers.h.

272 {
273 return providesValid<PARTICLETYPE>();
274}

◆ providesVelocity() [1/2]

template<typename PARTICLETYPE >
constexpr bool olb::particles::access::providesVelocity ( )
constexpr

Provides field VELOCITY.

Definition at line 194 of file dataAccessWrappers.h.

195{
196 using namespace descriptors;
197 return PARTICLETYPE::template providesNested<MOBILITY,VELOCITY>();
198}
+ Here is the caller graph for this function:

◆ providesVelocity() [2/2]

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

Definition at line 200 of file dataAccessWrappers.h.

200 {
201 return providesVelocity<PARTICLETYPE>();
202}

◆ setAccelerationStrd()

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

Definition at line 721 of file dataAccessWrappers.h.

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

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 1050 of file dataAccessWrappers.h.

1051{
1052 using namespace descriptors;
1053 static_assert(providesActive<PARTICLETYPE>(), "Field DYNBEHAVIOUR:ACTIVE has to be provided");
1054 particle.template setField<DYNBEHAVIOUR,ACTIVE>( value );
1055}
+ 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 1028 of file dataAccessWrappers.h.

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

◆ 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 990 of file dataAccessWrappers.h.

991{
992 using namespace descriptors;
993 static_assert(providesAngAccelerationStrd<PARTICLETYPE>(), "Field MOBILITY:ANG_ACC_STRD has to be provided");
994 particle.template setField<MOBILITY,ANG_ACC_STRD>(utilities::dimensions::convert<
995 PARTICLETYPE::d>::serialize_rotation(angAcceleration));
996}
+ 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 956 of file dataAccessWrappers.h.

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

◆ 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 981 of file dataAccessWrappers.h.

982{
983 using namespace descriptors;
984 static_assert(providesAngVelocity<PARTICLETYPE>(), "Field MOBILITY:ANG_VELOCITY has to be provided");
985 particle.template setField<MOBILITY,ANG_VELOCITY>(utilities::dimensions::convert<
986 PARTICLETYPE::d>::serialize_rotation(angVelocity));
987}
+ 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 947 of file dataAccessWrappers.h.

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

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 1117 of file dataAccessWrappers.h.

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

◆ setDensity()

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

Definition at line 906 of file dataAccessWrappers.h.

906 {1} )
907{
908 using namespace descriptors;
909 static_assert(providesMassOrDensity(particle),
910 "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
911
912 if constexpr(providesDensity(particle)) {
913 particle.template setField<PHYSPROPERTIES, DENSITY>(density);
914 }
915 if constexpr(providesMass(particle)) {
916 const T mass = density * getVolume(particle, shapeFactor);
917 particle.template setField<PHYSPROPERTIES, MASS>(mass);
918 }
919}
+ 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 1108 of file dataAccessWrappers.h.

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

◆ setDynamicsID()

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

Definition at line 1099 of file dataAccessWrappers.h.

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

◆ setElongation()

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

Definition at line 1125 of file dataAccessWrappers.h.

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

◆ setEnlargementForContact()

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

Definition at line 1133 of file dataAccessWrappers.h.

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

◆ setForce()

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

Definition at line 1001 of file dataAccessWrappers.h.

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

◆ setGlobalIC()

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

Definition at line 1091 of file dataAccessWrappers.h.

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

◆ setGlobalID()

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

Definition at line 1083 of file dataAccessWrappers.h.

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

◆ setInactive()

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

Definition at line 1058 of file dataAccessWrappers.h.

1059{
1060 setActive(particle, !value);
1061}
olb::particles::access::setActive
void setActive(Particle< T, PARTICLETYPE > particle, bool value=true)
Definition dataAccessWrappers.h:1050

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 1036 of file dataAccessWrappers.h.

1037{
1038 using namespace descriptors;
1039 static_assert(providesInvalid<PARTICLETYPE>(), "Field GENERAL:INVALID has to be provided");
1040 particle.template setField<GENERAL,INVALID>( value );
1041}
+ 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 922 of file dataAccessWrappers.h.

922 {1} )
923{
924 using namespace descriptors;
925 static_assert(providesMassOrDensity(particle),
926 "Field PHYSPROPERTIES:MASS or PHYSPROPERTIES:DENSITY has to be provided");
927
928 if constexpr(providesMass(particle)) {
929 particle.template setField<PHYSPROPERTIES, MASS>(mass);
930 }
931 if constexpr(providesDensity(particle)){
932 const T density = mass / getVolume(particle, shapeFactor);
933 particle.template setField<PHYSPROPERTIES, DENSITY>(density);
934 }
935}

◆ 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 1018 of file dataAccessWrappers.h.

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

◆ setPosition()

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

Definition at line 938 of file dataAccessWrappers.h.

939{
940 using namespace descriptors;
941 static_assert(providesPosition(particle),
942 "Field GENERAL:POSITION has to be provided");
943 particle.template setField<GENERAL, POSITION>(position);
944}
olb::particles::access::providesPosition
constexpr bool providesPosition()
Provides field POSITION.
Definition dataAccessWrappers.h:122

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 1075 of file dataAccessWrappers.h.

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

◆ setRestingParticle()

template<typename T , typename PARTICLETYPE >
void olb::particles::access::setRestingParticle ( Particle< T, PARTICLETYPE > particle)

Definition at line 1212 of file dataAccessWrappers.h.

1213{
1214 if constexpr(providesVelocity(particle)){
1215 setVelocity(particle, Vector<T,PARTICLETYPE::d>(0.));
1216 }
1217
1218 if constexpr(providesAccelerationStrd(particle)){
1219 setAccelerationStrd(particle, Vector<T,PARTICLETYPE::d>(0.));
1220 }
1221
1222
1223 if constexpr(providesAngVelocity(particle)){
1224 setAngularVelocity(particle, Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>(0.));
1225 }
1226
1227 if constexpr(providesAngAccelerationStrd(particle)){
1228 setAngAccelerationStrd(particle, Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>(0.));
1229 }
1230}
olb::particles::access::setVelocity
void setVelocity(Particle< T, PARTICLETYPE > particle, Vector< T, PARTICLETYPE::d > velocity)
Definition dataAccessWrappers.h:973
olb::particles::access::providesVelocity
constexpr bool providesVelocity()
Provides field VELOCITY.
Definition dataAccessWrappers.h:194

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 965 of file dataAccessWrappers.h.

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

◆ 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 1065 of file dataAccessWrappers.h.

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

◆ 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 1009 of file dataAccessWrappers.h.

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

◆ setValid()

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

Definition at line 1044 of file dataAccessWrappers.h.

1045{
1046 setInvalid(particle, !value);
1047}
olb::particles::access::setInvalid
void setInvalid(Particle< T, PARTICLETYPE > particle, bool value=true)
Definition dataAccessWrappers.h:1036

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 973 of file dataAccessWrappers.h.

974{
975 using namespace descriptors;
976 static_assert(providesVelocity<PARTICLETYPE>(), "Field MOBILITY:VELOCITY has to be provided");
977 particle.template setField<MOBILITY,VELOCITY>(velocity);
978}
+ Here is the caller graph for this function:
Generated on Tue Mar 5 2024 09:58:10 for OpenLB by doxygen 1.10.0