FairMonitor.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"                       *
 ********************************************************************************/
 
/*
 * FairMonitor.h
 *
 *  Created on: Aug 01, 2015
 *      Author: r.karabowicz
 */
 
#ifndef BASE_FAIRMONITOR_H_
#define BASE_FAIRMONITOR_H_
 
#include <Rtypes.h>
#include <TNamed.h>
#include <TStopwatch.h>
#include <map>
 
class TCanvas;
class TFile;
class TList;
class TTask;
 
class FairMonitor : public TNamed
{
  public:
    static FairMonitor* GetMonitor();
 
    void EnableMonitor(Bool_t tempBool = kTRUE, TString fileName = "")
    {
        fRunMonitor = tempBool;
        fOutputFileName = fileName;
    }
    void EnableDrawing(Bool_t tempBool = kTRUE) { fDrawCanvas = tempBool; }
    Bool_t IsRunning() { return fRunMonitor; }
 
    void StartMonitoring(const TTask* tTask, const char* identStr)
    {
        StartTimer(tTask, identStr);
        StartMemoryMonitor(tTask, identStr);
    }
    void StopMonitoring(const TTask* tTask, const char* identStr)
    {
        StopTimer(tTask, identStr);
        StopMemoryMonitor(tTask, identStr);
    }
 
    void StartTimer(const TTask* tTask, const char* identStr);
    void StopTimer(const TTask* tTask, const char* identStr);
 
    void StartMemoryMonitor(const TTask* tTask, const char* identStr);
    void StopMemoryMonitor(const TTask* tTask, const char* identStr);
 
    void RecordInfo(const TTask* tTask, const char* identStr, Double_t value);
 
    void RecordRegister(const char* name, const char* folderName, Bool_t toFile);
    void RecordGetting(const char* name);
 
    void SetCurrentTask(TTask* tTask) { fCurrentTask = tTask; }
 
    virtual void Print(Option_t* option = "") const;
    virtual void Draw(Option_t* option = "");
 
    void PrintTask(TString specString) const;
    void PrintTask(TTask* tempTask, Int_t taskLevel = 0) const;
    void DrawHist(TString specString);
 
    TList* GetHistList() { return fHistList; }
 
    void StoreHistograms(TFile* sinkFile);
 
  private:
    static FairMonitor* instance;
    FairMonitor();
    ~FairMonitor();
    FairMonitor(const FairMonitor&);
    FairMonitor& operator=(const FairMonitor&);
 
    Bool_t fRunMonitor;
    Bool_t fDrawCanvas;
 
    Double_t fRunTime;
    Double_t fRunMem;
 
    std::map<TString, TStopwatch> fTimerMap;
    std::map<TString, Int_t> fMemoryMap;
 
    TList* fHistList;
    TCanvas* fCanvas;
 
    Int_t fNoTaskRequired;
    Int_t fNoTaskCreated;
 
    TTask* fCurrentTask;
 
    TString fOutputFileName;   // output file name, if empty then try to use FairSink to store histograms
 
    std::multimap<TString, TString> fTaskRequired;
    std::multimap<TString, TString> fTaskCreated;
    std::multimap<TString, TString> fTaskCreatedTemp;
 
    std::map<TString, Int_t> fObjectMap;
    std::map<TString, Int_t> fTaskMap;
 
    std::map<TString, std::pair<Double_t, Double_t>> fObjectPos;
    std::map<TString, std::pair<Double_t, Double_t>> fTaskPos;
 
    void GetTaskMap(TTask* tempTask);
    void AnalyzeObjectMap(TTask* tempTask);
 
    ClassDef(FairMonitor, 0);
};
 
extern FairMonitor* gMonitor;
 
#endif   // BASE_FAIRMONITOR_H_