HLT/BASE/AliHLTTTreeProcessor.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTTTREEPROCESSOR_H
   5 #define ALIHLTTTREEPROCESSOR_H
   6 //* This file is property of and copyright by the ALICE HLT Project        *
   7 //* ALICE Experiment at CERN, All rights reserved.                         *
   8 //* See cxx source for full Copyright notice                               *
   9
  10 /// @file   AliHLTTTreeProcessor.h
  11 /// @author Timur Pocheptsov, Matthias Richter
  12 /// @date   05.07.2010
  13 /// @brief  Generic component for data collection in a TTree
  14
  15 #include <list>
  16
  17 #include <TString.h>
  18
  19 #include "AliHLTProcessor.h"
  20
  21 class TTree;
  22 class TH1;
  23 class TStopwatch;
  24
  25 /**
  26  * @class AliHLTTTreeProcessor
  27  * Generic component for data collection in a TTree, or as a special case
  28  * in a TNtuple (which is a tree with only float branches). Child components
  29  * implement the creation and filling of the tree, which is dependent on the
  30  * data itself.
  31  *
  32  * Child components have to implement the basic component property methods
  33  * like GetComponentID(), GetInputDataTypes(), and Spawn(). Default
  34  * implementations of GetOutputDataSize() and GetOutputDataType() are already
  35  * provided by the base class.
  36  *
  37  * The base class keeps a circular TTree of a specific event count. Histograms
  38  * are periodically generated by applying a table of selections and cuts. The
  39  * table can be configured and changed at run-time and the data sample in the
  40  * tree can be reset.
  41  *
  42  * @ingroup alihlt_base
  43  */
  44 class AliHLTTTreeProcessor : public AliHLTProcessor {
  45 private:
  46   enum EDefaults {
  47     kMaxEntries = 1000,
  48     kDefaultNBins = 200,
  49     kInterval = 5
  50   };
  51 public:
  52   /// default constructor
  53   AliHLTTTreeProcessor();
  54   /// destructor
  55   virtual ~AliHLTTTreeProcessor();
  56
  57   /// inherited from AliHLTComponent, get the output data type
  58   virtual AliHLTComponentDataType GetOutputDataType();
  59
  60   /// inherited from AliHLTComponent, get the output data size estimator
  61   virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
  62
  63 protected:
  64   /// initialization, overloaded from AliHLTComponent
  65   int DoInit(int argc, const char** argv);
  66   /// deinitialization, overloaded from AliHLTComponent
  67   int DoDeinit();
  68   /// inherited from AliHLTProcessor, data processing
  69   int DoEvent(const AliHLTComponentEventData& evtData,
  70               AliHLTComponentTriggerData& trigData);
  71   using AliHLTProcessor::DoEvent;
  72
  73   class AliHLTHistogramDefinition {
  74   public:
  75     AliHLTHistogramDefinition()
  76         : fName(), fSize(0), fExpr(), fCut(), fOpt()
  77     {
  78     }
  79
  80         const TString& GetName()const{return fName;}
  81         void SetName(const TString& name){fName = name;}
  82
  83         int GetSize()const{return fSize;}
  84         void SetSize(int size){fSize = size;}
  85
  86         const TString& GetExpression()const{return fExpr;}
  87         void SetExpression(const TString& expr){fExpr = expr;}
  88
  89         const TString& GetCut()const{return fCut;}
  90         void SetCut(const TString& cut){fCut = cut;}
  91
  92         const TString& GetDrawOption()const{return fOpt;}
  93         void SetDrawOption(const TString& opt){fOpt = opt;}
  94
  95   private:
  96
  97     TString fName;
  98     int     fSize;
  99     TString fExpr;
 100     TString fCut;
 101     TString fOpt;
 102   };
 103
 104   std::list<AliHLTHistogramDefinition> fDefinitions;
 105   typedef std::list<AliHLTHistogramDefinition>::iterator list_iterator;
 106   typedef std::list<AliHLTHistogramDefinition>::const_iterator list_const_iterator;
 107
 108
 109 private:
 110   /// inherited from AliHLTComponent, scan argument
 111   int ScanConfigurationArgument(int argc, const char** argv);
 112   /// create the tree instance and all branches
 113   virtual TTree* CreateTree(int argc, const char** argv) = 0;
 114   /// process input blocks and fill tree
 115   virtual int FillTree(TTree* pTree, const AliHLTComponentEventData& evtData,
 116                        AliHLTComponentTriggerData& trigData ) = 0;
 117   /// dtOrigin for PushBack.
 118   virtual AliHLTComponentDataType GetOriginDataType()const = 0;
 119   /// spec for PushBack
 120   virtual AliHLTUInt32_t GetDataSpec()const {return fUniqueId;}
 121   /// default histogram definitions.
 122   virtual void FillHistogramDefinitions() = 0;
 123
 124   /// create a histogram from the tree
 125   TH1* CreateHistogram(const AliHLTHistogramDefinition& def);
 126   /// parse arguments, containing histogram definition.
 127   int ParseHistogramDefinition(int argc, const char** argv, int pos, AliHLTHistogramDefinition& dst)const;
 128
 129   /// the TTree
 130   TTree* fTree; //! the tree instance
 131   /// max entries
 132   int fMaxEntries; //! maximum number of entries in the circular tree
 133   /// publish interval in s
 134   unsigned fPublishInterval; //! publish interval in s
 135   /// time stamp - publish or not.
 136   unsigned fLastTime; //! last time the histogramms were published
 137
 138   TStopwatch* fpEventTimer; //! stopwatch for event processing
 139   TStopwatch* fpCycleTimer; //! stopwatch for event cycle
 140   AliHLTUInt32_t fMaxMemory; //! maximum memory consumption allowed for the process
 141   AliHLTUInt32_t fMaxEventTime; //! allowed maximum processing time in usec
 142   AliHLTUInt32_t fNofEventsForce; //! number of events to ignore the processing time
 143   AliHLTUInt32_t fForcedEventsCount; //! event count for the forced events
 144   AliHLTUInt32_t fSkippedEventsCount; //! number of skipped events
 145   AliHLTUInt32_t fNewEventsCount; //! number of new events since last publishing
 146   AliHLTUInt32_t fUniqueId; //! a unique id for this process used to identify the output of multiple processes
 147   AliHLTUInt32_t fIgnoreCycleTime; //! ignore cycle time for n seconds
 148   float          fCycleTimeFactor; //! weight for the cycle time
 149
 150   static const AliHLTUInt32_t fgkTimeScale;
 151
 152   /// copy constructor prohibited
 153   AliHLTTTreeProcessor(const AliHLTTTreeProcessor&);
 154   /// assignment operator prohibited
 155   AliHLTTTreeProcessor& operator = (const AliHLTTTreeProcessor&);
 156
 157   ClassDef(AliHLTTTreeProcessor, 0)
 158 };
 159 #endif