FairRun.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"                       *
 ********************************************************************************/
// Modified for ALICE O2 in 2026: parts not used by O2 were removed (see README.md in this directory).
#ifndef FAIRRUN_H
#define FAIRRUN_H
 
#include "FairAlignmentHandler.h"
#include "FairRootManager.h"
 
#include <Rtypes.h>   // for Int_t, Bool_t, etc
#include <TMCtls.h>   // for multi-threading
#include <TNamed.h>   // for TNamed
#include <TString.h>
#include <map>
#include <string>
 
class FairEventHeader;
class FairFileHeader;
class FairSink;
class FairTask;
class TFile;
class FairField;
class TGeoHMatrix;
 
class FairRun : public TNamed
{
    friend class FairMCApplication;
 
  public:
    FairRun(Bool_t isMaster = kTRUE);
    virtual ~FairRun();
    static FairRun* Instance();
    virtual void AddTask(FairTask* t);
    virtual void StoreTaskNames(const FairTask* t);
    virtual void SetTask(FairTask* t);
    virtual void Init() = 0;
    /*
     * Get the magnetic field *
     */
    virtual FairField* GetField() = 0;
    virtual void Run(Int_t NStart = 0, Int_t NStop = 0) = 0;
    void SetEventHeader(FairEventHeader* EvHeader) { fEvtHeader = EvHeader; }
    void SetSink(FairSink* tempSink)
    {
        fSink = tempSink;
        fRootManager->SetSink(tempSink);
        fUserOutputFileName = fSink->GetFileName();
    }
    FairSink* GetSink() { return fSink; }
    Int_t GetRunId() { return (static_cast<Int_t>(fRunId)); }
 
    void SetRunId(UInt_t runId) { fRunId = runId; }
 
    FairEventHeader* GetEventHeader();
    Bool_t IsAna() { return fAna; }
    FairTask* GetTask(const char* taskName);
    FairTask* GetMainTask() { return fTask; }
    Int_t GetNTasks() { return fNTasks; }
 
    void CreateGeometryFile(const char* geofile);
 
    //** Set if RunInfo file should be written */
    void SetWriteRunInfoFile(Bool_t write);
 
    //** Set if RunInfo should be generated */
    void SetGenerateRunInfo(Bool_t write) { fGenerateRunInfo = write; }
 
    //** Get info if RunInfo file is written */
    Bool_t GetWriteRunInfoFile();
 
    //** Get info if RunInfo file is written */
    Bool_t IsRunInfoGenerated() { return fGenerateRunInfo; }
 
    //** Switches the use of FairLinks */
    void SetUseFairLinks(Bool_t val);
 
    //** Get info if run on master */
    Bool_t GetIsMaster() const { return fIsMaster; }
 
    //** Mark/Unmark event to be filled into output. Default is TRUE. */
    void MarkFill(Bool_t flag) { fMarkFill = flag; }
 
    //** Get option string */
    TString GetOptions() { return fOptions; };
 
    //** Set option string */
    void SetOptions(const TString& s) { fOptions = s; };
 
    // vvvvvvvvvv depracted functions, replaced by FairSink vvvvvvvvvv
    virtual void SetOutputFile(const char* fname);
    virtual void SetOutputFile(TFile* f);
    void SetOutputFileName(const TString& name);
    TFile* GetOutputFile();
    // ^^^^^^^^^^ depracted functions, replaced by FairSink ^^^^^^^^^^
 
    void SetUserOutputFileName(const TString& name);
    TString GetUserOutputFileName() const;
 
    void AddAlignmentMatrices(const std::map<std::string, TGeoHMatrix>& alignmentMatrices, bool invertMatrices = false);
 
  private:
    FairRun(const FairRun& M);
    FairRun& operator=(const FairRun&) { return *this; }
    Int_t fNTasks;
 
  protected:
    static TMCThreadLocal FairRun* fRunInstance;
    FairTask* fTask;
    FairRootManager* fRootManager;
    FairSink* fSink;
    TString fUserOutputFileName;
    TString fOptions;
    UInt_t fRunId;   
    Bool_t fAna;   
    FairEventHeader* fEvtHeader;   
    FairFileHeader* fFileHeader;
    Bool_t fGenerateRunInfo;   
    Bool_t fIsMaster;   
 
    Bool_t fMarkFill;   
 
    FairAlignmentHandler fAlignmentHandler;
 
    void AlignGeometry() const;
 
    ClassDef(FairRun, 5);
};
#endif   // FAIRRUN_H