MpdUnigenGenerator.h

Go to the documentation of this file.

#ifndef MPDUNIGENGENERATOR_H
#define MPDUNIGENGENERATOR_H
 
#include "FairIon.h"
#include "FairParticle.h"
#include "UEvent.h"
#include "UParticle.h"
#include "URun.h"
 
#include <FairGenerator.h>
#include <FairMCEventHeader.h>
#include <FairPrimaryGenerator.h>
#include <FairRunSim.h>
#include <TClonesArray.h>
#include <TDatabasePDG.h>
#include <TFile.h>
#include <TParticlePDG.h>
#include <TRandom.h>
#include <TString.h>
#include <TTree.h>
#include <iostream>
#include <random>
 
class TVirtualMCStack;
class FairPrimaryGenerator;
 
class MpdUnigenGenerator : public FairGenerator
{
  public:
    MpdUnigenGenerator();
    explicit MpdUnigenGenerator(TString fileName, Bool_t isSpectator = kFALSE);
    ~MpdUnigenGenerator() override = default;
    Long64_t GetNEntries() { return fNEntries; }
    Bool_t ReadEvent(FairPrimaryGenerator* primGen) override;
    Int_t RegisterIons();
 
    void SkipEvents(Int_t ev)
    {
        fEventNumber = ev;
        std::cout << "NUMBER OF SKIPPED EVENTS = " << ev << std::endl;
    }
 
    void SetEventPlane(Double_t phiMin, Double_t phiMax)
    {
        fPhiMin = phiMin;
        fPhiMax = phiMax;
        fEventPlaneSet = kTRUE;
        random_engine_ = std::mt19937(random_device_());
        uniform_real_distribution_ = std::uniform_real_distribution<double>(fPhiMin, fPhiMax);
    }
 
  private:
    std::random_device random_device_;
    std::mt19937 random_engine_;
    std::uniform_real_distribution<double> uniform_real_distribution_;
    Long64_t fEventNumber;   //!
    Long64_t fNEntries;      //!
    TFile* fInFile;
    TTree* fInTree;
    UEvent* fEvent;
    URun* fRun;
    UParticle* fParticle;
    Bool_t fSpectatorsON;
 
    Double_t fPhiMin, fPhiMax;   // Limits of event plane angle
    Bool_t fEventPlaneSet;       // Flag whether event plane angle is used
 
    std::map<TString, FairIon*> fIonMap;   //!< Map from ion name to FairIon
 
    static const Int_t kPdgLambda = 10000000;
    static const Int_t kPdgCharge = 10000;
    static const Int_t kPdgMass = 10;
 
    Double_t fGammaCM = 0.;
    Double_t fBetaCM = 0.;
 
    Int_t GetIonCharge(Int_t pdgCode) const { return (pdgCode % kPdgLambda) / kPdgCharge; }
    Int_t GetIonLambdas(Int_t pdgCode) { return (pdgCode % (10 * kPdgLambda)) / kPdgLambda; }
    Int_t GetIonMass(Int_t pdgCode) { return (pdgCode % kPdgCharge) / kPdgMass; }
 
    MpdUnigenGenerator(const MpdUnigenGenerator&);
    MpdUnigenGenerator& operator=(const MpdUnigenGenerator&);
 
    ClassDefOverride(MpdUnigenGenerator, 1);
};
 
#endif