FairTask.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"                       *
 ********************************************************************************/
// -------------------------------------------------------------------------
// -----                      FairTask header file                      -----
// -----          Created 12/01/04  by M. Al-Turany / D. Bertini       -----
// -------------------------------------------------------------------------

#ifndef FAIRTASK_H
#define FAIRTASK_H

#include "FairRootManager.h"   // for FairRootManager

#include <Rtypes.h>    // for Int_t, FairTask::Class, etc
#include <TString.h>   // for TString
#include <TTask.h>     // for TTask
#include <map>

class FairLogger;

enum InitStatus
{
    kSUCCESS,
    kERROR,
    kFATAL
};

class FairTask : public TTask
{
  public:
    FairTask();

    FairTask(const char* name, Int_t iVerbose = 1);

    virtual ~FairTask();

    void InitTask();

    void ReInitTask();

    void SetParTask();

    virtual void FinishTask();

    virtual void FinishEvent();

    void SetVerbose(Int_t iVerbose);

    void SetInputPersistance(Bool_t val) { fInputPersistance = val; }

    void CheckInputPersistance(TString branchName)
    {
        FairRootManager* ioman = FairRootManager::Instance();
        fInputPersistance = ioman->CheckBranch(branchName);
    }

    virtual void ExecuteTask(Option_t* option = "0");   // *MENU*

    void SetOutputBranchPersistent(TString, Bool_t);

    Bool_t IsOutputBranchPersistent(TString);

    void SetStreamProcessing(Bool_t val = kTRUE) { fStreamProcessing = val; }

  protected:
    Int_t fVerbose;            //  Verbosity level
    Int_t fInputPersistance;   
    FairLogger* fLogger;       
    Bool_t fStreamProcessing;

    virtual InitStatus Init() { return kSUCCESS; };

    virtual InitStatus ReInit() { return kSUCCESS; };

    virtual void SetParContainers(){};

    virtual void Finish(){};

    void InitTasks();

    void ReInitTasks();

    virtual void ExecuteTasks(Option_t* option);

    void SetParTasks();

    void FinishTasks();

    void FinishEvents();

  private:
    std::map<TString, Bool_t> fOutputPersistance;

    FairTask(const FairTask&);
    FairTask& operator=(const FairTask&);

    ClassDef(FairTask, 4);
};

#endif