da/d79/FairRunSim_8h_source.html

#ifndef FAIRRUNSIM_H

#define FAIRRUNSIM_H


#include "FairRun.h"


#include "FairMCApplication.h"

#include "FairIon.h"

#include "FairParticle.h"

#include "TObjArray.h"

#include "TString.h"

#include <iostream>


class FairModule;

class FairField;

class FairPrimaryGenerator;

class FairMCEventHeader;

class FairMesh;


class FairRunSim : public FairRun

{

  public:

    FairRunSim();

    virtual ~FairRunSim();

    static FairRunSim* Instance();

    virtual 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;}


    virtual void    SetMaterials(const char* MatFileName);


    void SetStoreTraj(Bool_t storeTraj=kTRUE) {fStoreTraj = storeTraj;}


    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;}


    void SetUserCuts(const TString& Cuts) {fUserCuts= Cuts;}


    void SetBeamMom(Double_t BeamMom) {  fBeamMom= BeamMom; fUseBeamMom=kTRUE;}


    Double_t GetBeamMom() {return fBeamMom;}


    Bool_t UseBeamMom() {return fUseBeamMom;}

    void SetFieldContainer();

  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 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;


    ClassDef(FairRunSim ,2)


};


#endif //FAIRRUNSIM_H