AlpideSimResponse.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_ITSSMFT_ALPIDESIMRESPONSE_H
#define ALICEO2_ITSSMFT_ALPIDESIMRESPONSE_H
 
#include <array>
#include <string>
#include <vector>
#include <Rtypes.h>
 
#include "ITSMFTBase/SegmentationAlpide.h"
 
namespace o2
{
namespace itsmft
{
/*
 * AlpideRespSimMat : class to access the response: probability to collect electron
 * in MNPix*MNPix cells.
 */
class AlpideRespSimMat
{
 public:
  static int constexpr NPix = 5;              
  static int constexpr MatSize = NPix * NPix; 
  static int constexpr getNPix() { return NPix; }
 
  AlpideRespSimMat() = default;
  virtual ~AlpideRespSimMat() = default;
 
  void adopt(const AlpideRespSimMat& src, bool flipRow = false, bool flipCol = false)
  {
    // copy constructor with option of channels flipping
    for (int iRow = NPix; iRow--;) {
      int rw = flipRow ? NPix - 1 - iRow : iRow;
      for (int iCol = NPix; iCol--;) {
        int bDest = rw * NPix + (flipCol ? NPix - 1 - iCol : iCol);
        data[bDest] = src.data[iRow * NPix + iCol];
      }
    }
  }
 
  float getValue(int iRow, int iCol) const { return data[iRow * NPix + iCol]; }
  float getValue(int iRow, int iCol, bool flipRow, bool flipCol) const
  {
    int bin = (flipRow ? NPix - 1 - iRow : iRow) * NPix + (flipCol ? NPix - 1 - iCol : iCol);
    return data[bin];
  }
 
  std::array<float, MatSize>* getArray() { return &data; }
 
  void print(bool flipRow = false, bool flipCol = false) const;
 
 private:
  std::array<float, MatSize> data;
 
  ClassDef(AlpideRespSimMat, 1);
};
 
/*
 * AlpideSimResponse: container for Alpide simulates parameterized response matrices
 * Based on the Miljenko Šuljić standalone code and needs as an input text matrices
 * from simulation.
 * Provides for the electron injected to point X(columns direction),Y (rows direction)
 * (with respect to pixel center) and Z (depth, with respect to epitaxial layer inner
 * serface!!! i.e. touching the substrate) the probability to be collected in every
 * of NPix*NPix pixels with reference pixel in the center.
 */
 
class AlpideSimResponse
{
 
 private:
  int getColBin(float pos) const;
  int getRowBin(float pos) const;
  int getDepthBin(float pos) const;
  std::string composeDataName(int colBin, int rowBin);
 
 protected:
  int mNBinCol = 0;                                   
  int mNBinRow = 0;                                   
  int mNBinDpt = 0;                                   
  int mMaxBinCol = 0;                                 
  int mMaxBinRow = 0;                                 
  float mColMax = SegmentationAlpide::PitchCol / 2.f; 
  float mRowMax = SegmentationAlpide::PitchRow / 2.f; 
  float mDptMin = 0.f;                                
  float mDptMax = 0.f;                                
  float mDptShift = 0.f;                              
  float mStepInvCol = 0;                              
  float mStepInvRow = 0;                              
  float mStepInvDpt = 0;                              
  std::vector<AlpideRespSimMat> mData;                
  std::string mDataPath;
  std::string mGridColName = "grid_list_x.txt";             
  std::string mGridRowName = "grid_list_y.txt";             
  std::string mColRowDataFmt = "data_pixels_%.2f_%.2f.txt"; 
 
 public:
  AlpideSimResponse() = default;
  ~AlpideSimResponse() = default;
 
  void initData(int tableNumber, std::string dataPath, const bool quiet = true);
 
  bool getResponse(float vRow, float vCol, float cDepth, AlpideRespSimMat& dest) const;
  const AlpideRespSimMat* getResponse(float vRow, float vCol, float vDepth, bool& flipRow, bool& flipCol) const;
  const AlpideRespSimMat* getResponse(float vRow, float vCol, float vDepth, bool& flipRow, bool& flipCol, float rowMax, float colMax) const;
  static int constexpr getNPix() { return AlpideRespSimMat::getNPix(); }
  int getNBinCol() const { return mNBinCol; }
  int getNBinRow() const { return mNBinRow; }
  int getNBinDepth() const { return mNBinDpt; }
  float getColMax() const { return mColMax; }
  float getRowMax() const { return mRowMax; }
  float getDepthMin() const { return mDptMin; }
  float getDepthMax() const { return mDptMax; }
  float getDepthShift() const { return mDptShift; }
  float getStepCol() const { return mStepInvCol ? 1. / mStepInvCol : 0.f; }
  float getStepRow() const { return mStepInvRow ? 1. / mStepInvRow : 0.f; }
  float getStepDepth() const { return mStepInvDpt ? 1. / mStepInvDpt : 0.f; }
  void setColMax(float v) noexcept { mColMax = v; }
  void setRowMax(float v) noexcept { mRowMax = v; }
  void setDataPath(const std::string pth) { mDataPath = pth; }
  void setGridColName(const std::string nm) { mGridColName = nm; }
  void setGridRowName(const std::string nm) { mGridRowName = nm; }
  void setColRowDataFmt(const std::string nm) { mColRowDataFmt = nm; }
  const std::string& getDataPath() const { return mDataPath; }
  const std::string& getGridColName() const { return mGridColName; }
  const std::string& getGridRowName() const { return mGridRowName; }
  const std::string& getColRowDataFmt() const { return mColRowDataFmt; }
  void print() const;
 
  ClassDefNV(AlpideSimResponse, 2);
};
 
//-----------------------------------------------------
inline int AlpideSimResponse::getColBin(float pos) const
{
  int i = pos * mStepInvCol + 0.5f;
  return i < mNBinCol ? i : mMaxBinCol;
}
 
//-----------------------------------------------------
inline int AlpideSimResponse::getRowBin(float pos) const
{
  int i = pos * mStepInvRow + 0.5f;
  return i < mNBinRow ? i : mMaxBinRow;
}
 
//-----------------------------------------------------
inline int AlpideSimResponse::getDepthBin(float pos) const
{
  int i = (mDptMax - pos) * mStepInvDpt;
  return i < 0 ? 0 : i; // depth bin
}
 
} // namespace itsmft
} // namespace o2
 
#endif