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 */