CbmTransport.h

Go to the documentation of this file.

 
#ifndef CBMTRANSPORT_H
#define CBMTRANSPORT_H 1
 
 
#include "CbmMCEventFilter.h"
#include "CbmSetup.h"
#include "CbmStackFilter.h"
#include "TNamed.h"
#include "TString.h"
#include <functional>
#include <iostream>
#include <memory>
 
class TGeant3;
class TGeant4;
class TVirtualMC;
class FairField;
class FairGenerator;
class FairRunSim;
class CbmEventGenerator;
class CbmTarget;
class CbmGeant3Settings;
class CbmGeant4Settings;
 
enum ECbmGenerator { kUnigen, kUrqmd, kPluto };
 
enum ECbmEngine { kGeant3, kGeant4 };
 
 
class CbmTransport : public TNamed {
 
public:
  CbmTransport();
 
 
  virtual ~CbmTransport();
 
 
  void AddInput(const char* fileName, ECbmGenerator generator = kUnigen);
 
 
  void AddInput(FairGenerator* generator);
 
 
  void ConfigureVMC();
 
 
  void ForceVertexAtZ(Double_t zVertex);
 
 
  void ForceVertexInTarget(Bool_t choice = kTRUE);
 
 
  void GenerateRunInfo(Bool_t choice = kTRUE) { fGenerateRunInfo = choice; }
 
 
  CbmSetup* GetSetup() const { return fSetup; }
 
 
  std::unique_ptr<CbmStackFilter>& GetStackFilter() { return fStackFilter; }
 
 
  void SetSetupSource(ECbmSetupSource setupSource);
 
 
  void LoadSetup(const char* setupName);
 
 
  void RegisterRadLength(Bool_t choice = kTRUE);
 
 
  void Run(Int_t nEvents);
 
 
  void SetBeamAngle(Double_t x0,
                    Double_t y0,
                    Double_t sigmaX = -1.,
                    Double_t sigmaY = -1.);
 
 
  void SetBeamPosition(Double_t x0,
                       Double_t y0,
                       Double_t sigmaX = -1.,
                       Double_t sigmaY = -1.,
                       Double_t zF     = 0.);
 
 
  void SetDecayMode(Int_t pdg, UInt_t nDaughters, Int_t* daughterPdg);
 
 
  void SetEngine(ECbmEngine engine) { fEngine = engine; }
 
 
  void SetEventFilter(std::unique_ptr<CbmMCEventFilter>& filter) {
    fEventFilter.reset();
    fEventFilter = std::move(filter);
  }
 
 
  void SetEventFilterMinNofData(ECbmDataType type, Int_t value) {
    fEventFilter->SetMinNofData(type, value);
  }
 
 
  void SetField(FairField* field) { fField = field; }
 
 
  void SetGeoFileName(TString name);
 
 
  void SetMediaFileName(TString fileName) {
    fSetup->SetMediaFilePath(fileName.Data());
  }
 
 
  void SetParFileName(TString name);
 
 
  void SetStackFilter(std::unique_ptr<CbmStackFilter>& filter) {
    fStackFilter.reset();
    fStackFilter = std::move(filter);
  }
 
 
  void SetTarget(const char* medium,
                 Double_t thickness,
                 Double_t diameter,
                 Double_t x   = 0.,
                 Double_t y   = 0.,
                 Double_t z   = 0.,
                 Double_t rot = 0.);
 
 
  void SetOutFileName(TString name);
 
 
  void SetRandomEventPlane(Double_t phiMin = 0.,
                           Double_t phiMax = 2. * TMath::Pi());
 
 
  void SetVertexSmearXY(Bool_t choice = kTRUE);
 
 
  void SetVertexSmearZ(Bool_t choice = kTRUE);
 
 
  void StoreTrajectories(Bool_t choice = kTRUE) { fStoreTrajectories = choice; }
 
  void SetGeant3Settings(CbmGeant3Settings* val) { fGeant3Settings = val; }
 
  void SetGeant4Settings(CbmGeant4Settings* val) { fGeant4Settings = val; }
 
private:
  CbmSetup* fSetup;
  FairField* fField;                   
  std::shared_ptr<CbmTarget> fTarget;  
  CbmEventGenerator* fEventGen;
  std::unique_ptr<CbmMCEventFilter> fEventFilter;
  FairRunSim* fRun;
  TString fOutFileName;
  TString fParFileName;
  TString fGeoFileName;
  std::vector<FairGenerator*> fGenerators;
  Double_t fRealTimeInit;
  Double_t fRealTimeRun;
  Double_t fCpuTime;
  ECbmEngine fEngine;
  std::unique_ptr<CbmStackFilter> fStackFilter;
  Bool_t fGenerateRunInfo;
  Bool_t fStoreTrajectories;
  std::function<void()> fSimSetup;
  std::map<Int_t, std::vector<Int_t>> fDecayModes;
 
  CbmGeant3Settings* fGeant3Settings {nullptr};  
  CbmGeant4Settings* fGeant4Settings {nullptr};  
 
  void InitEventGenerator();
 
 
  void ForceUserDecays();
 
 
  void PiAndEtaDecay(TVirtualMC* vmc);
 
  void RegisterIons();
 
 
  void RegisterSetup();
 
  ClassDef(CbmTransport, 3);
};
 
#endif /* CBMTRANSPORT_H */