]>
Commit | Line | Data |
---|---|---|
1 | // | |
2 | // See implementation or Doxygen comments for more information | |
3 | // | |
4 | #ifndef ALIAODFORWARDHEADER_H | |
5 | #define ALIAODFORWARDHEADER_H | |
6 | /** | |
7 | * @file AliAODForwardHeader.h | |
8 | * @author Christian Holm Christensen <cholm@nbi.dk> | |
9 | * @date Mon Dec 2 09:31:05 2013 | |
10 | * | |
11 | * @brief Header for forward data in stand-alone AOD | |
12 | * | |
13 | * @ingroup pwglf_forward_aod | |
14 | */ | |
15 | #include <TObject.h> | |
16 | class TBrowser; | |
17 | ||
18 | class AliAODForwardHeader : public TObject | |
19 | { | |
20 | public: | |
21 | /** | |
22 | * Bits of the trigger pattern | |
23 | */ | |
24 | enum { | |
25 | /** In-elastic collision */ | |
26 | kInel = 0x0001, | |
27 | /** In-elastic collision with at least one SPD tracklet */ | |
28 | kInelGt0 = 0x0002, | |
29 | /** Non-single diffractive collision */ | |
30 | kNSD = 0x0004, | |
31 | /** Empty bunch crossing */ | |
32 | kEmpty = 0x0008, | |
33 | /** A-side trigger */ | |
34 | kA = 0x0010, | |
35 | /** B(arrel) trigger */ | |
36 | kB = 0x0020, | |
37 | /** C-side trigger */ | |
38 | kC = 0x0080, | |
39 | /** Empty trigger */ | |
40 | kE = 0x0100, | |
41 | /** pileup from SPD */ | |
42 | kPileUp = 0x0200, | |
43 | /** true NSD from MC */ | |
44 | kMCNSD = 0x0400, | |
45 | /** Offline MB triggered */ | |
46 | kOffline = 0x0800, | |
47 | /** At least one SPD cluster */ | |
48 | kNClusterGt0 = 0x1000, | |
49 | /** V0-AND trigger */ | |
50 | kV0AND = 0x2000, | |
51 | /** Satellite event */ | |
52 | kSatellite = 0x4000 | |
53 | }; | |
54 | /** | |
55 | * Bin numbers in trigger histograms | |
56 | */ | |
57 | enum { | |
58 | kBinAll=1, | |
59 | kBinInel, | |
60 | kBinInelGt0, | |
61 | kBinNSD, | |
62 | kBinV0AND, | |
63 | kBinA, | |
64 | kBinB, | |
65 | kBinC, | |
66 | kBinE, | |
67 | kBinSatellite, | |
68 | kBinPileUp, | |
69 | kBinMCNSD, | |
70 | kBinOffline, | |
71 | kBinNClusterGt0, | |
72 | kWithTrigger, | |
73 | kWithVertex, | |
74 | kAccepted | |
75 | }; | |
76 | /** | |
77 | * Return codes of CheckEvent | |
78 | */ | |
79 | enum ECheckStatus { | |
80 | /** Event accepted by cuts */ | |
81 | kGoodEvent = 0, | |
82 | /** Event centrality not in range */ | |
83 | kWrongCentrality, | |
84 | /** Event trigger isn't in the supplied mask */ | |
85 | kWrongTrigger, | |
86 | /** Event is a pile-up event */ | |
87 | kIsPileup, | |
88 | /** Event has no interaction point information */ | |
89 | kNoVertex, | |
90 | /** Event interaction point is out of range */ | |
91 | kWrongVertex | |
92 | }; | |
93 | /** | |
94 | * Constructor | |
95 | */ | |
96 | AliForwardHeader() | |
97 | : fTriggers(0), fIpZ(fgkInvalidIpZ), fCentrality(-1), fNClusters(0) | |
98 | {} | |
99 | ||
100 | /** | |
101 | * @{ | |
102 | * @name Setters of data | |
103 | */ | |
104 | /** | |
105 | * Clear all data | |
106 | * | |
107 | * @param option Not used | |
108 | */ | |
109 | void Clear(Option_t* option=""); | |
110 | /** | |
111 | * Set the trigger mask | |
112 | * | |
113 | * @param trg Trigger mask | |
114 | */ | |
115 | void SetTriggerMask(UInt_t trg) { fTriggers = trg; } // Set triggers | |
116 | /** | |
117 | * Set bit(s) in trigger mask | |
118 | * | |
119 | * @param bits bit(s) to set | |
120 | */ | |
121 | void SetTriggerBits(UInt_t bits) { fTriggers |= bits; } // Set trigger bits | |
122 | /** | |
123 | * Set the z coordinate of the interaction point | |
124 | * | |
125 | * @param ipZ Interaction point z coordinate | |
126 | */ | |
127 | void SetIpZ(Float_t ipZ) { fIpZ = ipZ; } // Set Ip's Z coordinate | |
128 | /** | |
129 | * Set the event centrality | |
130 | * | |
131 | * @param c Centrality | |
132 | */ | |
133 | void SetCentrality(Float_t c) { fCentrality = c; } | |
134 | /** | |
135 | * Set the number of SPD clusters seen in @f$ |\eta|<1@f$ | |
136 | * | |
137 | * @param n Number of SPD clusters | |
138 | */ | |
139 | void SetNClusters(UShort_t n) { fNClusters = n; } | |
140 | /* @} */ | |
141 | ||
142 | ||
143 | /** | |
144 | * @{ | |
145 | * @name Tests | |
146 | */ | |
147 | /** | |
148 | * Check if all bit(s) are set in the trigger mask. Note, this is | |
149 | * an @e and between the bits. If you need an @e or you should use | |
150 | * the member function IsTriggerOrBits | |
151 | * | |
152 | * @param bits Bits to test for | |
153 | * | |
154 | * @return true if all enabled bits in the argument is also set in | |
155 | * the trigger word | |
156 | */ | |
157 | Bool_t IsTriggerBits(UInt_t bits) const; | |
158 | /** | |
159 | * Check if any of bit(s) are enabled in the trigger word. This is | |
160 | * an @e or between the selected bits. If you need and @a and you | |
161 | * should use the member function IsTriggerBits; | |
162 | * | |
163 | * @param bits Bits to check for | |
164 | * | |
165 | * @return true if any of the enabled bits in the arguments are also | |
166 | * enabled in the trigger mask | |
167 | */ | |
168 | Bool_t IsTriggerOrBits(UInt_t bits) const; | |
169 | /** | |
170 | * Whether we have any trigger bits | |
171 | * | |
172 | * @return true if we have some trigger | |
173 | */ | |
174 | Bool_t HasTrigger() const { return fTriggers != 0; } // Check for triggers | |
175 | /** | |
176 | * Check if we have a valid z coordinate of the interaction point | |
177 | * | |
178 | * @return True if we have a valid interaction point z coordinate | |
179 | */ | |
180 | Bool_t HasIpZ() const; | |
181 | /** | |
182 | * Check if the z coordinate of the interaction point is within the | |
183 | * given limits. Note that the convention used corresponds to the | |
184 | * convention used in ROOTs TAxis. | |
185 | * | |
186 | * @param low Lower cut (inclusive) | |
187 | * @param high Upper cut (exclusive) | |
188 | * | |
189 | * @return true if @f$ low \ge ipz < high@f$ | |
190 | */ | |
191 | Bool_t InRange(Float_t low, Float_t high) const; | |
192 | /** | |
193 | * Check if we have a valid centrality | |
194 | * | |
195 | * @return True if the centrality is set | |
196 | */ | |
197 | Bool_t HasCentrality() const { return !(fCentrality < 0); } | |
198 | /** | |
199 | * Check if event meets the passses requirements. | |
200 | * | |
201 | * It returns true if @e all of the following is true | |
202 | * | |
203 | * - The trigger is within the bit mask passed. | |
204 | * - The vertex is within the specified limits. | |
205 | * - The centrality is within the specified limits, or if lower | |
206 | * limit is equal to or larger than the upper limit. | |
207 | * | |
208 | * Note, for data with out a centrality estimate (e.g., pp), one | |
209 | * must pass equal centrality cuts, or no data will be accepted. In | |
210 | * other words, for pp data, always pass cMin=0, cMax=0 | |
211 | * | |
212 | * If a histogram is passed in the last parameter, then that | |
213 | * histogram is filled with the trigger bits. | |
214 | * | |
215 | * @param triggerMask Trigger mask | |
216 | * @param vzMin Minimum @f$ v_z@f$ (in centimeters) | |
217 | * @param vzMax Maximum @f$ v_z@f$ (in centimeters) | |
218 | * @param cMin Minimum centrality (in percent) | |
219 | * @param cMax Maximum centrality (in percent) | |
220 | * @param hist Histogram to fill | |
221 | * @param status Histogram to fill | |
222 | * | |
223 | * | |
224 | * @return @c true if the event meets the requirements | |
225 | */ | |
226 | Bool_t CheckEvent(Int_t triggerMask=kInel, | |
227 | Double_t vzMin=-10, Double_t vzMax=10, | |
228 | UShort_t cMin=0, UShort_t cMax=100, | |
229 | TH1* hist=0, | |
230 | TH1* status=0) const; | |
231 | /* @} */ | |
232 | ||
233 | /** | |
234 | * @{ | |
235 | * @name Getters of data | |
236 | */ | |
237 | /** | |
238 | * Get the trigger bits | |
239 | * | |
240 | * @return Trigger bits | |
241 | */ | |
242 | UInt_t GetTriggerBits() const { return fTriggers; } // Get triggers | |
243 | /** | |
244 | * Set the z coordinate of the interaction point | |
245 | * | |
246 | * @return Interaction point z coordinate | |
247 | */ | |
248 | Float_t GetIpZ() const { return fIpZ; } // Get Ip's Z coordinate | |
249 | /** | |
250 | * Get the event centrality | |
251 | * | |
252 | * @return The event centrality or -1 if not set | |
253 | */ | |
254 | Float_t GetCentrality() const { return fCentrality; } | |
255 | /** | |
256 | * Get the number of SPD clusters seen in @f$ |\eta|<1@f$ | |
257 | * | |
258 | * @return Number of SPD clusters seen | |
259 | */ | |
260 | UShort_t GetNClusters() const { return fNClusters; } | |
261 | /* @} */ | |
262 | ||
263 | /** | |
264 | * @{ | |
265 | * @name Standard TObject member functions | |
266 | */ | |
267 | /** | |
268 | * Print content | |
269 | * | |
270 | * @param option Passed verbatim to TH2::Print | |
271 | */ | |
272 | void Print(Option_t* option="") const; | |
273 | /** | |
274 | * Get the name of the object | |
275 | * | |
276 | * @return Name of object | |
277 | */ | |
278 | const Char_t* GetName() const { return "ForwardHeader"; } | |
279 | /** | |
280 | * browse this object | |
281 | * | |
282 | * @param b Browser | |
283 | */ | |
284 | void Browse(TBrowser* b); | |
285 | /** | |
286 | * This is a folder | |
287 | * | |
288 | * @return Always true | |
289 | */ | |
290 | Bool_t IsFolder() const { return kTRUE; } // Always true | |
291 | /* @} */ | |
292 | /** | |
293 | * @{ | |
294 | * @name Utility class functions | |
295 | */ | |
296 | /** | |
297 | * Get a string correspondig to the trigger mask | |
298 | * | |
299 | * @param mask Trigger mask | |
300 | * | |
301 | * @return Static string (copy before use) | |
302 | */ | |
303 | static const Char_t* GetTriggerString(UInt_t mask); | |
304 | /** | |
305 | * Make a histogram to record triggers in. | |
306 | * | |
307 | * The bins defined by the trigger enumeration in this class. One | |
308 | * can use this enumeration to retrieve the number of triggers for | |
309 | * each class. | |
310 | * | |
311 | * @param name Name of the histogram | |
312 | * @param mask Trigger mask | |
313 | * | |
314 | * @return Newly allocated histogram | |
315 | */ | |
316 | static TH1I* MakeTriggerHistogram(const char* name="triggers", | |
317 | Int_t mask=0); | |
318 | /** | |
319 | * Make a histogram to record status in. | |
320 | * | |
321 | * The bins defined by the status enumeration in this class. | |
322 | * | |
323 | * @param name Name of the histogram | |
324 | * | |
325 | * @return Newly allocated histogram | |
326 | */ | |
327 | static TH1I* MakeStatusHistogram(const char* name="status"); | |
328 | /** | |
329 | * Utility function to make a trigger mask from the passed string. | |
330 | * | |
331 | * The string is a comma or space seperated list of case-insensitive | |
332 | * strings | |
333 | * | |
334 | * - INEL | |
335 | * - INEL>0 | |
336 | * - NSD | |
337 | * | |
338 | * @param what Which triggers to put in the mask. | |
339 | * | |
340 | * @return The generated trigger mask. | |
341 | */ | |
342 | static UInt_t MakeTriggerMask(const char* what); | |
343 | /* @} */ | |
344 | protected: | |
345 | /** Trigger bits */ | |
346 | UInt_t fTriggers; // Trigger bit mask | |
347 | /** Interaction point @f$z@f$ coordinate */ | |
348 | Float_t fIpZ; // Z coordinate of the interaction point | |
349 | /** Centrality */ | |
350 | Float_t fCentrality; // Event centrality | |
351 | /** Number of clusters in @f$|\eta|<1@f$ */ | |
352 | UShort_t fNClusters; // Number of SPD clusters in |eta|<1 | |
353 | /** Invalid value for interaction point @f$z@f$ coordiante */ | |
354 | static const Float_t fgkInvalidIpZ; // Invalid IpZ value | |
355 | ClassDef(AliAODForwardHeader,1); // AOD forward header | |
356 | }; | |
357 | ||
358 | //____________________________________________________________________ | |
359 | inline Bool_t | |
360 | AliAODForwardHeader::InRange(Float_t low, Float_t high) const | |
361 | { | |
362 | return HasIpZ() && fIpZ >= low && fIpZ < high; | |
363 | } | |
364 | ||
365 | //____________________________________________________________________ | |
366 | inline Bool_t | |
367 | AliAODForwardHeader::IsTriggerBits(UInt_t bits) const | |
368 | { | |
369 | return HasTrigger() && ((fTriggers & bits) == bits); | |
370 | } | |
371 | //____________________________________________________________________ | |
372 | inline Bool_t | |
373 | AliAODForwardHeader::IsTriggerOrBits(UInt_t bits) const | |
374 | { | |
375 | return HasTrigger() && ((fTriggers & bits) != 0); | |
376 | } | |
377 | ||
378 | ||
379 | #endif | |
380 | // Local Variables: | |
381 | // mode: C++ | |
382 | // End: | |
383 |