CbmLitMCTrack.h

Go to the documentation of this file.

 
#ifndef CBMLITMCTRACK_H_
#define CBMLITMCTRACK_H_
 
#include "CbmDefs.h"
#include "CbmLitMCPoint.h"
#include <cassert>
#include <map>
#include <set>
#include <vector>
 
using std::endl;
using std::map;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
 
class CbmLitMCTrack {
public:
  CbmLitMCTrack()
    : fPoints()
    , fStationPoints()
    , fStationIds()
    , fMaxConsecutivePoints()
    , fNofRichHits(0)
    , fRingAaxis(0.)
    , fRingBaxis(0.)
    , fRingCenterX(0.)
    , fRingCenterY(0.) {
    // Initialize all maps
    fPoints[ECbmModuleId::kMvd];
    fPoints[ECbmModuleId::kSts];
    fPoints[ECbmModuleId::kTrd];
    fPoints[ECbmModuleId::kMuch];
    fPoints[ECbmModuleId::kTof];
    fPoints[ECbmModuleId::kRich];
    fStationPoints[ECbmModuleId::kMvd];
    fStationPoints[ECbmModuleId::kSts];
    fStationPoints[ECbmModuleId::kTrd];
    fStationPoints[ECbmModuleId::kMuch];
    fStationPoints[ECbmModuleId::kTof];
    fStationIds[ECbmModuleId::kMvd];
    fStationIds[ECbmModuleId::kSts];
    fStationIds[ECbmModuleId::kTrd];
    fStationIds[ECbmModuleId::kMuch];
    fStationIds[ECbmModuleId::kTof];
    fMaxConsecutivePoints[ECbmModuleId::kSts] = -1;
  }
 
  virtual ~CbmLitMCTrack() {};
 
  void AddPoint(ECbmModuleId detId, const CbmLitMCPoint& point) {
    fPoints[detId].push_back(point);
    if (detId != ECbmModuleId::kRich) {
      fStationPoints[detId][point.GetStationId()].push_back(point);
      fStationIds[detId].insert(point.GetStationId());
    }
  }
 
  const vector<CbmLitMCPoint>& GetPoints(ECbmModuleId detId) const {
    return fPoints.find(detId)->second;
  }
 
  const CbmLitMCPoint& GetPoint(ECbmModuleId detId, Int_t index) const {
    assert(GetNofPoints(detId) != 0);
    return fPoints.find(detId)->second[index];
  }
 
  UInt_t GetNofPoints(ECbmModuleId detId) const {
    return fPoints.find(detId)->second.size();
  }
 
  UInt_t GetNofPointsInDifferentStations(ECbmModuleId detId) const {
    assert(detId != ECbmModuleId::kRich);
    return fStationPoints.find(detId)->second.size();
  }
 
  Int_t GetNofConsecutivePoints(ECbmModuleId detId) const {
    //assert(detId == kSts);
    //      return fMaxConsecutivePoints.find(detId)->second;
    return (detId == ECbmModuleId::kSts)
             ? fMaxConsecutivePoints.find(detId)->second
             : -1;
  }
 
  void CalculateNofConsecutivePoints() {
    fMaxConsecutivePoints[ECbmModuleId::kSts] =
      MaxConsecutiveNumbers(fStationIds.find(ECbmModuleId::kSts)->second);
  }
 
  Int_t GetNofRichHits() const { return fNofRichHits; }
 
  void SetNofRichHits(Int_t nofRichHits) { fNofRichHits = nofRichHits; }
 
  Double_t GetRingAaxis() const { return fRingAaxis; }
 
  void SetRingAaxis(Double_t a) { fRingAaxis = a; }
 
  Double_t GetRingBaxis() const { return fRingBaxis; }
 
  void SetRingBaxis(Double_t b) { fRingBaxis = b; }
 
  Double_t GetRingCenterX() const { return fRingCenterX; }
 
  void SetRingCenterX(Double_t xc) { fRingCenterX = xc; }
 
  Double_t GetRingCenterY() const { return fRingCenterY; }
 
  void SetRingCenterY(Double_t yc) { fRingCenterY = yc; }
 
  const CbmLitMCPoint&
  GetPointAtStation(ECbmModuleId detId, Int_t stationId, Int_t index) const {
    assert((detId != ECbmModuleId::kRich)
           && (GetNofPointsAtStation(detId, stationId) != 0));
    return fStationPoints.find(detId)->second.find(stationId)->second[index];
  }
 
  UInt_t GetNofPointsAtStation(ECbmModuleId detId, Int_t stationId) const {
    assert(detId != ECbmModuleId::kRich);
    if (fStationPoints.find(detId)->second.count(stationId) > 0) {
      return fStationPoints.find(detId)->second.find(stationId)->second.size();
    } else
      return 0;
  }
 
private:
  // map<detector id, vector of MC points>
  map<ECbmModuleId, vector<CbmLitMCPoint>> fPoints;
 
  // map<detector id, map<station id, vector of MC points> >
  map<ECbmModuleId, map<Int_t, vector<CbmLitMCPoint>>> fStationPoints;
 
  // Temporary set to store unique station indices for fast access
  // map<detector id, set<station index>>
  map<ECbmModuleId, set<Int_t>> fStationIds;
 
  // temporary storage for maximum number of consecutive MC points
  // map<detector id, number of MC points>
  map<ECbmModuleId, Int_t> fMaxConsecutivePoints;
 
  Int_t fNofRichHits;     // Number of hits in RICH ring
  Double_t fRingAaxis;    // major semi-axis of the ellipse
  Double_t fRingBaxis;    // minor semi-axis of the ellipse
  Double_t fRingCenterX;  // X coordinate of the ring center
  Double_t fRingCenterY;  // Y coordinate of the ring center
 
private:
  Int_t MaxConsecutiveNumbers(const set<Int_t>& numbers) const {
    if (numbers.size() == 0) return 0;
    if (numbers.size() == 1) return 1;
 
    vector<Int_t> a(numbers.begin(), numbers.end());
 
    int maxCnt = 0;
    int cnt    = 1;
    for (UInt_t i = 0; i < a.size() - 1; i++) {
      if (a[i] == (a[i + 1] - 1)) {
        cnt++;
      } else {
        maxCnt = std::max(cnt, maxCnt);
        cnt    = 1;
      }
    }
    maxCnt = std::max(cnt, maxCnt);
    return maxCnt;
  }
 
  string PointsToString(ECbmModuleId detId, const string& detName) const {
    stringstream ss;
    ss << detName << " np=" << GetNofPoints(detId)
       << " npds=" << GetNofPointsInDifferentStations(detId)
       << " ncp=" << GetNofConsecutivePoints(detId) << " points=(";
    for (UInt_t i = 0; i < GetNofPoints(detId); i++) {
      ss << ":" << GetPoint(detId, i).GetRefId() << ":"
         << GetPoint(detId, i).GetStationId() << ",";
      //ss << GetPoint(detId, i);
    }
    ss << ") ";
    return ss.str();
  }
 
public:
  virtual string ToString() const {
    stringstream ss;
    ss << "MCTrack: ";
    ss << PointsToString(ECbmModuleId::kMvd, "MVD") << "|";
    ss << PointsToString(ECbmModuleId::kSts, "STS") << "|";
    ss << PointsToString(ECbmModuleId::kTrd, "TRD") << "|";
    ss << PointsToString(ECbmModuleId::kMuch, "MUCH") << "|";
    ss << PointsToString(ECbmModuleId::kTof, "TOF") << "|";
    ss << endl;
    return ss.str();
  }
 
  friend std::ostream& operator<<(std::ostream& strm,
                                  const CbmLitMCTrack& track) {
    strm << track.ToString();
    return strm;
  }
};
 
#endif /* CBMLITMCTRACK_H_ */