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

//  PndHoughMerge
//  Class for merging single tracklets

#ifndef PndHoughMerge_H_
#define PndHoughMerge_H_

#include "PndSttGeometryMap.h"

#include "PndHoughUtilities.h"
#include "PndHoughTransformation.h"
#include "PndHoughTrackCorrection.h"

#include <vector>

class PndHoughMerge {
 public:
  PndHoughMerge(PndHoughData *data) : fCutMergeByHoughSpace(5.), fWithGhostReduction(kTRUE)

  {

    // fPndHoughUtilities = new PndHoughUtilities(data);
    // fPndHoughTransformation = new PndHoughTransformation(data);

    ioman = FairRootManager::Instance();
    fMapFairLinktoFairHit = data->GetMapFairLinktoFairHit();
    fMergedTracks.clear();
    // fMergedTrackCands.clear();
    fData = data;
  };

  virtual ~PndHoughMerge() { fMergedTracks.clear(); };
  virtual void SetCutMergeByHoughSpace(float cut) { fCutMergeByHoughSpace = cut; };
  virtual void SetWithGhostReduction(bool ghostred) { fWithGhostReduction = ghostred; }

  virtual void SetUtilities(PndHoughUtilities *utilities) { fPndHoughUtilities = utilities; }
  // virtual void SetHoughTransformation(PndHoughTransformation *trafo) { fPndHoughTransformation = trafo; };
  virtual void SetTrackCorrection(PndHoughTrackCorrection *correction) { fPndHoughTrackCorrection = correction; };
  // virtual void SetHoughTransformation(PndHoughTransformation *trafo) { fPndHoughTransformation = trafo; };

  void mergeByHoughSpace(std::vector<TVector3> &PreselectedCircles, std::vector<PndTrackCand> &TrackCands, double fBz);
  void mergeSingle(std::vector<std::vector<int>> &mergeTracks, std::vector<PndTrack> &Tracks, std::vector<PndTrackCand> &TrackCands, double fBz);
  double findMedian(std::vector<double> a);
  bool IsGhost(std::vector<double> &trackcirc);
  void CalculateGhostReductionParameters(std::vector<double> &trackcirc);
  void CountHits();
  PndTrack GetMergedTrack(int i) { return fMergedTracks[i]; };
  // PndTrackCand GetMergedTrackCand(int i) { return fMergedTrackCands[i]; };
  int GetNumMergedTracks() { return fMergedTracks.size(); };
  // int GetNumMergedTrackCands() { return fMergedTrackCands.size(); };
  void UpdateMergedTrack(int i, PndTrack &track) { fMergedTracks[i] = track; };
  std::vector<PndTrack> GetMergedTracks() { return fMergedTracks; };
  void SetMergedTracks(std::vector<PndTrack> vec)
  {
    if (vec.size() < fMergedTracks.size()) {
      fMergedTracks.erase(fMergedTracks.begin() + vec.size(), fMergedTracks.end());
    }
    for (int i = 0; i < vec.size(); i++) {
      vec[i].Print();
      fMergedTracks[i] = (PndTrack)vec[i];
    }
  };

 private:
  FairRootManager *ioman = nullptr;

  PndHoughUtilities *fPndHoughUtilities = nullptr;
  // PndHoughTransformation *fPndHoughTransformation = nullptr;
  PndHoughTrackCorrection *fPndHoughTrackCorrection = nullptr;
  PndHoughData *fData = nullptr;

  std::map<FairLink, FairHit *> fMapFairLinktoFairHit;
  std::vector<PndTrack> fMergedTracks;
  // std::vector<PndTrackCand> fMergedTrackCands;

  std::vector<std::vector<double>> fMaxima_x;
  std::vector<std::vector<double>> fMaxima_y;
  std::vector<std::vector<double>> fMaxima_r;

  PndTrackCand fApolloniusTrackCand;

  float fCutMergeByHoughSpace;

  Int_t fMVDHits;
  Int_t fGEMHits;
  double fSTTHits;
  double fCounterHittedNeighborsRel;
  double fmeanD;

  bool fGEMNeighborCut;
  bool fSTTNeighborCut;
  bool fWithGhostReduction;

  ClassDef(PndHoughMerge, 1);
};

#endif /*PndHoughMerge_H_*/