- memory leak fixed, created histograms were not deleted
[u/mrichter/AliRoot.git] / 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