CTPPSToFDetector.h

Go to the documentation of this file.

#ifndef CTPPSToFDetector_h
#define CTPPSToFDetector_h
#include <vector>
#include <map>
#include <iterator>
#include <iostream>
 
class CTPPSToFDetector {
public:
  CTPPSToFDetector(int ncellx,
                   int ncelly,
                   std::vector<double>& cellw,
                   double cellh,
                   double pitchx,
                   double pitchy,
                   double pos,
                   int res);
  CTPPSToFDetector(
      int ncellx, int ncelly, double cellw, double cellh, double pitchx, double pitchy, double pos, int res);
  virtual ~CTPPSToFDetector(){};
 
  double getHeight() { return detH_; };
  double getWidth() { return detW_; };
  double getPosition() { return detPosition_; };
  int findCellId(double x, double y);                      // return the cell id corresponding to the given position
  bool get_CellCenter(int cell_id, double& x, double& y);  // return false if it failed
  int get_CellId(int idx) {
    if (idx >= (int)theToFInfo.size())
      return 0;
    std::map<int, std::vector<double> >::const_iterator it = theToFInfo.begin();
    std::advance(it, idx);
    return it->first;
  }
  int get_CellMultiplicity() { return (int)theToFInfo.size(); };  // return the number of cells with hit
  int getMultiplicityByCell(int cellid) {
    if (!theToFInfo.count(cellid))
      return 0;
    return (int)theToFInfo.at(cellid).size();
  };  // return the hit multiplicity of the given cell
 
  int get_nHits_() { return nHits_; };  // return the total hit multiplicity (full det)
  std::vector<double> get_ToF(int cell) {
    if (!theToFInfo.count(cell))
      return std::vector<double>();
    return theToFInfo.at(cell);
  };  // return the tof of the given cell
  int getADC(int cell, int hit) {
    if (!nADC_.count(cell))
      return 0;
    if ((int)nADC_.at(cell).size() < hit)
      return 0;
    return nADC_.at(cell).at(hit);
  }
 
  void AddHit(double x, double y, double tof);
  void clear() {
    detId_ = 0;
    nHits_ = 0;
    theToFInfo.clear();
  };
 
private:
  int nCellX_;
  int nCellY_;
  double cellWq_;                                       // width (X, horizontal dimension in mm)
  std::vector<double> cellW_;                           //move to vector - diamond geometry
  double cellH_;                                        // height(Y, vertical dimension in mm)
  double pitchX_;                                       // distance (in X) between cells
  double pitchY_;                                       // distance (in Y) between cells
  int fToFResolution_;                                  // in ps
  std::vector<std::pair<double, double> > cellColumn_;  // lower and upper limits of cells in X
  std::vector<std::pair<double, double> > cellRow_;     // lower and upper limits of cells in Y
                                                        //
  double detW_;                                         // detector width
  double detH_;                                         // detector height
  double detPosition_;                                  // detector position from beam (absolute value)
                                                        //
  int detId_;
  int nHits_;
  std::map<int, std::vector<int> > nADC_;  // fake ADC counter: in case of multiple hits in the same cell,
                                           // it  counts the number of overlaps
  std::map<int, std::vector<double> > theToFInfo;
 
  typedef std::map<int, std::vector<double> > theToFInfo_t;  // define a type for the tof info
};
#endif