209#ifndef HANDMADE_MATH_NO_SSE
213#if defined(_M_AMD64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1)
214#define HANDMADE_MATH__USE_SSE 1
218#define HANDMADE_MATH__USE_SSE 1
226#ifdef HANDMADE_MATH__USE_SSE
227#include <xmmintrin.h>
230#ifndef HANDMADE_MATH_H
231#define HANDMADE_MATH_H
234#pragma warning(disable : 4201)
238#pragma GCC diagnostic push
239#pragma GCC diagnostic ignored "-Wgnu-anonymous-struct"
246#define HMM_INLINE static inline
247#define HMM_EXTERN extern
249#if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \
250 !defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \
251 !defined(HMM_ACOSF) || !defined(HMM_ATANF) || !defined(HMM_ATAN2F)
268#define HMM_SQRTF sqrtf
280#define HMM_ACOSF acosf
284#define HMM_ATANF atanf
288#define HMM_ATAN2F atan2f
291#define HMM_PI32 3.14159265359f
292#define HMM_PI 3.14159265358979323846
294#define HMM_MIN(a, b) (a) > (b) ? (b) : (a)
295#define HMM_MAX(a, b) (a) < (b) ? (b) : (a)
296#define HMM_ABS(a) ((a) > 0 ? (a) : -(a))
297#define HMM_MOD(a, m) ((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m))
298#define HMM_SQUARE(x) ((x) * (x))
324 inline float& operator[](
int Index)
374 inline float& operator[](
int Index)
430#ifdef HANDMADE_MATH__USE_SSE
431 __m128 InternalElementsSSE;
435 inline float& operator[](
int Index)
445#ifdef HANDMADE_MATH__USE_SSE
454 inline hmm_vec4 operator[](
const int Index)
557#ifdef HANDMADE_MATH__USE_SSE
558 __m128 In = _mm_set_ss(Float);
559 __m128 Out = _mm_sqrt_ss(In);
560 Result = _mm_cvtss_f32(Out);
572#ifdef HANDMADE_MATH__USE_SSE
573 __m128 In = _mm_set_ss(Float);
574 __m128 Out = _mm_rsqrt_ss(In);
575 Result = _mm_cvtss_f32(Out);
597 float Result = Degrees * (
HMM_PI32 / 180.0f);
604 float Result = (1.0f - Time) *
A + Time *
B;
611 float Result =
Value;
615 }
else if (Result > Max) {
672#ifdef HANDMADE_MATH__USE_SSE
673 Result.InternalElementsSSE = _mm_setr_ps(X, Y, Z, W);
688#ifdef HANDMADE_MATH__USE_SSE
689 Result.InternalElementsSSE = _mm_setr_ps((
float)X, (
float)Y, (
float)Z, (
float)W);
704#ifdef HANDMADE_MATH__USE_SSE
705 Result.InternalElementsSSE = _mm_setr_ps(Vector.
X, Vector.
Y, Vector.
Z, W);
722 Result.
X = Left.X + Right.X;
723 Result.
Y = Left.Y + Right.Y;
732 Result.
X = Left.X + Right.X;
733 Result.
Y = Left.Y + Right.Y;
734 Result.
Z = Left.Z + Right.Z;
743#ifdef HANDMADE_MATH__USE_SSE
744 Result.InternalElementsSSE = _mm_add_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);
746 Result.
X = Left.X + Right.X;
747 Result.
Y = Left.Y + Right.Y;
748 Result.
Z = Left.Z + Right.Z;
749 Result.
W = Left.W + Right.W;
759 Result.
X = Left.X - Right.X;
760 Result.
Y = Left.Y - Right.Y;
769 Result.
X = Left.X - Right.X;
770 Result.
Y = Left.Y - Right.Y;
771 Result.
Z = Left.Z - Right.Z;
780#ifdef HANDMADE_MATH__USE_SSE
781 Result.InternalElementsSSE = _mm_sub_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);
783 Result.
X = Left.X - Right.X;
784 Result.
Y = Left.Y - Right.Y;
785 Result.
Z = Left.Z - Right.Z;
786 Result.
W = Left.W - Right.W;
796 Result.
X = Left.X * Right.X;
797 Result.
Y = Left.Y * Right.Y;
806 Result.
X = Left.X * Right;
807 Result.
Y = Left.Y * Right;
816 Result.
X = Left.X * Right.X;
817 Result.
Y = Left.Y * Right.Y;
818 Result.
Z = Left.Z * Right.Z;
827 Result.
X = Left.X * Right;
828 Result.
Y = Left.Y * Right;
829 Result.
Z = Left.Z * Right;
838#ifdef HANDMADE_MATH__USE_SSE
839 Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);
841 Result.
X = Left.X * Right.X;
842 Result.
Y = Left.Y * Right.Y;
843 Result.
Z = Left.Z * Right.Z;
844 Result.
W = Left.W * Right.W;
854#ifdef HANDMADE_MATH__USE_SSE
855 __m128 Scalar = _mm_set1_ps(Right);
856 Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Scalar);
858 Result.
X = Left.X * Right;
859 Result.
Y = Left.Y * Right;
860 Result.
Z = Left.Z * Right;
861 Result.
W = Left.W * Right;
871 Result.
X = Left.X / Right.X;
872 Result.
Y = Left.Y / Right.Y;
881 Result.
X = Left.X / Right;
882 Result.
Y = Left.Y / Right;
891 Result.
X = Left.X / Right.X;
892 Result.
Y = Left.Y / Right.Y;
893 Result.
Z = Left.Z / Right.Z;
902 Result.
X = Left.X / Right;
903 Result.
Y = Left.Y / Right;
904 Result.
Z = Left.Z / Right;
913#ifdef HANDMADE_MATH__USE_SSE
914 Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Right.InternalElementsSSE);
916 Result.
X = Left.X / Right.X;
917 Result.
Y = Left.Y / Right.Y;
918 Result.
Z = Left.Z / Right.Z;
919 Result.
W = Left.W / Right.W;
929#ifdef HANDMADE_MATH__USE_SSE
930 __m128 Scalar = _mm_set1_ps(Right);
931 Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Scalar);
933 Result.
X = Left.X / Right;
934 Result.
Y = Left.Y / Right;
935 Result.
Z = Left.Z / Right;
936 Result.
W = Left.W / Right;
944 hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y);
951 hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z);
958 hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W);
965 float Result = (VecOne.
X * VecTwo.
X) + (VecOne.
Y * VecTwo.
Y);
972 float Result = (VecOne.
X * VecTwo.
X) + (VecOne.
Y * VecTwo.
Y) + (VecOne.
Z * VecTwo.
Z);
984#ifdef HANDMADE_MATH__USE_SSE
985 __m128 SSEResultOne = _mm_mul_ps(VecOne.InternalElementsSSE, VecTwo.InternalElementsSSE);
986 __m128 SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(2, 3, 0, 1));
987 SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo);
988 SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(0, 1, 2, 3));
989 SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo);
990 _mm_store_ss(&Result, SSEResultOne);
992 Result = (VecOne.
X * VecTwo.
X) + (VecOne.
Y * VecTwo.
Y) + (VecOne.
Z * VecTwo.
Z) + (VecOne.
W * VecTwo.
W);
1002 Result.
X = (VecOne.
Y * VecTwo.
Z) - (VecOne.
Z * VecTwo.
Y);
1003 Result.
Y = (VecOne.
Z * VecTwo.
X) - (VecOne.
X * VecTwo.
Z);
1004 Result.
Z = (VecOne.
X * VecTwo.
Y) - (VecOne.
Y * VecTwo.
X);
1062 if (VectorLength != 0.0f) {
1063 Result.
X =
A.X * (1.0f / VectorLength);
1064 Result.
Y =
A.Y * (1.0f / VectorLength);
1077 if (VectorLength != 0.0f) {
1078 Result.
X =
A.X * (1.0f / VectorLength);
1079 Result.
Y =
A.Y * (1.0f / VectorLength);
1080 Result.
Z =
A.Z * (1.0f / VectorLength);
1093 if (VectorLength != 0.0f) {
1094 float Multiplier = 1.0f / VectorLength;
1096#ifdef HANDMADE_MATH__USE_SSE
1097 __m128 SSEMultiplier = _mm_set1_ps(Multiplier);
1098 Result.InternalElementsSSE = _mm_mul_ps(
A.InternalElementsSSE, SSEMultiplier);
1100 Result.
X =
A.X * Multiplier;
1101 Result.
Y =
A.Y * Multiplier;
1102 Result.
Z =
A.Z * Multiplier;
1103 Result.
W =
A.W * Multiplier;
1114#ifdef HANDMADE_MATH__USE_SSE
1118 Result = _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x00),
Right.Columns[0]);
1119 Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x55),
Right.Columns[1]));
1120 Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xaa),
Right.Columns[2]));
1121 Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xff),
Right.Columns[3]));
1150#ifdef HANDMADE_MATH__USE_SSE
1155 _MM_TRANSPOSE4_PS(Result.Columns[0], Result.Columns[1], Result.Columns[2], Result.Columns[3]);
1163#ifdef HANDMADE_MATH__USE_SSE
1168 Result.Columns[0] = _mm_add_ps(Left.Columns[0], Right.Columns[0]);
1169 Result.Columns[1] = _mm_add_ps(Left.Columns[1], Right.Columns[1]);
1170 Result.Columns[2] = _mm_add_ps(Left.Columns[2], Right.Columns[2]);
1171 Result.Columns[3] = _mm_add_ps(Left.Columns[3], Right.Columns[3]);
1179#ifdef HANDMADE_MATH__USE_SSE
1184 Result.Columns[0] = _mm_sub_ps(Left.Columns[0], Right.Columns[0]);
1185 Result.Columns[1] = _mm_sub_ps(Left.Columns[1], Right.Columns[1]);
1186 Result.Columns[2] = _mm_sub_ps(Left.Columns[2], Right.Columns[2]);
1187 Result.Columns[3] = _mm_sub_ps(Left.Columns[3], Right.Columns[3]);
1197#ifdef HANDMADE_MATH__USE_SSE
1202 __m128 SSEScalar = _mm_set1_ps(Scalar);
1203 Result.Columns[0] = _mm_mul_ps(Matrix.Columns[0], SSEScalar);
1204 Result.Columns[1] = _mm_mul_ps(Matrix.Columns[1], SSEScalar);
1205 Result.Columns[2] = _mm_mul_ps(Matrix.Columns[2], SSEScalar);
1206 Result.Columns[3] = _mm_mul_ps(Matrix.Columns[3], SSEScalar);
1216#ifdef HANDMADE_MATH__USE_SSE
1221 __m128 SSEScalar = _mm_set1_ps(Scalar);
1222 Result.Columns[0] = _mm_div_ps(Matrix.Columns[0], SSEScalar);
1223 Result.Columns[1] = _mm_div_ps(Matrix.Columns[1], SSEScalar);
1224 Result.Columns[2] = _mm_div_ps(Matrix.Columns[2], SSEScalar);
1225 Result.Columns[3] = _mm_div_ps(Matrix.Columns[3], SSEScalar);
1241 Result.
Elements[0][0] = 2.0f / (Right - Left);
1242 Result.
Elements[1][1] = 2.0f / (Top - Bottom);
1243 Result.
Elements[2][2] = 2.0f / (Near - Far);
1246 Result.
Elements[3][0] = (Left + Right) / (Left - Right);
1247 Result.
Elements[3][1] = (Bottom + Top) / (Bottom - Top);
1248 Result.
Elements[3][2] = (Far + Near) / (Near - Far);
1259 Result.
Elements[0][0] = 1.0f / TanThetaOver2;
1260 Result.
Elements[1][1] = AspectRatio / TanThetaOver2;
1262 Result.
Elements[2][2] = (Near + Far) / (Near - Far);
1263 Result.
Elements[3][2] = (2.0f * Near * Far) / (Near - Far);
1315 Result.
X = Vector.
X;
1316 Result.
Y = Vector.
Y;
1317 Result.
Z = Vector.
Z;
1318 Result.
W = Vector.
W;
1327 Result.
X = Left.X + Right.X;
1328 Result.
Y = Left.Y + Right.Y;
1329 Result.
Z = Left.Z + Right.Z;
1330 Result.
W = Left.W + Right.W;
1339 Result.
X = Left.X - Right.X;
1340 Result.
Y = Left.Y - Right.Y;
1341 Result.
Z = Left.Z - Right.Z;
1342 Result.
W = Left.W - Right.W;
1351 Result.
X = (Left.X * Right.W) + (Left.Y * Right.Z) - (Left.Z * Right.Y) + (Left.W * Right.X);
1352 Result.
Y = (-Left.X * Right.Z) + (Left.Y * Right.W) + (Left.Z * Right.X) + (Left.W * Right.Y);
1353 Result.
Z = (Left.X * Right.Y) - (Left.Y * Right.X) + (Left.Z * Right.W) + (Left.W * Right.Z);
1354 Result.
W = (-Left.X * Right.X) - (Left.Y * Right.Y) - (Left.Z * Right.Z) + (Left.W * Right.W);
1363 Result.
X = Left.X * Multiplicative;
1364 Result.
Y = Left.Y * Multiplicative;
1365 Result.
Z = Left.Z * Multiplicative;
1366 Result.
W = Left.W * Multiplicative;
1375 Result.
X = Left.X / Dividend;
1376 Result.
Y = Left.Y / Dividend;
1377 Result.
Z = Left.Z / Dividend;
1378 Result.
W = Left.W / Dividend;
1387 float Result = (Left.X * Right.X) + (Left.Y * Right.Y) + (Left.Z * Right.Z) + (Left.W * Right.W);
1406 Result.
X =
HMM_Lerp(Left.X, Time, Right.X);
1407 Result.
Y =
HMM_Lerp(Left.Y, Time, Right.Y);
1408 Result.
Z =
HMM_Lerp(Left.Z, Time, Right.Z);
1409 Result.
W =
HMM_Lerp(Left.W, Time, Right.W);
1988 return (Left = Left + Right);
1993 return (Left = Left + Right);
1998 return (Left = Left + Right);
2003 return (Left = Left + Right);
2008 return (Left = Left + Right);
2013 return (Left = Left - Right);
2018 return (Left = Left - Right);
2023 return (Left = Left - Right);
2028 return (Left = Left - Right);
2033 return (Left = Left - Right);
2038 return (Left = Left * Right);
2043 return (Left = Left * Right);
2048 return (Left = Left * Right);
2053 return (Left = Left * Right);
2058 return (Left = Left * Right);
2063 return (Left = Left * Right);
2068 return (Left = Left * Right);
2073 return (Left = Left * Right);
2078 return (Left = Left / Right);
2083 return (Left = Left / Right);
2088 return (Left = Left / Right);
2093 return (Left = Left / Right);
2098 return (Left = Left / Right);
2103 return (Left = Left / Right);
2108 return (Left = Left / Right);
2113 return (Left = Left / Right);
2149#pragma GCC diagnostic pop
2154#ifdef HANDMADE_MATH_IMPLEMENTATION
2158 float Result = 1.0f;
2159 float Mul = Exponent < 0 ? 1.f /
Base :
Base;
2160 unsigned int X = Exponent < 0 ? -Exponent : Exponent;
2173#ifndef HANDMADE_MATH__USE_SSE
2179 for (Columns = 0; Columns < 4; ++Columns) {
2181 for (Rows = 0; Rows < 4; ++Rows) {
2190#ifndef HANDMADE_MATH__USE_SSE
2196 for (Columns = 0; Columns < 4; ++Columns) {
2198 for (Rows = 0; Rows < 4; ++Rows) {
2199 Result.
Elements[Columns][Rows] =
Left.Elements[Columns][Rows] +
Right.Elements[Columns][Rows];
2207#ifndef HANDMADE_MATH__USE_SSE
2213 for (Columns = 0; Columns < 4; ++Columns) {
2215 for (Rows = 0; Rows < 4; ++Rows) {
2216 Result.
Elements[Columns][Rows] =
Left.Elements[Columns][Rows] -
Right.Elements[Columns][Rows];
2228#ifdef HANDMADE_MATH__USE_SSE
2230 Result.Columns[0] = HMM_LinearCombineSSE(
Right.Columns[0], Left);
2231 Result.Columns[1] = HMM_LinearCombineSSE(
Right.Columns[1], Left);
2232 Result.Columns[2] = HMM_LinearCombineSSE(
Right.Columns[2], Left);
2233 Result.Columns[3] = HMM_LinearCombineSSE(
Right.Columns[3], Left);
2237 for (Columns = 0; Columns < 4; ++Columns) {
2239 for (Rows = 0; Rows < 4; ++Rows) {
2242 for (CurrentMatrice = 0; CurrentMatrice < 4; ++CurrentMatrice) {
2243 Sum +=
Left.Elements[CurrentMatrice][Rows] *
Right.Elements[Columns][CurrentMatrice];
2254#ifndef HANDMADE_MATH__USE_SSE
2260 for (Columns = 0; Columns < 4; ++Columns) {
2262 for (Rows = 0; Rows < 4; ++Rows) {
2275#ifdef HANDMADE_MATH__USE_SSE
2276 Result.InternalElementsSSE = HMM_LinearCombineSSE(Vector.InternalElementsSSE, Matrix);
2279 for (Rows = 0; Rows < 4; ++Rows) {
2281 for (Columns = 0; Columns < 4; ++Columns) {
2292#ifndef HANDMADE_MATH__USE_SSE
2298 for (Columns = 0; Columns < 4; ++Columns) {
2300 for (Rows = 0; Rows < 4; ++Rows) {
2317 float CosValue = 1.0f - CosTheta;
2319 Result.
Elements[0][0] = (Axis.
X * Axis.
X * CosValue) + CosTheta;
2320 Result.
Elements[0][1] = (Axis.
X * Axis.
Y * CosValue) + (Axis.
Z * SinTheta);
2321 Result.
Elements[0][2] = (Axis.
X * Axis.
Z * CosValue) - (Axis.
Y * SinTheta);
2323 Result.
Elements[1][0] = (Axis.
Y * Axis.
X * CosValue) - (Axis.
Z * SinTheta);
2324 Result.
Elements[1][1] = (Axis.
Y * Axis.
Y * CosValue) + CosTheta;
2325 Result.
Elements[1][2] = (Axis.
Y * Axis.
Z * CosValue) + (Axis.
X * SinTheta);
2327 Result.
Elements[2][0] = (Axis.
Z * Axis.
X * CosValue) + (Axis.
Y * SinTheta);
2328 Result.
Elements[2][1] = (Axis.
Z * Axis.
Y * CosValue) - (Axis.
X * SinTheta);
2329 Result.
Elements[2][2] = (Axis.
Z * Axis.
Z * CosValue) + CosTheta;
2370 float NormSquared = 0;
2372 Conjugate.
X = -
Left.X;
2373 Conjugate.
Y = -
Left.Y;
2374 Conjugate.
Z = -
Left.Z;
2375 Conjugate.
W =
Left.W;
2378 NormSquared = Norm * Norm;
2380 Result.
X = Conjugate.
X / NormSquared;
2381 Result.
Y = Conjugate.
Y / NormSquared;
2382 Result.
Z = Conjugate.
Z / NormSquared;
2383 Result.
W = Conjugate.
W / NormSquared;
2397 float S1 =
HMM_SinF((1.0f - Time) * Angle);
2421 XX = NormalizedQuaternion.
X * NormalizedQuaternion.
X;
2422 YY = NormalizedQuaternion.
Y * NormalizedQuaternion.
Y;
2423 ZZ = NormalizedQuaternion.
Z * NormalizedQuaternion.
Z;
2424 XY = NormalizedQuaternion.
X * NormalizedQuaternion.
Y;
2425 XZ = NormalizedQuaternion.
X * NormalizedQuaternion.
Z;
2426 YZ = NormalizedQuaternion.
Y * NormalizedQuaternion.
Z;
2427 WX = NormalizedQuaternion.
W * NormalizedQuaternion.
X;
2428 WY = NormalizedQuaternion.
W * NormalizedQuaternion.
Y;
2429 WZ = NormalizedQuaternion.
W * NormalizedQuaternion.
Z;
2431 Result.
Elements[0][0] = 1.0f - 2.0f * (YY + ZZ);
2432 Result.
Elements[0][1] = 2.0f * (XY + WZ);
2433 Result.
Elements[0][2] = 2.0f * (XZ - WY);
2435 Result.
Elements[1][0] = 2.0f * (XY - WZ);
2436 Result.
Elements[1][1] = 1.0f - 2.0f * (XX + ZZ);
2437 Result.
Elements[1][2] = 2.0f * (YZ + WX);
2439 Result.
Elements[2][0] = 2.0f * (XZ + WY);
2440 Result.
Elements[2][1] = 2.0f * (YZ - WX);
2441 Result.
Elements[2][2] = 1.0f - 2.0f * (XX + YY);
2453 float SineOfRotation = 0;
2456 SineOfRotation =
HMM_SinF(AngleOfRotation / 2.0f);
2459 Result.
W =
HMM_CosF(AngleOfRotation / 2.0f);
o2::monitoring::tags::Value Value
configStandalone Light OpenGL display display_light Apply smoothing to points Enable Z buffer Highlight links Highlight seeds Highlight sector tracks Highlight final tracks Show individual Show related Highlight grid Show only individual collision Color clusters belonging to track objects Set line Enable drawing TPC data Enable drawing TOF data Enable drawing magnetic field Set field line step count Invert colors configStandalone Heavy OpenGL display display_heavy Show tracks with ITS contribution Show tracks with TOF contribution Enable propagation of loopers Show clusters at nominal x of pad row for early transformed data Split CE tracks when they cross the central Mark clusters Mark adjacent clusters Hide rejected tracks Apply filter on tracks to be displayed Separate increase X h configStandalone Camera window renderer OpenGL display display_camera Orient the camera such that the y axis is always upwards Full Screen MultiSample Anti Downsampling Anti Enable Vertical Sync Target frame or if the backend cannot limit to the refresh Use OpenGL indirect draws to reduce number of draw calls Display FOV
configStandalone Reconstruction rec_tpc multiplier for the combined cluster track error during track following area in cm for the search of for z only used if decrease removal by when above this local occupancy rowx Shift of TPC revert cluster flag edge bit distance to edge exceeds this ZOffset for secondary multiple of radius max P of electron K BB bands crossing max P of electron p BB bands crossing max P of electron d BB bands crossing max P of electron t BB bands crossing min accepted dEdxMaxTPC of the track Additive extra cluster error for Y2 if edge flag set Additive extra cluster error for Y2 if single set Additive extra cluster error for Y2 if or single set Additive extra cluster error for Z2 if or single set Extra errors to add to track when crossing depending on addErrorsCECrossing Inner portion of y range in sector that is not used in searching for extrapolated track candidates factor2YS for track merging factor2K for track merging Margin in cm of Y position when rejecting edge clusters based on uncorrected track Y Max fraction of shared clusters for tracklet Except pad from cluster finding if total number of charges in a fragment is above this Except pad from cluster finding if number of consecutive charges in a fragment is above this Threshold where a timebin is considered disabling the noisy pad check for that pad Treat signal above this minimum as saturated Smoothing factor for the exponential Highly Ionising Particle tail filter Number of timebins to use for the averaging Add additional custom track errors when crossing relative as fraction of Do N fit passes in final fit of< 0:reject at max -n hits") AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 1, "", 0, "Reject clusters that get the IFC mask error during refit") AddOptionRTC(dEdxTruncLow, uint8_t, 2, "", 0, "Low truncation threshold, fraction of 128") AddOptionRTC(dEdxTruncHigh, uint8_t, 77, "", 0, "High truncation threshold, fraction of 128") AddOptionRTC(extrapolationTracking, int8_t, 1, "", 0, "Enable Extrapolation Tracking(prolong tracks to adjacent sectors to find short segments)") AddOptionRTC(disableRefitAttachment, uint8_t, 0, "", 0, "Bitmask to disable certain attachment steps during refit(1:attachment, 2:propagation, 4:loop following, 8:mirroring)") AddOptionRTC(rejectionStrategy, uint8_t, o2::gpu::GPUSettings::RejectionStrategyA, "", 0, "Enable rejection of TPC clusters for compression(0=no, 1=strategy A, 2=strategy B)") AddOptionRTC(mergeLoopersAfterburner, uint8_t, 1, "", 0, "Run afterburner for additional looper merging") AddOptionRTC(compressionTypeMask, uint8_t, o2::gpu::GPUSettings::CompressionFull, "", 0, "TPC Compression mode bits(1=truncate charge/width LSB, 2=differences, 4=track-model)") AddOptionRTC(compressionSortOrder, uint8_t, o2::gpu::GPUSettings::SortTime, "", 0, "Sort order of TPC compression(0=time, 1=pad, 2=Z-time-pad, 3=Z-pad-time, 4=no sorting(use incoming order))") AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for TPC cluster charge in compression mode 1") AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1") AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop") AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection") AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position starting from NDF > mergerNonInterpolateRejectMinNDF Merge tracks accross the central electrode Enable PID response Add sub threshold clusters in TPC dEdx computation OR mask of TPC flags that will reject the cluster in alternative dEdx Reject edge clusters based on uncorrected track Y during track fit Increase decrease removal by when on this number of pads from the edge h configStandalone Reconstruction rec_trd Max chi2 for TRD tracklets to be matched to a track Chi2 cut for strict matching mode Number of sigmas for ITS TPC track time error estimate Addition to search road around track prolongation along Y in cm Optimal tracklet rphi resolution in maximum chi2 per attached tracklet for TRD tracks take into account the full likelihood of the slope including exponential tails Tracks with less attached tracklets are discarded after the tracking Post trigger Pile up integration time in BCs fits all iterations but the last one in projections Use material lookup table for TPC refit Apply workarounds to avoid cyclic merge should not be needed tpc dyn configStandalone Processing proc_rtc Replace constant variables static by constexpr expressions Compile RTC in deterministic with NO_FAST_MATH flags and GPUCA_DETERMINISTIC_MODE define Use RTC to optimize GPU code h configStandalone Processing proc_rtctech Use a file lock to serialize access to the cache folder int32_t
configStandalone Reconstruction rec_tpc float
HMM_INLINE hmm_mat4 HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far)
HMM_INLINE hmm_vec2 HMM_Vec2(float X, float Y)
HMM_INLINE hmm_vec3 HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right)
HMM_INLINE float HMM_LogF(float Float)
HMM_EXTERN float HMM_Power(float Base, int Exponent)
HMM_INLINE hmm_vec3 HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right)
HMM_INLINE hmm_vec2 HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right)
HMM_INLINE hmm_vec4 HMM_Vec4i(int X, int Y, int Z, int W)
HMM_INLINE float HMM_Lerp(float A, float Time, float B)
HMM_INLINE hmm_bool HMM_EqualsVec2(hmm_vec2 Left, hmm_vec2 Right)
HMM_INLINE float HMM_DotVec4(hmm_vec4 VecOne, hmm_vec4 VecTwo)
HMM_INLINE float HMM_TanF(float Radians)
HMM_EXTERN hmm_mat4 HMM_DivideMat4f(hmm_mat4 Matrix, float Scalar)
HMM_INLINE hmm_vec4 HMM_Vec4(float X, float Y, float Z, float W)
HMM_INLINE float HMM_ATan2F(float Left, float Right)
HMM_INLINE hmm_vec2 HMM_NormalizeVec2(hmm_vec2 A)
HMM_INLINE float HMM_DotQuaternion(hmm_quaternion Left, hmm_quaternion Right)
HMM_INLINE hmm_vec4 HMM_MultiplyVec4f(hmm_vec4 Left, float Right)
HMM_INLINE hmm_vec3 HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right)
HMM_INLINE hmm_mat4 HMM_Mat4d(float Diagonal)
HMM_INLINE hmm_vec4 HMM_NormalizeVec4(hmm_vec4 A)
HMM_INLINE hmm_vec2 HMM_MultiplyVec2f(hmm_vec2 Left, float Right)
HMM_INLINE hmm_quaternion HMM_DivideQuaternionF(hmm_quaternion Left, float Dividend)
HMM_INLINE hmm_vec4 HMM_Vec4v(hmm_vec3 Vector, float W)
HMM_INLINE float HMM_DotVec3(hmm_vec3 VecOne, hmm_vec3 VecTwo)
HMM_INLINE float HMM_LengthVec3(hmm_vec3 A)
HMM_INLINE hmm_mat4 HMM_Perspective(float FOV, float AspectRatio, float Near, float Far)
HMM_INLINE float HMM_LengthSquaredVec3(hmm_vec3 A)
HMM_INLINE hmm_mat4 HMM_Mat4()
HMM_INLINE hmm_quaternion HMM_Quaternion(float X, float Y, float Z, float W)
HMM_INLINE hmm_quaternion HMM_MultiplyQuaternionF(hmm_quaternion Left, float Multiplicative)
HMM_INLINE hmm_quaternion HMM_SubtractQuaternion(hmm_quaternion Left, hmm_quaternion Right)
HMM_EXTERN hmm_quaternion HMM_QuaternionFromAxisAngle(hmm_vec3 Axis, float AngleOfRotation)
HMM_INLINE hmm_vec2 HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right)
HMM_INLINE float HMM_LengthVec4(hmm_vec4 A)
HMM_INLINE hmm_vec4 HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right)
HMM_EXTERN hmm_mat4 HMM_MultiplyMat4f(hmm_mat4 Matrix, float Scalar)
HMM_INLINE hmm_quaternion HMM_QuaternionV4(hmm_vec4 Vector)
HMM_INLINE float HMM_Clamp(float Min, float Value, float Max)
HMM_INLINE hmm_vec3 HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right)
HMM_INLINE float HMM_SquareRootF(float Float)
HMM_EXTERN hmm_vec4 HMM_MultiplyMat4ByVec4(hmm_mat4 Matrix, hmm_vec4 Vector)
HMM_EXTERN hmm_mat4 HMM_SubtractMat4(hmm_mat4 Left, hmm_mat4 Right)
HMM_INLINE float HMM_RSquareRootF(float Float)
HMM_INLINE float HMM_LengthSquaredVec4(hmm_vec4 A)
HMM_INLINE hmm_vec3 HMM_DivideVec3f(hmm_vec3 Left, float Right)
HMM_INLINE float HMM_PowerF(float Base, float Exponent)
HMM_INLINE float HMM_ATanF(float Radians)
HMM_INLINE hmm_vec2 HMM_DivideVec2f(hmm_vec2 Left, float Right)
HMM_EXTERN hmm_mat4 HMM_Transpose(hmm_mat4 Matrix)
HMM_INLINE hmm_vec4 HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right)
HMM_INLINE hmm_vec4 HMM_DivideVec4f(hmm_vec4 Left, float Right)
HMM_INLINE hmm_vec4 HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right)
HMM_INLINE hmm_mat4 HMM_Translate(hmm_vec3 Translation)
HMM_EXTERN hmm_mat4 HMM_QuaternionToMat4(hmm_quaternion Left)
HMM_INLINE float HMM_ACosF(float Radians)
HMM_INLINE hmm_bool HMM_EqualsVec4(hmm_vec4 Left, hmm_vec4 Right)
HMM_INLINE hmm_vec2 HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right)
HMM_EXTERN hmm_quaternion HMM_InverseQuaternion(hmm_quaternion Left)
HMM_INLINE float HMM_SinF(float Radians)
HMM_INLINE hmm_quaternion HMM_NLerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
HMM_INLINE hmm_quaternion HMM_AddQuaternion(hmm_quaternion Left, hmm_quaternion Right)
HMM_EXTERN hmm_mat4 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
HMM_INLINE hmm_quaternion HMM_NormalizeQuaternion(hmm_quaternion Left)
HMM_INLINE float HMM_LengthSquaredVec2(hmm_vec2 A)
HMM_EXTERN hmm_quaternion HMM_Slerp(hmm_quaternion Left, float Time, hmm_quaternion Right)
HMM_INLINE hmm_bool HMM_EqualsVec3(hmm_vec3 Left, hmm_vec3 Right)
HMM_INLINE hmm_vec4 HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right)
HMM_INLINE hmm_vec3 HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo)
HMM_INLINE hmm_vec3 HMM_NormalizeVec3(hmm_vec3 A)
HMM_INLINE hmm_vec3 HMM_Vec3i(int X, int Y, int Z)
HMM_EXTERN hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
HMM_INLINE float HMM_ExpF(float Float)
HMM_INLINE hmm_vec3 HMM_Vec3(float X, float Y, float Z)
HMM_EXTERN hmm_mat4 HMM_Rotate(float Angle, hmm_vec3 Axis)
HMM_INLINE hmm_mat4 HMM_Scale(hmm_vec3 Scale)
HMM_INLINE hmm_vec2 HMM_Vec2i(int X, int Y)
HMM_EXTERN hmm_mat4 HMM_AddMat4(hmm_mat4 Left, hmm_mat4 Right)
HMM_INLINE hmm_quaternion HMM_MultiplyQuaternion(hmm_quaternion Left, hmm_quaternion Right)
HMM_INLINE float HMM_CosF(float Radians)
HMM_INLINE float HMM_ToRadians(float Degrees)
HMM_INLINE hmm_vec2 HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right)
HMM_INLINE float HMM_LengthVec2(hmm_vec2 A)
HMM_INLINE hmm_vec3 HMM_MultiplyVec3f(hmm_vec3 Left, float Right)
HMM_INLINE float HMM_DotVec2(hmm_vec2 VecOne, hmm_vec2 VecTwo)
auto operator+=(std::string &lhs, StringRef rhs) -> std::string &
Vec3 operator-(const Vec3 &firstVector, const Vec3 &secondVector)
MultPolicyGPU< T, R1, R2 >::RepType operator*(const SMatrixGPU< T, D1, D, R1 > &lhs, const SMatrixGPU< T, D, D2, R2 > &rhs)
bool operator!=(const DsChannelId &a, const DsChannelId &b)