CbmFastSim.h

Go to the documentation of this file.

/* Copyright (C) 2016 Justus-Liebig-Universitaet Giessen, Giessen
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Julian Book [committer] */
 
#ifndef CBMFASTSIM_H
#define CBMFASTSIM_H 1
 
 
#include "FairTask.h"
 
#include "TClonesArray.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TMatrixD.h"
#include "TString.h"
#include "TVector3.h"
 
#include <list>
#include <string>
 
class TObjectArray;
class TRandom3;
class TLorentzVector;
class TParticle;
class TF1;
class TH2;
class TProfile3D;
class THnBase;
class TDatabasePDG;
class PairAnalysisFunction;
 
class CbmFastSim : public FairTask {
 
public:
  enum EParticleType
  {
    kEle = 0,
    kPio,
    kKao,
    kPro,
    kMuo,
    kGam
  };
 
  enum EEfficiencyMethod
  {
    kIgnoreFluct = 0,
    kInterpolate,
    kAverage,
    kFactorize,
    kLastDim
  };
 
  CbmFastSim(bool persist = true);
 
  ~CbmFastSim();
 
  void Register();
 
  virtual InitStatus Init();
  virtual void InitTask();
 
  virtual void Finish();
 
 
  virtual void Exec(Option_t* opt);
 
  void SetLookupEfficiency(THnBase* nom, THnBase* denom, EParticleType part);
  void SetLookupResolutionP(TH2F* obj, EParticleType part) { fRFp[part] = obj; }
  void SetEfficiencyMethod(EEfficiencyMethod method) { fMethod = method; }
 
  void SetSeed(unsigned int seed = 65539);
 
private:
  TRandom3* fRand;
  TDatabasePDG* fdbPdg;
  static const Int_t fgkNParts = 8;             // numer of different particle species
  EEfficiencyMethod fMethod    = kIgnoreFluct;  // efficiency caluclations
 
  Bool_t PassEfficiencyFilter(Int_t pdg, Double_t* vals, Int_t* coord);
  Double_t GetEfficiency(Int_t idx, Double_t* vals, Int_t* coord);
 
  Bool_t Smearing(TLorentzVector* p4, Int_t pdg);
  Double_t AnalyzeMap(TH2F* map, Double_t refValue);
 
  virtual Bool_t IsSelected(TObject* sel, Int_t opt);
 
  TClonesArray* fFastTracks = NULL;
 
  THnBase* fEFF[fgkNParts];       // efficiency(nominator) map
  THnBase* fEFFdenom[fgkNParts];  // denominator map
  TH1* fEFFproj[fgkNParts][10];   // projections (method dependent)
 
  TH2F* fRFp[fgkNParts];  // smearing matrix
 
  virtual void SetParContainers();
 
  CbmFastSim(const CbmFastSim& obj);
  CbmFastSim& operator=(const CbmFastSim& obj);
 
  ClassDef(CbmFastSim, 1);
};
 
#endif