d0/d8b/TPCFastTransformPOD_8h_source.html

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.

// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.

// All rights not expressly granted are reserved.

//

// This software is distributed under the terms of the GNU General Public

// License v3 (GPL Version 3), copied verbatim in the file "COPYING".

//

// In applying this license CERN does not waive the privileges and immunities

// granted to it by virtue of its status as an Intergovernmental Organization

// or submit itself to any jurisdiction.


#ifndef ALICEO2_GPU_TPCFastTransformPOD_H

#define ALICEO2_GPU_TPCFastTransformPOD_H


#include "GPUCommonDef.h"


#include "GPUCommonRtypes.h"

#include "TPCFastTransform.h"

#include "TPCFastTransformGeoPOD.h"

#include "DataFormatsTPC/Constants.h"

#ifndef GPUCA_GPUCODE

#include <memory>

#include <cstdlib>

#include "GPUCommonAlignedAlloc.h"

#endif


/*

Binary buffer should be cast to TPCFastTransformPOD class using static TPCFastTransformPOD& t = get(buffer); method,

so that its head becomes `this` pointer of the object.


First we have all the fixed size data members mentioned explicitly. Part of them is duplicating fixed size

data members of TPCFastSpaceChargeCorrection but those starting with mOffs... provide the offset in bytes

(wrt this) for dynamic data which cannot be declared as data member explicitly (since we cannot have any

pointer except `this`) but obtained via getters using stored offsets wrt `this`.

This is followed dynamic part itself.


dynamic part layout:

1) size_t[ mNumberOfScenarios ] array starting at offset mOffsScenariosOffsets, each element is the offset

of distict spline object (scenario in TPCFastSpaceChargeCorrection)

2) size_t[ mNSplineIDs ] array starting at offset mOffsSplineDataOffsets, each element is the offset of the

beginning of splines data for give splineID


*/


namespace o2::gpu

{


class TPCFastTransformPOD

{

 public:

  using SliceInfo = TPCFastSpaceChargeCorrection::SliceInfo; // obsolete

  using GridInfo = TPCFastSpaceChargeCorrection::GridInfo;

  using RowInfo = TPCFastSpaceChargeCorrection::RowInfo;


  using SplineTypeXYZ = TPCFastSpaceChargeCorrection::SlimSplineTypeXYZ;

  using SplineTypeInvX = TPCFastSpaceChargeCorrection::SlimSplineTypeInvX;

  using SplineTypeInvYZ = TPCFastSpaceChargeCorrection::SlimSplineTypeInvYZ;

  using SplineType = TPCFastSpaceChargeCorrection::SlimSplineType;


  GPUd() static const TPCFastTransformPOD& get(const char* head) { return *reinterpret_cast<const TPCFastTransformPOD*>(head); }


  // Methods taking extra reference transform are legacy compound transforms used to scale corrections.

  GPUd() void Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const;

  GPUd() void TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z) const;


  GPUd() void TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;

  GPUd() void TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const;


  GPUd() void InverseTransformInTimeFrame(int32_t sector, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;

  GPUd() float InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const;


  GPUd() void InverseTransformYZtoX(int32_t sector, int32_t row, float y, float z, float& x) const;


  GPUd() void InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float y, float z, float& ny, float& nz) const;


  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const;


  GPUd() void TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;

  GPUd() void TransformIdealZ(int32_t sector, float time, float& z, float vertexTime) const;


  GPUd() void convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const;

  GPUd() void convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const;


  GPUd() void convLocalToPadTime(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float vertexTime) const;

  GPUd() void convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const;


  GPUd() float convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const;

  GPUd() float convZtoTimeInTimeFrame(int32_t sector, float z, float maxTimeBin) const;

  GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t sector, float deltaTime) const;

  GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t sector, float deltaZ) const;

  GPUd() float convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const;

  GPUd() float convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const;

  GPUd() float convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const;


  void setApplyCorrectionOn() { mApplyCorrection = 1; }

  void setApplyCorrectionOff() { mApplyCorrection = 0; }

  bool isCorrectionApplied() { return mApplyCorrection; }


  GPUd() const TPCFastTransformGeoPOD& getGeometry() const { return mGeo; }


  GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfos[row]; }


  GPUd() RowInfo& getRowInfo(int32_t row) { return mRowInfos[row]; }


  GPUd() size_t size() const { return mTotalSize; }


  GPUd() long int getTimeStamp() const { return mTimeStamp; }


  GPUd() float getVDrift() const { return mVdrift; }


  GPUd() float getT0() const { return mT0; }


  GPUd() float getIDC() const { return mIDC; }


  GPUd() float getLumi() const { return mLumi; }


  GPUd() float getMaxDriftTime(int32_t sector, int32_t row, float pad) const;


  GPUd() float getMaxDriftTime(int32_t sector, int32_t row) const;


  GPUd() float getMaxDriftTime(int32_t sector) const;


  GPUd() void setTimeStamp(long int v) { mTimeStamp = v; }


  GPUd() void setVDrift(float v) { mVdrift = v; }


  GPUd() void setT0(float v) { mT0 = v; }


  GPUd() void setIDC(float v) { mIDC = v; }


  GPUd() void setLumi(float v) { mLumi = v; }


  GPUd() void setCalibration(int64_t timeStamp, float t0, float vDrift);


  GPUd() const SplineType& getSplineForRow(int32_t row) const { return *reinterpret_cast<const SplineType*>(getThis() + getScenarioOffset(getRowInfo(row).splineScenarioID)); }


  GPUd() const float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0) const { return reinterpret_cast<const float*>(getThis() + mSplineDataOffsets[sector][iSpline] + getRowInfo(row).dataOffsetBytes[iSpline]); }


  GPUd() const SplineTypeInvX& getSplineInvXforRow(int32_t row) const { return reinterpret_cast<const SplineTypeInvX&>(getSplineForRow(row)); }


  GPUd() const float* getCorrectionDataInvX(int32_t sector, int32_t row) const { return getCorrectionData(sector, row, 1); }


  GPUd() const SplineTypeInvYZ& getSplineInvYZforRow(int32_t row) const { return reinterpret_cast<const SplineTypeInvYZ&>(getSplineForRow(row)); }


  GPUd() const float* getCorrectionDataInvYZ(int32_t sector, int32_t row) const { return getCorrectionData(sector, row, 2); }


  GPUdi() void getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const;


  GPUd() float getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;


  GPUd() void getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const;


  GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const;


  GPUd() void convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const;


  GPUd() void convGridToLocal(int32_t sector, int32_t row, float u, float v, float& y, float& z) const;


  GPUd() void convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const;


  GPUd() void convGridToRealLocal(int32_t sector, int32_t row, float u, float v, float& y, float& z) const;


  GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;

  GPUd() bool isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;


#if !defined(GPUCA_GPUCODE)

  static TPCFastTransformPOD* create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastTransform& src);


  static TPCFastTransformPOD* create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastSpaceChargeCorrection& src);


  static TPCFastTransformPOD* create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastTransformPOD& src)

  {

    destVector.alloc(src.size());

    std::memcpy(destVector.get(), &src, src.size());

    return destVector.get();

  }


  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastTransform& src);

  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& src);

  static size_t estimateSize(const TPCFastTransform& src) { return estimateSize(src.getCorrection()); }

  static size_t estimateSize(const TPCFastSpaceChargeCorrection& origCorr);


  bool test(const TPCFastTransform& src, int32_t npoints = 100000) const { return test(src.getCorrection(), npoints); }

  bool test(const TPCFastSpaceChargeCorrection& origCorr, int32_t npoints = 100000) const;

#endif


  void print() const;


  GPUd() float convDriftLengthToTime(float driftLength, float vertexTime) const;


  static GPUglobalconstexpr() int NROWS = o2::tpc::constants::MAXGLOBALPADROW;

  static GPUglobalconstexpr() int NSECTORS = o2::tpc::constants::MAXSECTOR;

  static GPUglobalconstexpr() int NSECTORSA = o2::tpc::constants::MAXSECTOR / 2;

  static GPUglobalconstexpr() int NSplineIDs = 3;


 private:

#if !defined(GPUCA_GPUCODE)

  static constexpr size_t AlignmentBytes = 8;

  static size_t alignOffset(size_t offs)

  {

    auto res = offs % AlignmentBytes;

    return res ? offs + (AlignmentBytes - res) : offs;

  }

  GPUd() static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }

#endif


  GPUd() const char* getThis() const { return reinterpret_cast<const char*>(this); }


  GPUd() size_t getScenarioOffset(int s) const { return (reinterpret_cast<const size_t*>(getThis() + mOffsScenariosOffsets))[s]; }


  GPUd() size_t getFlatBufferOffset(int s) const { return (reinterpret_cast<const size_t*>(getThis() + mOffsFlatBufferOffsets))[s]; }


  // Returns a pointer to the flat buffer of scenario isc, using only the

  // stored offset array (mOffsFlatBufferOffsets). No stale pointer involved.

  GPUd() const char* getSplineFlatBuffer(int32_t isc) const

  {

    const size_t* offs = reinterpret_cast<const size_t*>(getThis() + mOffsFlatBufferOffsets);

    return getThis() + offs[isc];

  }


  // Returns a pointer to mGridX2's flat buffer inside the spline flat buffer.

  // Reproduces the layout from Spline2DContainer::setActualBufferAddress using

  // only safe values: getFlatBufferSize() reads mNumberOfKnots/mUmax (plain ints).

  template <typename SplineT>

  GPUd() const char* getGridX2FlatBuffer(const SplineT& spline, int32_t isc) const

  {

    const size_t g1sz = spline.getGridX1().getFlatBufferSize();

    const size_t g2align = spline.getGridX2().getBufferAlignmentBytes();

    return getSplineFlatBuffer(isc) + FlatObject::alignSize(g1sz, g2align);

  }


  bool mApplyCorrection{};

  int mNumberOfScenarios{};

  size_t mTotalSize{};

  size_t mOffsScenariosOffsets{};

  size_t mOffsFlatBufferOffsets{};

  size_t mSplineDataOffsets[TPCFastTransformGeo::getNumberOfSectors()][NSplineIDs];

  long int mTimeStamp{};

  float mT0;

  float mVdrift;

  float mLumi;

  float mIDC;


  TPCFastTransformGeoPOD mGeo;

  RowInfo mRowInfos[NROWS];


  ClassDefNV(TPCFastTransformPOD, 0);

};


GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const

{

  const auto& info = getRowInfo(row);

  const int32_t isc = info.splineScenarioID;

  const SplineType& spline = getSplineForRow(row);

  const float* splineData = getCorrectionData(sector, row);


  float u, v, s;

  convLocalToGrid(sector, row, y, z, u, v, s);


  const char* g1buf = getSplineFlatBuffer(isc);

  const char* g2buf = getGridX2FlatBuffer(spline, isc);


  float dxyz[3];

  spline.interpolateAtUZeroCopy(g1buf, g2buf, splineData, u, v, dxyz);


  if (CAMath::Abs(dxyz[0]) > TPCFastSpaceChargeCorrection::kMaxCorrection || CAMath::Abs(dxyz[1]) > TPCFastSpaceChargeCorrection::kMaxCorrection || CAMath::Abs(dxyz[2]) > TPCFastSpaceChargeCorrection::kMaxCorrection) {

    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed

  }


  dx = s * dxyz[0];

  dy = s * dxyz[1];

  dz = s * dxyz[2];

}


GPUdi() float TPCFastTransformPOD::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const

{

  const auto& info = getRowInfo(row);

  float u, v, s;

  convRealLocalToGrid(sector, row, realY, realZ, u, v, s);


  const int32_t isc = info.splineScenarioID;

  const auto& spline = getSplineInvXforRow(row);

  const char* g1buf = getSplineFlatBuffer(isc);

  const char* g2buf = getGridX2FlatBuffer(spline, isc);


  float dx = 0;

  spline.interpolateAtUZeroCopy(g1buf, g2buf, getCorrectionDataInvX(sector, row), u, v, &dx);

  if (CAMath::Abs(dx) > TPCFastSpaceChargeCorrection::kMaxCorrection) {

    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed

  }

  dx = s * dx;

  return dx;

}


GPUdi() void TPCFastTransformPOD::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& y, float& z) const

{

  float u, v, s;

  convRealLocalToGrid(sector, row, realY, realZ, u, v, s);

  const auto& info = getRowInfo(row);

  const int32_t isc = info.splineScenarioID;

  const auto& spline = getSplineInvYZforRow(row);

  const char* g1buf = getSplineFlatBuffer(isc);

  const char* g2buf = getGridX2FlatBuffer(spline, isc);


  float dyz[2];

  spline.interpolateAtUZeroCopy(g1buf, g2buf, getCorrectionDataInvYZ(sector, row), u, v, dyz);

  if (CAMath::Abs(dyz[0]) > TPCFastSpaceChargeCorrection::kMaxCorrection || CAMath::Abs(dyz[1]) > TPCFastSpaceChargeCorrection::kMaxCorrection) {

    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed

  }

  y = s * dyz[0];

  z = s * dyz[1];

}


GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const

{

  const SplineType& spline = getSplineForRow(row);

  getRowInfo(row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);

  // shrink to the grid

  u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());

  v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());

}


GPUdi() void TPCFastTransformPOD::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const

{

  getRowInfo(row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);

}


GPUdi() void TPCFastTransformPOD::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const

{

  const SplineType& spline = getSplineForRow(row);

  getRowInfo(row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);

  // shrink to the grid

  u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());

  v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());

}


GPUdi() void TPCFastTransformPOD::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const

{

  getRowInfo(row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);

}


GPUdi() bool TPCFastTransformPOD::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const

{

  float u, v, s;

  getRowInfo(row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);

  const auto& spline = getSplineForRow(row);

  // shrink to the grid

  if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //

      v < 0.f || v > (float)spline.getGridX2().getUmax()) {

    return false;

  }

  return true;

}


GPUdi() bool TPCFastTransformPOD::isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const

{

  float u, v, s;

  getRowInfo(row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);

  const auto& spline = getSplineForRow(row);

  // shrink to the grid

  if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //

      v < 0.f || v > (float)spline.getGridX2().getUmax()) {

    return false;

  }

  return true;

}


GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const

{

  if (!mApplyCorrection) {

    return;

  }

  float dx, dy, dz;

  getCorrectionLocal(sector, row, y, z, dx, dy, dz);


  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {

    float lx = x, ly = y, lz = z;

    float gx, gy, gz;

    getGeometry().convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);

    float lxT = lx + dx;

    float lyT = ly + dy;

    float lzT = lz + dz;

    float invYZtoX;

    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoX);


    float YZtoNominalY;

    float YZtoNominalZ;

    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);


    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()

                                                                                       // corrections in x, u, v

                                                                                       << "dx=" << dx

                                                                                       << "dy=" << dy

                                                                                       << "dz=" << dz

                                                                                       << "row=" << row

                                                                                       << "sector=" << sector

                                                                                       // original local coordinates

                                                                                       << "ly=" << ly

                                                                                       << "lz=" << lz

                                                                                       << "lx=" << lx

                                                                                       // corrected local coordinated

                                                                                       << "lxT=" << lxT

                                                                                       << "lyT=" << lyT

                                                                                       << "lzT=" << lzT

                                                                                       // global uncorrected coordinates

                                                                                       << "gx=" << gx

                                                                                       << "gy=" << gy

                                                                                       << "gz=" << gz

                                                                                       // some transformations which are applied

                                                                                       << "invYZtoX=" << invYZtoX

                                                                                       << "YZtoNominalY=" << YZtoNominalY

                                                                                       << "YZtoNominalZ=" << YZtoNominalZ

                                                                                       << "\n";

  })


  x += dx;

  y += dy;

  z += dz;

}


GPUdi() void TPCFastTransformPOD::Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const

{


  x = getGeometry().getRowInfoX(row);

  convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);

  TransformLocal(sector, row, x, y, z);

}


GPUdi() void TPCFastTransformPOD::TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z) const

{


  TransformLocal(sector, row, x, y, z);

}


GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const

{

  float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm

  z = getGeometry().convDriftLengthToZ(sector, l);

}


GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const

{


  x = getGeometry().getRowInfoX(row);

  convPadTimeToLocalInTimeFrame(sector, row, pad, time, y, z, maxTimeBin);

}


GPUdi() void TPCFastTransformPOD::InverseTransformInTimeFrame(int32_t sector, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const

{

  convLocalToPadTimeInTimeFrame(sector, row, y, z, pad, time, maxTimeBin);

}


GPUdi() float TPCFastTransformPOD::InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const

{

  float pad, time;

  InverseTransformInTimeFrame(sector, 0, 0, 0, z, pad, time, maxTimeBin);

  return time;

}


GPUdi() void TPCFastTransformPOD::TransformIdealZ(int32_t sector, float time, float& z, float vertexTime) const

{


  float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm

  z = getGeometry().convDriftLengthToZ(sector, l);

}


GPUdi() void TPCFastTransformPOD::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const

{


  x = getGeometry().getRowInfoX(row);

  float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm

  getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength, y, z);

}


GPUdi() float TPCFastTransformPOD::convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const

{


  float v = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm

  float z = (sector < getGeometry().getNumberOfSectorsA()) ? -v : v;

  return z;

}


GPUdi() float TPCFastTransformPOD::convZtoTimeInTimeFrame(int32_t sector, float z, float maxTimeBin) const

{

  float v = (sector < getGeometry().getNumberOfSectorsA()) ? -z : z;

  return mT0 + maxTimeBin + v / mVdrift;

}


GPUdi() float TPCFastTransformPOD::convDeltaTimeToDeltaZinTimeFrame(int32_t sector, float deltaTime) const

{

  float deltaZ = deltaTime * mVdrift;

  return sector < getGeometry().getNumberOfSectorsA() ? -deltaZ : deltaZ;

}


GPUdi() float TPCFastTransformPOD::convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const

{

  return deltaZ / mVdrift;

}


GPUdi() float TPCFastTransformPOD::convDeltaZtoDeltaTimeInTimeFrame(int32_t sector, float deltaZ) const

{

  float deltaT = deltaZ / mVdrift;

  return sector < getGeometry().getNumberOfSectorsA() ? -deltaT : deltaT;

}


GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector, int32_t row, float pad) const

{

  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);

}


GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector, int32_t row) const

{

  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);

}


GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector) const

{

  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);

}


GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX(int32_t sector, int32_t row, float realY, float realZ, float& realX) const

{

  float dx = 0.f;

  dx = getCorrectionXatRealYZ(sector, row, realY, realZ);

  realX = getGeometry().getRowInfoX(row) + dx;


  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {

    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()

                                                                                       << "sector=" << sector

                                                                                       << "row=" << row

                                                                                       << "y=" << realY

                                                                                       << "z=" << realZ

                                                                                       << "x=" << realX

                                                                                       << "\n";

  })

}


GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const

{

  float dy, dz;

  getCorrectionYZatRealYZ(sector, row, realY, realZ, dy, dz);

  measuredY = realY - dy;

  measuredZ = realZ - dz;


  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {

    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()

                                                                                       << "sector=" << sector

                                                                                       << "row=" << row

                                                                                       << "real y=" << realY

                                                                                       << "real z=" << realZ

                                                                                       << "measured y=" << measuredY

                                                                                       << "measured z=" << measuredZ

                                                                                       << "\n";

  })

}


GPUdi() void TPCFastTransformPOD::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const

{

  float l = (time - mT0 - vertexTime) * mVdrift;

  getGeometry().convPadDriftLengthToLocal(sector, row, pad, l, y, z);

}


GPUdi() void TPCFastTransformPOD::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const

{

  float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift;

  getGeometry().convPadDriftLengthToLocal(sector, row, pad, l, y, z);

}


GPUdi() void TPCFastTransformPOD::convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const

{

  float length = 0;

  getGeometry().convLocalToPadDriftLength(sector, row, y, z, pad, length);

  time = convDriftLengthToTime(length, maxTimeBin);

}


GPUdi() float TPCFastTransformPOD::convDriftLengthToTime(float driftLength, float vertexTime) const

{

  return (mT0 + vertexTime + driftLength / mVdrift);

}


GPUdi() float TPCFastTransformPOD::convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const

{

  if (sector < getGeometry().getNumberOfSectorsA()) {

    return maxTimeBin - (getGeometry().getTPCzLength() + zOffset) / mVdrift;

  } else {

    return maxTimeBin - (getGeometry().getTPCzLength() - zOffset) / mVdrift;

  }

}


GPUdi() float TPCFastTransformPOD::convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const

{

  if (sector < getGeometry().getNumberOfSectorsA()) {

    return (maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLength();

  } else {

    return -((maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLength());

  }

}


#ifndef GPUCA_GPUCODE_DEVICE // Functions not needed during GPU processing

GPUdi() void TPCFastTransformPOD::setCalibration(int64_t timeStamp, float t0, float vDrift)

{

  mTimeStamp = timeStamp;

  mT0 = t0;

  mVdrift = vDrift;

}


GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const

{

  int32_t row2 = row + 1;

  if (row2 >= getGeometry().getNumberOfRows()) {

    row2 = row - 1;

  }

  float nx1, ny1, nz1; // nominal coordinates for row

  float nx2, ny2, nz2; // nominal coordinates for row2

  nx1 = getGeometry().getRowInfoX(row);

  nx2 = getGeometry().getRowInfoX(row2);

  InverseTransformYZtoNominalYZ(sector, row, y, z, ny1, nz1);

  InverseTransformYZtoNominalYZ(sector, row2, y, z, ny2, nz2);

  float c1 = (nx2 - nx) / (nx2 - nx1);

  float c2 = (nx - nx1) / (nx2 - nx1);

  nx = x;

  ny = (ny1 * c1 + ny2 * c2);

  nz = (nz1 * c1 + nz2 * c2);

}

#endif // GPUCA_GPUCODE_DEVICE


} // namespace o2::gpu


#endif

Constants.h

time
int16_t time
Definition RawEventData.h:4

GPUCommonAlignedAlloc.h

GPUCommonDef.h

GPUCA_DEBUG_STREAMER_CHECK
#define GPUCA_DEBUG_STREAMER_CHECK(...)
Definition GPUCommonDef.h:75

GPUCommonRtypes.h

sector
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 sector
Definition GPUSettingsListDisplay.h:44

s
Timeframe settings Average distance in cm of events merged into Randomize distance around average distance of merged events Simulate correct bunch interactions instead of placing only the average number of events A value[n] sets TFlen for[n] collisions in Number of bunches per trainsort Number of bunch trains Instantaneous interaction rate Do not simulate border Total number of collisions to be placed in the interior of all time Do not select random but walk over array of events in stride steps h Event generator settings h configStandalone Use CPU for GPU Force usage of the specified GPU device no CPU fallback Continue processing after an error s
Definition GPUSettingsListStandalone.h:55

int32_t
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
Definition GPUSettingsList.h:235

bool
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 bool
Definition GPUSettingsList.h:221

float
configStandalone Reconstruction rec_tpc float
Definition GPUSettingsList.h:36

res
uint32_t res
Definition RawData.h:0

TPCFastTransformGeoPOD.h
Version using constexpr GPUTPCGeometry to be used for TPCFastTransformationPOD.

TPCFastTransform.h
Definition of TPCFastTransform class.

int64_t

long

o2::gpu::FlatObject::alignSize
static constexpr size_t alignSize(size_t sizeBytes, size_t alignmentBytes)
_______________ Generic utilities _______________________________________________
Definition FlatObject.h:275

o2::gpu::Spline2D
Forward declaration — specializations below select ClassDefNV based on FlatBase.
Definition Spline2D.h:104

o2::gpu::TPCFastSpaceChargeCorrection
Definition TPCFastSpaceChargeCorrection.h:41

o2::gpu::TPCFastSpaceChargeCorrection::SlimSplineType
SlimSplineTypeXYZ SlimSplineType
Definition TPCFastSpaceChargeCorrection.h:124

o2::gpu::TPCFastSpaceChargeCorrection::SlimSplineTypeInvYZ
Spline2D< float, 2, NoFlatObject > SlimSplineTypeInvYZ
Definition TPCFastSpaceChargeCorrection.h:123

o2::gpu::TPCFastSpaceChargeCorrection::SlimSplineTypeXYZ
Spline2D< float, 3, NoFlatObject > SlimSplineTypeXYZ
Slim variants (NoFlatObject base) for use in TPCFastTransformPOD.
Definition TPCFastSpaceChargeCorrection.h:121

o2::gpu::TPCFastSpaceChargeCorrection::SlimSplineTypeInvX
Spline2D< float, 1, NoFlatObject > SlimSplineTypeInvX
Definition TPCFastSpaceChargeCorrection.h:122

o2::gpu::TPCFastTransformGeo::getNumberOfSectors
static constexpr int32_t getNumberOfSectors()
_______________ Getters _________________________________
Definition TPCFastTransformGeo.h:111

o2::gpu::TPCFastTransformPOD
Definition TPCFastTransformPOD.h:53

o2::gpu::TPCFastTransformPOD::float
int32_t float
Definition TPCFastTransformPOD.h:78

o2::gpu::TPCFastTransformPOD::SplineTypeInvYZ
TPCFastSpaceChargeCorrection::SlimSplineTypeInvYZ SplineTypeInvYZ
Definition TPCFastTransformPOD.h:61

o2::gpu::TPCFastTransformPOD::create
static TPCFastTransformPOD * create(aligned_unique_buffer_ptr< TPCFastTransformPOD > &destVector, const TPCFastTransformPOD &src)
Definition TPCFastTransformPOD.h:224

o2::gpu::TPCFastTransformPOD::test
bool test(const TPCFastSpaceChargeCorrection &origCorr, int32_t npoints=100000) const

o2::gpu::TPCFastTransformPOD::vertexTime
int32_t float float float float float float vertexTime
Definition TPCFastTransformPOD.h:70

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() RowInfo &getRowInfo(int32_t row)
Gives TPC sector & row info.
Definition TPCFastTransformPOD.h:120

o2::gpu::TPCFastTransformPOD::test
bool test(const TPCFastTransform &src, int32_t npoints=100000) const
Definition TPCFastTransformPOD.h:236

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() float getIDC() const
Return IDC estimator.
Definition TPCFastTransformPOD.h:135

o2::gpu::TPCFastTransformPOD::create
static TPCFastTransformPOD * create(aligned_unique_buffer_ptr< TPCFastTransformPOD > &destVector, const TPCFastTransform &src)
Create POD transform from old flat-buffer one. Provided vector will serve as a buffer.
Definition TPCFastTransformPOD.cxx:30

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() const RowInfo &getRowInfo(int32_t row) const
Gives TPC sector & row info.
Definition TPCFastTransformPOD.h:117

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() const TPCFastTransformGeoPOD &getGeometry() const
TPC geometry information.
Definition TPCFastTransformPOD.h:114

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() long int getTimeStamp() const
Gives the time stamp of the current calibaration parameters.
Definition TPCFastTransformPOD.h:126

o2::gpu::TPCFastTransformPOD::iSpline
int32_t int32_t iSpline
Definition TPCFastTransformPOD.h:170

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() float getVDrift() const
Return mVDrift in cm / time bin.
Definition TPCFastTransformPOD.h:129

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() void setLumi(float v)
Sets CTP Lumi estimator.
Definition TPCFastTransformPOD.h:162

o2::gpu::TPCFastTransformPOD::v
int32_t float float float float & v
Definition TPCFastTransformPOD.h:200

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() void setIDC(float v)
Sets IDC estimator.
Definition TPCFastTransformPOD.h:159

o2::gpu::TPCFastTransformPOD::row
int32_t row
Definition TPCFastTransformPOD.h:70

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() float getLumi() const
Return Lumi estimator.
Definition TPCFastTransformPOD.h:138

o2::gpu::TPCFastTransformPOD::isCorrectionApplied
bool isCorrectionApplied()
Definition TPCFastTransformPOD.h:111

o2::gpu::TPCFastTransformPOD::print
void print() const
Print method.
Definition TPCFastTransformPOD.cxx:77

o2::gpu::TPCFastTransformPOD::u
int32_t float float float & u
Definition TPCFastTransformPOD.h:200

o2::gpu::TPCFastTransformPOD::ny
int32_t float float float & ny
Definition TPCFastTransformPOD.h:85

o2::gpu::TPCFastTransformPOD::GPUglobalconstexpr
static GPUglobalconstexpr() int NROWS

o2::gpu::TPCFastTransformPOD::setApplyCorrectionOff
void setApplyCorrectionOff()
Definition TPCFastTransformPOD.h:110

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() const float *getCorrectionData(int32_t sector
Gives pointer to spline data.

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() void setVDrift(float v)
Sets current vdrift.
Definition TPCFastTransformPOD.h:153

o2::gpu::TPCFastTransformPOD::pad
int32_t float pad
Definition TPCFastTransformPOD.h:70

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() static const TPCFastTransformPOD &get(const char *head)
convert prefilled buffer to TPCFastTransformPOD
Definition TPCFastTransformPOD.h:65

o2::gpu::TPCFastTransformPOD::realY
int32_t float realY
Definition TPCFastTransformPOD.h:188

o2::gpu::TPCFastTransformPOD::setApplyCorrectionOn
void setApplyCorrectionOn()
_______________ methods a la TPCFastSpaceChargeCorrection: cluster correction _______________________
Definition TPCFastTransformPOD.h:109

o2::gpu::TPCFastTransformPOD::const
int32_t float float float &z const
Definition TPCFastTransformPOD.h:71

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() void Transform(int32_t sector

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() float getT0() const
Return T0 in time bin units.
Definition TPCFastTransformPOD.h:132

o2::gpu::TPCFastTransformPOD::time
int32_t float float time
Definition TPCFastTransformPOD.h:70

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() void setCalibration(int64_t timeStamp

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() void setT0(float v)
Sets current T0.
Definition TPCFastTransformPOD.h:156

o2::gpu::TPCFastTransformPOD::estimateSize
static size_t estimateSize(const TPCFastTransform &src)
Definition TPCFastTransformPOD.h:233

o2::gpu::TPCFastTransformPOD::zOffset
float zOffset
Definition TPCFastTransformPOD.h:105

o2::gpu::TPCFastTransformPOD::nx
int32_t float float float float & nx
Definition TPCFastTransformPOD.h:88

o2::gpu::TPCFastTransformPOD::realZ
int32_t float float realZ
Definition TPCFastTransformPOD.h:191

o2::gpu::TPCFastTransformPOD::GPUd
GPUd() size_t size() const
Gives its own size including dynamic part.
Definition TPCFastTransformPOD.h:123

o2::gpu::TPCFastTransformPOD::SplineTypeInvX
TPCFastSpaceChargeCorrection::SlimSplineTypeInvX SplineTypeInvX
Definition TPCFastTransformPOD.h:60

o2::gpu::TPCFastTransformPOD::vDrift
float float vDrift
Definition TPCFastTransformPOD.h:164

o2::gpu::TPCFastTransformPOD::RowInfo
TPCFastSpaceChargeCorrection::RowInfo RowInfo
Definition TPCFastTransformPOD.h:57

o2::gpu::TPCFastTransformPOD::measuredY
int32_t float float float & measuredY
Definition TPCFastTransformPOD.h:191

o2::gpu::TPCFastTransform
Definition TPCFastTransform.h:97

unsigned int

x
GLint GLenum GLint x
Definition glcorearb.h:403

size
GLsizeiptr size
Definition glcorearb.h:659

v
const GLdouble * v
Definition glcorearb.h:832

y
GLint y
Definition glcorearb.h:270

length
GLuint GLsizei GLsizei * length
Definition glcorearb.h:790

void
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)

t0
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat t0
Definition glcorearb.h:5034

z
GLdouble GLdouble GLdouble z
Definition glcorearb.h:843

o2::emcal::NROWS
constexpr unsigned int NROWS
Definition Clusterizer.h:32

o2::gpu::internal::loglevel::info
@ info

o2::gpu
Definition TrackTRD.h:36

o2::gpu::GPUdi
GPUdi() o2
Definition TrackTRD.h:39

o2::utils::streamFastTransform
@ streamFastTransform
stream tpc fast transform
Definition DebugStreamer.h:37

o2
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
Definition FlattenRestore.h:23

o2::gpu::TPCFastSpaceChargeCorrection::GridInfo
Definition TPCFastSpaceChargeCorrection.h:50

o2::gpu::TPCFastSpaceChargeCorrection::RowInfo
Definition TPCFastSpaceChargeCorrection.h:104

o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo
Definition TPCFastSpaceChargeCorrection.h:46

o2::gpu::TPCFastTransformGeoPOD
Definition TPCFastTransformGeoPOD.h:29

o2::gpu::aligned_unique_buffer_ptr
Definition GPUCommonAlignedAlloc.h:42

o2::gpu::aligned_unique_buffer_ptr::alloc
T * alloc(std::size_t n)
Definition GPUCommonAlignedAlloc.h:52

o2::gpu::aligned_unique_buffer_ptr::get
T * get()
Definition GPUCommonAlignedAlloc.h:48

row
std::vector< int > row
Definition test_ctf_io_itsmft.cxx:48