CbmTransport.h

Go to the documentation of this file.

/* Copyright (C) 2019-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese, Florian Uhlig [committer] */
 
#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 = "Gold", Double_t thickness = 0.025, Double_t diameter = 2.5, Double_t x = 0.,
                 Double_t y = 0., Double_t z = -44.0, Double_t rot = 0., Double_t density = -1);
 
 
  void SetOutFileName(TString name, Bool_t overwrite = kFALSE);
 
 
  void SetRandomEventPlane(Double_t phiMin = 0., Double_t phiMax = 2. * TMath::Pi());
 
 
  void SetRandomSeed(const ULong_t seedValue) { fRandomSeed = seedValue; }
 
  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};  
 
  ULong_t fRandomSeed {0};
 
  void InitEventGenerator();
 
 
  void ForceUserDecays();
 
 
  void PiAndEtaDecay(TVirtualMC* vmc);
 
  void RegisterIons();
 
 
  void RegisterSetup();
 
  ClassDef(CbmTransport, 4);
};
 
#endif /* CBMTRANSPORT_H */