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"                       *
 ********************************************************************************/
#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 FairRuntimeDb;
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; }
    FairRuntimeDb* GetRuntimeDb(void) { return fRtdb; }
    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;
    FairRuntimeDb* fRtdb;
    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