LitHitData.h

Go to the documentation of this file.

/* Copyright (C) 2010-2016 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev [committer] */
 
#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_ */