61899827 |
1 | /* $Id: AliPhysicsSelection.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */ |
2 | |
3 | /************************************************************************** |
4 | * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * |
5 | * * |
6 | * Author: The ALICE Off-line Project. * |
7 | * Contributors are mentioned in the code where appropriate. * |
8 | * * |
9 | * Permission to use, copy, modify and distribute this software and its * |
10 | * documentation strictly for non-commercial purposes is hereby granted * |
11 | * without fee, provided that the above copyright notice appears in all * |
12 | * copies and that both the copyright notice and this permission notice * |
13 | * appear in the supporting documentation. The authors make no claims * |
14 | * about the suitability of this software for any purpose. It is * |
15 | * provided "as is" without express or implied warranty. * |
16 | **************************************************************************/ |
17 | |
18 | //------------------------------------------------------------------------- |
19 | // Implementation of Class AliPhysicsSelection |
528640ed |
20 | // This class selects collision candidates from data runs, applying selection cuts on triggers |
21 | // and background rejection based on the content of the ESD |
22 | // |
23 | // Usage: |
24 | // |
a2ce3799 |
25 | // Create the object: |
528640ed |
26 | // fPhysicsSelection = new AliPhysicsSelection; |
a2ce3799 |
27 | // |
28 | // For MC data, call |
29 | // fPhysicsSelection->SetAnalyzeMC() |
528640ed |
30 | // |
31 | // To check if an event is a collision candidate, use: |
32 | // fPhysicsSelection->IsCollisionCandidate(fESD) |
33 | // |
34 | // After processing save the resulting histograms to a file with (a folder physics_selection |
35 | // will be created that contains the histograms): |
36 | // fPhysicsSelection->SaveHistograms("physics_selection") |
37 | // |
38 | // To print statistics after processing use: |
39 | // fPhysicsSelection->Print(); |
40 | // |
73cc8654 |
41 | // The BX ids corresponding to real bunches crossings p2 are |
42 | // automatically selected. You cannot process runs with different |
43 | // filling schemes if this option is set. If you want to disable this, |
44 | // use: |
45 | // fPhysicsSelection->SetUseBXNumbers(0); |
46 | // |
47 | // |
48 | // If you are analizing muons and you want to keep the muon triggers |
49 | // besides the CINT1B you can set: |
50 | // fPhysicsSelection->SetUseMuonTriggers(); |
51 | // |
85c71ba7 |
52 | // |
53 | // To compute the Background automatically using the control triggers |
54 | // use: |
55 | // fPhysicsSelection->SetComputeBG(); |
56 | // this will show the value of the Beam Gas, accidentals and good |
57 | // events as additional rows in the statistic tables, but it will NOT |
58 | // subtract the background automatically. |
59 | // This option will only work for runs taken with the CINT1 |
60 | // suite. This options enables automatically also the usage of BX |
61 | // numbers. You can only process one run at a time if you require this |
62 | // options, because it uses the bunch intensity estimated run by run. |
63 | // |
64 | // The BG will usually be more important in the so-called "bin 0": the |
65 | // class can also compute the statistics table for events in this |
66 | // bin. Since the definition of bin 0 may in general change from |
67 | // analysis to analysis, the user needs to provide a callback |
68 | // implementing the definition of bin zero. The callback should be |
69 | // implemented as a method in the analysis task and should override |
70 | // the IsEventInBinZero method of AliAnalysisTaskSE, and should thus |
71 | // have the the following prototype: |
72 | // Bool_t IsEventInBinZero(); |
73 | // It should return true if the event is in the bin 0 and it is set by |
74 | // passing to the physics selection the NAME of the task where the |
75 | // callback is implemented: |
76 | // fPhysicsSelection->SetBin0Callback("MyTask"). |
77 | // |
78 | // |
decf6fd4 |
79 | // Usually the class selects the trigger scheme by itself depending on the run number. |
80 | // Nevertheless, you can do that manually by calling AddCollisionTriggerClass() and AddBGTriggerClass() |
81 | // Example: |
82 | // To define the class CINT1B-ABCE-NOPF-ALL as collision trigger (those will be accepted as |
83 | // collision candidates when they pass the selection): |
84 | // AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #769 #3119"); |
85 | // To select on bunch crossing IDs in addition, use: |
86 | // AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #769 #3119"); |
87 | // To define the class CINT1A-ABCE-NOPF-ALL as a background trigger (those will only be counted |
88 | // for the control histograms): |
89 | // AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL"); |
90 | // You can also specify more than one trigger class in a string or you can require that some are *not* |
91 | // present. The following line would require CSMBA-ABCE-NOPF-ALL, but CSMBB-ABCE-NOPF-ALL is not allowed |
92 | // to be present: |
93 | // AddBGTriggerClass("+CSMBA-ABCE-NOPF-ALL -CSMBB-ABCE-NOPF-ALL"); |
94 | // |
85c71ba7 |
95 | // Origin: Jan Fiete Grosse-Oetringhaus, CERN |
96 | // Michele Floris, CERN |
61899827 |
97 | //------------------------------------------------------------------------- |
98 | |
99 | #include <Riostream.h> |
100 | #include <TH1F.h> |
101 | #include <TH2F.h> |
102 | #include <TList.h> |
103 | #include <TIterator.h> |
104 | #include <TDirectory.h> |
296dd262 |
105 | #include <TObjArray.h> |
61899827 |
106 | |
107 | #include <AliPhysicsSelection.h> |
108 | |
109 | #include <AliTriggerAnalysis.h> |
110 | #include <AliLog.h> |
111 | |
112 | #include <AliESDEvent.h> |
85c71ba7 |
113 | #include <AliAnalysisTaskSE.h> |
114 | #include "AliAnalysisManager.h" |
141265a2 |
115 | #include "TPRegexp.h" |
61899827 |
116 | |
117 | ClassImp(AliPhysicsSelection) |
118 | |
119 | AliPhysicsSelection::AliPhysicsSelection() : |
296dd262 |
120 | AliAnalysisCuts("AliPhysicsSelection", "AliPhysicsSelection"), |
121 | fCurrentRun(-1), |
a2ce3799 |
122 | fMC(kFALSE), |
296dd262 |
123 | fCollTrigClasses(), |
124 | fBGTrigClasses(), |
125 | fTriggerAnalysis(), |
126 | fBackgroundIdentification(0), |
91bea6e7 |
127 | fHistBunchCrossing(0), |
73cc8654 |
128 | fHistTriggerPattern(0), |
91bea6e7 |
129 | fSkipTriggerClassSelection(0), |
85c71ba7 |
130 | fUsingCustomClasses(0), |
131 | fSkipV0(0), |
132 | fBIFactorA(1), |
133 | fBIFactorC(1), |
141265a2 |
134 | fBIFactorAC(1), |
85c71ba7 |
135 | fComputeBG(0), |
141265a2 |
136 | fBGStatOffset(0), |
73cc8654 |
137 | fUseBXNumbers(1), |
138 | fUseMuonTriggers(0), |
85c71ba7 |
139 | fFillingScheme(""), |
ff097e3f |
140 | fBin0CallBack(""), |
141 | fBin0CallBackPointer(0) |
61899827 |
142 | { |
143 | // constructor |
144 | |
296dd262 |
145 | fCollTrigClasses.SetOwner(1); |
146 | fBGTrigClasses.SetOwner(1); |
147 | fTriggerAnalysis.SetOwner(1); |
85c71ba7 |
148 | fHistStatistics[0] = 0; |
149 | fHistStatistics[1] = 0; |
296dd262 |
150 | |
61899827 |
151 | AliLog::SetClassDebugLevel("AliPhysicsSelection", AliLog::kWarning); |
152 | } |
153 | |
154 | AliPhysicsSelection::~AliPhysicsSelection() |
155 | { |
156 | // destructor |
85c71ba7 |
157 | |
296dd262 |
158 | fCollTrigClasses.Delete(); |
159 | fBGTrigClasses.Delete(); |
160 | fTriggerAnalysis.Delete(); |
61899827 |
161 | |
85c71ba7 |
162 | if (fHistStatistics[0]) |
163 | { |
164 | delete fHistStatistics[0]; |
165 | fHistStatistics[0] = 0; |
166 | } |
167 | if (fHistStatistics[1]) |
61899827 |
168 | { |
85c71ba7 |
169 | delete fHistStatistics[1]; |
170 | fHistStatistics[1] = 0; |
61899827 |
171 | } |
172 | |
173 | if (fHistBunchCrossing) |
174 | { |
175 | delete fHistBunchCrossing; |
176 | fHistBunchCrossing = 0; |
177 | } |
73cc8654 |
178 | if (fHistTriggerPattern) |
179 | { |
180 | delete fHistTriggerPattern; |
181 | fHistTriggerPattern = 0; |
182 | } |
716f045f |
183 | if (fBackgroundIdentification) |
184 | { |
185 | delete fBackgroundIdentification; |
186 | fBackgroundIdentification = 0; |
187 | } |
61899827 |
188 | } |
296dd262 |
189 | |
0c6c629b |
190 | UInt_t AliPhysicsSelection::CheckTriggerClass(const AliESDEvent* aEsd, const char* trigger) const |
296dd262 |
191 | { |
192 | // checks if the given trigger class(es) are found for the current event |
0c6c629b |
193 | // format of trigger: +TRIGGER1 -TRIGGER2 [#XXX] [&YY] |
296dd262 |
194 | // requires TRIGGER1 and rejects TRIGGER2 |
0c6c629b |
195 | // in bunch crossing XXX |
1209509c |
196 | // if successful, YY is returned (for association between entry in fCollTrigClasses and AliVEvent::EOfflineTriggerTypes) |
296dd262 |
197 | |
decf6fd4 |
198 | Bool_t foundBCRequirement = kFALSE; |
199 | Bool_t foundCorrectBC = kFALSE; |
200 | |
0c6c629b |
201 | UInt_t returnCode = AliVEvent::kUserDefined; |
202 | |
296dd262 |
203 | TString str(trigger); |
204 | TObjArray* tokens = str.Tokenize(" "); |
205 | |
206 | for (Int_t i=0; i < tokens->GetEntries(); i++) |
207 | { |
208 | TString str2(((TObjString*) tokens->At(i))->String()); |
209 | |
decf6fd4 |
210 | if (str2[0] == '+' || str2[0] == '-') |
296dd262 |
211 | { |
decf6fd4 |
212 | Bool_t flag = (str2[0] == '+'); |
213 | |
214 | str2.Remove(0, 1); |
215 | |
216 | if (flag && !aEsd->IsTriggerClassFired(str2)) |
217 | { |
218 | AliDebug(AliLog::kDebug, Form("Rejecting event because trigger class %s is not present", str2.Data())); |
219 | delete tokens; |
220 | return kFALSE; |
221 | } |
222 | if (!flag && aEsd->IsTriggerClassFired(str2)) |
223 | { |
224 | AliDebug(AliLog::kDebug, Form("Rejecting event because trigger class %s is present", str2.Data())); |
225 | delete tokens; |
226 | return kFALSE; |
227 | } |
296dd262 |
228 | } |
decf6fd4 |
229 | else if (str2[0] == '#') |
296dd262 |
230 | { |
decf6fd4 |
231 | foundBCRequirement = kTRUE; |
232 | |
233 | str2.Remove(0, 1); |
234 | |
235 | Int_t bcNumber = str2.Atoi(); |
236 | AliDebug(AliLog::kDebug, Form("Checking for bunch crossing number %d", bcNumber)); |
237 | |
238 | if (aEsd->GetBunchCrossNumber() == bcNumber) |
239 | { |
240 | foundCorrectBC = kTRUE; |
241 | AliDebug(AliLog::kDebug, Form("Found correct bunch crossing %d", bcNumber)); |
242 | } |
296dd262 |
243 | } |
0c6c629b |
244 | else if (str2[0] == '&' && !fUsingCustomClasses) |
245 | { |
246 | str2.Remove(0, 1); |
247 | |
1209509c |
248 | returnCode = str2.Atoll(); |
0c6c629b |
249 | } |
decf6fd4 |
250 | else |
251 | AliFatal(Form("Invalid trigger syntax: %s", trigger)); |
296dd262 |
252 | } |
253 | |
254 | delete tokens; |
decf6fd4 |
255 | |
256 | if (foundBCRequirement && !foundCorrectBC) |
257 | return kFALSE; |
258 | |
0c6c629b |
259 | return returnCode; |
296dd262 |
260 | } |
2d45a1a7 |
261 | |
262 | //______________________________________________________________________________ |
263 | TObject *AliPhysicsSelection::GetStatistics(Option_t *option) const |
264 | { |
265 | // Get the statistics histograms ("ALL" and "BIN0") |
266 | TString opt(option); |
267 | opt.ToUpper(); |
268 | Int_t ihist = 0; |
269 | if (opt == "ALL") ihist = kStatIdxAll; |
270 | if (opt == "BIN0") ihist = kStatIdxBin0; |
271 | return fHistStatistics[ihist]; |
272 | } |
273 | |
274 | //______________________________________________________________________________ |
0c6c629b |
275 | UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd) |
61899827 |
276 | { |
277 | // checks if the given event is a collision candidate |
0c6c629b |
278 | // |
279 | // returns a bit word describing the fired offline triggers (see AliVEvent::EOfflineTriggerTypes) |
61899827 |
280 | |
141265a2 |
281 | if (fCurrentRun != aEsd->GetRunNumber()) { |
95e6f4ec |
282 | if (!Initialize(aEsd->GetRunNumber())) |
283 | AliFatal(Form("Could not initialize for run %d", aEsd->GetRunNumber())); |
141265a2 |
284 | if(fComputeBG) SetBIFactors(aEsd); // is this safe here? |
285 | } |
61899827 |
286 | const AliESDHeader* esdHeader = aEsd->GetHeader(); |
287 | if (!esdHeader) |
288 | { |
289 | AliError("ESD Header could not be retrieved"); |
290 | return kFALSE; |
291 | } |
292 | |
a2ce3799 |
293 | // check event type; should be PHYSICS = 7 for data and 0 for MC |
294 | if (!fMC) |
295 | { |
296 | if (esdHeader->GetEventType() != 7) |
297 | return kFALSE; |
298 | } |
299 | else |
300 | { |
301 | if (esdHeader->GetEventType() != 0) |
302 | AliFatal(Form("Invalid event type for MC: %d", esdHeader->GetEventType())); |
303 | } |
758941d4 |
304 | |
0c6c629b |
305 | UInt_t accept = 0; |
296dd262 |
306 | |
307 | Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); |
308 | for (Int_t i=0; i < count; i++) |
61899827 |
309 | { |
296dd262 |
310 | const char* triggerClass = 0; |
311 | if (i < fCollTrigClasses.GetEntries()) |
312 | triggerClass = ((TObjString*) fCollTrigClasses.At(i))->String(); |
313 | else |
314 | triggerClass = ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String(); |
61899827 |
315 | |
296dd262 |
316 | AliDebug(AliLog::kDebug, Form("Processing trigger class %s", triggerClass)); |
61899827 |
317 | |
296dd262 |
318 | AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i)); |
61899827 |
319 | |
296dd262 |
320 | triggerAnalysis->FillTriggerClasses(aEsd); |
61899827 |
321 | |
0c6c629b |
322 | UInt_t singleTriggerResult = CheckTriggerClass(aEsd, triggerClass); |
323 | if (singleTriggerResult) |
296dd262 |
324 | { |
325 | triggerAnalysis->FillHistograms(aEsd); |
326 | |
85c71ba7 |
327 | Bool_t isBin0 = kFALSE; |
328 | if (fBin0CallBack != "") { |
329 | AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); |
330 | if (!mgr) { |
331 | AliError("Cannot get the analysis manager"); |
332 | } |
333 | else { |
334 | isBin0 = ((AliAnalysisTaskSE*)mgr->GetTask(fBin0CallBack.Data()))->IsEventInBinZero(); |
335 | } |
ff097e3f |
336 | } else if (fBin0CallBackPointer) { |
337 | isBin0 = (*fBin0CallBackPointer)(aEsd); |
338 | |
85c71ba7 |
339 | } |
ff097e3f |
340 | |
85c71ba7 |
341 | |
cc9d9320 |
342 | |
343 | // hardware trigger (should only remove events for MC) |
344 | // replay CINT1B hardware trigger |
345 | // TODO this has to depend on the actual hardware trigger (and that depends on the run...) |
346 | Int_t fastORHW = triggerAnalysis->SPDFiredChips(aEsd, 1); // SPD number of chips from trigger bits (!) |
85c71ba7 |
347 | Bool_t v0A = fSkipV0 ? 0 :triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0A); |
348 | Bool_t v0C = fSkipV0 ? 0 :triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0C); |
349 | Bool_t v0AHW = fSkipV0 ? 0 :(triggerAnalysis->V0Trigger(aEsd, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);// should replay hw trigger |
350 | Bool_t v0CHW = fSkipV0 ? 0 :(triggerAnalysis->V0Trigger(aEsd, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);// should replay hw trigger |
cc9d9320 |
351 | // offline trigger |
352 | Int_t fastOROffline = triggerAnalysis->SPDFiredChips(aEsd, 0); // SPD number of chips from clusters (!) |
85c71ba7 |
353 | Bool_t v0ABG = fSkipV0 ? 0 :triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0ABG); |
354 | Bool_t v0CBG = fSkipV0 ? 0 :triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0CBG); |
f4ca8f20 |
355 | Bool_t v0BG = v0ABG || v0CBG; |
85c71ba7 |
356 | |
357 | // fmd |
358 | Bool_t fmdA = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kFMDA); |
359 | Bool_t fmdC = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kFMDC); |
360 | Bool_t fmd = fmdA || fmdC; |
61899827 |
361 | |
85c71ba7 |
362 | // SSD |
363 | Int_t ssdClusters = triggerAnalysis->SSDClusters(aEsd); |
364 | |
365 | // Some "macros" |
366 | Bool_t mb1 = (fastOROffline > 0 || v0A || v0C) && (!v0BG); |
367 | Bool_t mb1prime = (fastOROffline > 1 || (fastOROffline > 0 && (v0A || v0C)) || (v0A && v0C) ) && (!v0BG); |
368 | |
369 | // Background rejection |
8663e267 |
370 | Bool_t bgID = kFALSE; |
371 | if (fBackgroundIdentification) |
372 | bgID = ! fBackgroundIdentification->IsSelected(const_cast<AliESDEvent*> (aEsd)); |
373 | |
85c71ba7 |
374 | Int_t ntrig = fastOROffline; // any 2 hits |
375 | if(v0A) ntrig += 1; |
376 | if(v0C) ntrig += 1; //v0C alone is enough |
377 | if(fmd) ntrig += 1; |
378 | if(ssdClusters>1) ntrig += 1; |
379 | |
380 | |
381 | Bool_t hwTrig = fastORHW > 0 || v0AHW || v0CHW; |
382 | |
73cc8654 |
383 | // Fill trigger pattern histo |
384 | Int_t tpatt = 0; |
385 | if (fastORHW>0) tpatt+=1; |
386 | if (v0AHW) tpatt+=2; |
387 | if (v0CHW) tpatt+=4; |
388 | fHistTriggerPattern->Fill( tpatt ); |
389 | |
85c71ba7 |
390 | // fill statistics and return decision |
391 | const Int_t nHistStat = 2; |
392 | for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){ |
393 | if (iHistStat == kStatIdxBin0 && !isBin0) continue; // skip the filling of bin0 stats if the event is not in the bin0 |
394 | |
395 | fHistStatistics[iHistStat]->Fill(kStatTriggerClass, i); |
396 | |
397 | |
398 | |
399 | // We fill the rest only if hw trigger is ok |
400 | if (!hwTrig) |
401 | { |
402 | AliDebug(AliLog::kDebug, "Rejecting event because hardware trigger is not fired"); |
403 | continue; |
404 | } else { |
405 | fHistStatistics[iHistStat]->Fill(kStatHWTrig, i); |
406 | } |
733f0542 |
407 | |
85c71ba7 |
408 | |
409 | // v0 BG stats |
410 | if (v0ABG) |
411 | fHistStatistics[iHistStat]->Fill(kStatV0ABG, i); |
412 | if (v0CBG) |
413 | fHistStatistics[iHistStat]->Fill(kStatV0CBG, i); |
414 | |
415 | // We fill the rest only if mb1 && ! v0BG |
416 | if (mb1) |
417 | fHistStatistics[iHistStat]->Fill(kStatMB1, i); |
418 | else continue; |
419 | |
420 | if (mb1prime) |
421 | fHistStatistics[iHistStat]->Fill(kStatMB1Prime, i); |
422 | |
423 | if (fmd) |
424 | fHistStatistics[iHistStat]->Fill(kStatFMD, i); |
425 | |
426 | if(ssdClusters>1) |
427 | fHistStatistics[iHistStat]->Fill(kStatSSD1, i); |
428 | |
429 | if(ntrig >= 2 && !v0BG) |
430 | fHistStatistics[iHistStat]->Fill(kStatAny2Hits, i); |
431 | |
432 | if (fastOROffline > 0) |
433 | fHistStatistics[iHistStat]->Fill(kStatFO1, i); |
434 | if (fastOROffline > 1) |
435 | fHistStatistics[iHistStat]->Fill(kStatFO2, i); |
cc9d9320 |
436 | |
85c71ba7 |
437 | if (v0A) |
438 | fHistStatistics[iHistStat]->Fill(kStatV0A, i); |
439 | if (v0C) |
440 | fHistStatistics[iHistStat]->Fill(kStatV0C, i); |
441 | |
442 | // if (fastOROffline > 1 && !v0BG) |
443 | // fHistStatistics[iHistStat]->Fill(kStatFO2NoBG, i); |
444 | |
445 | if (fastOROffline > 0 && (v0A || v0C) && !v0BG) |
446 | fHistStatistics[iHistStat]->Fill(kStatFO1AndV0, i); |
296dd262 |
447 | |
85c71ba7 |
448 | if (v0A && v0C && !v0BG && !bgID) |
449 | fHistStatistics[iHistStat]->Fill(kStatV0, i); |
450 | |
451 | |
452 | if ( mb1 ) |
453 | |
454 | { |
455 | if (!v0BG || fSkipV0) |
456 | { |
457 | if (!v0BG) fHistStatistics[iHistStat]->Fill(kStatOffline, i); |
61899827 |
458 | |
85c71ba7 |
459 | if (fBackgroundIdentification && bgID) |
460 | { |
461 | AliDebug(AliLog::kDebug, "Rejecting event because of background identification"); |
462 | fHistStatistics[iHistStat]->Fill(kStatBG, i); |
463 | } |
464 | else |
465 | { |
466 | AliDebug(AliLog::kDebug, "Accepted event for histograms"); |
296dd262 |
467 | |
85c71ba7 |
468 | fHistStatistics[iHistStat]->Fill(kStatAccepted, i); |
469 | if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting) |
470 | if((i < fCollTrigClasses.GetEntries() || fSkipTriggerClassSelection) && (iHistStat==kStatIdxAll)) |
0c6c629b |
471 | accept |= singleTriggerResult; // only set for "all" (should not really matter) |
85c71ba7 |
472 | } |
473 | } |
474 | else |
475 | AliDebug(AliLog::kDebug, "Rejecting event because of V0 BG flag"); |
476 | } |
477 | else |
478 | AliDebug(AliLog::kDebug, "Rejecting event because trigger condition is not fulfilled"); |
296dd262 |
479 | } |
296dd262 |
480 | } |
481 | } |
482 | |
483 | if (accept) |
0c6c629b |
484 | AliDebug(AliLog::kDebug, Form("Accepted event as collision candidate with bit mask %d", accept)); |
61899827 |
485 | |
296dd262 |
486 | return accept; |
61899827 |
487 | } |
a2ce3799 |
488 | |
85c71ba7 |
489 | Int_t AliPhysicsSelection::GetTriggerScheme(UInt_t runNumber) const |
a2ce3799 |
490 | { |
491 | // returns the current trigger scheme (classes that are accepted/rejected) |
492 | |
493 | if (fMC) |
494 | return 0; |
495 | |
496 | // TODO dependent on run number |
4b7e8f3b |
497 | |
498 | switch (runNumber) |
499 | { |
500 | // CSMBB triggers |
501 | case 104044: |
502 | case 105054: |
503 | case 105057: |
504 | return 2; |
505 | } |
506 | |
507 | // default: CINT1 suite |
a2ce3799 |
508 | return 1; |
509 | } |
85c71ba7 |
510 | |
511 | const char * AliPhysicsSelection::GetFillingScheme(UInt_t runNumber) { |
512 | |
513 | if(fMC) return "MC"; |
514 | |
515 | if (runNumber >= 104065 && runNumber <= 104160) { |
516 | return "4x4a"; |
517 | } |
518 | else if (runNumber >= 104315 && runNumber <= 104321) { |
519 | return "4x4a*"; |
520 | } |
521 | else if (runNumber >= 104792 && runNumber <= 104803) { |
522 | return "4x4b"; |
523 | } |
524 | else if (runNumber >= 104824 && runNumber <= 104892) { |
525 | return "4x4c"; |
526 | } |
527 | else if (runNumber == 105143 || runNumber == 105160) { |
528 | return "16x16a"; |
529 | } |
530 | else if (runNumber >= 105256 && runNumber <= 105268) { |
531 | return "4x4c"; |
5f337f3d |
532 | } |
533 | else if (runNumber >= 114786 && runNumber <= 116684) { |
ca234d7a |
534 | return "Single_2b_1_1_1"; |
85c71ba7 |
535 | } |
5f337f3d |
536 | else if (runNumber >= 117048 && runNumber <= 117120) { |
537 | return "Single_3b_2_2_2"; |
538 | } |
539 | else if (runNumber >= 117220 && runNumber <= 119163) { |
540 | return "Single_2b_1_1_1"; |
541 | } |
542 | else if (runNumber >= 119837 && runNumber <= 119862) { |
543 | return "Single_4b_2_2_2"; |
544 | } |
545 | else if (runNumber >= 119902 && runNumber <= 120691) { |
546 | return "Single_6b_3_3_3"; |
547 | } |
548 | else if (runNumber >= 120741 && runNumber <= 122375) { |
549 | return "Single_13b_8_8_8"; |
550 | } |
141265a2 |
551 | else if (runNumber >= 130148 && runNumber <= 130375) { |
552 | return "125n_48b_36_16_36"; |
553 | } |
8fc17e87 |
554 | else if (runNumber >= 130601 && runNumber <= 130640) { |
555 | return "1000ns_50b_35_14_35"; |
556 | } |
85c71ba7 |
557 | else { |
558 | AliError(Form("Unknown filling scheme (run %d)", runNumber)); |
559 | } |
560 | |
561 | return "Unknown"; |
562 | } |
563 | |
85c71ba7 |
564 | const char * AliPhysicsSelection::GetBXIDs(UInt_t runNumber, const char * trigger) { |
565 | |
566 | if (!fUseBXNumbers || fMC) return ""; |
567 | |
568 | if (runNumber >= 104065 && runNumber <= 104160) { |
569 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #2128 #3019"; |
570 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #346 #3465"; |
571 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1234 #1680"; |
572 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790"; |
e0bf2892 |
573 | // else AliError(Form("Unknown trigger: %s", trigger)); |
85c71ba7 |
574 | } |
575 | else if (runNumber >= 104315 && runNumber <= 104321) { |
576 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #2000 #2891"; |
577 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #218 #3337"; |
578 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1106 #1552"; |
579 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790"; |
e0bf2892 |
580 | // else AliError(Form("Unknown trigger: %s", trigger)); |
85c71ba7 |
581 | } |
582 | else if (runNumber >= 104792 && runNumber <= 104803) { |
583 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #2228 #3119"; |
584 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2554 #446"; |
585 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1334 #769"; |
586 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790"; |
e0bf2892 |
587 | // else AliError(Form("Unknown trigger: %s", trigger)); |
85c71ba7 |
588 | } |
589 | else if (runNumber >= 104824 && runNumber <= 104892) { |
590 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #3119 #769"; |
591 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2554 #446"; |
592 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1334 #2228"; |
593 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790"; |
e0bf2892 |
594 | // else AliError(Form("Unknown trigger: %s", trigger)); |
85c71ba7 |
595 | } |
596 | else if (runNumber == 105143 || runNumber == 105160) { |
85c71ba7 |
597 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #1337 #1418 #2228 #2309 #3119 #3200 #446 #527"; |
598 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #1580 #1742 #1904 #2066 #2630 #2792 #2954 #3362"; |
599 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #845 #1007 #1169 #1577 #3359 #3521 #119 #281 "; |
600 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790"; |
e0bf2892 |
601 | // else AliError(Form("Unknown trigger: %s", trigger)); |
85c71ba7 |
602 | } |
603 | else if (runNumber >= 105256 && runNumber <= 105268) { |
604 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #3019 #669"; |
605 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2454 #346"; |
606 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1234 #2128"; |
607 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790"; |
e0bf2892 |
608 | // else AliError(Form("Unknown trigger: %s", trigger)); |
73cc8654 |
609 | } else if (runNumber >= 114786 && runNumber <= 116684) { // 7 TeV 2010, assume always the same filling scheme |
ca234d7a |
610 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346"; |
611 | else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131"; |
612 | else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019"; |
613 | else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238"; |
e0bf2892 |
614 | // else AliError(Form("Unknown trigger: %s", trigger)); |
85c71ba7 |
615 | } |
5f337f3d |
616 | else if (runNumber >= 117048 && runNumber <= 117120) { |
617 | // return "Single_3b_2_2_2"; |
618 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 #1240 "; |
619 | else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131 "; |
620 | else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 "; |
621 | else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238"; |
e0bf2892 |
622 | // else AliError(Form("Unknown trigger: %s", trigger)); |
5f337f3d |
623 | |
624 | } |
625 | else if (runNumber >= 117220 && runNumber <= 119163) { |
626 | // return "Single_2b_1_1_1"; |
627 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 "; |
628 | else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131 "; |
629 | else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 "; |
630 | else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238 "; |
e0bf2892 |
631 | // else AliError(Form("Unknown trigger: %s", trigger)); |
5f337f3d |
632 | } |
633 | else if (runNumber >= 119837 && runNumber <= 119862) { |
634 | // return "Single_4b_2_2_2"; |
635 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #669 #3019 "; |
636 | else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #346 #2454 "; |
637 | else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1234 #2128 "; |
638 | else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1681 #3463"; |
e0bf2892 |
639 | // else AliError(Form("Unknown trigger: %s", trigger)); |
5f337f3d |
640 | |
641 | } |
642 | else if (runNumber >= 119902 && runNumber <= 120691) { |
643 | // return "Single_6b_3_3_3"; |
644 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 #546 #746 "; |
645 | else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131 #2331 #2531 "; |
646 | else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 #3219 #3419 "; |
647 | else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1296 #1670"; |
e0bf2892 |
648 | // else AliError(Form("Unknown trigger: %s", trigger)); |
5f337f3d |
649 | } |
650 | else if (runNumber >= 120741 && runNumber <= 122375) { |
651 | // return "Single_13b_8_8_8"; |
652 | if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 #446 #546 #646 #1240 #1340 #1440 #1540 "; |
653 | else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #946 #2131 #2231 #2331 #2431 "; |
654 | else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 #3119 #3219 #3319 #3519 "; |
655 | else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1835 #2726"; |
e0bf2892 |
656 | // else AliError(Form("Unknown trigger: %s", trigger)); |
5f337f3d |
657 | |
bc18a83e |
658 | } |
659 | else if (runNumber >= 130148 && runNumber <= 130375) { |
660 | TString triggerString = trigger; |
661 | static TString returnString = " "; |
662 | returnString = ""; |
663 | if (triggerString.Contains("B")) returnString += " #346 #396 #446 #496 #546 #596 #646 #696 #1240 #1290 #1340 #1390 #1440 #1490 #1540 #1590 "; |
664 | if (triggerString.Contains("A")) returnString += " #755 #805 #855 #905 #955 #1005 #1799 #1849 #1899 #2131 #2181 #2231 #2281 #2331 #2381 #2431 #2481 #2531 #2581 #2631 #2846 #3016 #3066 #3116 #3166 #3216 #3266 #3316 #3366 #3425 #3475 #3525 "; |
665 | if (triggerString.Contains("C")) returnString += " #3019 #3069 #3119 #3169 #3219 #3269 #3319 #3369 #14 #64 #114 #746 #796 #846 #908 #958 #1008 #1640 #1690 #1740 #2055 #2125 #2175 #2225 #2275 #2325 #2375 #2425 #2475 #2534 #2584 #2634 "; |
666 | // Printf("0x%x",returnString.Data()); |
667 | // Printf("%s",returnString.Data()); |
668 | return returnString.Data(); |
8fc17e87 |
669 | } |
670 | else if (runNumber >= 130601 && runNumber <= 130640) { |
671 | TString triggerString = trigger; |
672 | static TString returnString = " "; |
673 | returnString = ""; |
674 | if (triggerString.Contains("B")) returnString += " #346 #386 #426 #466 #506 #546 #586 #1240 #1280 #1320 #1360 #1400 #1440 #1480 "; |
675 | if (triggerString.Contains("A")) returnString += " #626 #666 #706 #746 #786 #826 #866 #1520 #1560 #1600 #1640 #1680 #1720 #1760 #2076 #2131 #2171 #2211 #2251 #2291 #2331 #2371 #2414 #2454 #2494 #2534 #2574 #2614 #2654 #2694 #2734 #2774 #2814 "; //#2854 #2894 #2934 not present in this run |
676 | if (triggerString.Contains("C")) returnString += " #3019 #3059 #3099 #3139 #3179 #3219 #3259 #3299 #3339 #3379 #3419 #3459 #3499 #3539 #115 #629 #669 #709 #749 #789 #829 #869 #909 #949 #989 #1029 #1069 #1109 #1149 #1523 #1563 #1603 #1643 "; //#1683 #1723 #1763 not present in this run |
677 | return returnString.Data(); |
5f337f3d |
678 | } |
679 | |
85c71ba7 |
680 | else { |
8fc17e87 |
681 | AliWarning(Form("Unknown run %d, using all BXs!",runNumber)); |
85c71ba7 |
682 | } |
683 | |
684 | return ""; |
685 | } |
61899827 |
686 | |
85c71ba7 |
687 | Bool_t AliPhysicsSelection::Initialize(Int_t runNumber) |
61899827 |
688 | { |
689 | // initializes the object for the given run |
690 | // TODO having the run number here and parameters hardcoded is clearly temporary, a way needs to be found to have a CDB-like configuration also for analysis |
691 | |
29e8486e |
692 | Bool_t oldStatus = TH1::AddDirectoryStatus(); |
693 | TH1::AddDirectory(kFALSE); |
694 | |
85c71ba7 |
695 | if(!fBin0CallBack) |
696 | AliError("Bin0 Callback not set: will not fill the statistics for the bin 0"); |
697 | |
698 | if (fMC) { |
0c6c629b |
699 | // override BX and bg options in case of MC |
85c71ba7 |
700 | fComputeBG = kFALSE; |
701 | fUseBXNumbers = kFALSE; |
702 | } |
703 | |
a2ce3799 |
704 | Int_t triggerScheme = GetTriggerScheme(runNumber); |
91bea6e7 |
705 | if (!fUsingCustomClasses && fCurrentRun != -1 && triggerScheme != GetTriggerScheme(fCurrentRun)) |
a2ce3799 |
706 | AliFatal("Processing several runs with different trigger schemes is not supported"); |
296dd262 |
707 | |
85c71ba7 |
708 | if(fComputeBG && fCurrentRun != -1 && fCurrentRun != runNumber) |
709 | AliFatal("Cannot process several runs because BG computation is requested"); |
710 | |
711 | if(fComputeBG && !fUseBXNumbers) |
e0bf2892 |
712 | AliFatal("Cannot compute BG if BX numbers are not used"); |
85c71ba7 |
713 | |
714 | if(fUseBXNumbers && fFillingScheme != "" && fFillingScheme != GetFillingScheme(runNumber)) |
715 | AliFatal("Cannot process runs with different filling scheme if usage of BX numbers is requested"); |
716 | |
85c71ba7 |
717 | fFillingScheme = GetFillingScheme(runNumber); |
718 | |
61899827 |
719 | AliInfo(Form("Initializing for run %d", runNumber)); |
720 | |
758941d4 |
721 | // initialize first time? |
a2ce3799 |
722 | if (fCurrentRun == -1) |
a2ce3799 |
723 | { |
91bea6e7 |
724 | if (fUsingCustomClasses) { |
725 | AliInfo("Using user-provided trigger classes"); |
726 | } else { |
727 | switch (triggerScheme) |
728 | { |
a2ce3799 |
729 | case 0: |
962f52fe |
730 | fCollTrigClasses.Add(new TObjString(Form("&%u", (UInt_t) AliVEvent::kMB))); |
a2ce3799 |
731 | break; |
91bea6e7 |
732 | |
a2ce3799 |
733 | case 1: |
4a6e052f |
734 | // trigger classes used before August 2010 |
1209509c |
735 | fCollTrigClasses.Add(new TObjString(Form("%s%s &%u","+CINT1B-ABCE-NOPF-ALL", GetBXIDs(runNumber,"CINT1B-ABCE-NOPF-ALL"), (UInt_t) AliVEvent::kMB))); |
736 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u","+CINT1A-ABCE-NOPF-ALL", GetBXIDs(runNumber,"CINT1A-ABCE-NOPF-ALL"), (UInt_t) AliVEvent::kMB))); |
737 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u","+CINT1C-ABCE-NOPF-ALL", GetBXIDs(runNumber,"CINT1C-ABCE-NOPF-ALL"), (UInt_t) AliVEvent::kMB))); |
738 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u","+CINT1-E-NOPF-ALL", GetBXIDs(runNumber,"CINT1-E-NOPF-ALL"), (UInt_t) AliVEvent::kMB))); |
0c6c629b |
739 | |
740 | // Muon trigger have the same BXIDs of the corresponding CINT triggers |
1209509c |
741 | fCollTrigClasses.Add(new TObjString(Form("%s%s &%u","+CMUS1B-ABCE-NOPF-MUON", GetBXIDs(runNumber,"CINT1B-ABCE-NOPF-ALL"), (UInt_t) AliVEvent::kMUON))); |
742 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u","+CMUS1A-ABCE-NOPF-MUON", GetBXIDs(runNumber,"CINT1A-ABCE-NOPF-ALL"), (UInt_t) AliVEvent::kMUON))); |
743 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u","+CMUS1C-ABCE-NOPF-MUON", GetBXIDs(runNumber,"CINT1C-ABCE-NOPF-ALL"), (UInt_t) AliVEvent::kMUON))); |
744 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u","+CMUS1-E-NOPF-MUON" , GetBXIDs(runNumber,"CINT1-E-NOPF-ALL"), (UInt_t) AliVEvent::kMUON))); |
4a6e052f |
745 | |
746 | // triggers classes used from August 2010 |
747 | // MB |
bc18a83e |
748 | fCollTrigClasses.Add(new TObjString(Form("%s%s &%u", "+CINT1-B-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "B"), (UInt_t) AliVEvent::kMB))); |
749 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u", "+CINT1-AC-NOPF-ALLNOTRD", GetBXIDs(runNumber, "AC"), (UInt_t) AliVEvent::kMB))); |
750 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u", "+CINT1-E-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "E"), (UInt_t) AliVEvent::kMB))); |
751 | |
752 | // MUON |
753 | fCollTrigClasses.Add(new TObjString(Form("%s%s &%u", "+CMUS1-B-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "B"), (UInt_t) AliVEvent::kMUON))); |
754 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u", "+CMUS1-AC-NOPF-ALLNOTRD", GetBXIDs(runNumber, "AC"), (UInt_t) AliVEvent::kMUON))); |
755 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u", "+CMUS1-E-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "E"), (UInt_t) AliVEvent::kMUON))); |
756 | |
757 | // High Multiplicity |
758 | fCollTrigClasses.Add(new TObjString(Form("%s%s &%u", "+CSH1-B-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "B"), (UInt_t) AliVEvent::kHighMult))); |
759 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u", "+CSH1-AC-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "AC"), (UInt_t) AliVEvent::kHighMult))); |
760 | fBGTrigClasses.Add (new TObjString(Form("%s%s &%u", "+CSH1-E-NOPF-ALLNOTRD" , GetBXIDs(runNumber, "E"), (UInt_t) AliVEvent::kHighMult))); |
4a6e052f |
761 | |
141265a2 |
762 | // WARNING: IF YOU ADD MORE TRIGGER CLASSES, PLEASE CHECK THAT THE REGULAR EXPRESSION IN GetStatRow IS STILL VALID |
763 | |
a2ce3799 |
764 | break; |
765 | |
4b7e8f3b |
766 | case 2: |
1209509c |
767 | fCollTrigClasses.Add(new TObjString(Form("+CSMBB-ABCE-NOPF-ALL &%u", (UInt_t) AliVEvent::kMB))); |
768 | fBGTrigClasses.Add(new TObjString(Form("+CSMBA-ABCE-NOPF-ALL -CSMBB-ABCE-NOPF-ALL &%u", (UInt_t) AliVEvent::kMB))); |
769 | fBGTrigClasses.Add(new TObjString(Form("+CSMBC-ABCE-NOPF-ALL -CSMBB-ABCE-NOPF-ALL &%u", (UInt_t) AliVEvent::kMB))); |
0c6c629b |
770 | break; |
771 | |
772 | case 3: |
773 | // |
4b7e8f3b |
774 | break; |
91bea6e7 |
775 | |
a2ce3799 |
776 | default: |
777 | AliFatal(Form("Unsupported trigger scheme %d", triggerScheme)); |
91bea6e7 |
778 | } |
a2ce3799 |
779 | } |
91bea6e7 |
780 | |
a2ce3799 |
781 | Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); |
782 | |
783 | for (Int_t i=0; i<count; i++) |
784 | { |
785 | AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis; |
786 | triggerAnalysis->SetAnalyzeMC(fMC); |
787 | triggerAnalysis->EnableHistograms(); |
788 | triggerAnalysis->SetSPDGFOThreshhold(1); |
4011b280 |
789 | triggerAnalysis->SetDoFMD(kFALSE); |
a2ce3799 |
790 | fTriggerAnalysis.Add(triggerAnalysis); |
791 | } |
792 | |
85c71ba7 |
793 | // TODO: shall I really delete this? |
794 | if (fHistStatistics[0]) |
795 | delete fHistStatistics[0]; |
796 | if (fHistStatistics[1]) |
797 | delete fHistStatistics[1]; |
296dd262 |
798 | |
85c71ba7 |
799 | fHistStatistics[kStatIdxBin0] = BookHistStatistics("_Bin0"); |
800 | fHistStatistics[kStatIdxAll] = BookHistStatistics(""); |
a2ce3799 |
801 | |
802 | if (fHistBunchCrossing) |
803 | delete fHistBunchCrossing; |
804 | |
805 | fHistBunchCrossing = new TH2F("fHistBunchCrossing", "fHistBunchCrossing;bunch crossing number;", 4000, -0.5, 3999.5, count, -0.5, -0.5 + count); |
73cc8654 |
806 | |
807 | if (fHistTriggerPattern) |
808 | delete fHistTriggerPattern; |
809 | |
810 | const int ntrig=3; |
85c71ba7 |
811 | Int_t n = 1; |
73cc8654 |
812 | const Int_t nbinTrig = TMath::Nint(TMath::Power(2,ntrig)); |
813 | |
814 | fHistTriggerPattern = new TH1F("fHistTriggerPattern", "Trigger pattern: FO + 2*v0A + 4*v0C", |
815 | nbinTrig, -0.5, nbinTrig-0.5); |
816 | fHistTriggerPattern->GetXaxis()->SetBinLabel(1,"NO TRIG"); |
817 | fHistTriggerPattern->GetXaxis()->SetBinLabel(2,"FO"); |
818 | fHistTriggerPattern->GetXaxis()->SetBinLabel(3,"v0A"); |
819 | fHistTriggerPattern->GetXaxis()->SetBinLabel(4,"FO & v0A"); |
820 | fHistTriggerPattern->GetXaxis()->SetBinLabel(5,"v0C"); |
821 | fHistTriggerPattern->GetXaxis()->SetBinLabel(6,"FO & v0C"); |
822 | fHistTriggerPattern->GetXaxis()->SetBinLabel(7,"v0A & v0C"); |
823 | fHistTriggerPattern->GetXaxis()->SetBinLabel(8,"FO & v0A & v0C"); |
824 | |
825 | |
826 | n = 1; |
a2ce3799 |
827 | for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++) |
828 | { |
a2ce3799 |
829 | fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String()); |
830 | n++; |
831 | } |
832 | for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++) |
833 | { |
a2ce3799 |
834 | fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String()); |
835 | n++; |
836 | } |
85c71ba7 |
837 | |
838 | |
839 | |
a2ce3799 |
840 | } |
841 | |
842 | Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); |
296dd262 |
843 | for (Int_t i=0; i<count; i++) |
61899827 |
844 | { |
a2ce3799 |
845 | AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i)); |
846 | |
296dd262 |
847 | switch (runNumber) |
848 | { |
a2ce3799 |
849 | case 104315: |
296dd262 |
850 | case 104316: |
851 | case 104320: |
a2ce3799 |
852 | case 104321: |
296dd262 |
853 | case 104439: |
854 | triggerAnalysis->SetV0TimeOffset(7.5); |
855 | break; |
a2ce3799 |
856 | default: |
857 | triggerAnalysis->SetV0TimeOffset(0); |
296dd262 |
858 | } |
f4ca8f20 |
859 | } |
860 | |
758941d4 |
861 | fCurrentRun = runNumber; |
862 | |
29e8486e |
863 | TH1::AddDirectory(oldStatus); |
864 | |
61899827 |
865 | return kTRUE; |
866 | } |
867 | |
85c71ba7 |
868 | TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) { |
bc18a83e |
869 | // add 6 rows to count for the estimate of good, accidentals and |
870 | // BG and the ratio of BG and accidentals to total +ratio goot to |
871 | // first col + 2 for error on good. |
872 | // TODO: Remember the the indexes of rows for the BG selection. Add new member fBGRows[] and use kStat as indexes |
85c71ba7 |
873 | |
874 | Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); |
875 | #ifdef VERBOSE_STAT |
141265a2 |
876 | Int_t extrarows = fComputeBG != 0 ? 8 : 0; |
85c71ba7 |
877 | #else |
141265a2 |
878 | Int_t extrarows = fComputeBG != 0 ? 3 : 0; |
85c71ba7 |
879 | #endif |
880 | TH2F * h = new TH2F(Form("fHistStatistics%s",tag), Form("fHistStatistics - %s ;;",tag), kStatAccepted, 0.5, kStatAccepted+0.5, count+extrarows, -0.5, -0.5 + count+extrarows); |
881 | |
882 | h->GetXaxis()->SetBinLabel(kStatTriggerClass, "Trigger class"); |
883 | h->GetXaxis()->SetBinLabel(kStatHWTrig, "Hardware trigger"); |
884 | h->GetXaxis()->SetBinLabel(kStatFO1, "FO >= 1"); |
885 | h->GetXaxis()->SetBinLabel(kStatFO2, "FO >= 2"); |
886 | h->GetXaxis()->SetBinLabel(kStatV0A, "V0A"); |
887 | h->GetXaxis()->SetBinLabel(kStatV0C, "V0C"); |
888 | h->GetXaxis()->SetBinLabel(kStatFMD, "FMD"); |
889 | h->GetXaxis()->SetBinLabel(kStatSSD1, "SSD >= 2"); |
890 | h->GetXaxis()->SetBinLabel(kStatV0ABG, "V0A BG"); |
891 | h->GetXaxis()->SetBinLabel(kStatV0CBG, "V0C BG"); |
892 | h->GetXaxis()->SetBinLabel(kStatMB1, "(FO >= 1 | V0A | V0C) & !V0 BG"); |
893 | h->GetXaxis()->SetBinLabel(kStatMB1Prime, "(FO >= 2 | (FO >= 1 & (V0A | V0C)) | (V0A &v0C) ) & !V0 BG"); |
894 | h->GetXaxis()->SetBinLabel(kStatFO1AndV0, "FO >= 1 & (V0A | V0C) & !V0 BG"); |
895 | h->GetXaxis()->SetBinLabel(kStatV0, "V0A & V0C & !V0 BG & !BG ID"); |
896 | h->GetXaxis()->SetBinLabel(kStatOffline, "Offline Trigger"); |
897 | h->GetXaxis()->SetBinLabel(kStatAny2Hits, "2 Hits & !V0 BG"); |
898 | h->GetXaxis()->SetBinLabel(kStatBG, "Background identification"); |
899 | h->GetXaxis()->SetBinLabel(kStatAccepted, "Accepted"); |
900 | |
901 | Int_t n = 1; |
902 | for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++) |
903 | { |
904 | h->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String()); |
905 | n++; |
906 | } |
907 | for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++) |
908 | { |
909 | h->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String()); |
910 | n++; |
911 | } |
912 | |
913 | if(fComputeBG) { |
141265a2 |
914 | fBGStatOffset = n; |
915 | h->GetYaxis()->SetBinLabel(n++, Form("BG (A+C) (Mask [0x%x])", fComputeBG)); |
85c71ba7 |
916 | h->GetYaxis()->SetBinLabel(n++, "ACC"); |
917 | #ifdef VERBOSE_STAT |
918 | h->GetYaxis()->SetBinLabel(n++, "BG (A+C) % (rel. to CINT1B)"); |
919 | h->GetYaxis()->SetBinLabel(n++, "ACC % (rel. to CINT1B)"); |
920 | h->GetYaxis()->SetBinLabel(n++, "ERR GOOD %"); |
921 | h->GetYaxis()->SetBinLabel(n++, "GOOD % (rel. to 1st col)"); |
922 | h->GetYaxis()->SetBinLabel(n++, "ERR GOOD"); |
923 | #endif |
924 | h->GetYaxis()->SetBinLabel(n++, "GOOD"); |
925 | } |
926 | |
927 | return h; |
928 | } |
929 | |
e9247450 |
930 | void AliPhysicsSelection::Print(Option_t *option) const |
61899827 |
931 | { |
932 | // print the configuration |
e9247450 |
933 | TString msg; |
a2ce3799 |
934 | Printf("Configuration initialized for run %d (MC: %d):", fCurrentRun, fMC); |
e9247450 |
935 | msg += Form("Configuration initialized for run %d (MC: %d):\n", fCurrentRun, fMC); |
61899827 |
936 | |
296dd262 |
937 | Printf("Collision trigger classes:"); |
938 | for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++) |
939 | Printf("%s", ((TObjString*) fCollTrigClasses.At(i))->String().Data()); |
61899827 |
940 | |
296dd262 |
941 | Printf("Background trigger classes:"); |
942 | for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++) |
943 | Printf("%s", ((TObjString*) fBGTrigClasses.At(i))->String().Data()); |
944 | |
945 | AliTriggerAnalysis* triggerAnalysis = dynamic_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(0)); |
61899827 |
946 | |
296dd262 |
947 | if (triggerAnalysis) |
948 | { |
949 | if (triggerAnalysis->GetV0TimeOffset() > 0) |
950 | Printf("V0 time offset active: %.2f ns", triggerAnalysis->GetV0TimeOffset()); |
61899827 |
951 | |
296dd262 |
952 | Printf("\nTotal available events:"); |
528640ed |
953 | |
296dd262 |
954 | triggerAnalysis->PrintTriggerClasses(); |
955 | } |
528640ed |
956 | |
0c6c629b |
957 | if (fHistStatistics[kStatIdxAll]) |
b43e01ed |
958 | { |
0c6c629b |
959 | for (Int_t i=0; i<fCollTrigClasses.GetEntries(); i++) |
960 | { |
961 | Printf("\nSelection statistics for collision trigger %s:", ((TObjString*) fCollTrigClasses.At(i))->String().Data()); |
e9247450 |
962 | msg += Form("\nSelection statistics for collision trigger %s:\n", ((TObjString*) fCollTrigClasses.At(i))->String().Data()); |
0c6c629b |
963 | |
964 | Printf("Total events with correct trigger class: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1)); |
e9247450 |
965 | msg += Form("Total events with correct trigger class: %d\n", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1)); |
0c6c629b |
966 | Printf("Selected collision candidates: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1)); |
e9247450 |
967 | msg += Form("Selected collision candidates: %d\n", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1)); |
0c6c629b |
968 | } |
17ba346c |
969 | } |
970 | |
971 | if (fHistBunchCrossing) |
972 | { |
973 | Printf("\nBunch crossing statistics:"); |
e9247450 |
974 | msg += "\nBunch crossing statistics:\n"; |
17ba346c |
975 | |
976 | for (Int_t i=1; i<=fHistBunchCrossing->GetNbinsY(); i++) |
977 | { |
978 | TString str; |
979 | str.Form("Trigger %s has accepted events in the bunch crossings: ", fHistBunchCrossing->GetYaxis()->GetBinLabel(i)); |
980 | |
981 | for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) |
982 | if (fHistBunchCrossing->GetBinContent(j, i) > 0) |
983 | str += Form("%d, ", (Int_t) fHistBunchCrossing->GetXaxis()->GetBinCenter(j)); |
e9247450 |
984 | |
17ba346c |
985 | Printf("%s", str.Data()); |
e9247450 |
986 | msg += str; |
987 | msg += "\n"; |
17ba346c |
988 | } |
989 | |
990 | for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) |
991 | { |
0c6c629b |
992 | Int_t countColl = 0; |
993 | Int_t countBG = 0; |
17ba346c |
994 | for (Int_t i=1; i<=fHistBunchCrossing->GetNbinsY(); i++) |
995 | { |
996 | if (fHistBunchCrossing->GetBinContent(j, i) > 0) |
0c6c629b |
997 | { |
998 | if (fCollTrigClasses.FindObject(fHistBunchCrossing->GetYaxis()->GetBinLabel(i))) |
999 | countColl++; |
1000 | if (fBGTrigClasses.FindObject(fHistBunchCrossing->GetYaxis()->GetBinLabel(i))) |
1001 | countBG++; |
1002 | } |
17ba346c |
1003 | } |
0c6c629b |
1004 | if (countColl > 0 && countBG > 0) |
1005 | Printf("WARNING: Bunch crossing %d has collision and BG trigger classes active. Check BPTX functioning for this run!", (Int_t) fHistBunchCrossing->GetXaxis()->GetBinCenter(j)); |
17ba346c |
1006 | } |
b43e01ed |
1007 | } |
91bea6e7 |
1008 | |
1009 | if (fUsingCustomClasses) |
1010 | Printf("WARNING: Using custom trigger classes!"); |
1011 | if (fSkipTriggerClassSelection) |
1012 | Printf("WARNING: Skipping trigger class selection!"); |
85c71ba7 |
1013 | if (fSkipV0) |
1014 | Printf("WARNING: Ignoring V0 information in selection"); |
1015 | if(!fBin0CallBack) |
1016 | Printf("WARNING: Callback not set: will not fill the statistics for the bin 0"); |
e9247450 |
1017 | TString opt(option); |
1018 | opt.ToUpper(); |
1019 | if (opt == "STAT") { |
1020 | AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); |
1021 | if (mgr) mgr->AddStatisticsMsg(msg); |
1022 | } |
61899827 |
1023 | } |
1024 | |
1025 | Long64_t AliPhysicsSelection::Merge(TCollection* list) |
1026 | { |
1027 | // Merge a list of AliMultiplicityCorrection objects with this (needed for |
1028 | // PROOF). |
1029 | // Returns the number of merged objects (including this). |
1030 | |
1031 | if (!list) |
1032 | return 0; |
1033 | |
1034 | if (list->IsEmpty()) |
1035 | return 1; |
1036 | |
1037 | TIterator* iter = list->MakeIterator(); |
1038 | TObject* obj; |
17ba346c |
1039 | |
61899827 |
1040 | // collections of all histograms |
1041 | const Int_t nHists = 9; |
1042 | TList collections[nHists]; |
1043 | |
1044 | Int_t count = 0; |
1045 | while ((obj = iter->Next())) { |
1046 | |
1047 | AliPhysicsSelection* entry = dynamic_cast<AliPhysicsSelection*> (obj); |
1048 | if (entry == 0) |
1049 | continue; |
518b6d59 |
1050 | // Update run number. If this one is not initialized (-1) take the one from |
1051 | // the next physics selection to be merged with. In case of 2 different run |
1052 | // numbers issue a warning (should physics selections from different runs be |
1053 | // merged together) A.G. |
1054 | Int_t currentRun = entry->GetCurrentRun(); |
1055 | // Nothing to merge with since run number was not initialized. |
1056 | if (currentRun < 0) continue; |
1057 | if (fCurrentRun < 0) fCurrentRun = currentRun; |
1058 | if (fCurrentRun != currentRun) |
1059 | AliWarning(Form("Current run %d not matching the one to be merged with %d", fCurrentRun, currentRun)); |
1060 | |
17ba346c |
1061 | collections[0].Add(&(entry->fTriggerAnalysis)); |
85c71ba7 |
1062 | if (entry->fHistStatistics[0]) |
1063 | collections[1].Add(entry->fHistStatistics[0]); |
1064 | if (entry->fHistStatistics[1]) |
1065 | collections[2].Add(entry->fHistStatistics[1]); |
17ba346c |
1066 | if (entry->fHistBunchCrossing) |
85c71ba7 |
1067 | collections[3].Add(entry->fHistBunchCrossing); |
73cc8654 |
1068 | if (entry->fHistTriggerPattern) |
1069 | collections[4].Add(entry->fHistTriggerPattern); |
296dd262 |
1070 | if (entry->fBackgroundIdentification) |
73cc8654 |
1071 | collections[5].Add(entry->fBackgroundIdentification); |
61899827 |
1072 | |
1073 | count++; |
1074 | } |
1075 | |
17ba346c |
1076 | fTriggerAnalysis.Merge(&collections[0]); |
85c71ba7 |
1077 | if (fHistStatistics[0]) |
1078 | fHistStatistics[0]->Merge(&collections[1]); |
1079 | if (fHistStatistics[1]) |
1080 | fHistStatistics[1]->Merge(&collections[2]); |
17ba346c |
1081 | if (fHistBunchCrossing) |
85c71ba7 |
1082 | fHistBunchCrossing->Merge(&collections[3]); |
73cc8654 |
1083 | if (fHistTriggerPattern) |
1084 | fHistTriggerPattern->Merge(&collections[4]); |
296dd262 |
1085 | if (fBackgroundIdentification) |
73cc8654 |
1086 | fBackgroundIdentification->Merge(&collections[5]); |
61899827 |
1087 | |
1088 | delete iter; |
1089 | |
1090 | return count+1; |
1091 | } |
1092 | |
1093 | void AliPhysicsSelection::SaveHistograms(const char* folder) const |
1094 | { |
1095 | // write histograms to current directory |
1096 | |
85c71ba7 |
1097 | if (!fHistStatistics[0] || !fHistStatistics[1]) |
61899827 |
1098 | return; |
1099 | |
1100 | if (folder) |
1101 | { |
1102 | gDirectory->mkdir(folder); |
1103 | gDirectory->cd(folder); |
1104 | } |
1105 | |
85c71ba7 |
1106 | |
1107 | // Fill the last rows of fHistStatistics before saving |
1108 | if (fComputeBG) { |
1109 | Int_t triggerScheme = GetTriggerScheme(UInt_t(fCurrentRun)); |
1110 | if(triggerScheme != 1){ |
1111 | AliWarning("BG estimate only supported for trigger scheme \"1\" (CINT1 suite)"); |
73cc8654 |
1112 | } else if (fUseMuonTriggers) { |
1113 | AliWarning("BG estimate with muon triggers to be implemented"); |
141265a2 |
1114 | } else { |
1115 | AliInfo("BG estimate assumes that for a given run you only have A and C triggers separately or" |
1116 | " toghether as a AC class! Make sure this assumption holds in your case"); |
1117 | |
1118 | // use an anum for the different trigger classes, to make loops easier to read |
1119 | enum {kClassB =0 , kClassA, kClassC, kClassAC, kClassE, kNClasses}; |
1120 | const char * classFlags[] = {"B", "A", "C", "AC", "E"}; // labels |
1121 | |
1122 | UInt_t * rows[kNClasses] = {0}; // Array of matching rows |
1123 | Int_t nrows[kNClasses] = {0}; |
1124 | // Get rows matching the requested trigger bits for all trigger classes |
1125 | for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){ |
1126 | nrows[iTrigClass] = GetStatRow(classFlags[iTrigClass],fComputeBG,&rows[iTrigClass]); |
1127 | } |
1128 | |
5f337f3d |
1129 | // 0. Determine the ratios of triggers E/B, A/B, C/B from the stat histogram |
1130 | // Those are used to rescale the different classes to the same number of bx ids |
141265a2 |
1131 | // TODO: pass names of the rows for B, CA and E and look names of the rows. How do I handle the case in which both AC are in the same row? |
1132 | Int_t nBXIds[kNClasses] = {0}; |
1133 | cout <<"Computing BG:" << endl; |
1134 | |
1135 | for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){ |
1136 | for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) { |
1137 | if(irow==0) cout << "- Class " << classFlags[iTrigClass] << endl; |
1138 | for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) { |
1139 | if (fHistBunchCrossing->GetBinContent(j, rows[iTrigClass][irow]) > 0) { |
1140 | nBXIds[iTrigClass]++; |
1141 | } |
1142 | } |
1143 | if(nBXIds[iTrigClass]>0) cout << " Using row " << rows[iTrigClass][irow] << ": " |
1144 | << fHistBunchCrossing->GetYaxis()->GetBinLabel(rows[iTrigClass][irow]) |
1145 | << " (nBXID "<< nBXIds[iTrigClass] << ")"<< endl; |
1146 | |
1147 | } |
1148 | |
5f337f3d |
1149 | } |
141265a2 |
1150 | |
1151 | Float_t ratioToB[kNClasses]; |
1152 | ratioToB[kClassE] = nBXIds[kClassE] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassE] : 0; |
1153 | ratioToB[kClassA] = nBXIds[kClassA] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassA] : 0; |
1154 | ratioToB[kClassC] = nBXIds[kClassC] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassC] : 0; |
1155 | ratioToB[kClassAC] = nBXIds[kClassAC] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassAC] : 0; |
5f337f3d |
1156 | Printf("Ratio between the BX ids in the different trigger classes:"); |
141265a2 |
1157 | Printf(" B/E = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassE], ratioToB[kClassE] ); |
1158 | Printf(" B/A = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassA], ratioToB[kClassA] ); |
1159 | Printf(" B/C = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassC], ratioToB[kClassC] ); |
1160 | Printf(" B/AC = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassAC],ratioToB[kClassAC]); |
85c71ba7 |
1161 | Int_t nHistStat = 2; |
85c71ba7 |
1162 | |
141265a2 |
1163 | // 1. loop over all cols |
85c71ba7 |
1164 | for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){ |
85c71ba7 |
1165 | Int_t ncol = fHistStatistics[iHistStat]->GetNbinsX(); |
141265a2 |
1166 | Float_t good1 = 0; |
85c71ba7 |
1167 | for(Int_t icol = 1; icol <= ncol; icol++) { |
141265a2 |
1168 | Int_t nEvents[kNClasses] = {0}; // number of events should be reset at every column |
1169 | // For all trigger classes, add up over row matching trigger mask (as selected before) |
1170 | for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){ |
1171 | for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) { |
1172 | nEvents[iTrigClass] += (Int_t) fHistStatistics[iHistStat]->GetBinContent(icol,rows[iTrigClass][irow]); |
1173 | } |
1174 | // cout << "Events " << classFlags[iTrigClass] << " ("<<icol<<") " << nEvents[iTrigClass] << endl; |
1175 | } |
1176 | if (nEvents[kClassB]>0) { |
a67fbdc0 |
1177 | Float_t acc = ratioToB[kClassE]*nEvents[kClassE]; |
141265a2 |
1178 | Double_t acc_err = TMath::Sqrt(ratioToB[kClassE]*ratioToB[kClassE]*nEvents[kClassE]); |
85c71ba7 |
1179 | // Int_t bg = cint1A + cint1C - 2*acc; |
141265a2 |
1180 | |
1181 | // Assuming that for a given class the triggers are either recorded as A+C or AC |
1182 | Float_t bg = nEvents[kClassAC] > 0 ? |
1183 | fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc): |
1184 | fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) + |
1185 | fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) ; |
1186 | |
8fc17e87 |
1187 | // cout << "-----------------------" << endl; |
1188 | // cout << "Factors: " << fBIFactorA << " " << fBIFactorC << " " << fBIFactorAC << endl; |
1189 | // cout << "Ratios: " << ratioToB[kClassA] << " " << ratioToB[kClassC] << " " << ratioToB[kClassAC] << endl; |
1190 | // cout << "Evts: " << nEvents[kClassA] << " " << nEvents[kClassC] << " " << nEvents[kClassAC] << " " << nEvents[kClassB] << endl; |
1191 | // cout << "Acc: " << acc << endl; |
141265a2 |
1192 | // cout << "BG: " << bg << endl; |
1193 | // cout << " " << fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) <<endl; |
1194 | // cout << " " << fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) <<endl; |
1195 | // cout << " " << fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc) << endl; |
1196 | // cout << "-----------------------" << endl; |
1197 | |
1198 | Float_t good = Float_t(nEvents[kClassB]) - bg - acc; |
85c71ba7 |
1199 | if (icol ==1) good1 = good; |
141265a2 |
1200 | // Float_t errGood = TMath::Sqrt(2*(nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassE]));// Error on the number of goods assuming only bg fluctuates |
85c71ba7 |
1201 | // DeltaG^2 = B + FA^2 A + FC^2 C + Ratio^2 (FA+FC-1)^2 E. |
141265a2 |
1202 | Float_t errGood = nEvents[kClassAC] > 0 ? |
1203 | TMath::Sqrt( nEvents[kClassB] + |
1204 | fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC] + |
1205 | ratioToB[kClassE] * ratioToB[kClassE] * |
1206 | (fBIFactorAC - 1)*(fBIFactorAC - 1)*nEvents[kClassE]) : |
1207 | TMath::Sqrt( nEvents[kClassB] + |
1208 | fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA] + |
1209 | fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC] + |
1210 | ratioToB[kClassE] * ratioToB[kClassE] * |
1211 | (fBIFactorA + fBIFactorC - 1)*(fBIFactorA + fBIFactorC - 1)*nEvents[kClassE]); |
1212 | |
1213 | Float_t errBG = nEvents[kClassAC] > 0 ? |
1214 | TMath::Sqrt(fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC]+ |
1215 | 4*ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorAC*fBIFactorAC)*nEvents[kClassE]) : |
1216 | TMath::Sqrt(fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA]+ |
1217 | fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC]+ |
1218 | ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorA+fBIFactorC)*(fBIFactorA+fBIFactorC)*nEvents[kClassE]); |
85c71ba7 |
1219 | |
1220 | |
141265a2 |
1221 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBG,bg); |
1222 | fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowBG,errBG); |
1223 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAcc,acc); |
1224 | fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowAcc,acc_err); |
1225 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGood,good); |
1226 | fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowGood,errGood); |
85c71ba7 |
1227 | |
1228 | #ifdef VERBOSE_STAT |
141265a2 |
1229 | //kStatRowBG=0,kStatRowAcc,kStatRowBGFrac,kStatRowAccFrac,kStatRowErrGoodFrac,kStatRowGoodFrac,kStatRowGood,kStatRowErrGood |
1230 | Float_t accFrac = Float_t(acc) / nEvents[kClassB] *100; |
1231 | Float_t errAccFrac= Float_t(acc_err) / nEvents[kClassB] *100; |
1232 | Float_t bgFrac = Float_t(bg) / nEvents[kClassB] *100; |
85c71ba7 |
1233 | Float_t goodFrac = Float_t(good) / good1 *100; |
1234 | Float_t errGoodFrac = errGood/good1 * 100; |
141265a2 |
1235 | Float_t errFracBG = bg > 0 ? TMath::Sqrt((errBG/bg)*(errBG/bg) + 1/nEvents[kClassB])*bgFrac : 0; |
1236 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBGFrac,bgFrac); |
1237 | fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowBGFrac,errFracBG); |
1238 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAccFrac,accFrac); |
1239 | fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowAccFrac,errAccFrac); |
1240 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGoodFrac,goodFrac); |
1241 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGoodFrac,errGoodFrac); |
1242 | fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGood,errGood); |
85c71ba7 |
1243 | #endif |
1244 | } |
1245 | } |
1246 | } |
ed185ba9 |
1247 | for (Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){ |
1248 | delete [] rows[iTrigClass]; |
1249 | } |
85c71ba7 |
1250 | } |
1251 | } |
1252 | |
1253 | fHistStatistics[0]->Write(); |
1254 | fHistStatistics[1]->Write(); |
8e58a7b9 |
1255 | if(fHistBunchCrossing ) fHistBunchCrossing ->Write(); |
1256 | if(fHistTriggerPattern) fHistTriggerPattern->Write(); |
61899827 |
1257 | |
296dd262 |
1258 | Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); |
1259 | for (Int_t i=0; i < count; i++) |
1260 | { |
1261 | TString triggerClass = "trigger_histograms_"; |
1262 | if (i < fCollTrigClasses.GetEntries()) |
1263 | triggerClass += ((TObjString*) fCollTrigClasses.At(i))->String(); |
1264 | else |
1265 | triggerClass += ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String(); |
61899827 |
1266 | |
296dd262 |
1267 | gDirectory->mkdir(triggerClass); |
1268 | gDirectory->cd(triggerClass); |
61899827 |
1269 | |
296dd262 |
1270 | static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i))->SaveHistograms(); |
1271 | |
1272 | gDirectory->cd(".."); |
1273 | } |
1274 | |
1275 | if (fBackgroundIdentification) |
1276 | { |
1277 | gDirectory->mkdir("background_identification"); |
1278 | gDirectory->cd("background_identification"); |
1279 | |
1280 | fBackgroundIdentification->GetOutput()->Write(); |
1281 | |
1282 | gDirectory->cd(".."); |
1283 | } |
61899827 |
1284 | |
1285 | if (folder) |
1286 | gDirectory->cd(".."); |
1287 | } |
85c71ba7 |
1288 | |
141265a2 |
1289 | Int_t AliPhysicsSelection::GetStatRow(const char * triggerBXClass, UInt_t offlineTriggerType, UInt_t ** rowIDs) const { |
1290 | // Puts inside the array rowIDs the row number for a given offline |
1291 | // trigger in a given bx class. Returns the total number of lines |
1292 | // matching the selection |
1293 | // triggerBXClass can be either "A", "AC", "B" or "E" |
1294 | // offlineTriggerType is one of the types defined in AliVEvent |
1295 | // User should delete rowIDs if no longer needed |
1296 | |
1297 | if(!fHistStatistics[0]) { |
1298 | AliWarning("Not initialized, returning 0"); |
1299 | return 0; |
1300 | } |
1301 | const Int_t nrows = fHistStatistics[0]->GetNbinsY(); |
1302 | |
1303 | // allocate memory for at maximum nrows |
1304 | Int_t nMatches = 0; |
1305 | (*rowIDs) = new UInt_t[nrows]; |
1306 | |
1307 | // Build regular expression. look for a +, followed by the beginning |
1308 | // of a word. Within the word, look for the class id after any |
1309 | // number of any char, but at most one dash ("[^-]*-?"), followed by |
1310 | // a - and then any char (".*") and at the class id ("\\&(\\d)") |
1311 | // The class id is stored. |
1312 | // WARNING: please check this if the trigger classes change |
1313 | TPRegexp re(Form("\\+\\b[^-]*-?%s-.*\\&(\\d)",triggerBXClass)); |
1314 | // Loop over rows and find matching ones: |
1315 | for(Int_t irow = 1; irow <= nrows; irow++){ |
1316 | TObjArray * matches = re.MatchS(fHistStatistics[0]->GetYaxis()->GetBinLabel(irow)); |
1317 | if (matches->GetEntries()) { |
1318 | TString s = ((TObjString*)matches->At(1))->GetString(); |
1319 | if(UInt_t(s.Atoi()) & offlineTriggerType) { // bitwise comparison with the requested mask |
1320 | // cout << "Marching " << s.Data() << " " << offlineTriggerType << " " << fHistStatistics[0]->GetYaxis()->GetBinLabel(irow) << endl; |
1321 | (*rowIDs)[nMatches] = irow; |
1322 | nMatches++; |
1323 | } |
1324 | } |
1325 | delete matches; |
85c71ba7 |
1326 | } |
141265a2 |
1327 | |
1328 | return nMatches; |
1329 | } |
85c71ba7 |
1330 | |
141265a2 |
1331 | void AliPhysicsSelection::SetBIFactors(const AliESDEvent * aESD) { |
1332 | // Set factors for realtive bunch intesities |
1333 | if(!aESD) { |
1334 | AliFatal("ESD not given"); |
1335 | } |
1336 | Int_t run = aESD->GetRunNumber(); |
1337 | if (run > 105268) { |
1338 | // intensities stored in the ESDs |
1339 | const AliESDRun* esdRun = aESD->GetESDRun(); |
1340 | Double_t intAB = esdRun->GetMeanIntensityIntecting(0); |
1341 | Double_t intCB = esdRun->GetMeanIntensityIntecting(1); |
1342 | Double_t intAA = esdRun->GetMeanIntensityNonIntecting(0); |
1343 | Double_t intCC = esdRun->GetMeanIntensityNonIntecting(1); |
1344 | |
1345 | // cout << "INT " <<intAB <<endl; |
1346 | // cout << "INT " <<intCB <<endl; |
1347 | // cout << "INT " <<intAA <<endl; |
1348 | // cout << "INT " <<intCC <<endl; |
1349 | |
1350 | if (intAB > -1 && intAA > -1) { |
1351 | fBIFactorA = intAB/intAA; |
1352 | } else { |
1353 | AliWarning("Cannot set fBIFactorA, assuming 1"); |
1354 | } |
1355 | |
1356 | if (intCB > -1 && intCC > -1) { |
1357 | fBIFactorC = intCB/intCC; |
1358 | } else { |
1359 | AliWarning("Cannot set fBIFactorC, assuming 1"); |
1360 | } |
1361 | |
1362 | if (intAB > -1 && intAA > -1 && |
1363 | intCB > -1 && intCC > -1) { |
1364 | fBIFactorAC = (intAB+intCB)/(intAA+intCC); |
1365 | } else { |
1366 | AliWarning("Cannot set fBIFactorAC, assuming 1"); |
1367 | } |
1368 | |
1369 | } |
1370 | else { |
1371 | // First runs. Intensities hardcoded |
1372 | switch(run) { |
1373 | case 104155: |
1374 | fBIFactorA = 0.961912722908; |
1375 | fBIFactorC = 1.04992336081; |
1376 | break; |
1377 | case 104157: |
1378 | fBIFactorA = 0.947312854998; |
1379 | fBIFactorC = 1.01599706417; |
1380 | break; |
1381 | case 104159: |
1382 | fBIFactorA = 0.93659320151; |
1383 | fBIFactorC = 0.98580804207; |
1384 | break; |
1385 | case 104160: |
1386 | fBIFactorA = 0.929664189926; |
1387 | fBIFactorC = 0.963467679851; |
1388 | break; |
1389 | case 104315: |
1390 | fBIFactorA = 1.08939104979; |
1391 | fBIFactorC = 0.931113921925; |
1392 | break; |
1393 | case 104316: |
1394 | fBIFactorA = 1.08351880974; |
1395 | fBIFactorC = 0.916068345845; |
1396 | break; |
1397 | case 104320: |
1398 | fBIFactorA = 1.07669281245; |
1399 | fBIFactorC = 0.876818744763; |
1400 | break; |
1401 | case 104321: |
1402 | fBIFactorA = 1.00971079602; |
1403 | fBIFactorC = 0.773781299076; |
1404 | break; |
1405 | case 104792: |
1406 | fBIFactorA = 0.787215863962; |
1407 | fBIFactorC = 0.778253173071; |
1408 | break; |
1409 | case 104793: |
1410 | fBIFactorA = 0.692211363661; |
1411 | fBIFactorC = 0.733152456667; |
1412 | break; |
1413 | case 104799: |
1414 | fBIFactorA = 1.04027825161; |
1415 | fBIFactorC = 1.00530825942; |
1416 | break; |
1417 | case 104800: |
1418 | fBIFactorA = 1.05309910671; |
1419 | fBIFactorC = 1.00376801855; |
1420 | break; |
1421 | case 104801: |
1422 | fBIFactorA = 1.0531231922; |
1423 | fBIFactorC = 0.992439666758; |
1424 | break; |
1425 | case 104802: |
1426 | fBIFactorA = 1.04191478134; |
1427 | fBIFactorC = 0.979368585208; |
1428 | break; |
1429 | case 104803: |
1430 | fBIFactorA = 1.03121314094; |
1431 | fBIFactorC = 0.973379962609; |
1432 | break; |
1433 | case 104824: |
1434 | fBIFactorA = 0.969945926722; |
1435 | fBIFactorC = 0.39549745806; |
1436 | break; |
1437 | case 104825: |
1438 | fBIFactorA = 0.968627213937; |
1439 | fBIFactorC = 0.310100412205; |
1440 | break; |
1441 | case 104841: |
1442 | fBIFactorA = 0.991601393212; |
1443 | fBIFactorC = 0.83762204722; |
1444 | break; |
1445 | case 104845: |
1446 | fBIFactorA = 0.98040863886; |
1447 | fBIFactorC = 0.694824205793; |
1448 | break; |
1449 | case 104867: |
1450 | fBIFactorA = 1.10646173412; |
1451 | fBIFactorC = 0.841407246916; |
1452 | break; |
1453 | case 104876: |
1454 | fBIFactorA = 1.12063452421; |
1455 | fBIFactorC = 0.78726542895; |
1456 | break; |
1457 | case 104890: |
1458 | fBIFactorA = 1.02346137453; |
1459 | fBIFactorC = 1.03355663595; |
1460 | break; |
1461 | case 104892: |
1462 | fBIFactorA = 1.05406025913; |
1463 | fBIFactorC = 1.00029166135; |
1464 | break; |
1465 | case 105143: |
1466 | fBIFactorA = 0.947343384349; |
1467 | fBIFactorC = 0.972637444408; |
1468 | break; |
1469 | case 105160: |
1470 | fBIFactorA = 0.908854622177; |
1471 | fBIFactorC = 0.958851103977; |
1472 | break; |
1473 | case 105256: |
1474 | fBIFactorA = 0.810076150206; |
1475 | fBIFactorC = 0.884663561883; |
1476 | break; |
1477 | case 105257: |
1478 | fBIFactorA = 0.80974912303; |
1479 | fBIFactorC = 0.878859123479; |
1480 | break; |
1481 | case 105268: |
1482 | fBIFactorA = 0.809052110679; |
1483 | fBIFactorC = 0.87233890989; |
1484 | break; |
1485 | default: |
1486 | fBIFactorA = 1; |
1487 | fBIFactorC = 1; |
1488 | } |
1489 | } |
85c71ba7 |
1490 | |
1491 | } |