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"
#include "GPUCommonMath.h"
#include "DataFormatsTPC/Constants.h"
#ifndef GPUCA_GPUCODE_DEVICE
#include <memory>
#include "GPUCommonRtypes.h"
#include "GPUCommonArray.h" // Would work on GPU, but yields performance regressions
#endif
 
namespace o2::gpu
{
 
class TPCFastTransformGeo
{
 
 public:
  struct SectorInfo {
    float sinAlpha{0.f}; 
    float cosAlpha{0.f}; 
    ClassDefNV(SectorInfo, 1);
  };
 
  struct RowInfo {
    float x{0.f};        
    int32_t maxPad{0};   
    float padWidth{0.f}; 
    float yMin{0.f};     
 
    GPUdi() float getYmin() const { return yMin; }
 
    GPUdi() float getYmax() const { return -yMin; }
 
#ifndef GPUCA_GPUCODE_DEVICE
    GPUd() std::array<float, 2> getYrange() const { return {getYmin(), getYmax()}; }
#endif
 
    GPUdi() float getYwidth() const { return -2.f * yMin; }
 
    ClassDefNV(RowInfo, 2);
  };
 
 
  TPCFastTransformGeo();
 
  TPCFastTransformGeo(const TPCFastTransformGeo&) = default;
 
  TPCFastTransformGeo& operator=(const TPCFastTransformGeo&) = default;
 
  ~TPCFastTransformGeo() = default;
 
 
  inline 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 tpcZlength);
 
  void finishConstruction();
 
  bool isConstructed() const { return (mConstructionMask == (uint32_t)ConstructionState::Constructed); }
 
 
  inline static constexpr int32_t getNumberOfSectors() { return NumberOfSectors; }
 
  inline static constexpr int32_t getNumberOfSectorsA() { return NumberOfSectorsA; }
 
  GPUdi() int32_t getNumberOfRows() const { return mNumberOfRows; }
 
  inline static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
 
  GPUd() const SectorInfo& getSectorInfo(int32_t sector) const;
 
  GPUd() const RowInfo& getRowInfo(int32_t row) const;
 
  GPUdi() float getTPCzLength() const { return mTPCzLength; }
 
#ifndef GPUCA_GPUCODE_DEVICE
  GPUdi() std::array<float, 2> getZrange(int32_t sector) const
  {
    if (sector < NumberOfSectorsA) { // TPC side A
      return {0.f, mTPCzLength};
    } else { // TPC side C
      return {-mTPCzLength, 0.f};
    }
  }
#endif
  GPUd() float getZmin(int32_t sector) const;
  GPUd() float getZmax(int32_t sector) const;
 
 
  GPUd() void convLocalToGlobal(int32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
 
  GPUd() void convGlobalToLocal(int32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
 
  GPUd() void convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength, float& y, float& z) const;
 
  GPUd() float convDriftLengthToZ(int32_t sector, float driftLength) const;
 
  GPUd() float convZtoDriftLength(int32_t sector, float z) const;
 
  GPUd() void convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z, float& pad, float& l) const;
 
  void print() const;
 
  int32_t test(int32_t sector, int32_t row, float ly, float lz) const;
 
  int32_t test() const;
 
 private:
 
  static constexpr int32_t NumberOfSectors = o2::tpc::constants::MAXSECTOR; 
  static constexpr int32_t NumberOfSectorsA = NumberOfSectors / 2;          
  static constexpr int32_t MaxNumberOfRows = 160;                           
 
 
  enum ConstructionState : uint32_t {
    NotConstructed = 0x0, 
    Constructed = 0x1,    
    InProgress = 0x2,     
    GeometryIsSet = 0x4,  
  };
 
  uint32_t mConstructionMask = ConstructionState::NotConstructed; 
 
 
  int32_t mNumberOfRows = 0; 
  float mTPCzLength = 0.f;   
 
  SectorInfo mSectorInfos[NumberOfSectors + 1]; 
  RowInfo mRowInfos[MaxNumberOfRows + 1];       
 
 public:
  struct SliceInfo { // legacy, needed only for schema evolution
    ClassDefNV(SliceInfo, 2);
  };
 
  ClassDefNV(TPCFastTransformGeo, 3);
};
 
// =======================================================================
//              Inline implementations of some methods
// =======================================================================
 
GPUdi() const TPCFastTransformGeo::SectorInfo& TPCFastTransformGeo::getSectorInfo(int32_t sector) const
{
  if (sector < 0 || sector >= NumberOfSectors) { // return zero object
    sector = NumberOfSectors;
  }
  return mSectorInfos[sector];
}
 
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 sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
{
  const SectorInfo& sectorInfo = getSectorInfo(sector);
  gx = lx * sectorInfo.cosAlpha - ly * sectorInfo.sinAlpha;
  gy = lx * sectorInfo.sinAlpha + ly * sectorInfo.cosAlpha;
  gz = lz;
}
 
GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
{
  const SectorInfo& sectorInfo = getSectorInfo(sector);
  lx = gx * sectorInfo.cosAlpha + gy * sectorInfo.sinAlpha;
  ly = -gx * sectorInfo.sinAlpha + gy * sectorInfo.cosAlpha;
  lz = gz;
}
 
GPUdi() void TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength, float& y, float& z) const
{
  const RowInfo& rowInfo = getRowInfo(row);
  float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
  if (sector < NumberOfSectorsA) { // TPC side A
    y = u;
    z = mTPCzLength - driftLength;
  } else {                         // TPC side C
    y = -u;                        // pads are mirrorred on C-side
    z = driftLength - mTPCzLength; // drift direction is mirrored on C-side
  }
}
 
GPUdi() float TPCFastTransformGeo::convDriftLengthToZ(int32_t sector, float driftLength) const
{
  return (sector < NumberOfSectorsA) ? (mTPCzLength - driftLength) : (driftLength - mTPCzLength);
}
 
GPUdi() float TPCFastTransformGeo::convZtoDriftLength(int32_t sector, float z) const
{
  return (sector < NumberOfSectorsA) ? (mTPCzLength - z) : (z + mTPCzLength);
}
 
GPUdi() float TPCFastTransformGeo::getZmin(int32_t sector) const
{
  if (sector < NumberOfSectorsA) { // TPC side A
    return 0.f;
  } else { // TPC side C
    return -mTPCzLength;
  }
}
 
GPUdi() float TPCFastTransformGeo::getZmax(int32_t sector) const
{
  if (sector < NumberOfSectorsA) { // TPC side A
    return mTPCzLength;
  } else { // TPC side C
    return 0.f;
  }
}
 
GPUdi() void TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z, float& pad, float& l) const
{
  float u;
  if (sector < NumberOfSectorsA) { // TPC side A
    u = y;
    l = mTPCzLength - z;
  } else {               // TPC side C
    u = -y;              // pads are mirrorred on C-side
    l = z + mTPCzLength; // drift direction is mirrored on C-side
  }
  const TPCFastTransformGeo::RowInfo& rowInfo = getRowInfo(row);
  pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
}
 
} // namespace o2::gpu
 
#endif