FairMCApplication.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"                       *
 ********************************************************************************/
// -------------------------------------------------------------------------
// -----               FairMCApplication header file                   -----
// -----            Created 06/01/04  by M. Al-Turany                  -----
// -------------------------------------------------------------------------
 
#ifndef FAIR_MC_APPLICATION_H
#define FAIR_MC_APPLICATION_H
 
#include "FairRunInfo.h"   // for FairRunInfo
 
#include <Rtypes.h>                  // for Int_t, Bool_t, Double_t, etc
#include <TLorentzVector.h>          // for TLorentzVector
#include <TString.h>                 // for TString
#include <TVirtualMCApplication.h>   // for TVirtualMCApplication
#include <list>                      // for list
#include <map>                       // for map, multimap, etc
 
class FairDetector;
class FairEventHeader;
class FairField;
class FairGenericStack;
class FairMCEventHeader;
class FairPrimaryGenerator;
class FairRadGridManager;
class FairRadLenManager;
class FairRadMapManager;
class FairRootManager;
class FairTask;
class FairTrajFilter;
class FairVolume;
class FairRunSim;
class TChain;
class TIterator;
class TObjArray;
class TRefArray;
class TTask;
class TVirtualMC;
 
enum class FairMCApplicationState
{
    kUnknownState,
    kConstructGeometry,
    kInitGeometry
};
 
class FairMCApplication : public TVirtualMCApplication
{
  public:
    FairMCApplication(const char* name, const char* title, TObjArray* ModList, const char* MatName);
    FairMCApplication();
    virtual ~FairMCApplication();
    static FairMCApplication* Instance();
    virtual void AddDecayModes();
    virtual void AddParticles();   // MC Application
    virtual void AddIons();   // MC Application
    void AddTask(TTask* fTask);
    virtual void BeginEvent();   // MC Application
    virtual void BeginPrimary();   // MC Application
    virtual void ConstructGeometry();   // MC Application
    virtual Bool_t MisalignGeometry();
    virtual void ConstructOpGeometry();   // MC Application
    virtual void FinishEvent();   // MC Application
    virtual void FinishPrimary();   // MC Application
    void FinishRun();
    virtual void GeneratePrimaries();   // MC Application
    FairDetector* GetDetector(const char* DetName);
    FairField* GetField() { return fxField; }
    FairPrimaryGenerator* GetGenerator();
    TTask* GetListOfTasks();
    FairGenericStack* GetStack();
    TChain* GetChain();
    virtual void InitGeometry();   // MC Application
    void InitMC(const char* setup, const char* cuts);
    void InitTasks();
    virtual void PostTrack();   // MC Application
    virtual void PreTrack();   // MC Application
 
    virtual TVirtualMCApplication* CloneForWorker() const;
 
    virtual void InitOnWorker();
 
    virtual void FinishRunOnWorker();
 
    void RunMC(Int_t nofEvents);
    void SetField(FairField* field);
    void SetGenerator(FairPrimaryGenerator* fxGenerator);
    void SetParTask();
    void SetPythiaDecayer(Bool_t decayer) { fPythiaDecayer = decayer; }
    void SetPythiaDecayerConfig(const TString decayerConf) { fPythiaDecayerConfig = decayerConf; }
    void SetRadiationLengthReg(Bool_t RadLen);
    void SetRadiationMapReg(Bool_t RadMap);
    void SetTrackingDebugMode(Bool_t set) { fDebug = set; }
    void SetUserDecay(Bool_t decay) { fUserDecay = decay; }
    void SetUserDecayConfig(const TString decayerConf) { fUserDecayConfig = decayerConf; }
    virtual void Stepping();   // MC Application
    virtual void StopRun();
    virtual void StopMCRun();
    virtual Double_t TrackingRmax() const;   // MC Application
    virtual Double_t TrackingZmax() const;   // MC Application
 
    void AddMeshList(TObjArray* meshList);
 
    void SetSaveCurrentEvent(Bool_t set) { fSaveCurrentEvent = set; }
 
    FairMCApplicationState GetState() const { return fState; }
 
  private:
    // methods
    Int_t GetIonPdg(Int_t z, Int_t a) const;
 
    void UndoGeometryModifications();
 
  protected:
    // data members
    TRefArray* fActiveDetectors;
    FairTask* fFairTaskList;   
    TRefArray* fDetectors;
    TRefArray* fDetMap;
    TIterator* fModIter;   
    TObjArray* fModules;
    Int_t fNoSenVolumes;   
    Bool_t fPythiaDecayer;
    TString fPythiaDecayerConfig;   
    FairGenericStack* fStack;   
    FairRootManager* fRootManager;   
    TRefArray* fSenVolumes;   
    FairField* fxField;   //
    FairPrimaryGenerator* fEvGen;   //
    Int_t fMcVersion;   // mc Version
    FairTrajFilter* fTrajFilter;   
    Bool_t fTrajAccepted;   
    Bool_t fUserDecay;
    TString fUserDecayConfig;   
    Bool_t fDebug;   
    FairVolume* fDisVol;
    FairDetector* fDisDet;
    std::multimap<Int_t, FairVolume*> fVolMap;   
    std::multimap<Int_t, FairVolume*>::iterator fVolIter;   
    std::map<Int_t, Int_t> fModVolMap;   
    std::map<Int_t, Int_t>::iterator fModVolIter;   
    TLorentzVector fTrkPos;                         
    Bool_t fRadLength;   
 
    FairRadLenManager* fRadLenMan;   
    Bool_t fRadMap;   
    FairRadMapManager* fRadMapMan;   
    FairRadGridManager* fRadGridMan;   
 
    FairEventHeader* fEventHeader;   
 
    FairMCEventHeader* fMCEventHeader;   
    std::list<FairDetector*> listActiveDetectors;   
    std::list<FairDetector*> listDetectors;   
    TVirtualMC* fMC;
    FairRunSim* fRun;
 
    Bool_t fSaveCurrentEvent;
 
    FairMCApplicationState fState;   
 
    ClassDef(FairMCApplication, 4);
 
  private:
    FairMCApplication(const FairMCApplication&);
    FairMCApplication& operator=(const FairMCApplication&);
 
    FairRunInfo fRunInfo;   
    Bool_t fGeometryIsInitialized;
 
    static FairMCApplication* fgMasterInstance;
};
 
// inline functions
 
inline FairMCApplication* FairMCApplication::Instance()
{
    return static_cast<FairMCApplication*>(TVirtualMCApplication::Instance());
}
 
#endif