Updated macros for PHOS alignment calculation
[u/mrichter/AliRoot.git] / HLT / trigger / AliHLTTriggerCounterComponent.h
1 //-*- Mode: C++ -*-
2 // $Id: $
3 #ifndef ALIHLTTRIGGERCOUNTERCOMPONENT_H
4 #define ALIHLTTRIGGERCOUNTERCOMPONENT_H
5 /* This file is property of and copyright by the ALICE HLT Project        *
6  * ALICE Experiment at CERN, All rights reserved.                         *
7  * See cxx source for full Copyright notice                               */
8
9 /// \file   AliHLTTriggerCounterComponent.h
10 /// \author Artur Szostak <artursz@iafrica.com>
11 /// \date   3 Nov 2010
12 /// \brief  Declaration of the AliHLTTriggerCounterComponent component class.
13
14 #include "AliHLTProcessor.h"
15 #include "AliHLTTriggerCounters.h"
16 #include "THashTable.h"
17 #include "TTimeStamp.h"
18 #include "TMap.h"
19
20 /**
21  * \class AliHLTTriggerCounterComponent
22  * This component is used to calculate online the trigger counters and rates for
23  * output HLT and input CTP / HLT triggers. The component should be connected to
24  * all the global trigger component instances in the chain and there should be
25  * only one instance of AliHLTTriggerCounterComponent in the chain. If more instances
26  * of AliHLTTriggerCounterComponent exist in the chain then the statistics will not
27  * be calculated correctly.
28  *
29  * <h2>General properties:</h2>
30  *
31  * Component ID: \b HLTTriggerCounter <br>
32  * Library: \b libAliHLTTrigger.so   <br>
33  * Input Data Types:  kAliHLTDataTypeGlobalTrigger | kAliHLTDataTypeTriggerDecision <br>
34  * Output Data Types: kAliHLTDataTypeInputTriggerCounters | kAliHLTDataTypeOutputTriggerCounters <br>
35  *
36  * <h2>Mandatory arguments:</h2>
37  * None.
38  *
39  * <h2>Optional arguments:</h2>
40  * \li -config <i>filename</i> <br>
41  *      Indicates the configuration macro file to use for the initial trigger counter lists.
42  * \li -publishperiod <i>period</i> <br>
43  *      Sets the period between publishing of the trigger counters in seconds.
44  *      The default is to publish for every event.
45  * \li -skipcdb  <br>
46  *      If specified then the initial counter configuration is not loaded from the CDB.
47  * \li -countfalseinputs  <br>
48  *      Indicates that input triggers which have false decision results should also be counted.
49  * \li -countfalseoutputs  <br>
50  *      Indicates that output triggers which have false decision results should also be counted.
51  * \li -integrationtime <i>period</i> <br>
52  *      Sets the default maximum integration time in seconds to use for measuring the counter rates.
53  *
54  * <h2>Configuration:</h2>
55  * Can only be configured with the command line arguments.
56  *
57  * <h2>Default CDB entries:</h2>
58  * HLT/ConfigHLT/HLTTriggerCounter - Contains the initial counter configuration.
59  *
60  * <h2>Performance:</h2>
61  * Can run up to 1.8kHz in the HLT online system.
62  *
63  * <h2>Memory consumption:</h2>
64  * Negligible.
65  *
66  * <h2>Output size:</h2>
67  * Same order of magnitude as the input data size.
68  *
69  * \ingroup alihlt_tpc_components
70  */
71 class AliHLTTriggerCounterComponent : public AliHLTProcessor
72 {
73 public:
74         
75         AliHLTTriggerCounterComponent();
76         virtual ~AliHLTTriggerCounterComponent();
77         
78         // Methods inherited from AliHLTComponent:
79         virtual const char* GetComponentID();
80         virtual void GetInputDataTypes(AliHLTComponentDataTypeList& list);
81         virtual AliHLTComponentDataType GetOutputDataType();
82         virtual int GetOutputDataTypes(AliHLTComponentDataTypeList& list);
83         virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
84         virtual AliHLTComponent* Spawn();
85         virtual Int_t DoInit(int argc, const char** argv);
86         virtual Int_t DoDeinit();
87         
88         /**
89          * Returns a reference to the initial counter configuration to use.
90          * This should be used in the configuration file passed to the component with
91          * the -config option to setup the initial counter configuration. The following
92          * is an example of such a config file.
93          * \code
94          *   void SetupConfig() {
95          *     TMap& counters = AliHLTTriggerCounterComponent::InitialCounterConfig();
96          *     counters.Add(new TObjString("TRIGGER-A"), new TObjString("Some input trigger"));
97          *     TObjString* outname = new TObjString("TRIGGER-B");
98          *     outname->SetBit(1<<14);
99          *     counters.Add(outname, new TObjString("Some output trigger"));
100          *   }
101          * \endcode
102          */
103         static TMap& InitialCounterConfig()
104         {
105                 fgInitialCounterConfig.SetOwner(kTRUE); // Make sure its the owner of all objects.
106                 return fgInitialCounterConfig;
107         }
108         
109 protected:
110         
111         // Method inherited from AliHLTProcessor:
112         virtual int DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
113         using AliHLTProcessor::DoEvent;
114         
115 private:
116         
117         /// Implements a ring buffer for old counter and time stamp values.
118         class AliRingBuffer : public TObject
119         {
120         public:
121                 enum 
122                 {
123                         /// The maximum number of time stamp entries held in the ring buffers for rate calculations.
124                         /// The uncertainty in the rate should be ~ rate/sqrt(kTimeStampEntries)
125                         kTimeStampEntries = 100
126                 };
127                 
128                 /// Constructor initialises the buffer
129                 AliRingBuffer(const char* counterName, Double_t startTime, Double_t maxIntegTime = 1.) :
130                         TObject(), fCounterName(counterName), fMaxIntegrationTime(maxIntegTime), fPos(0)
131                 {
132                         for (size_t i = 0; i < kTimeStampEntries; ++i) {
133                                 fCounterBuffer[i] = 0; fTimeBuffer[i] = startTime;
134                         }
135                 }
136                 
137                 /// Overloaded new operator to catch and log memory allocation failures.
138                 void* operator new (std::size_t size) throw (std::bad_alloc);
139                 
140                 /// Symmetric delete operator for overloaded new.
141                 void operator delete (void* mem) throw ();
142                 
143                 /// Inherited form TObject. Returns the counter name this buffer is associated to.
144                 virtual const char* GetName() const { return fCounterName.Data(); }
145                 
146                 /// Inherited from TObject. Returns a hash value calculated from the counter name.
147                 virtual ULong_t Hash() const { return fCounterName.Hash(); }
148                 
149                 /// Returns the maximum integration time for this counter to compute the rate.
150                 Double_t MaxIntegrationTime() const { return fMaxIntegrationTime; }
151                 
152                 /// Returns the oldest counter value.
153                 ULong64_t OldestCounter() const { return fCounterBuffer[fPos]; }
154                 
155                 /// Returns the oldest time value.
156                 Double_t OldestTime() const { return fTimeBuffer[fPos]; }
157                 
158                 /**
159                  * Increments the buffer. The new time and counter values are put into the
160                  * current location to replace the existing values, then the current position
161                  * is incremented (and wrapped around if necessary).
162                  * \note All values that are older than the fMaxIntegrationTime are also replaced.
163                  * \param newCounter  The new counter value to put into the buffer.
164                  * \param newTime  The new time value to put into the buffer.
165                  */
166                 void Increment(ULong64_t newCounter, Double_t newTime);
167                 
168                 /**
169                  * Replaces all values that are older than the fMaxIntegrationTime.
170                  * \param currentCounter  The current counter's value.
171                  * \param newTime  The new time value to put into the buffer.
172                  */
173                 void Update(ULong64_t currentCounter, Double_t newTime);
174                 
175         private:
176                 
177                 TString fCounterName;  // The name of the counter.
178                 Double_t fMaxIntegrationTime;  // The maximum integration time in seconds to calculate the rate.
179                 UInt_t fPos;  // Current position in the buffers.
180                 ULong64_t fCounterBuffer[kTimeStampEntries];  // The counter elements of the buffer.
181                 Double_t fTimeBuffer[kTimeStampEntries];  // The time elements of the buffer.
182         };
183         
184         // Do not allow copying of this class.
185         AliHLTTriggerCounterComponent(const AliHLTTriggerCounterComponent& obj);
186         AliHLTTriggerCounterComponent& operator = (const AliHLTTriggerCounterComponent& obj);
187         
188         /// Updates the counter rate value.
189         void UpdateCounterRate(AliHLTTriggerCounters::AliCounter* counter, AliRingBuffer* timeBuf, Double_t newTime);
190         
191         /// Updates the counter rate value when the counter was not incremented.
192         void UpdateCounterRate2(AliHLTTriggerCounters::AliCounter* counter, AliRingBuffer* timeBuf, Double_t newTime);
193         
194         /// Loads the initial configuration of counters from the given CDB path.
195         int LoadConfigFromCDB(const char* cdbPath);
196         
197         /// Loads the initial configuration of counters from the given configuration file.
198         int LoadConfigFromFile(const char* configFile);
199         
200         /**
201          * Sets the initial counter values from a TMap object containing name description pairs.
202          * \param counters  The list of counters to initialise. This TMap should contain TObjString
203          *     pairs where the key is the name of the counter and the TMap value is the description.
204          *     If the 14th bit is set in the key TObjString then the counter is considered an
205          *     output counter and an input counter otherwise.
206          */
207         void SetInitialCounters(const TMap* counters);
208         
209         double fOutputMultiplier;    //! Multiplier value for the output size estimate.
210         AliHLTTriggerCounters fInputCounters; //! Input trigger counters.
211         AliHLTTriggerCounters fOutputCounters; //! Output trigger counters.
212         THashTable fInputTimes;  //! Cyclic buffer storing the time stamps when the input counters were received.
213         THashTable fOutputTimes;  //! Cyclic buffer storing the time stamps when the output counters were received.
214         Double_t fLastPublishTime;  //! The last time the counters were pushed back to the output.
215         Double_t fPublishPeriod;  //! The time between calls to push back the counters to output.
216         Double_t fDefaultMaxIntegrationTime; //! The maximum integration time to use for calculating the rates.
217         bool fCountFalseInputs; //! Indicates if the false input trigger decisions should also be counted.
218         bool fCountFalseOutputs; //! Indicates if the false output trigger decisions should also be counted.
219         
220         static const char* fgkConfigCDBPath;  //! CDB configuration path.
221         static TMap fgInitialCounterConfig;   //! Initial configuration information for the counters.
222         
223         ClassDef(AliHLTTriggerCounterComponent, 0)  // Component for counting HLT triggers.
224 };
225
226 #endif // ALIHLTTRIGGERCOUNTERCOMPONENT_H