PndSttMvdGemTracking.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

#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