]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ANALYSIS/AliPhysicsSelection.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bugfix
[u/mrichter/AliRoot.git] / ANALYSIS / AliPhysicsSelection.cxx
CommitLineData
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
117ClassImp(AliPhysicsSelection)
118
119AliPhysicsSelection::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
154AliPhysicsSelection::~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 190UInt_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//______________________________________________________________________________
263TObject *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 275UInt_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 489Int_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
511const 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 564const 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 687Bool_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);
789 fTriggerAnalysis.Add(triggerAnalysis);
790 }
791
85c71ba7 792 // TODO: shall I really delete this?
793 if (fHistStatistics[0])
794 delete fHistStatistics[0];
795 if (fHistStatistics[1])
796 delete fHistStatistics[1];
296dd262 797
85c71ba7 798 fHistStatistics[kStatIdxBin0] = BookHistStatistics("_Bin0");
799 fHistStatistics[kStatIdxAll] = BookHistStatistics("");
a2ce3799 800
801 if (fHistBunchCrossing)
802 delete fHistBunchCrossing;
803
804 fHistBunchCrossing = new TH2F("fHistBunchCrossing", "fHistBunchCrossing;bunch crossing number;", 4000, -0.5, 3999.5, count, -0.5, -0.5 + count);
73cc8654 805
806 if (fHistTriggerPattern)
807 delete fHistTriggerPattern;
808
809 const int ntrig=3;
85c71ba7 810 Int_t n = 1;
73cc8654 811 const Int_t nbinTrig = TMath::Nint(TMath::Power(2,ntrig));
812
813 fHistTriggerPattern = new TH1F("fHistTriggerPattern", "Trigger pattern: FO + 2*v0A + 4*v0C",
814 nbinTrig, -0.5, nbinTrig-0.5);
815 fHistTriggerPattern->GetXaxis()->SetBinLabel(1,"NO TRIG");
816 fHistTriggerPattern->GetXaxis()->SetBinLabel(2,"FO");
817 fHistTriggerPattern->GetXaxis()->SetBinLabel(3,"v0A");
818 fHistTriggerPattern->GetXaxis()->SetBinLabel(4,"FO & v0A");
819 fHistTriggerPattern->GetXaxis()->SetBinLabel(5,"v0C");
820 fHistTriggerPattern->GetXaxis()->SetBinLabel(6,"FO & v0C");
821 fHistTriggerPattern->GetXaxis()->SetBinLabel(7,"v0A & v0C");
822 fHistTriggerPattern->GetXaxis()->SetBinLabel(8,"FO & v0A & v0C");
823
824
825 n = 1;
a2ce3799 826 for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
827 {
a2ce3799 828 fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String());
829 n++;
830 }
831 for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
832 {
a2ce3799 833 fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
834 n++;
835 }
85c71ba7 836
837
838
a2ce3799 839 }
840
841 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
296dd262 842 for (Int_t i=0; i<count; i++)
61899827 843 {
a2ce3799 844 AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i));
845
296dd262 846 switch (runNumber)
847 {
a2ce3799 848 case 104315:
296dd262 849 case 104316:
850 case 104320:
a2ce3799 851 case 104321:
296dd262 852 case 104439:
853 triggerAnalysis->SetV0TimeOffset(7.5);
854 break;
a2ce3799 855 default:
856 triggerAnalysis->SetV0TimeOffset(0);
296dd262 857 }
f4ca8f20 858 }
859
758941d4 860 fCurrentRun = runNumber;
861
29e8486e 862 TH1::AddDirectory(oldStatus);
863
61899827 864 return kTRUE;
865}
866
85c71ba7 867TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) {
bc18a83e 868 // add 6 rows to count for the estimate of good, accidentals and
869 // BG and the ratio of BG and accidentals to total +ratio goot to
870 // first col + 2 for error on good.
871 // TODO: Remember the the indexes of rows for the BG selection. Add new member fBGRows[] and use kStat as indexes
85c71ba7 872
873 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
874#ifdef VERBOSE_STAT
141265a2 875 Int_t extrarows = fComputeBG != 0 ? 8 : 0;
85c71ba7 876#else
141265a2 877 Int_t extrarows = fComputeBG != 0 ? 3 : 0;
85c71ba7 878#endif
879 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);
880
881 h->GetXaxis()->SetBinLabel(kStatTriggerClass, "Trigger class");
882 h->GetXaxis()->SetBinLabel(kStatHWTrig, "Hardware trigger");
883 h->GetXaxis()->SetBinLabel(kStatFO1, "FO >= 1");
884 h->GetXaxis()->SetBinLabel(kStatFO2, "FO >= 2");
885 h->GetXaxis()->SetBinLabel(kStatV0A, "V0A");
886 h->GetXaxis()->SetBinLabel(kStatV0C, "V0C");
887 h->GetXaxis()->SetBinLabel(kStatFMD, "FMD");
888 h->GetXaxis()->SetBinLabel(kStatSSD1, "SSD >= 2");
889 h->GetXaxis()->SetBinLabel(kStatV0ABG, "V0A BG");
890 h->GetXaxis()->SetBinLabel(kStatV0CBG, "V0C BG");
891 h->GetXaxis()->SetBinLabel(kStatMB1, "(FO >= 1 | V0A | V0C) & !V0 BG");
892 h->GetXaxis()->SetBinLabel(kStatMB1Prime, "(FO >= 2 | (FO >= 1 & (V0A | V0C)) | (V0A &v0C) ) & !V0 BG");
893 h->GetXaxis()->SetBinLabel(kStatFO1AndV0, "FO >= 1 & (V0A | V0C) & !V0 BG");
894 h->GetXaxis()->SetBinLabel(kStatV0, "V0A & V0C & !V0 BG & !BG ID");
895 h->GetXaxis()->SetBinLabel(kStatOffline, "Offline Trigger");
896 h->GetXaxis()->SetBinLabel(kStatAny2Hits, "2 Hits & !V0 BG");
897 h->GetXaxis()->SetBinLabel(kStatBG, "Background identification");
898 h->GetXaxis()->SetBinLabel(kStatAccepted, "Accepted");
899
900 Int_t n = 1;
901 for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
902 {
903 h->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String());
904 n++;
905 }
906 for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
907 {
908 h->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
909 n++;
910 }
911
912 if(fComputeBG) {
141265a2 913 fBGStatOffset = n;
914 h->GetYaxis()->SetBinLabel(n++, Form("BG (A+C) (Mask [0x%x])", fComputeBG));
85c71ba7 915 h->GetYaxis()->SetBinLabel(n++, "ACC");
916#ifdef VERBOSE_STAT
917 h->GetYaxis()->SetBinLabel(n++, "BG (A+C) % (rel. to CINT1B)");
918 h->GetYaxis()->SetBinLabel(n++, "ACC % (rel. to CINT1B)");
919 h->GetYaxis()->SetBinLabel(n++, "ERR GOOD %");
920 h->GetYaxis()->SetBinLabel(n++, "GOOD % (rel. to 1st col)");
921 h->GetYaxis()->SetBinLabel(n++, "ERR GOOD");
922#endif
923 h->GetYaxis()->SetBinLabel(n++, "GOOD");
924 }
925
926 return h;
927}
928
61899827 929void AliPhysicsSelection::Print(Option_t* /* option */) const
930{
931 // print the configuration
932
a2ce3799 933 Printf("Configuration initialized for run %d (MC: %d):", fCurrentRun, fMC);
61899827 934
296dd262 935 Printf("Collision trigger classes:");
936 for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
937 Printf("%s", ((TObjString*) fCollTrigClasses.At(i))->String().Data());
61899827 938
296dd262 939 Printf("Background trigger classes:");
940 for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
941 Printf("%s", ((TObjString*) fBGTrigClasses.At(i))->String().Data());
942
943 AliTriggerAnalysis* triggerAnalysis = dynamic_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(0));
61899827 944
296dd262 945 if (triggerAnalysis)
946 {
947 if (triggerAnalysis->GetV0TimeOffset() > 0)
948 Printf("V0 time offset active: %.2f ns", triggerAnalysis->GetV0TimeOffset());
61899827 949
296dd262 950 Printf("\nTotal available events:");
528640ed 951
296dd262 952 triggerAnalysis->PrintTriggerClasses();
953 }
528640ed 954
0c6c629b 955 if (fHistStatistics[kStatIdxAll])
b43e01ed 956 {
0c6c629b 957 for (Int_t i=0; i<fCollTrigClasses.GetEntries(); i++)
958 {
959 Printf("\nSelection statistics for collision trigger %s:", ((TObjString*) fCollTrigClasses.At(i))->String().Data());
960
961 Printf("Total events with correct trigger class: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1));
962 Printf("Selected collision candidates: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1));
963 }
17ba346c 964 }
965
966 if (fHistBunchCrossing)
967 {
968 Printf("\nBunch crossing statistics:");
969
970 for (Int_t i=1; i<=fHistBunchCrossing->GetNbinsY(); i++)
971 {
972 TString str;
973 str.Form("Trigger %s has accepted events in the bunch crossings: ", fHistBunchCrossing->GetYaxis()->GetBinLabel(i));
974
975 for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++)
976 if (fHistBunchCrossing->GetBinContent(j, i) > 0)
977 str += Form("%d, ", (Int_t) fHistBunchCrossing->GetXaxis()->GetBinCenter(j));
978
979 Printf("%s", str.Data());
980 }
981
982 for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++)
983 {
0c6c629b 984 Int_t countColl = 0;
985 Int_t countBG = 0;
17ba346c 986 for (Int_t i=1; i<=fHistBunchCrossing->GetNbinsY(); i++)
987 {
988 if (fHistBunchCrossing->GetBinContent(j, i) > 0)
0c6c629b 989 {
990 if (fCollTrigClasses.FindObject(fHistBunchCrossing->GetYaxis()->GetBinLabel(i)))
991 countColl++;
992 if (fBGTrigClasses.FindObject(fHistBunchCrossing->GetYaxis()->GetBinLabel(i)))
993 countBG++;
994 }
17ba346c 995 }
0c6c629b 996 if (countColl > 0 && countBG > 0)
997 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 998 }
b43e01ed 999 }
91bea6e7 1000
1001 if (fUsingCustomClasses)
1002 Printf("WARNING: Using custom trigger classes!");
1003 if (fSkipTriggerClassSelection)
1004 Printf("WARNING: Skipping trigger class selection!");
85c71ba7 1005 if (fSkipV0)
1006 Printf("WARNING: Ignoring V0 information in selection");
1007 if(!fBin0CallBack)
1008 Printf("WARNING: Callback not set: will not fill the statistics for the bin 0");
1009
61899827 1010}
1011
1012Long64_t AliPhysicsSelection::Merge(TCollection* list)
1013{
1014 // Merge a list of AliMultiplicityCorrection objects with this (needed for
1015 // PROOF).
1016 // Returns the number of merged objects (including this).
1017
1018 if (!list)
1019 return 0;
1020
1021 if (list->IsEmpty())
1022 return 1;
1023
1024 TIterator* iter = list->MakeIterator();
1025 TObject* obj;
17ba346c 1026
61899827 1027 // collections of all histograms
1028 const Int_t nHists = 9;
1029 TList collections[nHists];
1030
1031 Int_t count = 0;
1032 while ((obj = iter->Next())) {
1033
1034 AliPhysicsSelection* entry = dynamic_cast<AliPhysicsSelection*> (obj);
1035 if (entry == 0)
1036 continue;
518b6d59 1037 // Update run number. If this one is not initialized (-1) take the one from
1038 // the next physics selection to be merged with. In case of 2 different run
1039 // numbers issue a warning (should physics selections from different runs be
1040 // merged together) A.G.
1041 Int_t currentRun = entry->GetCurrentRun();
1042 // Nothing to merge with since run number was not initialized.
1043 if (currentRun < 0) continue;
1044 if (fCurrentRun < 0) fCurrentRun = currentRun;
1045 if (fCurrentRun != currentRun)
1046 AliWarning(Form("Current run %d not matching the one to be merged with %d", fCurrentRun, currentRun));
1047
17ba346c 1048 collections[0].Add(&(entry->fTriggerAnalysis));
85c71ba7 1049 if (entry->fHistStatistics[0])
1050 collections[1].Add(entry->fHistStatistics[0]);
1051 if (entry->fHistStatistics[1])
1052 collections[2].Add(entry->fHistStatistics[1]);
17ba346c 1053 if (entry->fHistBunchCrossing)
85c71ba7 1054 collections[3].Add(entry->fHistBunchCrossing);
73cc8654 1055 if (entry->fHistTriggerPattern)
1056 collections[4].Add(entry->fHistTriggerPattern);
296dd262 1057 if (entry->fBackgroundIdentification)
73cc8654 1058 collections[5].Add(entry->fBackgroundIdentification);
61899827 1059
1060 count++;
1061 }
1062
17ba346c 1063 fTriggerAnalysis.Merge(&collections[0]);
85c71ba7 1064 if (fHistStatistics[0])
1065 fHistStatistics[0]->Merge(&collections[1]);
1066 if (fHistStatistics[1])
1067 fHistStatistics[1]->Merge(&collections[2]);
17ba346c 1068 if (fHistBunchCrossing)
85c71ba7 1069 fHistBunchCrossing->Merge(&collections[3]);
73cc8654 1070 if (fHistTriggerPattern)
1071 fHistTriggerPattern->Merge(&collections[4]);
296dd262 1072 if (fBackgroundIdentification)
73cc8654 1073 fBackgroundIdentification->Merge(&collections[5]);
61899827 1074
1075 delete iter;
1076
1077 return count+1;
1078}
1079
1080void AliPhysicsSelection::SaveHistograms(const char* folder) const
1081{
1082 // write histograms to current directory
1083
85c71ba7 1084 if (!fHistStatistics[0] || !fHistStatistics[1])
61899827 1085 return;
1086
1087 if (folder)
1088 {
1089 gDirectory->mkdir(folder);
1090 gDirectory->cd(folder);
1091 }
1092
85c71ba7 1093
1094 // Fill the last rows of fHistStatistics before saving
1095 if (fComputeBG) {
1096 Int_t triggerScheme = GetTriggerScheme(UInt_t(fCurrentRun));
1097 if(triggerScheme != 1){
1098 AliWarning("BG estimate only supported for trigger scheme \"1\" (CINT1 suite)");
73cc8654 1099 } else if (fUseMuonTriggers) {
1100 AliWarning("BG estimate with muon triggers to be implemented");
141265a2 1101 } else {
1102 AliInfo("BG estimate assumes that for a given run you only have A and C triggers separately or"
1103 " toghether as a AC class! Make sure this assumption holds in your case");
1104
1105 // use an anum for the different trigger classes, to make loops easier to read
1106 enum {kClassB =0 , kClassA, kClassC, kClassAC, kClassE, kNClasses};
1107 const char * classFlags[] = {"B", "A", "C", "AC", "E"}; // labels
1108
1109 UInt_t * rows[kNClasses] = {0}; // Array of matching rows
1110 Int_t nrows[kNClasses] = {0};
1111 // Get rows matching the requested trigger bits for all trigger classes
1112 for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1113 nrows[iTrigClass] = GetStatRow(classFlags[iTrigClass],fComputeBG,&rows[iTrigClass]);
1114 }
1115
5f337f3d 1116 // 0. Determine the ratios of triggers E/B, A/B, C/B from the stat histogram
1117 // Those are used to rescale the different classes to the same number of bx ids
141265a2 1118 // 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?
1119 Int_t nBXIds[kNClasses] = {0};
1120 cout <<"Computing BG:" << endl;
1121
1122 for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1123 for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {
1124 if(irow==0) cout << "- Class " << classFlags[iTrigClass] << endl;
1125 for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) {
1126 if (fHistBunchCrossing->GetBinContent(j, rows[iTrigClass][irow]) > 0) {
1127 nBXIds[iTrigClass]++;
1128 }
1129 }
1130 if(nBXIds[iTrigClass]>0) cout << " Using row " << rows[iTrigClass][irow] << ": "
1131 << fHistBunchCrossing->GetYaxis()->GetBinLabel(rows[iTrigClass][irow])
1132 << " (nBXID "<< nBXIds[iTrigClass] << ")"<< endl;
1133
1134 }
1135
5f337f3d 1136 }
141265a2 1137
1138 Float_t ratioToB[kNClasses];
1139 ratioToB[kClassE] = nBXIds[kClassE] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassE] : 0;
1140 ratioToB[kClassA] = nBXIds[kClassA] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassA] : 0;
1141 ratioToB[kClassC] = nBXIds[kClassC] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassC] : 0;
1142 ratioToB[kClassAC] = nBXIds[kClassAC] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassAC] : 0;
5f337f3d 1143 Printf("Ratio between the BX ids in the different trigger classes:");
141265a2 1144 Printf(" B/E = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassE], ratioToB[kClassE] );
1145 Printf(" B/A = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassA], ratioToB[kClassA] );
1146 Printf(" B/C = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassC], ratioToB[kClassC] );
1147 Printf(" B/AC = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassAC],ratioToB[kClassAC]);
85c71ba7 1148 Int_t nHistStat = 2;
85c71ba7 1149
141265a2 1150 // 1. loop over all cols
85c71ba7 1151 for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){
85c71ba7 1152 Int_t ncol = fHistStatistics[iHistStat]->GetNbinsX();
141265a2 1153 Float_t good1 = 0;
85c71ba7 1154 for(Int_t icol = 1; icol <= ncol; icol++) {
141265a2 1155 Int_t nEvents[kNClasses] = {0}; // number of events should be reset at every column
1156 // For all trigger classes, add up over row matching trigger mask (as selected before)
1157 for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1158 for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {
1159 nEvents[iTrigClass] += (Int_t) fHistStatistics[iHistStat]->GetBinContent(icol,rows[iTrigClass][irow]);
1160 }
1161 // cout << "Events " << classFlags[iTrigClass] << " ("<<icol<<") " << nEvents[iTrigClass] << endl;
1162 }
1163 if (nEvents[kClassB]>0) {
a67fbdc0 1164 Float_t acc = ratioToB[kClassE]*nEvents[kClassE];
141265a2 1165 Double_t acc_err = TMath::Sqrt(ratioToB[kClassE]*ratioToB[kClassE]*nEvents[kClassE]);
85c71ba7 1166 // Int_t bg = cint1A + cint1C - 2*acc;
141265a2 1167
1168 // Assuming that for a given class the triggers are either recorded as A+C or AC
1169 Float_t bg = nEvents[kClassAC] > 0 ?
1170 fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc):
1171 fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) +
1172 fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) ;
1173
8fc17e87 1174 // cout << "-----------------------" << endl;
1175 // cout << "Factors: " << fBIFactorA << " " << fBIFactorC << " " << fBIFactorAC << endl;
1176 // cout << "Ratios: " << ratioToB[kClassA] << " " << ratioToB[kClassC] << " " << ratioToB[kClassAC] << endl;
1177 // cout << "Evts: " << nEvents[kClassA] << " " << nEvents[kClassC] << " " << nEvents[kClassAC] << " " << nEvents[kClassB] << endl;
1178 // cout << "Acc: " << acc << endl;
141265a2 1179 // cout << "BG: " << bg << endl;
1180 // cout << " " << fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) <<endl;
1181 // cout << " " << fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) <<endl;
1182 // cout << " " << fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc) << endl;
1183 // cout << "-----------------------" << endl;
1184
1185 Float_t good = Float_t(nEvents[kClassB]) - bg - acc;
85c71ba7 1186 if (icol ==1) good1 = good;
141265a2 1187 // Float_t errGood = TMath::Sqrt(2*(nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassE]));// Error on the number of goods assuming only bg fluctuates
85c71ba7 1188 // DeltaG^2 = B + FA^2 A + FC^2 C + Ratio^2 (FA+FC-1)^2 E.
141265a2 1189 Float_t errGood = nEvents[kClassAC] > 0 ?
1190 TMath::Sqrt( nEvents[kClassB] +
1191 fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC] +
1192 ratioToB[kClassE] * ratioToB[kClassE] *
1193 (fBIFactorAC - 1)*(fBIFactorAC - 1)*nEvents[kClassE]) :
1194 TMath::Sqrt( nEvents[kClassB] +
1195 fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA] +
1196 fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC] +
1197 ratioToB[kClassE] * ratioToB[kClassE] *
1198 (fBIFactorA + fBIFactorC - 1)*(fBIFactorA + fBIFactorC - 1)*nEvents[kClassE]);
1199
1200 Float_t errBG = nEvents[kClassAC] > 0 ?
1201 TMath::Sqrt(fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC]+
1202 4*ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorAC*fBIFactorAC)*nEvents[kClassE]) :
1203 TMath::Sqrt(fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA]+
1204 fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC]+
1205 ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorA+fBIFactorC)*(fBIFactorA+fBIFactorC)*nEvents[kClassE]);
85c71ba7 1206
1207
141265a2 1208 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBG,bg);
1209 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowBG,errBG);
1210 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAcc,acc);
1211 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowAcc,acc_err);
1212 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGood,good);
1213 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowGood,errGood);
85c71ba7 1214
1215#ifdef VERBOSE_STAT
141265a2 1216 //kStatRowBG=0,kStatRowAcc,kStatRowBGFrac,kStatRowAccFrac,kStatRowErrGoodFrac,kStatRowGoodFrac,kStatRowGood,kStatRowErrGood
1217 Float_t accFrac = Float_t(acc) / nEvents[kClassB] *100;
1218 Float_t errAccFrac= Float_t(acc_err) / nEvents[kClassB] *100;
1219 Float_t bgFrac = Float_t(bg) / nEvents[kClassB] *100;
85c71ba7 1220 Float_t goodFrac = Float_t(good) / good1 *100;
1221 Float_t errGoodFrac = errGood/good1 * 100;
141265a2 1222 Float_t errFracBG = bg > 0 ? TMath::Sqrt((errBG/bg)*(errBG/bg) + 1/nEvents[kClassB])*bgFrac : 0;
1223 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBGFrac,bgFrac);
1224 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowBGFrac,errFracBG);
1225 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAccFrac,accFrac);
1226 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowAccFrac,errAccFrac);
1227 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGoodFrac,goodFrac);
1228 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGoodFrac,errGoodFrac);
1229 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGood,errGood);
85c71ba7 1230#endif
1231 }
1232 }
1233 }
ed185ba9 1234 for (Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1235 delete [] rows[iTrigClass];
1236 }
85c71ba7 1237 }
1238 }
1239
1240 fHistStatistics[0]->Write();
1241 fHistStatistics[1]->Write();
8e58a7b9 1242 if(fHistBunchCrossing ) fHistBunchCrossing ->Write();
1243 if(fHistTriggerPattern) fHistTriggerPattern->Write();
61899827 1244
296dd262 1245 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
1246 for (Int_t i=0; i < count; i++)
1247 {
1248 TString triggerClass = "trigger_histograms_";
1249 if (i < fCollTrigClasses.GetEntries())
1250 triggerClass += ((TObjString*) fCollTrigClasses.At(i))->String();
1251 else
1252 triggerClass += ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String();
61899827 1253
296dd262 1254 gDirectory->mkdir(triggerClass);
1255 gDirectory->cd(triggerClass);
61899827 1256
296dd262 1257 static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i))->SaveHistograms();
1258
1259 gDirectory->cd("..");
1260 }
1261
1262 if (fBackgroundIdentification)
1263 {
1264 gDirectory->mkdir("background_identification");
1265 gDirectory->cd("background_identification");
1266
1267 fBackgroundIdentification->GetOutput()->Write();
1268
1269 gDirectory->cd("..");
1270 }
61899827 1271
1272 if (folder)
1273 gDirectory->cd("..");
1274}
85c71ba7 1275
141265a2 1276Int_t AliPhysicsSelection::GetStatRow(const char * triggerBXClass, UInt_t offlineTriggerType, UInt_t ** rowIDs) const {
1277 // Puts inside the array rowIDs the row number for a given offline
1278 // trigger in a given bx class. Returns the total number of lines
1279 // matching the selection
1280 // triggerBXClass can be either "A", "AC", "B" or "E"
1281 // offlineTriggerType is one of the types defined in AliVEvent
1282 // User should delete rowIDs if no longer needed
1283
1284 if(!fHistStatistics[0]) {
1285 AliWarning("Not initialized, returning 0");
1286 return 0;
1287 }
1288 const Int_t nrows = fHistStatistics[0]->GetNbinsY();
1289
1290 // allocate memory for at maximum nrows
1291 Int_t nMatches = 0;
1292 (*rowIDs) = new UInt_t[nrows];
1293
1294 // Build regular expression. look for a +, followed by the beginning
1295 // of a word. Within the word, look for the class id after any
1296 // number of any char, but at most one dash ("[^-]*-?"), followed by
1297 // a - and then any char (".*") and at the class id ("\\&(\\d)")
1298 // The class id is stored.
1299 // WARNING: please check this if the trigger classes change
1300 TPRegexp re(Form("\\+\\b[^-]*-?%s-.*\\&(\\d)",triggerBXClass));
1301 // Loop over rows and find matching ones:
1302 for(Int_t irow = 1; irow <= nrows; irow++){
1303 TObjArray * matches = re.MatchS(fHistStatistics[0]->GetYaxis()->GetBinLabel(irow));
1304 if (matches->GetEntries()) {
1305 TString s = ((TObjString*)matches->At(1))->GetString();
1306 if(UInt_t(s.Atoi()) & offlineTriggerType) { // bitwise comparison with the requested mask
1307 // cout << "Marching " << s.Data() << " " << offlineTriggerType << " " << fHistStatistics[0]->GetYaxis()->GetBinLabel(irow) << endl;
1308 (*rowIDs)[nMatches] = irow;
1309 nMatches++;
1310 }
1311 }
1312 delete matches;
85c71ba7 1313 }
141265a2 1314
1315 return nMatches;
1316}
85c71ba7 1317
141265a2 1318void AliPhysicsSelection::SetBIFactors(const AliESDEvent * aESD) {
1319 // Set factors for realtive bunch intesities
1320 if(!aESD) {
1321 AliFatal("ESD not given");
1322 }
1323 Int_t run = aESD->GetRunNumber();
1324 if (run > 105268) {
1325 // intensities stored in the ESDs
1326 const AliESDRun* esdRun = aESD->GetESDRun();
1327 Double_t intAB = esdRun->GetMeanIntensityIntecting(0);
1328 Double_t intCB = esdRun->GetMeanIntensityIntecting(1);
1329 Double_t intAA = esdRun->GetMeanIntensityNonIntecting(0);
1330 Double_t intCC = esdRun->GetMeanIntensityNonIntecting(1);
1331
1332 // cout << "INT " <<intAB <<endl;
1333 // cout << "INT " <<intCB <<endl;
1334 // cout << "INT " <<intAA <<endl;
1335 // cout << "INT " <<intCC <<endl;
1336
1337 if (intAB > -1 && intAA > -1) {
1338 fBIFactorA = intAB/intAA;
1339 } else {
1340 AliWarning("Cannot set fBIFactorA, assuming 1");
1341 }
1342
1343 if (intCB > -1 && intCC > -1) {
1344 fBIFactorC = intCB/intCC;
1345 } else {
1346 AliWarning("Cannot set fBIFactorC, assuming 1");
1347 }
1348
1349 if (intAB > -1 && intAA > -1 &&
1350 intCB > -1 && intCC > -1) {
1351 fBIFactorAC = (intAB+intCB)/(intAA+intCC);
1352 } else {
1353 AliWarning("Cannot set fBIFactorAC, assuming 1");
1354 }
1355
1356 }
1357 else {
1358 // First runs. Intensities hardcoded
1359 switch(run) {
1360 case 104155:
1361 fBIFactorA = 0.961912722908;
1362 fBIFactorC = 1.04992336081;
1363 break;
1364 case 104157:
1365 fBIFactorA = 0.947312854998;
1366 fBIFactorC = 1.01599706417;
1367 break;
1368 case 104159:
1369 fBIFactorA = 0.93659320151;
1370 fBIFactorC = 0.98580804207;
1371 break;
1372 case 104160:
1373 fBIFactorA = 0.929664189926;
1374 fBIFactorC = 0.963467679851;
1375 break;
1376 case 104315:
1377 fBIFactorA = 1.08939104979;
1378 fBIFactorC = 0.931113921925;
1379 break;
1380 case 104316:
1381 fBIFactorA = 1.08351880974;
1382 fBIFactorC = 0.916068345845;
1383 break;
1384 case 104320:
1385 fBIFactorA = 1.07669281245;
1386 fBIFactorC = 0.876818744763;
1387 break;
1388 case 104321:
1389 fBIFactorA = 1.00971079602;
1390 fBIFactorC = 0.773781299076;
1391 break;
1392 case 104792:
1393 fBIFactorA = 0.787215863962;
1394 fBIFactorC = 0.778253173071;
1395 break;
1396 case 104793:
1397 fBIFactorA = 0.692211363661;
1398 fBIFactorC = 0.733152456667;
1399 break;
1400 case 104799:
1401 fBIFactorA = 1.04027825161;
1402 fBIFactorC = 1.00530825942;
1403 break;
1404 case 104800:
1405 fBIFactorA = 1.05309910671;
1406 fBIFactorC = 1.00376801855;
1407 break;
1408 case 104801:
1409 fBIFactorA = 1.0531231922;
1410 fBIFactorC = 0.992439666758;
1411 break;
1412 case 104802:
1413 fBIFactorA = 1.04191478134;
1414 fBIFactorC = 0.979368585208;
1415 break;
1416 case 104803:
1417 fBIFactorA = 1.03121314094;
1418 fBIFactorC = 0.973379962609;
1419 break;
1420 case 104824:
1421 fBIFactorA = 0.969945926722;
1422 fBIFactorC = 0.39549745806;
1423 break;
1424 case 104825:
1425 fBIFactorA = 0.968627213937;
1426 fBIFactorC = 0.310100412205;
1427 break;
1428 case 104841:
1429 fBIFactorA = 0.991601393212;
1430 fBIFactorC = 0.83762204722;
1431 break;
1432 case 104845:
1433 fBIFactorA = 0.98040863886;
1434 fBIFactorC = 0.694824205793;
1435 break;
1436 case 104867:
1437 fBIFactorA = 1.10646173412;
1438 fBIFactorC = 0.841407246916;
1439 break;
1440 case 104876:
1441 fBIFactorA = 1.12063452421;
1442 fBIFactorC = 0.78726542895;
1443 break;
1444 case 104890:
1445 fBIFactorA = 1.02346137453;
1446 fBIFactorC = 1.03355663595;
1447 break;
1448 case 104892:
1449 fBIFactorA = 1.05406025913;
1450 fBIFactorC = 1.00029166135;
1451 break;
1452 case 105143:
1453 fBIFactorA = 0.947343384349;
1454 fBIFactorC = 0.972637444408;
1455 break;
1456 case 105160:
1457 fBIFactorA = 0.908854622177;
1458 fBIFactorC = 0.958851103977;
1459 break;
1460 case 105256:
1461 fBIFactorA = 0.810076150206;
1462 fBIFactorC = 0.884663561883;
1463 break;
1464 case 105257:
1465 fBIFactorA = 0.80974912303;
1466 fBIFactorC = 0.878859123479;
1467 break;
1468 case 105268:
1469 fBIFactorA = 0.809052110679;
1470 fBIFactorC = 0.87233890989;
1471 break;
1472 default:
1473 fBIFactorA = 1;
1474 fBIFactorC = 1;
1475 }
1476 }
85c71ba7 1477
1478}