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