TPCFastTransformGeo.h

Go to the documentation of this file.

// 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_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMGEO_H
#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMGEO_H
 
#include "GPUCommonDef.h"
#ifndef GPUCA_GPUCODE_DEVICE
#include <memory>
#include "GPUCommonRtypes.h"
#endif
 
namespace o2
{
namespace gpu
{
 
class TPCFastTransformGeo
{
 public:
  struct SliceInfo {
    float sinAlpha;
    float cosAlpha;
    ClassDefNV(SliceInfo, 1);
  };
 
  struct RowInfo {
    float x;          
    int32_t maxPad;   
    float padWidth;   
    float u0;         
    float scaleUtoSU; 
    float scaleSUtoU; 
 
    GPUd() float getUwidth() const { return -2.f * u0; }
    ClassDefNV(RowInfo, 1);
  };
 
 
  TPCFastTransformGeo();
 
  TPCFastTransformGeo(const TPCFastTransformGeo&) = default;
 
  TPCFastTransformGeo& operator=(const TPCFastTransformGeo&) = default;
 
  ~TPCFastTransformGeo() = default;
 
 
  static constexpr size_t getClassAlignmentBytes() { return 8; }
 
 
  void startConstruction(int32_t numberOfRows);
 
  void setTPCrow(int32_t iRow, float x, int32_t nPads, float padWidth);
 
  void setTPCzLength(float tpcZlengthSideA, float tpcZlengthSideC);
 
  void setTPCalignmentZ(float tpcAlignmentZ);
 
  void finishConstruction();
 
  bool isConstructed() const { return (mConstructionMask == (uint32_t)ConstructionState::Constructed); }
 
 
  GPUd() static constexpr int32_t getNumberOfSlices() { return NumberOfSlices; }
 
  GPUd() static constexpr int32_t getNumberOfSlicesA() { return NumberOfSlicesA; }
 
  GPUd() int32_t getNumberOfRows() const { return mNumberOfRows; }
 
  GPUd() const SliceInfo& getSliceInfo(int32_t slice) const;
 
  GPUd() const RowInfo& getRowInfo(int32_t row) const;
 
  GPUd() float getTPCzLengthA() const { return mTPCzLengthA; }
 
  GPUd() float getTPCzLengthC() const { return mTPCzLengthC; }
 
  GPUd() float getTPCzLength(int32_t slice) const
  {
    return (slice < NumberOfSlicesA) ? mTPCzLengthA
                                     : mTPCzLengthC;
  }
 
  GPUd() float getTPCalignmentZ() const { return mTPCalignmentZ; }
 
 
  GPUd() void convLocalToGlobal(int32_t slice, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
 
  GPUd() void convGlobalToLocal(int32_t slice, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
 
  GPUd() void convUVtoLocal(int32_t slice, float u, float v, float& y, float& z) const;
  GPUd() void convVtoLocal(int32_t slice, float v, float& z) const;
 
  GPUd() void convLocalToUV(int32_t slice, float y, float z, float& u, float& v) const;
 
  GPUd() void convUVtoScaledUV(int32_t slice, int32_t row, float u, float v, float& su, float& sv) const;
 
  GPUd() void convScaledUVtoUV(int32_t slice, int32_t row, float su, float sv, float& u, float& v) const;
 
  GPUd() void convScaledUVtoLocal(int32_t slice, int32_t row, float su, float sv, float& ly, float& lz) const;
 
  GPUd() float convPadToU(int32_t row, float pad) const;
 
  GPUd() float convUtoPad(int32_t row, float u) const;
 
  void print() const;
 
  int32_t test(int32_t slice, int32_t row, float ly, float lz) const;
 
  int32_t test() const;
 
 private:
 
  static constexpr int32_t NumberOfSlices = 36;                  
  static constexpr int32_t NumberOfSlicesA = NumberOfSlices / 2; 
  static constexpr int32_t MaxNumberOfRows = 160;                
 
 
  enum ConstructionState : uint32_t {
    NotConstructed = 0x0, 
    Constructed = 0x1,    
    InProgress = 0x2,     
    GeometryIsSet = 0x4,  
    AlignmentIsSet = 0x8  
  };
 
  uint32_t mConstructionMask = ConstructionState::NotConstructed; 
 
 
  int32_t mNumberOfRows = 0;    
  float mTPCzLengthA = 0.f;     
  float mTPCzLengthC = 0.f;     
  float mTPCalignmentZ = 0.f;   
  float mScaleVtoSVsideA = 0.f; 
  float mScaleVtoSVsideC = 0.f; 
  float mScaleSVtoVsideA = 0.f; 
  float mScaleSVtoVsideC = 0.f; 
 
  SliceInfo mSliceInfos[NumberOfSlices + 1]; 
  RowInfo mRowInfos[MaxNumberOfRows + 1];    
 
  ClassDefNV(TPCFastTransformGeo, 1);
};
 
// =======================================================================
//              Inline implementations of some methods
// =======================================================================
 
GPUdi() const TPCFastTransformGeo::SliceInfo& TPCFastTransformGeo::getSliceInfo(int32_t slice) const
{
  if (slice < 0 || slice >= NumberOfSlices) { // return zero object
    slice = NumberOfSlices;
  }
  return mSliceInfos[slice];
}
 
GPUdi() const TPCFastTransformGeo::RowInfo& TPCFastTransformGeo::getRowInfo(int32_t row) const
{
  if (row < 0 || row >= mNumberOfRows) { // return zero object
    row = MaxNumberOfRows;
  }
  return mRowInfos[row];
}
 
GPUdi() void TPCFastTransformGeo::convLocalToGlobal(int32_t slice, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
{
  const SliceInfo& sliceInfo = getSliceInfo(slice);
  gx = lx * sliceInfo.cosAlpha - ly * sliceInfo.sinAlpha;
  gy = lx * sliceInfo.sinAlpha + ly * sliceInfo.cosAlpha;
  gz = lz;
}
 
GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t slice, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
{
  const SliceInfo& sliceInfo = getSliceInfo(slice);
  lx = gx * sliceInfo.cosAlpha + gy * sliceInfo.sinAlpha;
  ly = -gx * sliceInfo.sinAlpha + gy * sliceInfo.cosAlpha;
  lz = gz;
}
 
GPUdi() void TPCFastTransformGeo::convVtoLocal(int32_t slice, float v, float& lz) const
{
  if (slice < NumberOfSlicesA) { // TPC side A
    lz = mTPCzLengthA - v;
  } else {                 // TPC side C
    lz = v - mTPCzLengthC; // drift direction is mirrored on C-side
  }
  lz += mTPCalignmentZ; // global TPC alignment
}
 
GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t slice, float u, float v, float& ly, float& lz) const
{
  if (slice < NumberOfSlicesA) { // TPC side A
    ly = u;
    lz = mTPCzLengthA - v;
  } else {                 // TPC side C
    ly = -u;               // pads are mirrorred on C-side
    lz = v - mTPCzLengthC; // drift direction is mirrored on C-side
  }
  lz += mTPCalignmentZ; // global TPC alignment
}
 
GPUdi() void TPCFastTransformGeo::convLocalToUV(int32_t slice, float ly, float lz, float& u, float& v) const
{
  lz = lz - mTPCalignmentZ;      // global TPC alignment
  if (slice < NumberOfSlicesA) { // TPC side A
    u = ly;
    v = mTPCzLengthA - lz;
  } else {                 // TPC side C
    u = -ly;               // pads are mirrorred on C-side
    v = lz + mTPCzLengthC; // drift direction is mirrored on C-side
  }
}
 
GPUdi() void TPCFastTransformGeo::convUVtoScaledUV(int32_t slice, int32_t row, float u, float v, float& su, float& sv) const
{
  const RowInfo& rowInfo = getRowInfo(row);
  su = (u - rowInfo.u0) * rowInfo.scaleUtoSU;
  if (slice < NumberOfSlicesA) {
    sv = v * mScaleVtoSVsideA;
  } else {
    sv = v * mScaleVtoSVsideC;
  }
}
 
GPUdi() void TPCFastTransformGeo::convScaledUVtoUV(int32_t slice, int32_t row, float su, float sv, float& u, float& v) const
{
  const RowInfo& rowInfo = getRowInfo(row);
  u = rowInfo.u0 + su * rowInfo.scaleSUtoU;
  if (slice < NumberOfSlicesA) {
    v = sv * mScaleSVtoVsideA;
  } else {
    v = sv * mScaleSVtoVsideC;
  }
}
 
GPUdi() void TPCFastTransformGeo::convScaledUVtoLocal(int32_t slice, int32_t row, float su, float sv, float& ly, float& lz) const
{
  float u, v;
  convScaledUVtoUV(slice, row, su, sv, u, v);
  convUVtoLocal(slice, u, v, ly, lz);
}
 
GPUdi() float TPCFastTransformGeo::convPadToU(int32_t row, float pad) const
{
  const RowInfo& rowInfo = getRowInfo(row);
  return (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
}
 
GPUdi() float TPCFastTransformGeo::convUtoPad(int32_t row, float u) const
{
  const RowInfo& rowInfo = getRowInfo(row);
  return u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
}
 
} // namespace gpu
} // namespace o2
 
#endif