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   /// inherited from AliHLTComponent, scan argument
  73   virtual int ScanConfigurationArgument(int argc, const char** argv);
  74
  75   class AliHLTHistogramDefinition {
  76   public:
  77     AliHLTHistogramDefinition()
  78         : fName(), fSize(0), fExpr(), fCut(), fOpt()
  79     {
  80     }
  81
  82         const TString& GetName()const{return fName;}
  83         void SetName(const TString& name){fName = name;}
  84
  85         int GetSize()const{return fSize;}
  86         void SetSize(int size){fSize = size;}
  87
  88         const TString& GetExpression()const{return fExpr;}
  89         void SetExpression(const TString& expr){fExpr = expr;}
  90
  91         const TString& GetCut()const{return fCut;}
  92         void SetCut(const TString& cut){fCut = cut;}
  93
  94         const TString& GetDrawOption()const{return fOpt;}
  95         void SetDrawOption(const TString& opt){fOpt = opt;}
  96
  97   private:
  98
  99     TString fName;
 100     int     fSize;
 101     TString fExpr;
 102     TString fCut;
 103     TString fOpt;
 104   };
 105
 106   std::list<AliHLTHistogramDefinition> fDefinitions;
 107   typedef std::list<AliHLTHistogramDefinition>::iterator list_iterator;
 108   typedef std::list<AliHLTHistogramDefinition>::const_iterator list_const_iterator;
 109
 110 private:
 111   /// create the tree instance and all branches
 112   virtual TTree* CreateTree(int argc, const char** argv) = 0;
 113   /// process input blocks and fill tree
 114   virtual int FillTree(TTree* pTree, const AliHLTComponentEventData& evtData,
 115                        AliHLTComponentTriggerData& trigData ) = 0;
 116   /// dtOrigin for PushBack.
 117   virtual AliHLTComponentDataType GetOriginDataType()const = 0;
 118   /// spec for PushBack
 119   virtual AliHLTUInt32_t GetDataSpec()const {return fUniqueId;}
 120   /// default histogram definitions.
 121   virtual void FillHistogramDefinitions() = 0;
 122
 123   /// create a histogram from the tree
 124   TH1* CreateHistogram(const AliHLTHistogramDefinition& def);
 125   /// parse arguments, containing histogram definition.
 126   int ParseHistogramDefinition(int argc, const char** argv, int pos, AliHLTHistogramDefinition& dst)const;
 127
 128   /// the TTree
 129   TTree* fTree; //! the tree instance
 130   /// max entries
 131   int fMaxEntries; //! maximum number of entries in the circular tree
 132   /// publish interval in s
 133   unsigned fPublishInterval; //! publish interval in s
 134   /// time stamp - publish or not.
 135   unsigned fLastTime; //! last time the histogramms were published
 136
 137   TStopwatch* fpEventTimer; //! stopwatch for event processing
 138   TStopwatch* fpCycleTimer; //! stopwatch for event cycle
 139   AliHLTUInt32_t fMaxMemory; //! maximum memory consumption allowed for the process
 140   AliHLTUInt32_t fMaxEventTime; //! allowed maximum processing time in usec
 141   AliHLTUInt32_t fNofEventsForce; //! number of events to ignore the processing time
 142   AliHLTUInt32_t fForcedEventsCount; //! event count for the forced events
 143   AliHLTUInt32_t fSkippedEventsCount; //! number of skipped events
 144   AliHLTUInt32_t fNewEventsCount; //! number of new events since last publishing
 145   AliHLTUInt32_t fUniqueId; //! a unique id for this process used to identify the output of multiple processes
 146   AliHLTUInt32_t fIgnoreCycleTime; //! ignore cycle time for n seconds
 147   float          fCycleTimeFactor; //! weight for the cycle time
 148
 149   static const AliHLTUInt32_t fgkTimeScale;
 150
 151   /// copy constructor prohibited
 152   AliHLTTTreeProcessor(const AliHLTTTreeProcessor&);
 153   /// assignment operator prohibited
 154   AliHLTTTreeProcessor& operator = (const AliHLTTTreeProcessor&);
 155
 156   ClassDef(AliHLTTTreeProcessor, 0)
 157 };
 158 #endif