PadRegionInfo.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_TPC_PadRegionInfo_H
#define AliceO2_TPC_PadRegionInfo_H
 
#include <vector>
 
#include "DataFormatsTPC/Defs.h"
#include "TPCBase/PadPos.h"
 
namespace o2
{
namespace tpc
{
 
class PadRegionInfo
{
 public:
  PadRegionInfo() = default;
 
  PadRegionInfo(const unsigned char region,
                const unsigned char partition,
                const unsigned char numberOfPadRows,
                const float padHeight,
                const float padWidth,
                const float radiusFirstRow,
                const unsigned char rowOffset,
                const float xhelper,
                const unsigned char globalRowOffset);
 
  unsigned char getRegion() const { return mRegion; }
 
  unsigned char getPartition() const { return mPartition; }
 
  unsigned char getNumberOfPadRows() const { return mNumberOfPadRows; }
 
  unsigned short getNumberOfPads() const { return mNumberOfPads; }
 
  float getPadHeight() const { return mPadHeight; }
 
  float getPadWidth() const { return mPadWidth; }
 
  float getRadiusFirstRow() const { return mRadiusFirstRow; }
 
  unsigned char getGlobalRowOffset() const { return mGlobalRowOffset; }
 
  unsigned char getRowOffset() const { return mRowOffset; }
 
  float getXhelper() const { return mXhelper; }
 
  unsigned char getPadsInRow(const PadPos& padPos) const
  {
    return mPadsPerRow[padPos.getRow() - mGlobalRowOffset];
  }
 
  unsigned char getPadsInRow(const int row) const { return mPadsPerRow[row - mGlobalRowOffset]; }
 
  unsigned char getPadsInRowRegion(const int row) const { return mPadsPerRow[row]; }
 
  bool isInRegion(float localX, float border = 0.f) const
  {
    return localX - mRadiusFirstRow - border > 0.f && localX - mRadiusFirstRow < (mNumberOfPadRows + 1) * mPadHeight + border;
  }
 
#ifndef GPUCA_ALIGPUCODE // LocalPosition.. = ROOT:Cartesian.. is not available on the GPU
  const PadPos findPad(const LocalPosition3D& pos) const
  {
    return findPad(pos.X(), pos.Y(), (pos.Z() >= 0) ? Side::A : Side::C);
  }
 
  const PadPos findPad(const LocalPosition2D& pos, const Side side = Side::A) const
  {
    return findPad(pos.X(), pos.Y(), side);
  }
#endif
 
  const PadPos findPad(const float localX, const float localY, const Side side /*=Side::A*/) const
  {
    if (!isInRegion(localX)) {
      return PadPos(255, 255);
    }
 
    // the pad coordinate system is for pad-side view.
    // on the A-Side one looks from the back-side, therefore
    // the localY-sign must be changed
    const float localYfactor = (side == Side::A) ? -1.f : 1.f;
    const unsigned int row = (localX - mRadiusFirstRow) * mInvPadHeight;
    if (row >= mNumberOfPadRows) {
      return PadPos(255, 255);
    }
 
    const unsigned int npads = getPadsInRowRegion(row);
    const float padfloat = (0.5f * npads * mPadWidth - localYfactor * localY) * mInvPadWidth;
    if (padfloat < 0) {
      return PadPos(255, 255);
    }
    const unsigned int pad = static_cast<unsigned int>(padfloat);
 
    if (pad >= npads) {
      return PadPos(255, 255);
    }
 
    return PadPos(row, pad);
  }
 
 private:
  float mPadHeight{0.f};             
  float mPadWidth{0.f};              
  float mInvPadHeight{0.f};          
  float mInvPadWidth{0.f};           
  float mRadiusFirstRow{0.f};        
  float mXhelper{0.f};               
  unsigned short mNumberOfPads{0};   
  unsigned char mPartition{0};       
  unsigned char mRegion{0};          
  unsigned char mNumberOfPadRows{0}; 
 
  unsigned char mRowOffset{0}; 
 
  unsigned char mGlobalRowOffset{0}; 
 
  void init();
 
  std::vector<unsigned char> mPadsPerRow; 
};
 
} // namespace tpc
} // namespace o2
#endif