LitHitData.h

Go to the documentation of this file.

 
#ifndef LITHITDATA_H_
#define LITHITDATA_H_
 
#include "LitScalPixelHit.h"
#include "LitScalStripHit.h"
 
#include <cassert>
#include <cmath>
#include <set>
#include <sstream>
#include <vector>
using std::endl;
using std::max;
using std::ostream;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
 
namespace lit {
  namespace parallel {
 
    class LitHitData {
    public:
      LitHitData()
        : fHits()
        , fMaxErrX()
        , fMaxErrY()
        , fNofStations(0)
        , fZPosSet()
        , fZPosBins() {}
 
      virtual ~LitHitData() {}
 
      void SetNofStations(unsigned char nofStations) {
        fNofStations = nofStations;
        fHits.resize(nofStations);
        fMaxErrX.resize(nofStations);
        fMaxErrY.resize(nofStations);
        fZPosSet.resize(nofStations);
        fZPosBins.resize(nofStations);
        for (unsigned char i = 0; i < nofStations; i++) {
          fHits[i].reserve(1500);
        }
      }
 
      void AddHit(LitScalPixelHit* hit) {
        unsigned char station = hit->stationId;
        assert(station < fNofStations);
        fHits[station].push_back(hit);
        fZPosSet[station].insert(hit->Z);  // Find different Z positions of hits
        fMaxErrX[station] = max(hit->Dx, fMaxErrX[station]);
        fMaxErrY[station] = max(hit->Dy, fMaxErrY[station]);
      }
 
      const LitScalPixelHit* GetHit(unsigned char station,
                                    unsigned int hitId) const {
        return fHits[station][hitId];
      }
 
      const vector<LitScalPixelHit*>& GetHits(unsigned char station) {
        return fHits[station];
      }
 
      unsigned int GetNofHits(unsigned char station) const {
        return fHits[station].size();
      }
 
      fscal GetMaxErrX(unsigned char station) const {
        return fMaxErrX[station];
      }
 
      fscal GetMaxErrY(unsigned char station) const {
        return fMaxErrY[station];
      }
 
      const vector<int>& GetZPosBins(unsigned char station) const {
        return fZPosBins[station];
      }
 
      fscal GetZPosByBin(unsigned char station, int bin) const {
        return GetMinZPos(station) + bin * EPSILON;
      }
 
      int GetBinByZPos(unsigned char station, fscal zPos) const {
        return (zPos - GetMinZPos(station)) / EPSILON;
      }
 
      fscal GetMinZPos(unsigned char station) const {
        return (fZPosSet[station].empty()) ? 0. : *fZPosSet[station].begin();
      }
 
      void Clear() {
        for (unsigned int i = 0; i < fNofStations; i++) {
          fHits[i].clear();
          fHits[i].reserve(1500);
          fMaxErrX[i] = 0.;
          fMaxErrY[i] = 0.;
          fZPosSet[i].clear();
          fZPosBins[i].clear();
        }
      }
 
      void Arrange() {
        for (int iStation = 0; iStation < fNofStations; iStation++) {
          if (fZPosSet[iStation].empty()) continue;
          fscal minZ = *fZPosSet[iStation].begin();
          //         fscal maxZ = *fZPosSet[iStation].rbegin();
          set<int> binSet;
          set<fscal>::const_iterator it;
          for (it = fZPosSet[iStation].begin(); it != fZPosSet[iStation].end();
               it++) {
            fscal z = *it;
            int bin = (z - minZ) / EPSILON;
            binSet.insert(bin);
          }
 
          set<int>::const_iterator it2;
          for (it2 = binSet.begin(); it2 != binSet.end(); it2++) {
            int bin = *it2;
            //            fscal z = minZ + bin * EPSILON;
            //  fZPos[iStation].push_back(z);
            fZPosBins[iStation].push_back(bin);
          }
        }
      }
 
      string ToString() const {
        stringstream ss;
        ss << "LitHitData:" << endl;
        for (unsigned int i = 0; i < fHits.size(); i++) {
          ss << " station " << i << ": " << GetNofHits(i) << " hits, "
             << "maxerrx=" << GetMaxErrX(i) << ", maxerry=" << GetMaxErrY(i)
             << ", ";
          ss << "zposset=(";
          for (set<fscal>::const_iterator it = fZPosSet[i].begin();
               it != fZPosSet[i].end();
               it++) {
            ss << *it << ", ";
          }
          ss << ")" << endl;
          ss << "zposbins=(";
          for (vector<int>::const_iterator it = fZPosBins[i].begin();
               it != fZPosBins[i].end();
               it++) {
            ss << "|" << *it << "," << GetZPosByBin(i, *it) << "| ";
          }
          ss << ")" << endl;
        }
        return ss.str();
      }
 
      friend ostream& operator<<(ostream& strm, const LitHitData& hitData) {
        strm << hitData.ToString();
        return strm;
      }
 
    private:
      static const fscal EPSILON;
      vector<vector<LitScalPixelHit*>> fHits;  // Array of hits
      vector<fscal> fMaxErrX;      // Array of maximum X error for each station
      vector<fscal> fMaxErrY;      // Array of maximum Y error for each station
      unsigned char fNofStations;  // Number of stations
      vector<set<fscal>>
        fZPosSet;  // Set of Z positions of hits in each station
                   // Temporarily used for Z different Z positions calculation
      vector<vector<int>>
        fZPosBins;  // Array of Z positions bin number of hits in each station
    } _fvecalignment;
 
  }  // namespace parallel
}  // namespace lit
 
#endif /* LITHITDATA_H_ */