FairRunAna.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file FairRunAna.h

#ifndef FAIRRUNANA_H
#define FAIRRUNANA_H


#include "FairRun.h"
#include "FairRunInfo.h"
#include "FairRootManager.h"

#include "TProof.h"
#include "TString.h"
#include <iostream>

class FairRuntimeDb;
class FairEventHeader;
class FairMCEventHeader;
class FairField;
class TFile;
class FairLogger;
class TF1;
class TTree;

class FairRunAna : public FairRun
{

  public:

    static FairRunAna* Instance();
    virtual ~FairRunAna();
    FairRunAna();
    FairRunAna(const char* type, const char* proofName="");
    void        AddFriend(TString fName);
    virtual void        Init();
    virtual void        Run(Int_t NStart ,Int_t NStop);
    void        Run(Double_t delta_t);
    void        Run(Long64_t entry);
    void        RunOneEvent(Long64_t entry);
    void        RunMixed(Int_t NStart, Int_t NStop);
    void        RunTSBuffers();
    void        DummyRun(Int_t NStart ,Int_t NStop);
    void        RunOnProof(Int_t NStart, Int_t NStop);
    void        RunOnLmdFiles(UInt_t NStart=0, UInt_t NStop=0);
    void        TerminateRun();
    void        SetSignalFile(TString name, UInt_t identifier );
    void        SetBackgroundFile(TString name);
    void        AddBackgroundFile(TString name);
    void        AddSignalFile(TString name, UInt_t identifier );
    virtual void        SetInputFile(TString fname);
    void        AddFile(TString name);

    void        Reinit(UInt_t runId);
    UInt_t      getRunId() {
      return fRunId;
    }
    FairField*  GetField() {
      return fField;
    }
    void        SetField (FairField* ffield ) {
      fField=ffield ;
    }
    void        SetGeomFile(const char* GeoFileName);
    TFile*      GetGeoFile() {
      return fInputGeoFile;
    }
    void        InitContainers();

    void        SetInTree (TTree* tempTree)   {
      fRootManager->SetInTree (tempTree);
    }

    void        SetContainerStatic(Bool_t tempBool=kTRUE);
    Bool_t      GetContainerStatic() { return fStatic; };
    void        RunWithTimeStamps();
    Bool_t      IsTimeStamp() {
      return fTimeStamps;
    }
    void        CompressData();

    void SetEventTimeInterval(Double_t min, Double_t max);

    void SetEventMeanTime(Double_t mean);

    void BGWindowWidthNo(UInt_t background, UInt_t Signalid);
    void BGWindowWidthTime(Double_t background, UInt_t Signalid);

    TProof* GetProof() { return fProof;}

    void SetRunOnProofWorker(Bool_t tb = kTRUE) {
      fRunOnProofWorker = tb;
    }
    void SetProofParName(TString parName) {
      fProofParName = parName;
    }
    void SetOutputDirectory(TString dirName) {
      fOutputDirectory = dirName;
    }
    void SetProofOutputStatus(TString outStat) {
      fProofOutputStatus = outStat;
    }

    void StopProcessingLMD( void ) {
      fFinishProcessingLMDFile = kTRUE;
    }
    Bool_t GetLMDProcessingStatus( void ) {
      return fFinishProcessingLMDFile;
    }


  private:

    FairRunAna(const FairRunAna& M);
    FairRunAna& operator= (const  FairRunAna&) {
      return *this;
    }

 protected:
    FairRunInfo fRunInfo;

  protected:
    Bool_t                                  fIsInitialized;
    TFile*                                  fInputGeoFile;
    static FairRunAna*                      fgRinstance;
    Bool_t                                  fLoadGeo;
    FairEventHeader*                        fEvtHeader;
    FairMCEventHeader*                      fMCHeader;

    Bool_t                                  fStatic;
    FairField*                              fField;
    Bool_t                                  fTimeStamps;
    Bool_t                                  fInFileIsOpen;

    Bool_t                                  fMixedInput;

    Double_t                                fEventTimeMin;  

    Double_t                                fEventTimeMax;  

    Double_t                                fEventTime;     

    Double_t                                fEventMeanTime; 

    TF1*                                    fTimeProb;      

    TProof*                                 fProof;
    Bool_t                                  fProofAnalysis; 

    Bool_t                                  fRunOnProofWorker; 

    TString                                 fProofServerName; 

    TString                                 fProofParName; 

    TString                                 fOutputDirectory; 

    TString                                  fProofOutputStatus;
    Bool_t                                   fFinishProcessingLMDFile;  

    ClassDef(FairRunAna ,4)

};

#endif //FAIRRUNANA_H