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"                       *
 ********************************************************************************/
#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 SetFieldContainer();

    void SetSimSetup(std::function<void()> f)
    {
        fSimSetup = f;
        fUseSimSetupFunction = true;
    }
    void SetSimSetupPostInit(std::function<void()> f)
    {
        fSimSetupPostInit = f;
        fUseSimSetupPostInitFunction = 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;
    std::function<void()> fSimSetupPostInit;   
    bool fUseSimSetupPostInitFunction = false;
    FairGenericVMCConfig* fSimulationConfig;   

    ClassDef(FairRunSim, 2);
};

#endif   // FAIRRUNSIM_H