PndSttMvdGemTracking.h

Go to the documentation of this file.

#ifndef PNDSTTMVDGEMTRACKING_H
#define PNDSTTMVDGEMTRACKING_H 1

#include "PndGeoSttPar.h"
#include "PndGemDigiPar.h"
#include "PndGemHit.h"
#include "PndSttHit.h"
#include "PndTrackCand.h"
#include "PndTrack.h"
#include "PndPersistencyTask.h"
#include "FairGeanePro.h"

#include "TCanvas.h"
#include "TH2F.h"

class TClonesArray; 

class PndSttMvdGemTracking : public PndPersistencyTask {

 public:

  PndSttMvdGemTracking();

  PndSttMvdGemTracking(Int_t verbose);


  ~PndSttMvdGemTracking();


  virtual InitStatus Init();


  virtual void Exec(Option_t* opt);


  void SetPersistenc(Bool_t persistence) { SetPersistency(persistence); }
 

  virtual void SetParContainers();

  // -------- MVD + STT ---> + GEM --------------
  void Copy(PndTrackCand *completeCand, PndTrack *completeTrack,
            PndTrackCand *sttmvdCand, PndTrack *sttmvd);
  void SetTimes(Int_t times) {fTimes = times;}
  void SetMaxDistance(Double_t maxdistance) {fMaxDistance = maxdistance;}
  void SwitchOnDisplay() {fDisplayOn = true;}
    
  void SetupGEMPlanes();
  void Reset(Int_t nhits, Int_t ntracks);
  void OrderGemHits(Int_t nhits);

  Int_t GetTrackIndex(Int_t i);
  Int_t GetHitIndex(Int_t i);
  Int_t GetPosIndex(PndGemHit *hit);

  Int_t CountTracks();  
  Int_t CountHitsInTrack(Int_t itrk);
  void AddHitToTrack(Int_t ihit, Int_t itrk);
  void DeleteHitFromTrack(Int_t ihit, Int_t itrk);
  std::vector<int> GetTracksAssociatedToHit(Int_t ihit);
  std::vector<int> GetHitsAssociatedToTrack(Int_t itrk);
  std::vector<int> GetHitsAssociatedToTrackOnPlane(Int_t itrk, Int_t ipos);
  void AddRemainingHits(Int_t ntracks);

  void CheckCombinatorial(Int_t nhits, Int_t ntracks);
  void ForbidMultiAssignedHits(Int_t nhits, Int_t ntracks);
  void OnlyOneHitToEachTrack(Int_t nhits, Int_t ntracks);
  void Retrack();

  Bool_t PropagateToGemPlane(FairTrackParP *tmppar, FairTrackParP *gempar, Int_t ipos);
  Bool_t PropagateToGemPlaneAsHelix(PndTrack *sttmvd, FairTrackParP *gempar, Int_t ipos);

  Double_t IsAssignable(FairTrackParP *gempar, PndGemHit *gemhit);
  std::vector<int> AssignHits(Int_t itrk, FairTrackParP *gempar, Int_t ipos);
  void EvaluatePerformances(Int_t nhits, Int_t ntracks);
  void FillTrueDistances();
  // -----------------------------------------------
  Int_t SelectPdgCode(PndTrack *sttmvd);

  void Kalman(TMatrixT<double> extrap, TMatrixT<double> measurement,
              TMatrixT<double> H,
              TMatrixT<double> extrap_cov, TMatrixT<double> measurement_cov,
              TMatrixT<double> &kalman, TMatrixT<double> &kalman_cov);
  FairTrackParP SetStartParameters(PndTrack *sttmvd, PndTrackCand *sttmvdCand);

  Int_t GetClosestOnFirst(FairTrackParP* gempar, Int_t ipos, Double_t &closestdistance);


  // PREFIT -----------------------------
  Bool_t Prefit(PndTrack *sttmvdTrack, PndTrackCand *sttmvdCand, TVector3 &lastpos, TVector3 &lastmom);
  Bool_t IntersectionFinder(Double_t xc, Double_t yc, Double_t radius, PndSttHit* stthit, TVector3 &xyz, TVector3 &dxyz);
  Bool_t Fit(TMatrixT<double> points, Double_t &outxc, Double_t &outyc, Double_t &outradius);
  Bool_t ZFit(TMatrixT<double> points, Int_t charge, Double_t xc, Double_t yc, Double_t radius, Double_t &fitm, Double_t &fip);
  Bool_t GetInitialParams(PndTrack * sttmvd, Double_t &xc, Double_t &yc, Double_t &radius, Double_t &fitm, Double_t &fitp);
  Double_t CalculatePhi(TVector2 v, TVector2 p, double alpha, double Phi0, int charge);
  Double_t CompareToPreviousPhi(Double_t Fi, Double_t Fi_pre, int charge);
  Bool_t ZFind(Int_t nhits, TMatrixT<double> points, Double_t xc, Double_t yc, Double_t radius);


  // COMBINATORIAL EFFECS ----------------
  void ConsiderCombinatorialEffect(Int_t nhits);
  void SetCombinatorialDistance(Double_t combidistance) { fCombiDistance = combidistance; }
  void UpdateMCTrackId(PndTrackCand *completeCand);



  // CHECK delete this when everything is ok
  void UseMonteCarlo() {  fUseMC = kTRUE; }
  void WriteHistograms();


  void SetEvaluateFlag(Bool_t flag) { fEvaluate = flag; }

  // PDG stuff
  Int_t GetPdgFromMC(int trackid);
  Int_t GetChargeCorrectedPdgFromMC(int trackid, int charge);
  void SetPdgFromMC() { fPdgFromMC = kTRUE; }
  void SetPdgFromMC(TString trackid) { 
    fStartTrackIDBranchName = trackid;
    fPdgFromMC = kTRUE; 
  }
  void SetDefaultPdg(int pdg) { fDefaultPdgCode = pdg; }

  void SetBranchNames(TString mvdpixel, TString mvdstrip, TString stt, TString gem);
  void SetTrackBranchNames(TString startingtrack, TString startingtrackcand);

 private: 

  TClonesArray* fGemHitArray;
  TClonesArray* fGemPointArray;

  TClonesArray* fMvdPixelHitArray;
  TClonesArray* fMvdStripHitArray;
  TClonesArray* fSttHitArray;

  TClonesArray* fMvdPointArray;
  TClonesArray* fSttPointArray;


  TClonesArray* fMCTrackArray;
  TClonesArray* fTrackArray;
  TClonesArray* fTrackIDArray;
  TClonesArray* fTrackCandArray;

  TClonesArray* fCompleteTrackCandArray;  
  TClonesArray* fCompleteTrackArray;  

  TClonesArray* fTubeArray;

 Bool_t  fPdgFromMC; 


  PndGeoSttPar *fSttParameters; 
  PndGemDigiPar *fGemParameters; 
 
  FairGeanePro *fPro;

  Int_t countgood, countbad, countdoubt, countreconstructablehit, countprinotassigned, countsecnotassigned, countreconstructablepoint;
  Int_t countplane[8], countprop[2][8], countsttmvd, countsttmvdusable, countnohitonplane[8], evt ;

  std::vector<int> usabletracks;

  std::vector<int> fOrdering;
  std::vector<int>::iterator fOrderingIterator; 

  TClonesArray *fSensPositions;

  Int_t fNPositions;

  TVector3 fDj, fDk;

  Int_t fPdgCode, fDefaultPdgCode;

  // CHECK added -------------------------
  std::vector<std::pair<int, int> > trackvector;
  std::vector<int> trackindexes;
  std::vector<int> notassignedhits;
  std::vector<int> notassignedtracks;

  std::map<int, bool> towhichplane;

  std::map<int, bool> fProTracks;
  
  TMatrixT<float> hitmap;
  
  TMatrixT<float> hitcounter;

  TMatrixT<double> distancemap;
  // ----------------------------------------

  Double_t fMaxDistance;
  Int_t fTimes;
  Int_t fTurn;  

  // DISPLAY
  Bool_t fDisplayOn;
  TCanvas *display;
  TH2F *h[8], *hnotskewed, *hskewed;
  TH1F *hdist[8], *hdist2[8], *hsigma[8], *hsigma2[8], *hchosen[8], *hchosen2[8], *hmcdist[8], *hmcx[8], *hmcy[8];

  // MonteCarlo
  // CHECK delete this when everything is ok
  Bool_t fUseMC;

  TString fMvdPixelBranchName, fMvdStripBranchName, fSttBranchName, fGemBranchName;
  TString fStartTrackBranchName, fStartTrackCandBranchName, fStartTrackIDBranchName;


  std::map<int, int> fCombiMap;
  Double_t fCombiDistance;

  // evaluate performances? yes/no
  Bool_t fEvaluate;

  ClassDef(PndSttMvdGemTracking,1);

};

#endif