BmnMCTrack.h

Go to the documentation of this file.

 
#ifndef BMNMCTRACK_H_
#define BMNMCTRACK_H_
 
#include "BmnDetectorList.h"
#include "BmnMCPoint.h"
 
#include <cassert>
#include <map>
#include <vector>
#include <set>
 
using namespace std;
 
class BmnMCTrack
{
public:
   BmnMCTrack() {
      // Initialize all maps
      fPoints[kSILICON];
      fPoints[kSSD];
      fPoints[kGEM];
      fPoints[kTOF1];
      fPoints[kDCH];
      fPoints[kTOF];
      fPoints[kCSC];
//      fStationPoints[kGEM];
//      fStationPoints[kTOF1];
//      fStationPoints[kDCH1];
//      fStationPoints[kDCH2];
//      fStationPoints[kTOF];
//      fStationIds[kGEM];
//      fStationIds[kTOF1];
//      fStationIds[kDCH1];
//      fStationIds[kDCH2];
//      fStationIds[kTOF];
//      fMaxConsecutivePoints[kGEM] = -1;
   }
 
   virtual ~BmnMCTrack() {};
 
   void AddPoint(DetectorId detId, const BmnMCPoint& point) {
      fPoints[detId].push_back(point);
//      fStationPoints[detId][point.GetStationId()].push_back(point);
//      fStationIds[detId].insert(point.GetStationId());
 
   }
 
   const vector<BmnMCPoint>& GetPoints(DetectorId detId) const {
      return fPoints.find(detId)->second;
   }
 
   const BmnMCPoint& GetPoint(DetectorId detId, Int_t index) const {
      assert(GetNofPoints(detId) != 0);
      return fPoints.find(detId)->second[index];
   }
 
   UInt_t GetNofPoints(DetectorId detId) const {
      return fPoints.find(detId)->second.size();
   }
 
//   UInt_t GetNofPointsInDifferentStations(DetectorId detId) const {
//      return fStationPoints.find(detId)->second.size();
//   }
 
//   Int_t GetNofConsecutivePoints(DetectorId detId) const {
//    //assert(detId == kSTS);
//     return (detId == kGEM) ? fMaxConsecutivePoints.find(detId)->second : -1;
//   }
 
//   void CalculateNofConsecutivePoints() {
//    fMaxConsecutivePoints[kGEM] = MaxConsecutiveNumbers(fStationIds.find(kGEM)->second);
//   }
 
//   const BmnMCPoint& GetPointAtStation(
//         DetectorId detId,
//         Int_t stationId,
//         Int_t index) const {
//      assert(GetNofPointsAtStation(detId, stationId) != 0);
//      return fStationPoints.find(detId)->second.find(stationId)->second[index];
//   }
 
//   UInt_t GetNofPointsAtStation(
//         DetectorId detId,
//         Int_t stationId) const {
//      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<Int_t, vector<BmnMCPoint> > fPoints;
 
   // map<detector id, map<station id, vector of MC points> >
 //  map<Int_t, map<Int_t, vector<BmnMCPoint> > > fStationPoints;
 
   // Temporary set to store unique station indices for fast access
   // map<detector id, set<station index>>
  // map<Int_t, set<Int_t> > fStationIds;
 
   // temporary storage for maximum number of consecutive MC points
   // map<detector id, number of MC points>
  // map<Int_t, Int_t> fMaxConsecutivePoints;
 
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 (size_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(
         DetectorId detId,
         const string& detName) const {
      stringstream ss;
//      ss << detName << " np=" << GetNofPoints(detId) << " npds=" << GetNofPointsInDifferentStations(detId)
//          << " ncp=" << GetNofConsecutivePoints(detId) << " points=(";
//      for (Int_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(kGEM, "STS") << "|";
      ss << PointsToString(kTOF1, "TOF1") << "|";
      ss << PointsToString(kDCH, "DCH1") << "|";
      ss << PointsToString(kTOF, "TOF") << "|";
      ss << endl;
      return ss.str();
   }
 
   friend ostream& operator<<(ostream& strm, const BmnMCTrack& track) {
      strm << track.ToString();
      return strm;
   }
};
 
#endif /* BmnMCTRACK_H_ */