PndHoughTrackFinder.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".              *
//****************************************************************************

//  PndHoughTrackFinder
//  Finds Track for one event

#ifndef PndHoughTrackFinder_H_
#define PndHoughTrackFinder_H_

#include <vector>

#include "PndSttCA.h"

#include "PndHoughData.h"
#include "PndHoughUtilities.h"
#include "PndHoughTransformation.h"
#include "PndHoughSegment.h"
#include "PndHoughTrackCorrection.h"
#include "PndHoughPreprocessing.h"
#include "PndHoughMerge.h"
#include "PndApolloniusTriplet.h"

class PndHoughTrackFinder {
 public:
  PndHoughTrackFinder(){};

  PndHoughTrackFinder(TClonesArray *tubeArray) : fNbins1(450), fNbins2(450), fNBinsSeg(90.), fBz(2.), fCutMergeByHoughSpace(5.), fWithGPU(kFALSE), fWithGhostReduction(kTRUE)
  {
    // Generate TrackFinderData-Object
    fData = new PndHoughData(tubeArray);
    fCATrackFinder = new PndSttCA(tubeArray);
    ioman = FairRootManager::Instance();
  };

  virtual ~PndHoughTrackFinder()
  {
    delete fData;
    delete fCATrackFinder;

    delete fPndHoughTransformation;
    delete fPndHoughPreprocessing;
    delete fPndHoughMerge;
    delete fPndHoughSegment;
    delete fPndHoughUtilities;
    delete fPndHoughTrackCorrection;
  }

  virtual void SetBinningX(double bin) { fNbins1 = bin; };
  virtual void SetBinningY(double bin) { fNbins2 = bin; };
  virtual void SetNBinsSeg(Int_t n) { fNBinsSeg = n; };
  virtual void SetBz(double B) { fBz = B; };
  virtual void SetCutMergeByHoughSpace(float cut){ fCutMergeByHoughSpace = cut; }
  virtual void SetWithGPU(bool cuda) { fWithGPU = cuda; }
  virtual void SetWithGhostReduction(bool ghostred) { fWithGhostReduction = ghostred; }
  virtual void SetPreselectedTrackCands(std::vector<PndTrackCand> cands) { fPreselectedTrackCands = cands; };
  virtual void UseDefaultPreselection(bool pres) { fUseDefaultPreselection = pres; };
  virtual void SetCombinedSkewed(TClonesArray *skewed) { fCombinedSkewed = skewed; };
  void Init()
  {
    fData->Init(fNbins1, fNbins2);
    fCATrackFinder->SetUseGPU(fWithGPU);
  }

  void Reset()
  {
    fData->clear();

    fCATrackFinder->SetUseGPU(fWithGPU);
    fCATrackFinder->Reset();

    fPreselectedTrackCands.clear();
    fPreselectedTrackCircles.clear();
  }

  void AddHits(TClonesArray *hits, TString branchName);

  void CreateNeighborhood()
  {
    fData->CreateSTTNeighborhoodData();
    fData->CreateGEMNeighborhoodData();
  }
  void FindTracks();

  void Preselection();

  void FindHoughMaxima();
  TVector2 calcPhiRange(PndTrackCand &trackCand);
  bool IsInPhiRange(FairHit *hit, double phiLow, double phiHigh);
  void AddSkewedHits(int i);
  void AddOtherDetectorHits(int i, TString type);
  PndApollonius::TripletSolution FromPndTrackToTripletSolution(PndTrack &track, PndHoughData *fData);
  std::vector<PndApollonius::TripletSolution> CombineIdenticalSolutionsFinal(std::vector<PndApollonius::TripletSolution> &solutions, Double_t ratioOfSameHits);
  PndTrack FromTripletSolutionToPndTrack(PndApollonius::TripletSolution &sol, Double_t B);

  double CalcRatioSameHits(PndApollonius::TripletSolution &sol, std::vector<PndApollonius::TripletSolution> &AlreadyFoundSolutions);

  PndTrackCand GetPreselectedTrackCand(int i) { return fPreselectedTrackCands[i]; };

  int GetNumPreselectedTrackCands() { return fPreselectedTrackCands.size(); };

  TVector3 GetPreselectedTrackCircles(int i) { return fPreselectedTrackCircles[i]; };

  int GetNumPreselectedTrackCircles() { return fPreselectedTrackCircles.size(); };

  PndTrack GetMergedTrack(int i) { return fPndHoughMerge->GetMergedTrack(i); };

  int GetNumMergedTracks() { return fPndHoughMerge->GetNumMergedTracks(); };

  // PndTrackCand GetMergedTrackCand(int i) { return fPndHoughMerge->GetMergedTrackCand(i); };

  // int GetNumMergedTrackCands() { return fPndHoughMerge->GetNumMergedTrackCands(); };

  std::map<FairLink, FairHit *> GetMapFairLinktoFairHit() { return fData->GetMapFairLinktoFairHit(); };

  PndHoughData *GetData() { return fData; };

 private:
  FairRootManager *ioman = nullptr;

  PndSttCA *fCATrackFinder = nullptr;

  PndHoughData *fData = nullptr;
  PndHoughTransformation *fPndHoughTransformation = nullptr;
  PndHoughPreprocessing *fPndHoughPreprocessing = nullptr;
  PndHoughMerge *fPndHoughMerge = nullptr;
  PndHoughSegment *fPndHoughSegment = nullptr;
  PndHoughUtilities *fPndHoughUtilities = nullptr;
  PndHoughTrackCorrection *fPndHoughTrackCorrection = nullptr;
  TClonesArray *fCombinedSkewed = nullptr;
  std::vector<std::vector<TVector3>> fHoughSpacesToTracks;
  std::vector<PndTrackCand> fHoughSpacesToTrackCands;
  std::vector<PndTrackCand> fHoughSpacesToTrackCandTots;

  std::vector<FairLink> fFoundHits;

  std::vector<PndTrackCand> fPreselectedTrackCands;
  std::vector<TVector3> fPreselectedTrackCircles;
  std::vector<PndTrack> fApolloniusMergedTracks;
  std::vector<PndTrackCand> fApolloniusMergedTrackCands;

  Double_t fBz;
  float fCutMergeByHoughSpace;
  Int_t fNbins1;
  Int_t fNbins2;
  Int_t fNBinsSeg;
  bool fWithGPU;
  bool fWithGhostReduction;
  bool fUseDefaultPreselection = kTRUE;
  double fDistanceThresholdSTTCombinedSkewed = 1.;
  double fDistanceThresholdSTT = 0.3;
  double fDistanceThresholdMVD = 0.5;
  double fDistanceThresholdGEM = 1.;
  std::map<FairLink, FairHit *> fMapFairLinktoFairHit;
  std::map<FairLink, double> fMapFairLinktoIsochrone;
  ClassDef(PndHoughTrackFinder, 1);
};

#endif /*PndHoughTrackFinder_H_*/