LmvmTask.h

Go to the documentation of this file.

/* Copyright (C) 2010-2021 UGiessen, JINR-LIT
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Semen Lebedev [committer], Elena Lebedeva, Florian Uhlig, Cornelius Feier-Riesen */
 
#ifndef LMVM_TASK_H
#define LMVM_TASK_H
 
#include "CbmDigiManager.h"
#include "CbmGlobalTrack.h"
#include "CbmKFVertex.h"
#include "CbmStsKFTrackFitter.h"
#include "FairMCEventHeader.h"
#include "FairRootManager.h"
#include "FairTask.h"
#include "LmvmCand.h"
#include "LmvmCuts.h"
#include "LmvmDef.h"
#include "LmvmHist.h"
#include "LmvmKinePar.h"
 
#include <fstream>
#include <map>
#include <string>
#include <vector>
 
class TClonesArray;
class TH2D;
class TH1D;
class TH2F;
class TRandom3;
 
 
class LmvmTask : public FairTask {
 
 public:
  /*
    * \brief Standard constructor.
    */
  LmvmTask();
 
  /*
     * \brief Standard destructor.
     */
  virtual ~LmvmTask();
 
  /*
     * \brief Inherited from FairTask.
     */
  virtual InitStatus Init();
 
  /*
     * \brief Inherited from FairTask.
     */
  virtual void Exec(Option_t* option);
 
  template<typename T>
  T* InitOrFatal(const std::string& name)
  {
    FairRootManager* ioman = FairRootManager::Instance();
    if (ioman == nullptr) {
      LOG(fatal) << "LmvmTask::Init No FairRootManager!";
    }
    T* array = static_cast<T*>(ioman->GetObject(name.c_str()));
    if (array == nullptr) {
      LOG(fatal) << "LmvmTask::Init No " << name << " object!";
    }
    return array;
  }
 
  /*
     * \brief Fills histograms for pairs.
     * \param[in] candP Positive candidate.
     * \param[in] candM Negative candidate.
     * \param[in] step Enumeration AnalysisSteps, specify analysis step.
     * \param[in] parRec Kinematic parameters for reconstructed pair.
     */
  void PairSource(const LmvmCand& candP, const LmvmCand& candM, ELmvmAnaStep step, const LmvmKinePar& parRec);
 
  /*
     *  \brief Fills minv, pty, mom histograms for specified analysis step.
     * \param[in] candP Positive candidate.
     * \param[in] candM Negative candidate.
     * \param[in] parMc MC kinematic parameters.
     * \param[in] parRec Reconstructed kinematic parameters.
     * \param[in] step Enumeration AnalysisSteps, specify analysis step.
     */
  void FillPairHists(const LmvmCand& candP, const LmvmCand& candM, const LmvmKinePar& parMc, const LmvmKinePar& parRec,
                     ELmvmAnaStep step);
  void FillMomHists(const CbmMCTrack* mct, const LmvmCand* cand, ELmvmSrc src, ELmvmAnaStep step);
  void FillCandsForEventMix();
  void TrackSource(const LmvmCand& cand, ELmvmAnaStep step, int pdg);
  void BgPairPdg(const LmvmCand& candP, const LmvmCand& candM, ELmvmAnaStep step);
  void DoMcTrack();
  void DoMcPair();
  void FillRichRingNofHits();
  bool IsRecoTrackAccepted(const CbmGlobalTrack* gTrack);
  void RichPmtXY();
  void FillTopologyCands();
  void FillCands();
  void AssignMcToCands(std::vector<LmvmCand>& cands);
  void AssignMcToTopologyCands(std::vector<LmvmCand>& topoCands);
  void FillSourceHistos(const LmvmCand& cand);
 
  /*
     * \brief Initialize all histograms.
     */
  void InitHists();
 
  double MinvScale(const CbmMCTrack* mct, const std::string& signal);
 
  void AnalyseCandidates();
  void AnalyseGlobalTracks();
  void AnalyseRichRings();
  void AnalyseProperties();
 
  std::string fhrep;
  std::string fhrec;
  void FillHistosForFastSim();
 
  void CheckLikeSignCorrelations();
 
  void CheckMismatches(const CbmGlobalTrack* gTrack, int pdg, bool isElectron, const std::string& ptcl, double weight);
  void BetaMom(const CbmMCTrack* mct, const CbmGlobalTrack* gTrack, const std::string& ptcl);
  void PidVsMom(const CbmGlobalTrack* gTrack, int iGTrack, int pdg, double mom, bool isAcc);
 
  CbmMCTrack* GetMcTrackSts(int stsIndex);
 
  void CheckGammaConvAndPi0();
 
  /*
     * \brief
     * \param[in] mvdStationNum MVD station number.
     * \param[in, out] hist Vector of histograms for different source types.
     */
  void CheckClosestMvdHit(int mvdStationNum, const std::string& hist, const std::string& histQa);
 
  /*
     * \brief Set cut values and fill histograms for topology cut
     * \param[in] cutName ST or TT
     */
  void CheckTopologyCut(ELmvmTopologyCut cut, const std::string& name);
 
  void CalculateNofTopologyPairs(const std::string& name, ELmvmSrc src);
 
  void MvdCutMcDistance();
 
  void CombinatorialPairs();
 
  void RatioMomentum(const CbmMCTrack* mct, const LmvmCand& cand, ELmvmAnaStep step, int pdg);
 
  void CheckTofId(const CbmMCTrack* mcTrack, const LmvmCand& cand, ELmvmAnaStep step, int pdg);
  bool IsInTofPile(double mom, double m2);
  bool IsInBox(double boxX, double boxY, double xVal, double yVal, double width);
 
  std::string GetPidString(const CbmMCTrack* mct, const LmvmCand* cand);
  std::string GetPidString(double vertexZ, int pdg);
 
  /*
     * \brief Check if global track has entries in all detectors.
     */
  bool IsInAllDets(const CbmGlobalTrack* gTrack);
 
  bool IsPrimary(double vertexZ) { return (vertexZ < fZ + 0.1 && vertexZ > fZ - 0.1); }
 
  virtual void Finish();
 
  ClassDef(LmvmTask, 1);
 
 private:
  LmvmTask(const LmvmTask&);
  LmvmTask& operator=(const LmvmTask&);
 
  FairMCEventHeader* fMCEventHeader = nullptr;
  TClonesArray* fCbmEvents          = nullptr;
  TClonesArray* fMCTracks           = nullptr;
  TClonesArray* fRichRings          = nullptr;
  TClonesArray* fRichProj           = nullptr;
  TClonesArray* fRichPoints         = nullptr;
  TClonesArray* fRichRingMatches    = nullptr;
  TClonesArray* fRichHits           = nullptr;
  TClonesArray* fGlobalTracks       = nullptr;
  TClonesArray* fStsTracks          = nullptr;
  TClonesArray* fStsTrackMatches    = nullptr;
  TClonesArray* fStsHits            = nullptr;
  TClonesArray* fMvdHits            = nullptr;
  TClonesArray* fMvdPoints          = nullptr;
  TClonesArray* fMvdHitMatches      = nullptr;
  TClonesArray* fTrdTracks          = nullptr;
  TClonesArray* fTrdHits            = nullptr;
  TClonesArray* fTrdTrackMatches    = nullptr;
  TClonesArray* fTofHits            = nullptr;
  TClonesArray* fTofHitsMatches     = nullptr;
  TClonesArray* fTofPoints          = nullptr;
  TClonesArray* fTofTracks          = nullptr;
  CbmVertex* fPrimVertex            = nullptr;
  CbmDigiManager* fDigiManager      = nullptr;  // Interface to digi branches
  CbmKFVertex fKFVertex;
  CbmStsKFTrackFitter fKFFitter;
 
  bool fUseMvd = false;
 
  std::vector<LmvmCand> fCands;
  std::vector<LmvmCand> fCandsTotal;
  std::vector<LmvmCand>
    fCandsMix;  // will be filled with cands >= chi2prim and inserted into 'fCandsTotal' to avoid too many unnecessary candidates in event mixing
  // STCut Segmented tracks, reconstructed only in STS
  std::vector<LmvmCand> fSTCands;
  // TTCut Reconstructed tracks, reconstructed in all detectors but not identified as electrons
  std::vector<LmvmCand> fTTCands;
  // RTCut Reconstructed tracks, reconstructed in STS + at least in one of the  detectro (RICH, TRD, TOF)
  std::vector<LmvmCand> fRTCands;
 
  double fW = 0.;  //Multiplicity*BR
 
  double fPionMisidLevel = -1.;  // For the ideal particle identification cases, set to -1 for real PID
 
  Int_t fEventNumber = 0;  // number of current event
  LmvmCuts fCuts;        // electorn identification and analisys cuts
 
  LmvmHist fH;  // histogram manager
 
  std::map<int, int> fNofHitsInRingMap;  // Number of hits in the MC RICH ring
 
  double fZ = -44.;  // z-position of target in cm
 
  int fNofMinHitsStsMvd = 4;
  int fNofMinHitsRich   = 7;
  int fNofMinHitsTrd    = 2;
  int fNofMinHitsTof    = 1;
 
  std::string fParticle = "";
  std::string fTaskId   = "";
 
 public:
  void SetUseMvd(bool use) { fUseMvd = use; }
  void SetWeight(double w) { fW = w; }
  void SetEnergyAndPlutoParticle(const std::string& energy, const std::string& particle);
  void SetTaskId(const std::string& taskId) { fTaskId = taskId; }
  void SetPionMisidLevel(double level) { fPionMisidLevel = level; }
};
 
#endif