CTPPSPixelCluster.h

Go to the documentation of this file.

#ifndef DataFormats_CTPPS_CTPPSPixelCluster_h
#define DataFormats_CTPPS_CTPPSPixelCluster_h

/*
  \class CTPPSPixelCluster 
  \brief CTPPSPixelCluster stores the information of CTPPS Tracker clusters of 3D pixels
 Author: F.Ferro - INFN Genova - 2016
*/


#include <vector>
#include <cstdint>
#include <cassert>


class CTPPSPixelCluster {

public:

  CTPPSPixelCluster() {}
  static constexpr uint8_t MAXSPAN=255;
  static constexpr uint8_t MAXCOL=155; 
  static constexpr uint8_t MAXROW=159; 

  
CTPPSPixelCluster(uint16_t isize, uint16_t * adcs,         
          uint8_t const * rowpos,  uint8_t const * colpos ) :
  thePixelOffset(2*isize), // the pixel offset is the pixel position inside the cluster wrt rowmin (even positions) and colmin (odd positions)
    thePixelADC(adcs, adcs+isize)   
    {

      uint8_t maxCol = 0;
      uint8_t maxRow = 0;
      uint8_t rowmin = MAXROW;
      uint8_t colmin = MAXCOL;
      for (unsigned int j=0; j!=isize; ++j) {
    rowmin = std::min(rowpos[j],rowmin);
    colmin = std::min(colpos[j],colmin);
      }
      for (unsigned int i=0; i!=isize; ++i) {
    uint8_t rowoffset = rowpos[i]-rowmin;
    uint8_t coloffset = colpos[i]-colmin;
    thePixelOffset[i*2] = std::min(MAXSPAN, rowoffset);
    thePixelOffset[i*2+1] = std::min(MAXSPAN, coloffset);
    if (rowoffset > maxRow) maxRow = rowoffset; 
    if (coloffset > maxCol) maxCol = coloffset; 
      }
      
      
      theMinPixelRow = rowmin;
      thePixelRowSpan = std::min(maxRow, MAXSPAN);
                
      theMinPixelCol = colmin;
      thePixelColSpan = std::min(maxCol, MAXSPAN);
    }

// barycenter

  float avg_row() const {
    float qm = 0.0;
    unsigned int isize = thePixelADC.size();
    for (unsigned int i=0; i<isize; ++i)
      qm += float(thePixelADC[i]) * (thePixelOffset[i*2] + theMinPixelRow + 0.5f);
    return qm/charge();
  }
   
  float avg_col() const {
    float qm = 0.0;
    unsigned int isize = thePixelADC.size();
    for (unsigned int i=0; i<isize; ++i)
      qm += float(thePixelADC[i]) * (thePixelOffset[i*2+1]  + theMinPixelCol + 0.5f);
    return qm/charge();
  }

//cluster charge

  inline float charge() const {
    float qm = 0.0;
    unsigned int isize = thePixelADC.size();
    for (unsigned int i=0; i<isize; ++i) 
      qm += float(thePixelADC[i]);
    return qm;
  }

  // Return number of pixels.
  unsigned int size() const { return thePixelADC.size();}
   
  // Return cluster dimension in rows
  unsigned int sizeRow() const { return thePixelRowSpan +1;}
   
  // Return cluster dimension in columns
  unsigned int sizeCol() const { return thePixelColSpan +1;}

  inline unsigned int minPixelRow() const { return theMinPixelRow;}
  inline unsigned int minPixelCol() const { return theMinPixelCol;}

  
  inline unsigned int colSpan() const {return thePixelColSpan; }
  inline unsigned int rowSpan() const { return thePixelRowSpan; }

  const std::vector<uint8_t> & pixelOffset() const { return thePixelOffset;}
  const std::vector<uint16_t> & pixelADC() const { return thePixelADC;}

  unsigned int pixelRow(unsigned int i) const {
    return theMinPixelRow + thePixelOffset[i*2];
  }
  unsigned int pixelCol(unsigned int i) const {
    return theMinPixelCol + thePixelOffset[i*2+1];
  }
  unsigned int pixelADC(unsigned int i) const {
    return thePixelADC[i];
  }
  
private:

  std::vector<uint8_t>  thePixelOffset;
  std::vector<uint16_t> thePixelADC;

  
  uint8_t theMinPixelRow=MAXROW;
  uint8_t theMinPixelCol=MAXCOL; 
  uint8_t thePixelRowSpan=0; 
  uint8_t thePixelColSpan=0; 
   
};

inline bool operator<( const CTPPSPixelCluster& one, const CTPPSPixelCluster& two) {
  if ( one.minPixelRow() < two.minPixelRow() ) {
    return true;
  } else if ( one.minPixelRow() > two.minPixelRow() ) {
    return false;
  } else if ( one.minPixelCol() < two.minPixelCol() ) {
    return true;
  } else {
    return false;
  }
}

#endif