LitHitDataMuon.h

Go to the documentation of this file.

 
#ifndef LITHITDATAMUON_H_
#define LITHITDATAMUON_H_
 
#include "../LitComparators.h"
#include "../LitHit.h"
#include "LitDetectorLayoutMuon.h"
 
#include <algorithm>
#include <vector>
 
namespace lit {
  namespace parallel {
 
    template<class T>
    class LitHitDataMuon {
    public:
      LitHitDataMuon() : fMaxErr(), fHits(), fLayout() {}
 
      virtual ~LitHitDataMuon() {}
 
      void SetDetectorLayout(const LitDetectorLayoutMuon<T>& layout) {
        fLayout       = layout;
        int nofGroups = layout.GetNofStationGroups();
        fHits.resize(nofGroups);
        fMaxErr.resize(nofGroups);
        for (int i = 0; i < nofGroups; i++) {
          int nofStations = layout.GetNofStations(i);
          fHits[i].resize(nofStations);
          fMaxErr[i].resize(nofStations);
          for (int j = 0; j < nofStations; j++) {
            int nofSubstations = layout.GetNofSubstations(i, j);
            fHits[i][j].resize(nofSubstations);
            fMaxErr[i][j].resize(nofSubstations);
            for (int k = 0; k < nofSubstations; k++) {
              fHits[i][j][k].reserve(1500);
            }
          }
        }
      }
 
      void AddHit(int stationGroup,
                  int station,
                  int substation,
                  LitScalPixelHit* hit) {
        fHits[stationGroup][station][substation].push_back(hit);
        if (fMaxErr[stationGroup][station][substation] < hit->Dx) {
          fMaxErr[stationGroup][station][substation] = hit->Dx;
        }
      }
 
      void AddHit(unsigned char planeId, LitScalPixelHit* hit) {
        unsigned char stationGroup;
        unsigned char station;
        unsigned char substation;
        StationByPlaneId(planeId, stationGroup, station, substation);
        AddHit(stationGroup, station, substation, hit);
      }
 
      const LitScalPixelHit*
      GetHit(int stationGroup, int station, int substation, int hitId) const {
        return fHits[stationGroup][station][substation][hitId];
      }
 
      const std::vector<LitScalPixelHit*>&
      GetHits(int stationGroup, int station, int substation) {
        return fHits[stationGroup][station][substation];
      }
 
      unsigned int
      GetNofHits(int stationGroup, int station, int substation) const {
        return fHits[stationGroup][station][substation].size();
      }
 
      fscal GetMaxErr(int stationGroup, int station, int substation) const {
        return fMaxErr[stationGroup][station][substation];
      }
 
      void Clear() {
        for (unsigned int i = 0; i < fHits.size(); i++) {
          for (unsigned int j = 0; j < fHits[i].size(); j++) {
            for (unsigned int k = 0; k < fHits[i][j].size(); k++) {
              fHits[i][j][k].clear();
              fHits[i][j][k].reserve(1500);
              fMaxErr[i][j][k] = 0.;
            }
          }
        }
      }
 
      void SortHits() {
        // TODO : add threads here
        for (int i = 0; i < fLayout.GetNofStationGroups(); i++) {
          for (int j = 0; j < fLayout.GetNofStations(i); j++) {
            for (int k = 0; k < fLayout.GetNofSubstations(i, j); k++) {
              std::vector<LitScalPixelHit*>& shits = fHits[i][j][k];
              std::sort(shits.begin(), shits.end(), ComparePixelHitXLess());
              //                std::cout << "station group " << i << " station " << j
              //                   << " substation " << k << std::endl;
              //                for(unsigned int i = 0; i < nh; i++)
              //                   std::cout << *shits[i];
            }
          }
        }
      }
 
      std::string ToString() const {
        std::string str = "HitDataMuon:\n";
        for (int i = 0; i < fLayout.GetNofStationGroups(); i++) {
          str += " station group " + lit::parallel::ToString<int>(i) + "\n";
          for (int j = 0; j < fLayout.GetNofStations(i); j++) {
            str += "  station " + lit::parallel::ToString<int>(j) + "\n";
            for (int k = 0; k < fLayout.GetNofSubstations(i, j); k++) {
              str += "   substation " + lit::parallel::ToString<int>(k) + ": "
                     + lit::parallel::ToString<int>(GetNofHits(i, j, k))
                     + " hits, " + "max err="
                     + lit::parallel::ToString<T>(GetMaxErr(i, j, k)) + "\n";
            }
          }
        }
        return str;
      }
 
      friend std::ostream& operator<<(std::ostream& strm,
                                      const LitHitDataMuon& hitData) {
        strm << hitData.ToString();
        return strm;
      }
 
    public:
      void StationByPlaneId(unsigned char planeId,
                            unsigned char& stationGroup,
                            unsigned char& station,
                            unsigned char& substation) const {
        unsigned char counter = 0;
        for (unsigned char i = 0; i < fLayout.GetNofStationGroups(); i++) {
          for (unsigned char j = 0; j < fLayout.GetNofStations(i); j++) {
            counter += fLayout.GetNofSubstations(i, j);
            if (counter > planeId) {
              stationGroup = i;
              station      = j;
              substation =
                fLayout.GetNofSubstations(i, j) - (counter - planeId);
              return;
            }
          }
        }
      }
 
      // Arrays of hits
      std::vector<std::vector<std::vector<PixelHitArray>>> fHits;
      // Arrays of maximum hit position errors for each substation
      std::vector<std::vector<std::vector<fscal>>> fMaxErr;
      // Detector layout
      LitDetectorLayoutMuon<T> fLayout;
    } _fvecalignment;
 
  }  // namespace parallel
}  // namespace lit
#endif /* LITHITDATAMUON_H_ */