PndHoughData.h

Go to the documentation of this file.

//  PndHoughData
//  Data structure for fast access to STT data

/*
This class is similar to the data structure of the CellTrackFinder.
*/

#ifndef PndHoughData_H_
#define PndHoughData_H_

#include <vector>
#include <map>

#include "PndSttGeometryMap.h"
#include "PndSttStrawMap.h"
#include "FairHit.h"
#include "PndHoughSpace.h"

class PndHoughData {

 public:
  PndHoughData(TClonesArray *fTubeArray);

  virtual ~PndHoughData()
  {
    delete fGeometryMap;
    delete fPndHoughSpace;
    for (size_t i = 0; i < fHits.size(); ++i)
      delete fHits.at(i);
  }

  void AddHits(TClonesArray *hits, TString branchName);
  void AddHit(FairLink link);
  void CreateGEMNeighborhoodData();
  void CreateSTTNeighborhoodData();
  void Init(int NBins1 = 450, int NBins2 = 450)
  {
    fNbins1 = NBins1;
    fNbins2 = NBins2;
    fPndHoughSpace->SetNBins1(fNbins1);
    fPndHoughSpace->SetNBins2(fNbins2);
    fPndHoughSpace->Init();
  }
  void clear()
  {
    fHits.clear();
    fLinks.clear();
    fSTTLinks.clear();
    fGEMLinks.clear();
    fhittedTubes.clear();
    fMVDHits.clear();

    fMapFairLinktoFairHit.clear();
    fMapFairLinktoIsochrone.clear();
    fMapFairLinktoIsochroneError.clear();
    fMapFairLinktoTubeId.clear();
    fMapTubetoHit.clear();
    fMapTubetoLink.clear();

    fGEMNeighbors.clear();
    fMapNumberhittedSTTNeighbors.clear();

    fPndHoughSpace->clear();
  }
  std::vector<FairHit *> GetHits() const { return fHits; }
  std::vector<FairLink> GetLinks() const { return fLinks; }
  PndSttGeometryMap *GetGeometryMap() const { return fGeometryMap; }
  PndSttStrawMap *GetStrawMap() const { return fStrawMap; }
  std::map<FairLink, FairHit *> GetMapFairLinktoFairHit() const { return fMapFairLinktoFairHit; }
  std::map<FairLink, Double_t> GetMapFairLinktoIsochrone() const { return fMapFairLinktoIsochrone; }
  std::map<FairLink, Double_t> GetMapFairLinktoIsochroneError() const { return fMapFairLinktoIsochroneError; }
  std::map<FairLink, Int_t> GetMapFairLinktoTubeId() const { return fMapFairLinktoTubeId; }
  std::map<int, FairHit *> GetMapTubetoHit() const { return fMapTubetoHit; }
  std::map<int, FairLink> GetMapTubetoLink() const { return fMapTubetoLink; }
  std::vector<int> GetHittedTubes() { return fhittedTubes; };
  std::vector<FairLink> GetGEMNeighbors(FairLink link) { return fGEMNeighbors[link]; };
  int GetNumOfGEMNeighbors(FairLink link) { return fGEMNeighbors[link].size(); };
  double GetNumOfSTTNeighbors(FairLink link) { return fMapNumberhittedSTTNeighbors[link]; };
  PndHoughSpace *GetHoughSpace() { return fPndHoughSpace; };
  std::vector<FairLink> GetMVDHits() { return fMVDHits; };
  std::vector<FairLink> GetGEMHits() { return fGEMLinks; };
  std::vector<FairLink> GetSTTHits() { return fSTTLinks; };

 private:
  PndSttStrawMap *fStrawMap = nullptr;       // for getting more information about the tubes
  PndSttGeometryMap *fGeometryMap = nullptr; // for initializing the neighbors of each tube
  PndHoughSpace *fPndHoughSpace = nullptr;

  std::map<FairLink, FairHit *> fMapFairLinktoFairHit;
  std::map<FairLink, Double_t> fMapFairLinktoIsochrone;
  std::map<FairLink, Double_t> fMapFairLinktoIsochroneError;
  std::map<FairLink, Int_t> fMapFairLinktoTubeId;
  std::map<FairLink, std::vector<FairLink>> fGEMNeighbors;
  std::map<FairLink, double> fMapNumberhittedSTTNeighbors;
  std::map<int, FairHit *> fMapTubetoHit; // maps hitted tube to FairHit
  std::map<int, FairLink> fMapTubetoLink; // maps hitted tube to FairLink

  std::vector<FairHit *> fHits;
  std::vector<FairLink> fGEMLinks;
  std::vector<FairLink> fSTTLinks;
  std::vector<FairLink> fLinks; // vector with selected hits of an event
  std::vector<int> fhittedTubes;
  std::vector<FairLink> fMVDHits;

  int fNbins1;
  int fNbins2;

  ClassDef(PndHoughData, 1);
};

#endif /* PndHoughData_H_ */