CbmLitGlobalElectronId.h

Go to the documentation of this file.

/* Copyright (C) 2011-2025 UGiessen/JINR-LIT, Giessen/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev, Semen Lebedev [committer], Cornelius Feier-Riesen */
 
#ifndef CBMLITGLOBALELECTRONID_H_
#define CBMLITGLOBALELECTRONID_H_
 
#include "TCutG.h"
#include "TObject.h"
 
#include <memory>  // TODO: needed?
 
class TClonesArray;
class CbmGlobalTrack;
 
class CbmLitGlobalElectronId : public TObject {
 private:
  CbmLitGlobalElectronId();

  void Init();
 
 
 public:
  static CbmLitGlobalElectronId& GetInstance()
  {
    static CbmLitGlobalElectronId fInstance;
    return fInstance;
  }

  virtual ~CbmLitGlobalElectronId();

  Bool_t IsStsElectron(Int_t globalTrackIndex, Double_t momentum);

  Bool_t IsRichElectron(Int_t globalTrackIndex, Double_t momentum);

  Bool_t IsTrdElectron(Int_t globalTrackindex, Double_t momentum);

 
  // TODO: 1000 ns is a hardcoded offset for event-by-event mode
  Bool_t IsTofElectron(Int_t globalTrackIndex, Double_t momentum, Double_t eventTime = 1000.);
 
  std::unique_ptr<TCutG> fStsELossCut2D = std::make_unique<TCutG>(*[]() {
    // Cut values for 8 Gev
    auto stsCut = new TCutG("StsELossCut2D", 6);
    stsCut->SetVarX("P");
    stsCut->SetVarY("eLoss");
    stsCut->SetPoint(0, 0., 21e3);
    stsCut->SetPoint(1, 10., 23e3);
    stsCut->SetPoint(2, 10., 28e3);
    stsCut->SetPoint(3, 4., 33e3);
    stsCut->SetPoint(4, 2., 33e3);
    stsCut->SetPoint(5, 0., 27e3);
    return stsCut;
  }());
 
  std::unique_ptr<TCutG> fRichAnnCut2D = std::make_unique<TCutG>(*[]() {
    // Cut values for 8 Gev
    auto richCut = new TCutG("RichAnnCut2D", 6);
    richCut->SetVarX("P");
    richCut->SetVarY("ANN");
    richCut->SetPoint(0, 0.0, 0.0);
    richCut->SetPoint(1, 2.0, 0.0);
    richCut->SetPoint(2, 3.0, 0.6);
    richCut->SetPoint(3, 10.0, 0.9);
    richCut->SetPoint(4, 10.0, 1.5);
    richCut->SetPoint(5, 0.0, 1.5);
    return richCut;
  }());
 
  std::unique_ptr<TCutG> fTrdElLikeCut2D = std::make_unique<TCutG>(*[]() {
    // Cut values for 8 Gev
    auto trdLikeCut = new TCutG("TrdElLikeCut2D", 8);
    trdLikeCut->SetVarX("P");
    trdLikeCut->SetVarY("Likelihood");
    trdLikeCut->SetPoint(0, 0.0, 0.65);
    trdLikeCut->SetPoint(1, 2.0, 0.65);
    trdLikeCut->SetPoint(2, 3.0, 0.4);
    trdLikeCut->SetPoint(3, 5.5, 0.4);
    trdLikeCut->SetPoint(4, 6., 0.85);
    trdLikeCut->SetPoint(5, 8., 0.9);
    trdLikeCut->SetPoint(6, 8., 1.5);
    trdLikeCut->SetPoint(7, 0., 1.5);
    return trdLikeCut;
  }());
 
  std::unique_ptr<TCutG> fTrdChi2Cut2D = std::make_unique<TCutG>(*[]() {
    // Cut values for 8 Gev
    auto trdChi2Cut = new TCutG("TrdChi2Cut2D", 5);
    trdChi2Cut->SetVarX("P");
    trdChi2Cut->SetVarY("Chi2");
    trdChi2Cut->SetPoint(0, 0.0, 0.0);
    trdChi2Cut->SetPoint(1, 10.0, 1.0);
    trdChi2Cut->SetPoint(2, 10.0, 7.0);
    trdChi2Cut->SetPoint(3, 7.0, 10.0);
    trdChi2Cut->SetPoint(4, 0.0, 10.0);
    return trdChi2Cut;
  }());
 
  std::unique_ptr<TCutG> fTofM2Cut2D = std::make_unique<TCutG>(*[]() {
    // Cut values for 8 Gev
    auto tofM2Cut = new TCutG("TofM2Cut2D", 8);
    tofM2Cut->SetVarX("P");
    tofM2Cut->SetVarY("m2");
    tofM2Cut->SetPoint(0, 0., -0.01);
    tofM2Cut->SetPoint(1, 2., -0.06);
    tofM2Cut->SetPoint(2, 8., -0.35);
    tofM2Cut->SetPoint(3, 10., -0.35);
    tofM2Cut->SetPoint(4, 10., 0.2);
    tofM2Cut->SetPoint(5, 6., 0.3);
    tofM2Cut->SetPoint(6, 1.3, 0.01);
    tofM2Cut->SetPoint(7, 0., 0.01);
    return tofM2Cut;
  }());
 
  std::unique_ptr<TCutG> fTofDistCut2D = std::make_unique<TCutG>(*[]() {
    // Cut values for 8 Gev
    auto tofDistCut = new TCutG("TofDistCut2D", 7);
    tofDistCut->SetVarX("P");
    tofDistCut->SetVarY("Dist");
    tofDistCut->SetPoint(0, 0., 0.);
    tofDistCut->SetPoint(1, 10., 0.);
    tofDistCut->SetPoint(2, 10., 5.);
    tofDistCut->SetPoint(3, 5., 7.);
    tofDistCut->SetPoint(4, 2.5, 25.);
    tofDistCut->SetPoint(5, 1., 50.);
    tofDistCut->SetPoint(6, 0., 50.);
    return tofDistCut;
  }());

  /*
        Bool_t IsElectron(
              Int_t globalTrackIndex,
              Double_t momentum);
*/

  Double_t GetRichAnn(Int_t globalTrackIndex, Double_t momentum);

  Double_t GetTrdAnn(Int_t globalTrackindex, Double_t momentum);
 

  // TODO: 1000 ns is a hardcoded offset for even-by-even mode
  Double_t GetTofM2(Int_t globalTrackIndex, Double_t momentum, Double_t eventTime = 1000.);
 

  void SetTrdAnnCut(Double_t par) { fTrdAnnCut = par; }

  void SetRichUseAnn(Bool_t par) { fRichUseAnn = par; }

  void SetRichAnnCut(Double_t par) { fRichAnnCut = par; }

  void SetRichCuts(Double_t meanA, Double_t rmsA, Double_t meanB, Double_t rmsB, Double_t rmsCoeff, Double_t rtDistCut)
  {
    fRichMeanA    = meanA;
    fRichMeanB    = meanB;
    fRichRmsA     = rmsA;
    fRichRmsB     = rmsB;
    fRichRmsCoeff = rmsCoeff;
    fRichDistCut  = rtDistCut;
  }

  Double_t GetRichAnnCut() { return fRichAnnCut; }

  Double_t GetTrdAnnCut() { return fTrdAnnCut; }
 
 private:
  Double_t fRichAnnCut;
  Bool_t fRichUseAnn;
  Double_t fRichMeanA;
  Double_t fRichMeanB;
  Double_t fRichRmsA;
  Double_t fRichRmsB;
  Double_t fRichRmsCoeff;
  Double_t fRichDistCut;
  Double_t fTrdAnnCut;
 
  TClonesArray* fGlobalTracks;
  TClonesArray* fStsTracks;
  TClonesArray* fRichRings;
  TClonesArray* fTrdTracks;
  TClonesArray* fTofHits;
  TClonesArray* fTofTracks;
 
  CbmLitGlobalElectronId(const CbmLitGlobalElectronId&);
  CbmLitGlobalElectronId& operator=(const CbmLitGlobalElectronId&);
 
  ClassDef(CbmLitGlobalElectronId, 1);
};
 
#endif /* CBMLITGLOBALELECTRONID_H_ */