FairRunSim.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
// Modified for ALICE O2 in 2026: parts not used by O2 were removed (see README.md in this directory).
#ifndef FAIRRUNSIM_H
#define FAIRRUNSIM_H
 
#include "FairIon.h"             // for FairIon
#include "FairMCApplication.h"   // for FairMCApplication
#include "FairParticle.h"        // for FairParticle
#include "FairRun.h"             // for FairRun
 
#include <Rtypes.h>      // for Bool_t, Double_t, Int_t, etc
#include <TMCtls.h>      // for multi-threading
#include <TObjArray.h>   // for TObjArray
#include <TString.h>     // for TString
#include <functional>
 
class FairField;
class FairMCEventHeader;
class FairMesh;
class FairModule;
class FairPrimaryGenerator;
class FairGenericVMCConfig;
 
class FairRunSim : public FairRun
{
  public:
    FairRunSim(Bool_t isMaster = kTRUE);
    virtual ~FairRunSim();
    static FairRunSim* Instance();
    void AddModule(FairModule* Mod);
    void AddNewIon(FairIon* ion) { fIons->Add(ion); }
    void AddNewParticle(FairParticle* Particle) { fParticles->Add(Particle); }
    TObjArray* GetUserDefIons();
    TObjArray* GetUserDefParticles();
 
    virtual void Init();
    virtual void Run(Int_t NEvents = 0, Int_t NotUsed = 0);
    void SetField(FairField* field);
    void SetGenerator(FairPrimaryGenerator* Gen);
 
    void SetMCEventHeader(FairMCEventHeader* McHeader) { fMCEvHead = McHeader; }
 
    void SetMaterials(const char* MatFileName);
 
    void SetStoreTraj(Bool_t storeTraj = kTRUE) { fStoreTraj = storeTraj; }
 
    Bool_t GetStoreTraj() const { return fStoreTraj; }
 
    void SetTrackingDebugMode(Bool_t set)
    {
        if (fApp) {
            fApp->SetTrackingDebugMode(set);
        }
    }
 
    void SetGeoModel(char* name);
 
    TString* GetGeoModel() { return fLoaderName; }
 
    FairField* GetField() { return fField; }
 
    FairMCEventHeader* GetMCEventHeader();
 
    TObjArray* GetListOfModules() { return ListOfModules; }
 
    FairPrimaryGenerator* GetPrimaryGenerator() { return fGen; }
 
    void SetPythiaDecayer(Bool_t decayer) { fPythiaDecayer = decayer; }
 
    void SetPythiaDecayer(const TString& Config);
 
    void SetUserDecay(const TString& Config);
 
    void SetUserDecay(Bool_t decay) { fUserDecay = decay; }
 
    Bool_t IsExtDecayer() { return fPythiaDecayer; }
 
    Bool_t IsUserDecay() { return fUserDecay; }
 
    void SetRadLenRegister(Bool_t value) { fRadLength = value; }
 
    void SetRadMapRegister(Bool_t value) { fRadMap = value; }
 
    void SetRadGridRegister(Bool_t value) { fRadGrid = value; }
 
    void AddMesh(FairMesh* Mesh);
 
    void SetUserConfig(const TString& Config) { fUserConfig = Config; }
    TString GetUserConfig() { return fUserConfig; }
 
    void SetUserCuts(const TString& Cuts) { fUserCuts = Cuts; }
    TString GetUserCuts() { return fUserCuts; }
 
    void SetBeamMom(Double_t BeamMom)
    {
        fBeamMom = BeamMom;
        fUseBeamMom = kTRUE;
    }
 
    Double_t GetBeamMom() { return fBeamMom; }
 
    Bool_t UseBeamMom() { return fUseBeamMom; }
 
    void SetSimSetup(std::function<void()> f)
    {
        fSimSetup = f;
        fUseSimSetupFunction = true;
    }
 
    void SetSimulationConfig(FairGenericVMCConfig* tconf) { fSimulationConfig = tconf; }
    FairGenericVMCConfig* GetSimulationConfig() { return fSimulationConfig; }
 
    void SetIsMT(Bool_t isMT) { fIsMT = isMT; }
    Bool_t IsMT() const { return fIsMT; }
 
    void SetImportTGeoToVMC(Bool_t v) { fImportTGeoToVMC = v; }
    Bool_t IsImportTGeoToVMC() const { return fImportTGeoToVMC; }
 
    void StopMCRun() { fApp->StopMCRun(); }
 
  private:
    FairRunSim(const FairRunSim& M);
    FairRunSim& operator=(const FairRunSim&) { return *this; }
    void SetMCConfig();
    void CheckFlukaExec();
 
  protected:
    Int_t count;                                    
    FairMCApplication* fApp;                        
    Double_t fBeamMom;                              
    Bool_t fUseBeamMom;                             
    FairPrimaryGenerator* fGen;                     
    FairMCEventHeader* fMCEvHead;                   
    static TMCThreadLocal FairRunSim* fginstance;   
    FairField* fField;                              
    const char* fMapName;                           
    TObjArray* fIons;                               
    TObjArray* fParticles;                          
    TObjArray* ListOfModules;                       
    TString MatFname;                               
    Bool_t fStoreTraj;                              
    TString* fLoaderName;                           
    Bool_t fPythiaDecayer;                          
    TString fPythiaDecayerConfig;                   
    Bool_t fUserDecay;                              
    TString fUserDecayConfig;                       
    Bool_t fRadLength;                              
    Bool_t fRadMap;                                 
    Bool_t fRadGrid;                                
    TObjArray* fMeshList;                           
    TString fUserConfig;                            
    TString fUserCuts;                              
    Bool_t fIsMT;                                   
    Bool_t fImportTGeoToVMC;                        
    std::function<void()> fSimSetup;   
    bool fUseSimSetupFunction = false;
    FairGenericVMCConfig* fSimulationConfig;   
 
    ClassDef(FairRunSim, 2);
};
 
#endif   // FAIRRUNSIM_H