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