dc/d59/FairMCApplication_8h_source.html

// -------------------------------------------------------------------------

// -----               FairMCApplication header file                   -----

// -----            Created 06/01/04  by M. Al-Turany                  -----

// -------------------------------------------------------------------------


#ifndef FAIR_MC_APPLICATION_H

#define FAIR_MC_APPLICATION_H


#include "TVirtualMCApplication.h"

#include "TLorentzVector.h"

#include "FairTask.h"

#include "FairRunInfo.h"


#include <map>


class FairRootManager;

class FairGenericStack;

class FairModule;

class FairLogger;

class FairDetector;

class FairField;

class FairPrimaryGenerator;

class FairTrajFilter;

class FairVolume;

class FairRadLenManager;

class FairRadGridManager;

class FairRadMapManager;

class FairEventHeader;

class FairMCEventHeader;


class TChain;

class TRefArray;

class TObjArray;

class TTask;


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 void          ConstructOpGeometry();                            // MC Application

#if ROOT_VERSION_CODE < 333824


    virtual void          Field(const Double_t* x, Double_t* b) const;      // MC Application

#endif


    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

    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 Double_t      TrackingRmax() const;                             // MC Application

    virtual Double_t      TrackingZmax() const;                              // MC Application


    void AddMeshList ( TObjArray* meshList );


  private:

    // methods

    void RegisterStack();


    Int_t GetIonPdg(Int_t z, Int_t a) const;


    // data members

    TIterator*           fActDetIter;


    TRefArray*           fActiveDetectors;

    FairTask*             fFairTaskList;


    TIterator*           fDetIter;


    TRefArray*           fDetectors;

    TRefArray*           fDetMap;

    FairLogger*          fLogger;


    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;


 protected:

    std::map <Int_t, Int_t > fModVolMap;


    std::map <Int_t, Int_t >::iterator fModVolIter;

 private:

    TLorentzVector fTrkPos;


    Bool_t   fRadLength;


    FairRadLenManager*  fRadLenMan;


    Bool_t   fRadMap;


    FairRadMapManager*  fRadMapMan;


    FairRadGridManager* fRadGridMan;


    FairEventHeader*    fEventHeader;


    FairMCEventHeader*  fMCEventHeader;


    ClassDef(FairMCApplication,2)  //Interface to MonteCarlo application


  private:

    FairMCApplication(const FairMCApplication&);

    FairMCApplication& operator=(const FairMCApplication&);


    FairRunInfo fRunInfo;

};


// inline functions


inline FairMCApplication* FairMCApplication::Instance()

{ return (FairMCApplication*)(TVirtualMCApplication::Instance());}


#endif