]> 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
Merge branch 'flatdev' of https://git.cern.ch/reps/AliRoot into flatdev
[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//
869f9767 95// The class also supports the triggers used in heavy ion runs
96//
85c71ba7 97// Origin: Jan Fiete Grosse-Oetringhaus, CERN
98// Michele Floris, CERN
61899827 99//-------------------------------------------------------------------------
100
101#include <Riostream.h>
102#include <TH1F.h>
103#include <TH2F.h>
104#include <TList.h>
105#include <TIterator.h>
106#include <TDirectory.h>
296dd262 107#include <TObjArray.h>
7c55ebd9 108#include <TPRegexp.h>
109#include <TFormula.h>
110#include <TParameter.h>
111#include <TInterpreter.h>
61899827 112
113#include <AliPhysicsSelection.h>
114
115#include <AliTriggerAnalysis.h>
116#include <AliLog.h>
117
118#include <AliESDEvent.h>
85c71ba7 119#include <AliAnalysisTaskSE.h>
120#include "AliAnalysisManager.h"
141265a2 121#include "TPRegexp.h"
7c55ebd9 122#include "TFile.h"
123#include <AliOADBContainer.h>
124#include "AliOADBPhysicsSelection.h"
125#include "AliOADBFillingScheme.h"
eeaab745 126#include "AliOADBTriggerAnalysis.h"
61899827 127
c82bb898 128using std::cout;
129using std::endl;
61899827 130ClassImp(AliPhysicsSelection)
131
132AliPhysicsSelection::AliPhysicsSelection() :
296dd262 133 AliAnalysisCuts("AliPhysicsSelection", "AliPhysicsSelection"),
134 fCurrentRun(-1),
a2ce3799 135 fMC(kFALSE),
296dd262 136 fCollTrigClasses(),
137 fBGTrigClasses(),
138 fTriggerAnalysis(),
7c55ebd9 139// fHistStatisticsTokens(0),
91bea6e7 140 fHistBunchCrossing(0),
73cc8654 141 fHistTriggerPattern(0),
91bea6e7 142 fSkipTriggerClassSelection(0),
85c71ba7 143 fUsingCustomClasses(0),
144 fSkipV0(0),
8dec6e35 145 fBIFactorA(-1),
146 fBIFactorC(-1),
147 fBIFactorAC(-1),
85c71ba7 148 fComputeBG(0),
7c55ebd9 149 fBGStatOffset(-1),
73cc8654 150 fUseBXNumbers(1),
151 fUseMuonTriggers(0),
85c71ba7 152 fFillingScheme(""),
ff097e3f 153 fBin0CallBack(""),
869f9767 154 fBin0CallBackPointer(0),
7c55ebd9 155 fIsPP(kFALSE),
156 fPSOADB(0),
157 fFillOADB(0),
eeaab745 158 fTriggerOADB(0),
7c55ebd9 159 fRegexp(0),
160 fCashedTokens(0)
161
61899827 162{
163 // constructor
164
296dd262 165 fCollTrigClasses.SetOwner(1);
166 fBGTrigClasses.SetOwner(1);
167 fTriggerAnalysis.SetOwner(1);
85c71ba7 168 fHistStatistics[0] = 0;
169 fHistStatistics[1] = 0;
296dd262 170
7c55ebd9 171 fRegexp = new TPRegexp("([[:alpha:]]\\w*)");
172 fCashedTokens = new TList;
173 fCashedTokens->SetOwner();
174
61899827 175 AliLog::SetClassDebugLevel("AliPhysicsSelection", AliLog::kWarning);
176}
177
178AliPhysicsSelection::~AliPhysicsSelection()
179{
180 // destructor
85c71ba7 181
296dd262 182 fCollTrigClasses.Delete();
183 fBGTrigClasses.Delete();
184 fTriggerAnalysis.Delete();
61899827 185
85c71ba7 186 if (fHistStatistics[0])
187 {
188 delete fHistStatistics[0];
189 fHistStatistics[0] = 0;
190 }
191 if (fHistStatistics[1])
61899827 192 {
85c71ba7 193 delete fHistStatistics[1];
194 fHistStatistics[1] = 0;
61899827 195 }
7c55ebd9 196 // if (fHistStatisticsTokens) {
197 // delete fHistStatisticsTokens;
198 // fHistStatisticsTokens = 0;
199 // }
61899827 200 if (fHistBunchCrossing)
201 {
202 delete fHistBunchCrossing;
203 fHistBunchCrossing = 0;
204 }
73cc8654 205 if (fHistTriggerPattern)
206 {
207 delete fHistTriggerPattern;
208 fHistTriggerPattern = 0;
209 }
7c55ebd9 210
211 if (fPSOADB)
212 {
213 delete fPSOADB;
eeaab745 214 fPSOADB = 0;
7c55ebd9 215 }
216 if (fFillOADB)
217 {
218 delete fFillOADB;
219 fFillOADB = 0;
220 }
eeaab745 221 if (fTriggerOADB)
222 {
223 delete fTriggerOADB;
224 fTriggerOADB = 0;
225 }
7c55ebd9 226
227 if (fRegexp)
228 {
229 delete fRegexp;
230 fRegexp = 0;
231 }
232
233 if (fCashedTokens)
234 {
235 delete fCashedTokens;
236 fCashedTokens = 0;
237 }
238
239
61899827 240}
296dd262 241
c2ba5a61 242UInt_t AliPhysicsSelection::CheckTriggerClass(const AliESDEvent* aEsd, const char* trigger, Int_t& triggerLogic) const
296dd262 243{
244 // checks if the given trigger class(es) are found for the current event
05e1da5d 245 // format of trigger: +TRIGGER1,TRIGGER1b,TRIGGER1c -TRIGGER2 [#XXX] [&YY] [*ZZ]
246 // requires one out of TRIGGER1,TRIGGER1b,TRIGGER1c and rejects TRIGGER2
0c6c629b 247 // in bunch crossing XXX
1209509c 248 // if successful, YY is returned (for association between entry in fCollTrigClasses and AliVEvent::EOfflineTriggerTypes)
c2ba5a61 249 // triggerLogic is filled with ZZ, defaults to kCINT1
296dd262 250
decf6fd4 251 Bool_t foundBCRequirement = kFALSE;
252 Bool_t foundCorrectBC = kFALSE;
253
0c6c629b 254 UInt_t returnCode = AliVEvent::kUserDefined;
c2ba5a61 255 triggerLogic = kCINT1;
0c6c629b 256
6340be16 257 AliDebug(AliLog::kDebug+1, Form("Processing event with triggers %s", aEsd->GetFiredTriggerClasses().Data()));
258
296dd262 259 TString str(trigger);
260 TObjArray* tokens = str.Tokenize(" ");
261
262 for (Int_t i=0; i < tokens->GetEntries(); i++)
263 {
264 TString str2(((TObjString*) tokens->At(i))->String());
265
decf6fd4 266 if (str2[0] == '+' || str2[0] == '-')
296dd262 267 {
decf6fd4 268 Bool_t flag = (str2[0] == '+');
269
270 str2.Remove(0, 1);
271
05e1da5d 272 TObjArray* tokens2 = str2.Tokenize(",");
273
274 Bool_t foundTriggerClass = kFALSE;
275 for (Int_t j=0; j < tokens2->GetEntries(); j++)
decf6fd4 276 {
05e1da5d 277 TString str3(((TObjString*) tokens2->At(j))->String());
278
279 if (flag && aEsd->IsTriggerClassFired(str3))
280 foundTriggerClass = kTRUE;
281 if (!flag && aEsd->IsTriggerClassFired(str3))
282 {
7c55ebd9 283 AliDebug(AliLog::kDebug+1, Form("Rejecting event because trigger class %s is present", str3.Data()));
05e1da5d 284 delete tokens2;
285 delete tokens;
286 return kFALSE;
287 }
decf6fd4 288 }
05e1da5d 289
290 delete tokens2;
291
6340be16 292 if (flag && !foundTriggerClass)
decf6fd4 293 {
7c55ebd9 294 AliDebug(AliLog::kDebug+1, Form("Rejecting event because (none of the) trigger class(es) %s is present", str2.Data()));
decf6fd4 295 delete tokens;
296 return kFALSE;
297 }
296dd262 298 }
decf6fd4 299 else if (str2[0] == '#')
296dd262 300 {
decf6fd4 301 foundBCRequirement = kTRUE;
302
303 str2.Remove(0, 1);
304
305 Int_t bcNumber = str2.Atoi();
7c55ebd9 306 AliDebug(AliLog::kDebug+1, Form("Checking for bunch crossing number %d", bcNumber));
decf6fd4 307
308 if (aEsd->GetBunchCrossNumber() == bcNumber)
309 {
310 foundCorrectBC = kTRUE;
7c55ebd9 311 AliDebug(AliLog::kDebug+1, Form("Found correct bunch crossing %d", bcNumber));
decf6fd4 312 }
296dd262 313 }
7c55ebd9 314 else if (str2[0] == '&')
0c6c629b 315 {
316 str2.Remove(0, 1);
317
1209509c 318 returnCode = str2.Atoll();
0c6c629b 319 }
c2ba5a61 320 else if (str2[0] == '*')
321 {
322 str2.Remove(0, 1);
323
324 triggerLogic = str2.Atoi();
325 }
decf6fd4 326 else
327 AliFatal(Form("Invalid trigger syntax: %s", trigger));
296dd262 328 }
329
330 delete tokens;
decf6fd4 331
332 if (foundBCRequirement && !foundCorrectBC)
333 return kFALSE;
334
0c6c629b 335 return returnCode;
296dd262 336}
2d45a1a7 337
338//______________________________________________________________________________
7c55ebd9 339TObject *AliPhysicsSelection::GetStatistics(const Option_t *option) const
2d45a1a7 340{
7c55ebd9 341// Get the statistics histograms ("ALL" and "BIN0" and "TOK")
2d45a1a7 342 TString opt(option);
343 opt.ToUpper();
344 Int_t ihist = 0;
345 if (opt == "ALL") ihist = kStatIdxAll;
346 if (opt == "BIN0") ihist = kStatIdxBin0;
7c55ebd9 347 // if (opt == "TOK") return fHistStatisticsTokens;
2d45a1a7 348 return fHistStatistics[ihist];
349}
350
7c55ebd9 351//______________________________________________________________________________
352Bool_t AliPhysicsSelection::EvaluateTriggerLogic(const AliESDEvent* aEsd, AliTriggerAnalysis* triggerAnalysis, const char* triggerLogic, Bool_t offline)
353{
354 // evaluates trigger logic. If called with no ESD pointer/triggerAnalysis pointer, it just caches the tokens
355 // Fills the statistics histogram, if booked at row i
356 TString trigger(triggerLogic);
357
358 // add space after each token (to use ReplaceAll later)
359 fRegexp->Substitute(trigger, "$1 ", "g");
360
361 while (1)
362 {
363 AliDebug(AliLog::kDebug, trigger.Data());
364
365 TArrayI pos;
366 Int_t nMatches = fRegexp->Match(trigger, "", 0, 2, &pos);
367
368 if (nMatches <= 0)
369 break;
370
371 TString token(trigger(pos[0], pos[1]-pos[0]+1));
372
373 TParameter<Int_t>* param = (TParameter<Int_t>*) fCashedTokens->FindObject(token);
374 if (!param)
375 {
376 TInterpreter::EErrorCode error;
377 Int_t bit = gInterpreter->ProcessLine(Form("AliTriggerAnalysis::k%s;", token.Data()), &error);
378
379 if (error > 0)
380 AliFatal(Form("Trigger token %s unknown", token.Data()));
381
382 param = new TParameter<Int_t>(token, bit);
383 fCashedTokens->Add(param);
384 AliDebug(AliLog::kDebug, "Added token");
385 }
386
387 Long64_t bit = param->GetVal();
388
389 AliDebug(AliLog::kDebug, Form("Tok %d %d %s %lld", pos[0], pos[1], token.Data(), bit));
390
391 if (offline)
392 bit |= AliTriggerAnalysis::kOfflineFlag;
393
394 if(aEsd && triggerAnalysis) {
395 trigger.ReplaceAll(token, Form("%d", triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) bit)));
396 // if(fHistStatisticsTokens)
397 }
398 }
7a4eb25e 399
7c55ebd9 400 TFormula formula("formula", trigger);
7a4eb25e 401 if (formula.Compile() > 0)
402 AliFatal(Form("Could not evaluate trigger logic %s (evaluated to %s)", triggerLogic, trigger.Data()));
7c55ebd9 403 Bool_t result = formula.Eval(0);
404
405 AliDebug(AliLog::kDebug, Form("%s --> %d", trigger.Data(), result));
406
407 return result;
408}
409
2d45a1a7 410//______________________________________________________________________________
0c6c629b 411UInt_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd)
61899827 412{
413 // checks if the given event is a collision candidate
0c6c629b 414 //
415 // returns a bit word describing the fired offline triggers (see AliVEvent::EOfflineTriggerTypes)
7acc5b9d 416 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
417 if (!mgr) {
418 AliError("Cannot get the analysis manager");
419 return 0;
420 }
421 mgr->LoadBranch("AliESDHeader.");
422 mgr->LoadBranch("AliESDRun.");
1ea7a921 423
141265a2 424 if (fCurrentRun != aEsd->GetRunNumber()) {
1107e2ce 425 if (!Initialize(aEsd))
95e6f4ec 426 AliFatal(Form("Could not initialize for run %d", aEsd->GetRunNumber()));
141265a2 427 if(fComputeBG) SetBIFactors(aEsd); // is this safe here?
428 }
61899827 429 const AliESDHeader* esdHeader = aEsd->GetHeader();
430 if (!esdHeader)
431 {
432 AliError("ESD Header could not be retrieved");
433 return kFALSE;
434 }
435
a2ce3799 436 // check event type; should be PHYSICS = 7 for data and 0 for MC
437 if (!fMC)
438 {
439 if (esdHeader->GetEventType() != 7)
440 return kFALSE;
441 }
442 else
443 {
444 if (esdHeader->GetEventType() != 0)
445 AliFatal(Form("Invalid event type for MC: %d", esdHeader->GetEventType()));
446 }
758941d4 447
1ea7a921 448 mgr->LoadBranch("AliMultiplicity.");
449//mgr->LoadBranch("AliESDFMD.");
450 mgr->LoadBranch("AliESDVZERO.");
451 mgr->LoadBranch("AliESDZDC.");
452 mgr->LoadBranch("SPDVertex.");
453 mgr->LoadBranch("PrimaryVertex.");
454 mgr->LoadBranch("TPCVertex.");
455 mgr->LoadBranch("Tracks");
456 mgr->LoadBranch("SPDPileupVertices");
457
0c6c629b 458 UInt_t accept = 0;
296dd262 459
460 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
461 for (Int_t i=0; i < count; i++)
61899827 462 {
296dd262 463 const char* triggerClass = 0;
464 if (i < fCollTrigClasses.GetEntries())
465 triggerClass = ((TObjString*) fCollTrigClasses.At(i))->String();
466 else
467 triggerClass = ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String();
61899827 468
7c55ebd9 469 AliDebug(AliLog::kDebug+1, Form("Processing trigger class %s", triggerClass));
61899827 470
296dd262 471 AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i));
61899827 472
296dd262 473 triggerAnalysis->FillTriggerClasses(aEsd);
61899827 474
c2ba5a61 475 Int_t triggerLogic = 0;
476 UInt_t singleTriggerResult = CheckTriggerClass(aEsd, triggerClass, triggerLogic);
477
0c6c629b 478 if (singleTriggerResult)
296dd262 479 {
480 triggerAnalysis->FillHistograms(aEsd);
481
85c71ba7 482 Bool_t isBin0 = kFALSE;
483 if (fBin0CallBack != "") {
85c71ba7 484 isBin0 = ((AliAnalysisTaskSE*)mgr->GetTask(fBin0CallBack.Data()))->IsEventInBinZero();
ff097e3f 485 } else if (fBin0CallBackPointer) {
486 isBin0 = (*fBin0CallBackPointer)(aEsd);
85c71ba7 487 }
ff097e3f 488
7c55ebd9 489 // ---->
490 // FIXME: this stuff is still used to fill the stat
491 // tables. Decide wethere we are switching to a new stat table
492 // (with all AliTriggerAnalysis tokens? Only we the tokens
493 // actually used in the selection?) and clean up
494
020c88fa 495 AliESDVZERO *esdV0 = aEsd->GetVZEROData();
496 if(!esdV0) fSkipV0 = kTRUE;
497
c2ba5a61 498 // hardware trigger
7c55ebd9 499 Int_t fastORHW = triggerAnalysis->EvaluateTrigger(aEsd, AliTriggerAnalysis::kSPDGFO); // SPD number of chips from trigger bits (!)
500 // Int_t fastORHWL1 = triggerAnalysis->EvaluateTrigger(aEsd, AliTriggerAnalysis::kSPDGFOL1); // SPD number of chips from trigger bits in second layer (!)
501 Bool_t v0AHW = fSkipV0 ? 0 : triggerAnalysis->EvaluateTrigger(aEsd, AliTriggerAnalysis::kV0A);// should replay hw trigger
502 Bool_t v0CHW = fSkipV0 ? 0 : triggerAnalysis->EvaluateTrigger(aEsd, AliTriggerAnalysis::kV0C);// should replay hw trigger
c2ba5a61 503
cc9d9320 504 // offline trigger
7c55ebd9 505 Int_t fastOROffline = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kSPDGFO)); // SPD number of chips from clusters (!)
506 Int_t fastOROfflineL1 = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kSPDGFOL1)); // SPD number of chips from clusters in second layer (!)
507 Bool_t v0A = fSkipV0 ? 0 : triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kV0A));
508 Bool_t v0C = fSkipV0 ? 0 : triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kV0C));
509 Bool_t v0ABG = fSkipV0 ? 0 : triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kV0ABG));
510 Bool_t v0CBG = fSkipV0 ? 0 : triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kV0CBG));
f4ca8f20 511 Bool_t v0BG = v0ABG || v0CBG;
559b5ed7 512 Bool_t t0 = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0 ));
513 Bool_t t0BG = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0BG ));
514 Bool_t t0PileUp = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kT0Pileup));
85c71ba7 515
516 // fmd
396981c2 517 // Bool_t fmdA = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kFMDA));
518 // Bool_t fmdC = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kFMDC));
519 // Bool_t fmd = fmdA || fmdC;
61899827 520
85c71ba7 521 // SSD
1107e2ce 522 //Int_t ssdClusters = triggerAnalysis->SSDClusters(aEsd);
c2ba5a61 523
524 // ZDC
ce08cb1f 525 // Bool_t zdcA = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kZDCA);
526 // Bool_t zdcC = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kZDCC);
7c55ebd9 527 Bool_t zdcA = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZDCTDCA));
528 Bool_t zdcC = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZDCTDCC));
529 Bool_t zdcTime = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZDCTime));
3c6c0362 530 Bool_t znABG = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZNABG));
531 Bool_t znCBG = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kZNCBG));
85c71ba7 532
396981c2 533 Bool_t laserCut = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kTPCLaserWarmUp));
b68d0b5e 534 Bool_t hvDipCut = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kTPCHVdip));
396981c2 535
85c71ba7 536 // Some "macros"
537 Bool_t mb1 = (fastOROffline > 0 || v0A || v0C) && (!v0BG);
538 Bool_t mb1prime = (fastOROffline > 1 || (fastOROffline > 0 && (v0A || v0C)) || (v0A && v0C) ) && (!v0BG);
539
540 // Background rejection
8663e267 541 Bool_t bgID = kFALSE;
1ea7a921 542 bgID = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kSPDClsVsTrkBG | AliTriggerAnalysis::kOfflineFlag)); // FIXME: temporarily, we keep both ways to validate the new one. if the external BG id is not set, it will use the new one
8663e267 543
c2ba5a61 544 /*Int_t ntrig = fastOROffline; // any 2 hits
85c71ba7 545 if(v0A) ntrig += 1;
546 if(v0C) ntrig += 1; //v0C alone is enough
547 if(fmd) ntrig += 1;
c2ba5a61 548 if(ssdClusters>1) ntrig += 1;*/
85c71ba7 549
8d5a14d6 550 // // EMCAL offline trigger validation
551 // Bool_t emcCut = triggerAnalysis->EvaluateTrigger(aEsd, (AliTriggerAnalysis::Trigger) (AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kEMCAL));
7c55ebd9 552
553 // <---
554
555 TString triggerLogicOnline = fPSOADB->GetHardwareTrigger(triggerLogic);
556 TString triggerLogicOffline = fPSOADB->GetOfflineTrigger(triggerLogic);
557
010e7ad7 558 AliDebug(AliLog::kDebug, Form("Triggers from OADB [0x%x][%d][%s][%s]",singleTriggerResult,AliOADBPhysicsSelection::GetActiveBit(singleTriggerResult),triggerLogicOffline.Data(),triggerLogicOnline.Data()));
7c55ebd9 559
c2ba5a61 560 // replay hardware trigger (should only remove events for MC)
7c55ebd9 561 Bool_t onlineTrigger = EvaluateTriggerLogic(aEsd, triggerAnalysis, triggerLogicOnline, kFALSE);
562 // offline selection
563 Bool_t offlineTrigger = EvaluateTriggerLogic(aEsd, triggerAnalysis, triggerLogicOffline, kTRUE);
c2ba5a61 564
7c55ebd9 565 // Printf("%s %s", triggerLogicOnline.Data(), triggerLogicOffline.Data());
566 // Printf("%d %d", onlineTrigger, offlineTrigger);
567
85c71ba7 568
73cc8654 569 // Fill trigger pattern histo
570 Int_t tpatt = 0;
571 if (fastORHW>0) tpatt+=1;
572 if (v0AHW) tpatt+=2;
573 if (v0CHW) tpatt+=4;
574 fHistTriggerPattern->Fill( tpatt );
575
85c71ba7 576 // fill statistics and return decision
577 const Int_t nHistStat = 2;
578 for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){
579 if (iHistStat == kStatIdxBin0 && !isBin0) continue; // skip the filling of bin0 stats if the event is not in the bin0
580
581 fHistStatistics[iHistStat]->Fill(kStatTriggerClass, i);
8dec6e35 582 if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting)
85c71ba7 583
85c71ba7 584 // We fill the rest only if hw trigger is ok
7c55ebd9 585 if (!onlineTrigger)
85c71ba7 586 {
587 AliDebug(AliLog::kDebug, "Rejecting event because hardware trigger is not fired");
588 continue;
589 } else {
590 fHistStatistics[iHistStat]->Fill(kStatHWTrig, i);
591 }
733f0542 592
85c71ba7 593
594 // v0 BG stats
595 if (v0ABG)
596 fHistStatistics[iHistStat]->Fill(kStatV0ABG, i);
597 if (v0CBG)
598 fHistStatistics[iHistStat]->Fill(kStatV0CBG, i);
599
559b5ed7 600 // T0 stats
601 if(t0)
602 fHistStatistics[iHistStat]->Fill(kStatT0BB, i);
603 if(t0BG)
604 fHistStatistics[iHistStat]->Fill(kStatT0BG, i);
605 if(t0PileUp)
606 fHistStatistics[iHistStat]->Fill(kStatT0PileUp, i);
607
7c55ebd9 608 // mb 1
85c71ba7 609 if (mb1)
610 fHistStatistics[iHistStat]->Fill(kStatMB1, i);
85c71ba7 611
612 if (mb1prime)
613 fHistStatistics[iHistStat]->Fill(kStatMB1Prime, i);
614
396981c2 615 if (laserCut)
616 fHistStatistics[iHistStat]->Fill(kStatLaserCut, i);
85c71ba7 617
b68d0b5e 618 if (hvDipCut)
619 fHistStatistics[iHistStat]->Fill(kHVdipCut, i);
620
c2ba5a61 621 //if(ntrig >= 2 && !v0BG)
622 // fHistStatistics[iHistStat]->Fill(kStatAny2Hits, i);
85c71ba7 623
624 if (fastOROffline > 0)
625 fHistStatistics[iHistStat]->Fill(kStatFO1, i);
626 if (fastOROffline > 1)
627 fHistStatistics[iHistStat]->Fill(kStatFO2, i);
c2ba5a61 628 if (fastOROfflineL1 > 1)
629 fHistStatistics[iHistStat]->Fill(kStatFO2L1, i);
cc9d9320 630
85c71ba7 631 if (v0A)
632 fHistStatistics[iHistStat]->Fill(kStatV0A, i);
633 if (v0C)
634 fHistStatistics[iHistStat]->Fill(kStatV0C, i);
c2ba5a61 635
636 if (zdcA)
637 fHistStatistics[iHistStat]->Fill(kStatZDCA, i);
638 if (zdcC)
639 fHistStatistics[iHistStat]->Fill(kStatZDCC, i);
640 if (zdcA && zdcC)
641 fHistStatistics[iHistStat]->Fill(kStatZDCAC, i);
7c55ebd9 642
869f9767 643 if (zdcTime)
644 fHistStatistics[iHistStat]->Fill(kStatZDCTime, i);
3c6c0362 645 if (znABG)
646 fHistStatistics[iHistStat]->Fill(kStatZNABG, i);
647 if (znCBG)
648 fHistStatistics[iHistStat]->Fill(kStatZNCBG, i);
296dd262 649
869f9767 650 if (v0A && v0C && !v0BG && (!bgID && fIsPP))
85c71ba7 651 fHistStatistics[iHistStat]->Fill(kStatV0, i);
652
3c6c0362 653 if (v0A && v0C && !v0BG && (!bgID && fIsPP) && !znABG && !znCBG)
654 fHistStatistics[iHistStat]->Fill(kStatV0ZN, i);
655
1ea7a921 656 if (bgID && !v0BG)
657 fHistStatistics[iHistStat]->Fill(kStatBG, i);
7c55ebd9 658
659 // FIXME: check lines below
660 if ( offlineTrigger )
85c71ba7 661 {
662 if (!v0BG || fSkipV0)
663 {
664 if (!v0BG) fHistStatistics[iHistStat]->Fill(kStatOffline, i);
1ea7a921 665 AliDebug(AliLog::kDebug, Form("Accepted event for histograms with trigger logic %d", triggerLogic));
296dd262 666
1ea7a921 667 fHistStatistics[iHistStat]->Fill(kStatAccepted, i);
668
669 if (aEsd->IsPileupFromSPD())
670 fHistStatistics[iHistStat]->Fill(kStatAcceptedPileUp, i);
671
8dec6e35 672 // if(iHistStat == kStatIdxAll) fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); // Fill only for all (avoid double counting)
1ea7a921 673 if((i < fCollTrigClasses.GetEntries() || fSkipTriggerClassSelection) && (iHistStat==kStatIdxAll))
674 accept |= singleTriggerResult; // only set for "all" (should not really matter)
85c71ba7 675 }
676 else
677 AliDebug(AliLog::kDebug, "Rejecting event because of V0 BG flag");
678 }
679 else
c2ba5a61 680 AliDebug(AliLog::kDebug, Form("Rejecting event because trigger logic %d is not fulfilled", triggerLogic));
296dd262 681 }
296dd262 682 }
683 }
684
685 if (accept)
0c6c629b 686 AliDebug(AliLog::kDebug, Form("Accepted event as collision candidate with bit mask %d", accept));
61899827 687
296dd262 688 return accept;
61899827 689}
a2ce3799 690
5f337f3d 691
7c55ebd9 692// const char * AliPhysicsSelection::GetFillingScheme(UInt_t runNumber) {
693
694// if(fMC) return "MC";
695
696// if (runNumber >= 104065 && runNumber <= 104160) {
697// return "4x4a";
698// }
699// else if (runNumber >= 104315 && runNumber <= 104321) {
700// return "4x4a*";
701// }
702// else if (runNumber >= 104792 && runNumber <= 104803) {
703// return "4x4b";
704// }
705// else if (runNumber >= 104824 && runNumber <= 104892) {
706// return "4x4c";
707// }
708// else if (runNumber == 105143 || runNumber == 105160) {
709// return "16x16a";
710// }
711// else if (runNumber >= 105256 && runNumber <= 105268) {
712// return "4x4c";
713// }
714// else if (runNumber >= 114786 && runNumber <= 116684) {
715// return "Single_2b_1_1_1";
716// }
717// else if (runNumber >= 117048 && runNumber <= 117120) {
718// return "Single_3b_2_2_2";
719// }
720// else if (runNumber >= 117220 && runNumber <= 119163) {
721// return "Single_2b_1_1_1";
722// }
723// else if (runNumber >= 119837 && runNumber <= 119862) {
724// return "Single_4b_2_2_2";
725// }
726// else if (runNumber >= 119902 && runNumber <= 120691) {
727// return "Single_6b_3_3_3";
728// }
729// else if (runNumber >= 120741 && runNumber <= 122375) {
730// return "Single_13b_8_8_8";
731// }
732// else if (runNumber >= 130148 && runNumber <= 130375) {
733// return "125n_48b_36_16_36";
734// }
735// else if (runNumber >= 130601 && runNumber <= 130640) {
736// return "1000ns_50b_35_14_35";
737// }
738// else {
739// AliError(Form("Unknown filling scheme (run %d)", runNumber));
740// }
741
742// return "Unknown";
743// }
744
745// const char * AliPhysicsSelection::GetBXIDs(UInt_t runNumber, const char * trigger) {
746
747// if (!fUseBXNumbers || fMC) return "";
748
749// if (runNumber >= 104065 && runNumber <= 104160) {
750// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #2128 #3019";
751// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #346 #3465";
752// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1234 #1680";
753// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790";
754// // else AliError(Form("Unknown trigger: %s", trigger));
755// }
756// else if (runNumber >= 104315 && runNumber <= 104321) {
757// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #2000 #2891";
758// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #218 #3337";
759// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1106 #1552";
760// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790";
761// // else AliError(Form("Unknown trigger: %s", trigger));
762// }
763// else if (runNumber >= 104792 && runNumber <= 104803) {
764// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #2228 #3119";
765// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2554 #446";
766// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1334 #769";
767// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790";
768// // else AliError(Form("Unknown trigger: %s", trigger));
769// }
770// else if (runNumber >= 104824 && runNumber <= 104892) {
771// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #3119 #769";
772// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2554 #446";
773// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1334 #2228";
774// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790";
775// // else AliError(Form("Unknown trigger: %s", trigger));
776// }
777// else if (runNumber == 105143 || runNumber == 105160) {
778// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #1337 #1418 #2228 #2309 #3119 #3200 #446 #527";
779// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #1580 #1742 #1904 #2066 #2630 #2792 #2954 #3362";
780// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #845 #1007 #1169 #1577 #3359 #3521 #119 #281 ";
781// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790";
782// // else AliError(Form("Unknown trigger: %s", trigger));
783// }
784// else if (runNumber >= 105256 && runNumber <= 105268) {
785// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #3019 #669";
786// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2454 #346";
787// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1234 #2128";
788// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #790";
789// // else AliError(Form("Unknown trigger: %s", trigger));
790// } else if (runNumber >= 114786 && runNumber <= 116684) { // 7 TeV 2010, assume always the same filling scheme
791// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346";
792// else if(!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131";
793// else if(!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019";
794// else if(!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238";
795// // else AliError(Form("Unknown trigger: %s", trigger));
796// }
797// else if (runNumber >= 117048 && runNumber <= 117120) {
798// // return "Single_3b_2_2_2";
799// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 #1240 ";
800// else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131 ";
801// else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 ";
802// else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238";
803// // else AliError(Form("Unknown trigger: %s", trigger));
804
805// }
806// else if ((runNumber >= 117220 && runNumber <= 118555) || (runNumber >= 118784 && runNumber <= 119163))
807// {
808// // return "Single_2b_1_1_1";
809// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 ";
810// else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131 ";
811// else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 ";
812// else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238 ";
813// // else AliError(Form("Unknown trigger: %s", trigger));
814// }
815// else if (runNumber >= 118556 && runNumber <= 118783) {
816// // return "Single_2b_1_1_1";
817// // same as previous but was misaligned by 1 BX in fill 1069
818// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #345 ";
819// else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2130 ";
820// else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3018 ";
821// else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1238 ";
822// // else AliError(Form("Unknown trigger: %s", trigger));
823// }
824// else if (runNumber >= 119837 && runNumber <= 119862) {
825// // return "Single_4b_2_2_2";
826// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #669 #3019 ";
827// else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #346 #2454 ";
828// else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #1234 #2128 ";
829// else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1681 #3463";
830// // else AliError(Form("Unknown trigger: %s", trigger));
831
832// }
833// else if (runNumber >= 119902 && runNumber <= 120691) {
834// // return "Single_6b_3_3_3";
835// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 #546 #746 ";
836// else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #2131 #2331 #2531 ";
837// else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 #3219 #3419 ";
838// else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1296 #1670";
839// // else AliError(Form("Unknown trigger: %s", trigger));
840// }
841// else if (runNumber >= 120741 && runNumber <= 122375) {
842// // return "Single_13b_8_8_8";
843// if (!strcmp("CINT1B-ABCE-NOPF-ALL",trigger)) return " #346 #446 #546 #646 #1240 #1340 #1440 #1540 ";
844// else if (!strcmp("CINT1A-ABCE-NOPF-ALL",trigger)) return " #946 #2131 #2231 #2331 #2431 ";
845// else if (!strcmp("CINT1C-ABCE-NOPF-ALL",trigger)) return " #3019 #3119 #3219 #3319 #3519 ";
846// else if (!strcmp("CINT1-E-NOPF-ALL",trigger)) return " #1835 #2726";
847// // else AliError(Form("Unknown trigger: %s", trigger));
5f337f3d 848
7c55ebd9 849// }
850// else if (runNumber >= 130148 && runNumber <= 130375) {
851// TString triggerString = trigger;
852// static TString returnString = " ";
853// returnString = "";
854// if (triggerString.Contains("B")) returnString += " #346 #396 #446 #496 #546 #596 #646 #696 #1240 #1290 #1340 #1390 #1440 #1490 #1540 #1590 ";
855// 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 ";
856// 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 ";
857// // Printf("0x%x",returnString.Data());
858// // Printf("%s",returnString.Data());
859// return returnString.Data();
860// }
861// else if (runNumber >= 130601 && runNumber <= 130640) {
862// TString triggerString = trigger;
863// static TString returnString = " ";
864// returnString = "";
865// if (triggerString.Contains("B")) returnString += " #346 #386 #426 #466 #506 #546 #586 #1240 #1280 #1320 #1360 #1400 #1440 #1480 ";
866// 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
867// 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
868// return returnString.Data();
869// }
870
871// else {
872// AliWarning(Form("Unknown run %d, using all BXs!",runNumber));
873// }
874
875// return "";
876// }
1107e2ce 877
878Bool_t AliPhysicsSelection::Initialize(const AliESDEvent* aEsd)
879{
880 // initializes the object for the given ESD
881
c8aeecab 882 AliInfo(Form("Initializing for beam type: %s", aEsd->GetESDRun()->GetBeamType()));
869f9767 883 fIsPP = kTRUE;
c915635b 884 if (strcmp(aEsd->GetESDRun()->GetBeamType(), "A-A") == 0)
869f9767 885 fIsPP = kFALSE;
886
7c55ebd9 887 return Initialize(aEsd->GetRunNumber());
1107e2ce 888}
889
7c55ebd9 890Bool_t AliPhysicsSelection::Initialize(Int_t runNumber)
61899827 891{
7c55ebd9 892 // initializes the object for the given run
893
894
29e8486e 895 Bool_t oldStatus = TH1::AddDirectoryStatus();
896 TH1::AddDirectory(kFALSE);
7c55ebd9 897
898 /// Open OADB file and fetch OADB objects
899 TString oadbfilename = AliPhysicsSelection::GetOADBFileName();
900
28cbc692 901 TFile * foadb = TFile::Open(oadbfilename);
7c55ebd9 902 if(!foadb->IsOpen()) AliFatal(Form("Cannot open OADB file %s", oadbfilename.Data()));
903
904
905 if(!fPSOADB || !fUsingCustomClasses) { // if it's already set and custom class is required, we use the one provided by the user
906 AliInfo("Using Standard OADB");
907 AliOADBContainer * psContainer = (AliOADBContainer*) foadb->Get("physSel");
6340be16 908 if (!psContainer) AliFatal("Cannot fetch OADB container for Physics selection");
909 fPSOADB = (AliOADBPhysicsSelection*) psContainer->GetObject(runNumber, fIsPP ? "oadbDefaultPP" : "oadbDefaultPbPb");
7c55ebd9 910 if (!fPSOADB) AliFatal(Form("Cannot find physics selection object for run %d", runNumber));
911 } else {
912 AliInfo("Using Custom OADB");
913 }
914 if(!fFillOADB || !fUsingCustomClasses) { // if it's already set and custom class is required, we use the one provided by the user
915 AliOADBContainer * fillContainer = (AliOADBContainer*) foadb->Get("fillScheme");
6340be16 916 if (!fillContainer) AliFatal("Cannot fetch OADB container for filling scheme");
7c55ebd9 917 fFillOADB = (AliOADBFillingScheme*) fillContainer->GetObject(runNumber, "Default");
918 if (!fFillOADB) AliFatal(Form("Cannot find filling scheme object for run %d", runNumber));
919 }
eeaab745 920 if(!fTriggerOADB || !fUsingCustomClasses) { // if it's already set and custom class is required, we use the one provided by the user
921 AliOADBContainer * triggerContainer = (AliOADBContainer*) foadb->Get("trigAnalysis");
922 if (!triggerContainer) AliFatal("Cannot fetch OADB container for trigger analysis");
923 fTriggerOADB = (AliOADBTriggerAnalysis*) triggerContainer->GetObject(runNumber, "Default");
924 fTriggerOADB->Print();
925 if (!fTriggerOADB) AliFatal(Form("Cannot find trigger analysis object for run %d", runNumber));
926 }
7c55ebd9 927
29e8486e 928
85c71ba7 929 if(!fBin0CallBack)
930 AliError("Bin0 Callback not set: will not fill the statistics for the bin 0");
931
932 if (fMC) {
0c6c629b 933 // override BX and bg options in case of MC
85c71ba7 934 fComputeBG = kFALSE;
935 fUseBXNumbers = kFALSE;
936 }
937
7c55ebd9 938 // FIXME: think how to implement this check with the OADB, trigger scheme is not a int number here
939 // Int_t triggerScheme = GetTriggerScheme(runNumber);
940 // if (!fUsingCustomClasses && fCurrentRun != -1 && triggerScheme != GetTriggerScheme(fCurrentRun))
941 // AliFatal("Processing several runs with different trigger schemes is not supported");
296dd262 942
85c71ba7 943 if(fComputeBG && fCurrentRun != -1 && fCurrentRun != runNumber)
944 AliFatal("Cannot process several runs because BG computation is requested");
945
946 if(fComputeBG && !fUseBXNumbers)
e0bf2892 947 AliFatal("Cannot compute BG if BX numbers are not used");
85c71ba7 948
7c55ebd9 949 if(fUseBXNumbers && fFillingScheme != "" && fFillingScheme != fFillOADB->GetFillingSchemeName())
85c71ba7 950 AliFatal("Cannot process runs with different filling scheme if usage of BX numbers is requested");
951
7c55ebd9 952 fFillingScheme = fFillOADB->GetFillingSchemeName();
85c71ba7 953
61899827 954 AliInfo(Form("Initializing for run %d", runNumber));
955
758941d4 956 // initialize first time?
a2ce3799 957 if (fCurrentRun == -1)
a2ce3799 958 {
7c55ebd9 959 const UInt_t ntriggerBits = fPSOADB->GetNTriggerBits(); // FIXME!
960 for(UInt_t ibit = 0; ibit < ntriggerBits; ibit++){
961
962 TIterator * collIter = fPSOADB->GetCollTrigClass(ibit)->MakeIterator();
963 TIterator * bgIter = fPSOADB->GetBGTrigClass(ibit)->MakeIterator();
964 TObjString * obj = 0;
965 while((obj = (TObjString*) collIter->Next())){
966 if (obj->String() != "") {
967 fCollTrigClasses.Add(new TObjString(GetTriggerString(obj)));
968 }
1107e2ce 969 }
7c55ebd9 970 // BG classes only make sense for real data
971 if(!fMC) {
972 obj = 0 ;
973 while((obj = (TObjString*) bgIter->Next())){
974 if (obj->String() != "") {
975 fBGTrigClasses.Add(new TObjString(GetTriggerString(obj)));
976 }
977 }
91bea6e7 978 }
7c55ebd9 979
a2ce3799 980 }
7c55ebd9 981 // not sure how to handle this in the case of > x cuts
982 // // Book the token histo with the tokens actually used here!
983 // // 1. Cache the tokens
984 // for(UInt_t ibit = 0; ibit < ntriggerBits; ibit++){
985 // EvaluateTriggerLogic(0,0, fPSOADB->GetHardwareTrigger(ibit), 0);
986 // EvaluateTriggerLogic(0,0, fPSOADB->GetOfflineTrigger(ibit), 1);
987 // }
988 // // 2. Book the histogram
989 // if (!fHistStatisticsTokens) {
990 // Int_t ntokens = fCashedTokens->GetEntries();
991 // Int_t count = fCollTrigClasses->GetEntries() + fBGTrigClasses->GetEntries();
992 // fHistStatisticsTokens = new TH2F("fHistStatisticsTokens", "fHistStatisticsTokens", ntokens + 2, 0.5, ntokens+2+0.5, count, -0.5, -0.5 + count);
993
994 // Int_t nrow = 0;
995 // fHistStatisticsTokens->GetXaxis()->SetBinLabel(nrow++, "Trigger class");
996 // for(Int_t itoken = 0; itoken < ntoken; itoken++){
997 // TParameter<Int_t> * param = fCashedTokens->At(itoken);
998 // fHistStatisticsTokens->GetXaxis()->SetBinLabel(nrow++, param->GetName());
999 // }
1000
1001 // fHistStatisticsTokens->GetXaxis()->SetBinLabel(nrow++, "Accepted");
1002
1003 // }
1004
1005
91bea6e7 1006
7c55ebd9 1007 // TODO:
1008 // Add a new statistics histo containing only the tokens actually used in the selection
1009
a2ce3799 1010 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
1011
1012 for (Int_t i=0; i<count; i++)
1013 {
7c55ebd9 1014
a2ce3799 1015 AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
1016 triggerAnalysis->SetAnalyzeMC(fMC);
891c67bd 1017 triggerAnalysis->EnableHistograms(fIsPP);
a2ce3799 1018 triggerAnalysis->SetSPDGFOThreshhold(1);
4011b280 1019 triggerAnalysis->SetDoFMD(kFALSE);
eeaab745 1020 triggerAnalysis->SetCorrZDCCutParams(fTriggerOADB->GetZDCCutRefSumCorr(),
1021 fTriggerOADB->GetZDCCutRefDeltaCorr(),
1022 fTriggerOADB->GetZDCCutSigmaSumCorr(),
1023 fTriggerOADB->GetZDCCutSigmaDeltaCorr());
b68d0b5e 1024 triggerAnalysis->SetZNCorrCutParams(fTriggerOADB->GetZDCCutZNATimeCorrMin(),fTriggerOADB->GetZDCCutZNATimeCorrMax(),
1025 fTriggerOADB->GetZDCCutZNCTimeCorrMin(),fTriggerOADB->GetZDCCutZNCTimeCorrMax());
a2ce3799 1026 fTriggerAnalysis.Add(triggerAnalysis);
1027 }
7c55ebd9 1028
1029
85c71ba7 1030 // TODO: shall I really delete this?
1031 if (fHistStatistics[0])
1032 delete fHistStatistics[0];
1033 if (fHistStatistics[1])
1034 delete fHistStatistics[1];
296dd262 1035
85c71ba7 1036 fHistStatistics[kStatIdxBin0] = BookHistStatistics("_Bin0");
1037 fHistStatistics[kStatIdxAll] = BookHistStatistics("");
a2ce3799 1038
7c55ebd9 1039
a2ce3799 1040 if (fHistBunchCrossing)
1041 delete fHistBunchCrossing;
1042
1043 fHistBunchCrossing = new TH2F("fHistBunchCrossing", "fHistBunchCrossing;bunch crossing number;", 4000, -0.5, 3999.5, count, -0.5, -0.5 + count);
73cc8654 1044
7c55ebd9 1045 // TODO: remove fHistTriggerPattern
73cc8654 1046 if (fHistTriggerPattern)
1047 delete fHistTriggerPattern;
1048
1049 const int ntrig=3;
85c71ba7 1050 Int_t n = 1;
73cc8654 1051 const Int_t nbinTrig = TMath::Nint(TMath::Power(2,ntrig));
1052
1053 fHistTriggerPattern = new TH1F("fHistTriggerPattern", "Trigger pattern: FO + 2*v0A + 4*v0C",
1054 nbinTrig, -0.5, nbinTrig-0.5);
1055 fHistTriggerPattern->GetXaxis()->SetBinLabel(1,"NO TRIG");
1056 fHistTriggerPattern->GetXaxis()->SetBinLabel(2,"FO");
1057 fHistTriggerPattern->GetXaxis()->SetBinLabel(3,"v0A");
1058 fHistTriggerPattern->GetXaxis()->SetBinLabel(4,"FO & v0A");
1059 fHistTriggerPattern->GetXaxis()->SetBinLabel(5,"v0C");
1060 fHistTriggerPattern->GetXaxis()->SetBinLabel(6,"FO & v0C");
1061 fHistTriggerPattern->GetXaxis()->SetBinLabel(7,"v0A & v0C");
1062 fHistTriggerPattern->GetXaxis()->SetBinLabel(8,"FO & v0A & v0C");
1063
1064
1065 n = 1;
a2ce3799 1066 for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
1067 {
7c55ebd9 1068
a2ce3799 1069 fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String());
1070 n++;
1071 }
1072 for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
1073 {
7c55ebd9 1074
a2ce3799 1075 fHistBunchCrossing->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
1076 n++;
1077 }
85c71ba7 1078
1079
1080
a2ce3799 1081 }
1082
1083 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
296dd262 1084 for (Int_t i=0; i<count; i++)
61899827 1085 {
7c55ebd9 1086
a2ce3799 1087 AliTriggerAnalysis* triggerAnalysis = static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i));
1088
296dd262 1089 switch (runNumber)
1090 {
a2ce3799 1091 case 104315:
296dd262 1092 case 104316:
1093 case 104320:
a2ce3799 1094 case 104321:
296dd262 1095 case 104439:
1096 triggerAnalysis->SetV0TimeOffset(7.5);
1097 break;
a2ce3799 1098 default:
1099 triggerAnalysis->SetV0TimeOffset(0);
296dd262 1100 }
f4ca8f20 1101 }
1102
758941d4 1103 fCurrentRun = runNumber;
1104
29e8486e 1105 TH1::AddDirectory(oldStatus);
1106
7c55ebd9 1107
61899827 1108 return kTRUE;
1109}
1110
85c71ba7 1111TH2F * AliPhysicsSelection::BookHistStatistics(const char * tag) {
bc18a83e 1112 // add 6 rows to count for the estimate of good, accidentals and
1113 // BG and the ratio of BG and accidentals to total +ratio goot to
1114 // first col + 2 for error on good.
1115 // TODO: Remember the the indexes of rows for the BG selection. Add new member fBGRows[] and use kStat as indexes
85c71ba7 1116
1117 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
1118#ifdef VERBOSE_STAT
8dec6e35 1119 Int_t extrarows = fComputeBG != 0 ? 11 : 0;
85c71ba7 1120#else
8dec6e35 1121 Int_t extrarows = fComputeBG != 0 ? 6 : 0;
85c71ba7 1122#endif
559b5ed7 1123 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);
85c71ba7 1124
1125 h->GetXaxis()->SetBinLabel(kStatTriggerClass, "Trigger class");
1126 h->GetXaxis()->SetBinLabel(kStatHWTrig, "Hardware trigger");
1127 h->GetXaxis()->SetBinLabel(kStatFO1, "FO >= 1");
1128 h->GetXaxis()->SetBinLabel(kStatFO2, "FO >= 2");
c2ba5a61 1129 h->GetXaxis()->SetBinLabel(kStatFO2L1, "FO (L1) >= 2");
85c71ba7 1130 h->GetXaxis()->SetBinLabel(kStatV0A, "V0A");
1131 h->GetXaxis()->SetBinLabel(kStatV0C, "V0C");
559b5ed7 1132 h->GetXaxis()->SetBinLabel(kStatT0BB, "T0");
1133 h->GetXaxis()->SetBinLabel(kStatT0BG, "T0BG");
1134 h->GetXaxis()->SetBinLabel(kStatT0PileUp, "T0 PileUp");
396981c2 1135 h->GetXaxis()->SetBinLabel(kStatLaserCut, "TPC Laser Wup Cut");
b68d0b5e 1136 h->GetXaxis()->SetBinLabel(kHVdipCut, "TPC HV dip Cut");
85c71ba7 1137 h->GetXaxis()->SetBinLabel(kStatV0ABG, "V0A BG");
1138 h->GetXaxis()->SetBinLabel(kStatV0CBG, "V0C BG");
c2ba5a61 1139 h->GetXaxis()->SetBinLabel(kStatZDCA, "ZDCA");
1140 h->GetXaxis()->SetBinLabel(kStatZDCC, "ZDCC");
1141 h->GetXaxis()->SetBinLabel(kStatZDCAC, "ZDCA & ZDCC");
869f9767 1142 h->GetXaxis()->SetBinLabel(kStatZDCTime, "ZDC Time Cut");
3c6c0362 1143 h->GetXaxis()->SetBinLabel(kStatZNABG, "ZNA BG");
1144 h->GetXaxis()->SetBinLabel(kStatZNCBG, "ZNC BG");
85c71ba7 1145 h->GetXaxis()->SetBinLabel(kStatMB1, "(FO >= 1 | V0A | V0C) & !V0 BG");
1146 h->GetXaxis()->SetBinLabel(kStatMB1Prime, "(FO >= 2 | (FO >= 1 & (V0A | V0C)) | (V0A &v0C) ) & !V0 BG");
c2ba5a61 1147 //h->GetXaxis()->SetBinLabel(kStatFO1AndV0, "FO >= 1 & (V0A | V0C) & !V0 BG");
85c71ba7 1148 h->GetXaxis()->SetBinLabel(kStatV0, "V0A & V0C & !V0 BG & !BG ID");
3c6c0362 1149 h->GetXaxis()->SetBinLabel(kStatV0ZN, "V0A & V0C & !V0 BG & !BG ID & !ZN BG");
85c71ba7 1150 h->GetXaxis()->SetBinLabel(kStatOffline, "Offline Trigger");
c2ba5a61 1151 //h->GetXaxis()->SetBinLabel(kStatAny2Hits, "2 Hits & !V0 BG");
85c71ba7 1152 h->GetXaxis()->SetBinLabel(kStatBG, "Background identification");
e219c292 1153 h->GetXaxis()->SetBinLabel(kStatAcceptedPileUp, "Pile up (in accepted)");
559b5ed7 1154 h->GetXaxis()->SetBinLabel(kStatAccepted, "Accepted");
e219c292 1155
85c71ba7 1156
1157 Int_t n = 1;
1158 for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
1159 {
1160 h->GetYaxis()->SetBinLabel(n, ((TObjString*) fCollTrigClasses.At(i))->String());
1161 n++;
1162 }
1163 for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
1164 {
1165 h->GetYaxis()->SetBinLabel(n, ((TObjString*) fBGTrigClasses.At(i))->String());
1166 n++;
1167 }
1168
1169 if(fComputeBG) {
141265a2 1170 fBGStatOffset = n;
8dec6e35 1171 h->GetYaxis()->SetBinLabel(n++, "All B");
1172 h->GetYaxis()->SetBinLabel(n++, "All A+C");
1173 h->GetYaxis()->SetBinLabel(n++, "All E");
141265a2 1174 h->GetYaxis()->SetBinLabel(n++, Form("BG (A+C) (Mask [0x%x])", fComputeBG));
85c71ba7 1175 h->GetYaxis()->SetBinLabel(n++, "ACC");
1176#ifdef VERBOSE_STAT
1177 h->GetYaxis()->SetBinLabel(n++, "BG (A+C) % (rel. to CINT1B)");
1178 h->GetYaxis()->SetBinLabel(n++, "ACC % (rel. to CINT1B)");
1179 h->GetYaxis()->SetBinLabel(n++, "ERR GOOD %");
1180 h->GetYaxis()->SetBinLabel(n++, "GOOD % (rel. to 1st col)");
1181 h->GetYaxis()->SetBinLabel(n++, "ERR GOOD");
1182#endif
1183 h->GetYaxis()->SetBinLabel(n++, "GOOD");
1184 }
1185
1186 return h;
1187}
1188
7c55ebd9 1189void AliPhysicsSelection::Print(const Option_t *option) const
61899827 1190{
1191 // print the configuration
e9247450 1192 TString msg;
a2ce3799 1193 Printf("Configuration initialized for run %d (MC: %d):", fCurrentRun, fMC);
e9247450 1194 msg += Form("Configuration initialized for run %d (MC: %d):\n", fCurrentRun, fMC);
61899827 1195
296dd262 1196 Printf("Collision trigger classes:");
1197 for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++)
1198 Printf("%s", ((TObjString*) fCollTrigClasses.At(i))->String().Data());
61899827 1199
296dd262 1200 Printf("Background trigger classes:");
1201 for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++)
1202 Printf("%s", ((TObjString*) fBGTrigClasses.At(i))->String().Data());
1203
1204 AliTriggerAnalysis* triggerAnalysis = dynamic_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(0));
61899827 1205
296dd262 1206 if (triggerAnalysis)
1207 {
1208 if (triggerAnalysis->GetV0TimeOffset() > 0)
1209 Printf("V0 time offset active: %.2f ns", triggerAnalysis->GetV0TimeOffset());
61899827 1210
296dd262 1211 Printf("\nTotal available events:");
528640ed 1212
296dd262 1213 triggerAnalysis->PrintTriggerClasses();
7e7fadb8 1214 // Check if all triggers with counts are known to the physics selection. If not, print a WARNING (only for MC)
1215 if(!fMC) {
1216 TMap * triggers = triggerAnalysis->GetTriggerClasses();
1217 TIterator* iter = triggers->MakeIterator();
1218 TObjString* obj = 0;
1219 static TString alreadyFoundTriggers;
1220 while ((obj = dynamic_cast<TObjString*> (iter->Next())))
1221 {
1222 TString strTrigger = obj->GetString();
1223 TParameter<Long64_t>* param = static_cast<TParameter<Long64_t>*> (triggers->GetValue(obj));
1224 Long_t counts = (Long_t)param->GetVal();
1225 TObjArray* tokens = obj->String().Tokenize(" ");
1226 for (Int_t i=0; i<tokens->GetEntries(); i++)
1227 {
1228 TString singleTrigStr = ((TObjString*) tokens->At(i))->String();
1229 singleTrigStr.Strip(TString::kBoth, ' ' );
1230 const char * singleTrig = singleTrigStr.Data();
1231 // Printf("%s", singleTrig);
1232 TString singleTrigStrFull;
1233 Bool_t found = kFALSE;
1234 Int_t nCollTriggers = fCollTrigClasses.GetEntries();
1235 for(Int_t iCollTriggers = 0; iCollTriggers < nCollTriggers; iCollTriggers++){
1236 singleTrigStrFull = ((TObjString*)fCollTrigClasses.At(iCollTriggers))->String();
1237 if(singleTrigStrFull.Contains(singleTrigStr)) {
1238 found = kTRUE;
1239 break;
1240 }
1241 singleTrigStrFull = singleTrigStr;
b885484d 1242 }
7e7fadb8 1243 Int_t nBGTriggers = fBGTrigClasses.GetEntries();
1244 for(Int_t iBGTriggers = 0; iBGTriggers < nBGTriggers; iBGTriggers++){
1245 singleTrigStrFull = ((TObjString*)fBGTrigClasses.At(iBGTriggers))->String();
1246 if(singleTrigStrFull.Contains(singleTrigStr)) {
1247 found = kTRUE;
1248 break;
1249 }
1250 singleTrigStrFull = singleTrigStr;
b885484d 1251 }
7e7fadb8 1252
6aca0ab9 1253 TString blacklist = "CEMC7WU-B-NOPF-ALL, CEMC7WU-AC-NOPF-ALL CEMC7WU-E-NOPF-ALL C0LSR-ABCE-NOPF-TPC CBEAMB-B-NOPF-ALLNOTRD"; // We know we dont support those, so we print no warning
7e7fadb8 1254 if(counts>0 && !found && !blacklist.Contains(singleTrig) && !singleTrigStr.Contains("WU") && !alreadyFoundTriggers.Contains(singleTrig)) {
1255 Printf("WARNING: Found unknown trigger [%s] with %ld counts in the ESD!", singleTrig, counts);
1256 alreadyFoundTriggers += singleTrig; // Avoid printing warning twice for the same trigger
1257 }
1258 }
1259 delete tokens;
1260 }
1261 delete iter;
1262 }
296dd262 1263 }
528640ed 1264
0c6c629b 1265 if (fHistStatistics[kStatIdxAll])
b43e01ed 1266 {
7e7fadb8 1267 static TString alreadyFoundTriggers; // avoids printing twice the same warning
1268
0c6c629b 1269 for (Int_t i=0; i<fCollTrigClasses.GetEntries(); i++)
1270 {
1271 Printf("\nSelection statistics for collision trigger %s:", ((TObjString*) fCollTrigClasses.At(i))->String().Data());
e9247450 1272 msg += Form("\nSelection statistics for collision trigger %s:\n", ((TObjString*) fCollTrigClasses.At(i))->String().Data());
0c6c629b 1273
b885484d 1274 Float_t allEvents = fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1);
1275 Float_t triggeredEvents = fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1);
1276
0c6c629b 1277 Printf("Total events with correct trigger class: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1));
e9247450 1278 msg += Form("Total events with correct trigger class: %d\n", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(1, i+1));
0c6c629b 1279 Printf("Selected collision candidates: %d", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1));
e9247450 1280 msg += Form("Selected collision candidates: %d\n", (Int_t) fHistStatistics[kStatIdxAll]->GetBinContent(fHistStatistics[kStatIdxAll]->GetXaxis()->FindBin("Accepted"), i+1));
b885484d 1281
1282 // If the fraction of accepted events is too low, print a warning.
1283 Float_t eff = allEvents > 0 ? triggeredEvents/allEvents : 0;
7e7fadb8 1284 if(allEvents > 0 && (eff < 0.5) && // FIXME: make threshold programmable in OADB
1285 !alreadyFoundTriggers.Contains(((TObjString*) fCollTrigClasses.At(i))->String().Data())) {
b885484d 1286 Printf("WARNING: Trigger class %s has a very low efficiency (%d/%d=%.2f)",((TObjString*) fCollTrigClasses.At(i))->String().Data(), (Int_t) triggeredEvents, (Int_t) allEvents, eff);
7e7fadb8 1287 alreadyFoundTriggers += ((TObjString*) fCollTrigClasses.At(i))->String().Data();
e219c292 1288 Printf("%s", alreadyFoundTriggers.Data());
b885484d 1289 }
1290
0c6c629b 1291 }
17ba346c 1292 }
1293
1294 if (fHistBunchCrossing)
1295 {
1296 Printf("\nBunch crossing statistics:");
e9247450 1297 msg += "\nBunch crossing statistics:\n";
17ba346c 1298
1299 for (Int_t i=1; i<=fHistBunchCrossing->GetNbinsY(); i++)
1300 {
1301 TString str;
8dec6e35 1302 str.Form("Trigger %s has events in the bunch crossings: ", fHistBunchCrossing->GetYaxis()->GetBinLabel(i));
17ba346c 1303
1304 for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++)
1305 if (fHistBunchCrossing->GetBinContent(j, i) > 0)
1306 str += Form("%d, ", (Int_t) fHistBunchCrossing->GetXaxis()->GetBinCenter(j));
e9247450 1307
17ba346c 1308 Printf("%s", str.Data());
e9247450 1309 msg += str;
1310 msg += "\n";
17ba346c 1311 }
1312
1313 for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++)
1314 {
0c6c629b 1315 Int_t countColl = 0;
1316 Int_t countBG = 0;
17ba346c 1317 for (Int_t i=1; i<=fHistBunchCrossing->GetNbinsY(); i++)
1318 {
1319 if (fHistBunchCrossing->GetBinContent(j, i) > 0)
0c6c629b 1320 {
1321 if (fCollTrigClasses.FindObject(fHistBunchCrossing->GetYaxis()->GetBinLabel(i)))
1322 countColl++;
1323 if (fBGTrigClasses.FindObject(fHistBunchCrossing->GetYaxis()->GetBinLabel(i)))
1324 countBG++;
1325 }
17ba346c 1326 }
0c6c629b 1327 if (countColl > 0 && countBG > 0)
1328 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 1329 }
b43e01ed 1330 }
91bea6e7 1331
1332 if (fUsingCustomClasses)
1333 Printf("WARNING: Using custom trigger classes!");
1334 if (fSkipTriggerClassSelection)
1335 Printf("WARNING: Skipping trigger class selection!");
85c71ba7 1336 if (fSkipV0)
1337 Printf("WARNING: Ignoring V0 information in selection");
1338 if(!fBin0CallBack)
1339 Printf("WARNING: Callback not set: will not fill the statistics for the bin 0");
e9247450 1340 TString opt(option);
1341 opt.ToUpper();
1342 if (opt == "STAT") {
1343 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1344 if (mgr) mgr->AddStatisticsMsg(msg);
1345 }
61899827 1346}
1347
1348Long64_t AliPhysicsSelection::Merge(TCollection* list)
1349{
1350 // Merge a list of AliMultiplicityCorrection objects with this (needed for
1351 // PROOF).
1352 // Returns the number of merged objects (including this).
1353
1354 if (!list)
1355 return 0;
1356
1357 if (list->IsEmpty())
1358 return 1;
1359
1360 TIterator* iter = list->MakeIterator();
1361 TObject* obj;
17ba346c 1362
61899827 1363 // collections of all histograms
1ea7a921 1364 const Int_t nHists = 8;
61899827 1365 TList collections[nHists];
1366
1367 Int_t count = 0;
1368 while ((obj = iter->Next())) {
1369
1370 AliPhysicsSelection* entry = dynamic_cast<AliPhysicsSelection*> (obj);
1371 if (entry == 0)
1372 continue;
518b6d59 1373 // Update run number. If this one is not initialized (-1) take the one from
1374 // the next physics selection to be merged with. In case of 2 different run
1375 // numbers issue a warning (should physics selections from different runs be
1376 // merged together) A.G.
1377 Int_t currentRun = entry->GetCurrentRun();
1378 // Nothing to merge with since run number was not initialized.
1379 if (currentRun < 0) continue;
c2ba5a61 1380 if (fCurrentRun < 0)
1381 {
1382 fCurrentRun = currentRun;
1383 fMC = entry->fMC;
1384 for (Int_t i=0; i<entry->fCollTrigClasses.GetEntries(); i++)
1385 fCollTrigClasses.Add(entry->fCollTrigClasses.At(i)->Clone());
1386 for (Int_t i=0; i<entry->fBGTrigClasses.GetEntries(); i++)
1387 fBGTrigClasses.Add(entry->fBGTrigClasses.At(i)->Clone());
1388 }
518b6d59 1389 if (fCurrentRun != currentRun)
1390 AliWarning(Form("Current run %d not matching the one to be merged with %d", fCurrentRun, currentRun));
7c55ebd9 1391
1392 // With the same strategy update fBGStatOffset
1393 Int_t bgstatoffset = entry->GetBGStatOffset();
1394
504e41a3 1395 // Nothing to merge with since BG was not initialized.
1396 if (!(bgstatoffset < 0)){
1397 if (fBGStatOffset < 0)
1398 {
1399 fBGStatOffset = bgstatoffset;
1400 }
7c55ebd9 1401 }
1402 if (fBGStatOffset != bgstatoffset)
504e41a3 1403 AliWarning(Form("Current run %d not matching the one to be merged with %d", fBGStatOffset, bgstatoffset));
518b6d59 1404
7c55ebd9 1405
1406
1407 // Merge the OADBs (Take just the first instance you find
28cbc692 1408 if (!fPSOADB && entry->GetOADBPhysicsSelection()) {
7c55ebd9 1409 fPSOADB = (AliOADBPhysicsSelection*) entry->GetOADBPhysicsSelection()->Clone();
1410 }
28cbc692 1411 if (!fFillOADB && entry->GetOADBFillingScheme()){
7c55ebd9 1412 fFillOADB = (AliOADBFillingScheme*) entry->GetOADBFillingScheme()->Clone();
1413 }
1414
c2ba5a61 1415 if (entry->fTriggerAnalysis.GetEntries() > 0)
1416 collections[0].Add(&(entry->fTriggerAnalysis));
85c71ba7 1417 if (entry->fHistStatistics[0])
1418 collections[1].Add(entry->fHistStatistics[0]);
1419 if (entry->fHistStatistics[1])
1420 collections[2].Add(entry->fHistStatistics[1]);
7c55ebd9 1421 // if (entry->fHistStatisticsTokens)
1422 // collections[3].Add(entry->fHistStatisticsTokens);
17ba346c 1423 if (entry->fHistBunchCrossing)
85c71ba7 1424 collections[3].Add(entry->fHistBunchCrossing);
73cc8654 1425 if (entry->fHistTriggerPattern)
1426 collections[4].Add(entry->fHistTriggerPattern);
61899827 1427
1428 count++;
1429 }
1430
c2ba5a61 1431 if (fTriggerAnalysis.GetEntries() == 0 && collections[0].GetEntries() > 0)
1432 {
1433 TList* firstList = (TList*) collections[0].First();
1434 for (Int_t i=0; i<firstList->GetEntries(); i++)
1435 fTriggerAnalysis.Add(firstList->At(i)->Clone());
1436
1437 collections[0].RemoveAt(0);
1438 }
17ba346c 1439 fTriggerAnalysis.Merge(&collections[0]);
c2ba5a61 1440
1441 // if this instance is empty (not initialized) nothing would be merged here --> copy first entry
1442 if (!fHistStatistics[0] && collections[1].GetEntries() > 0)
1443 {
1444 fHistStatistics[0] = (TH2F*) collections[1].First()->Clone();
1445 collections[1].RemoveAt(0);
1446 }
85c71ba7 1447 if (fHistStatistics[0])
1448 fHistStatistics[0]->Merge(&collections[1]);
c2ba5a61 1449
1450 if (!fHistStatistics[1] && collections[2].GetEntries() > 0)
1451 {
1452 fHistStatistics[1] = (TH2F*) collections[2].First()->Clone();
1453 collections[2].RemoveAt(0);
1454 }
85c71ba7 1455 if (fHistStatistics[1])
1456 fHistStatistics[1]->Merge(&collections[2]);
c2ba5a61 1457
1458 if (!fHistBunchCrossing && collections[3].GetEntries() > 0)
1459 {
1460 fHistBunchCrossing = (TH2F*) collections[3].First()->Clone();
1461 collections[3].RemoveAt(0);
1462 }
17ba346c 1463 if (fHistBunchCrossing)
85c71ba7 1464 fHistBunchCrossing->Merge(&collections[3]);
c2ba5a61 1465
1466 if (!fHistTriggerPattern && collections[4].GetEntries() > 0)
1467 {
1468 fHistTriggerPattern = (TH1F*) collections[4].First()->Clone();
1469 collections[4].RemoveAt(0);
1470 }
73cc8654 1471 if (fHistTriggerPattern)
1472 fHistTriggerPattern->Merge(&collections[4]);
1ea7a921 1473
61899827 1474 delete iter;
1475
1476 return count+1;
1477}
1478
8dec6e35 1479void AliPhysicsSelection::SaveHistograms(const char* folder)
61899827 1480{
1481 // write histograms to current directory
1482
85c71ba7 1483 if (!fHistStatistics[0] || !fHistStatistics[1])
61899827 1484 return;
1485
1486 if (folder)
1487 {
1488 gDirectory->mkdir(folder);
1489 gDirectory->cd(folder);
1490 }
1491
85c71ba7 1492
1493 // Fill the last rows of fHistStatistics before saving
8dec6e35 1494 if (fComputeBG) {
1495 AliInfo("BG estimate assumes that for a given run you only have A and C triggers separately or"
1496 " toghether as a AC class! Make sure this assumption holds in your case");
1497
1498 // use an anum for the different trigger classes, to make loops easier to read
1499 enum {kClassB =0 , kClassA, kClassC, kClassAC, kClassE, kNClasses};
1500 const char * classFlags[] = {"B", "A", "C", "AC", "E"}; // labels
1501
1502 UInt_t * rows[kNClasses] = {0}; // Array of matching rows
1503 Int_t nrows[kNClasses] = {0};
1504 // Get rows matching the requested trigger bits for all trigger classes
1505 for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1506 nrows[iTrigClass] = GetStatRow(classFlags[iTrigClass],fComputeBG,&rows[iTrigClass]);
1507 }
1508
1509 // 0. Determine the ratios of triggers E/B, A/B, C/B from the stat histogram
1510 // Those are used to rescale the different classes to the same number of bx ids
1511 // 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?
1512 Int_t nBXIds[kNClasses] = {0};
1513 // cout <<"Computing BG:" << endl;
1514
1515 for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1516 for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {
1517 if(irow==0) cout << "- Class " << classFlags[iTrigClass] << endl;
1518 for (Int_t j=1; j<=fHistBunchCrossing->GetNbinsX(); j++) {
1519 if (fHistBunchCrossing->GetBinContent(j, rows[iTrigClass][irow]) > 0) {
1520 nBXIds[iTrigClass]++;
141265a2 1521 }
141265a2 1522 }
8dec6e35 1523 if(nBXIds[iTrigClass]>0) cout << " Using row " << rows[iTrigClass][irow] << ": "
1524 << fHistBunchCrossing->GetYaxis()->GetBinLabel(rows[iTrigClass][irow])
1525 << " (nBXID "<< nBXIds[iTrigClass] << ")"<< endl;
141265a2 1526
5f337f3d 1527 }
141265a2 1528
8dec6e35 1529 }
1530
1531 Float_t ratioToB[kNClasses];
1532 ratioToB[kClassE] = nBXIds[kClassE] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassE] : 0;
1533 ratioToB[kClassA] = nBXIds[kClassA] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassA] : 0;
1534 ratioToB[kClassC] = nBXIds[kClassC] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassC] : 0;
1535 ratioToB[kClassAC] = nBXIds[kClassAC] >0 ? Float_t(nBXIds[kClassB])/nBXIds[kClassAC] : 0;
1536 Printf("Ratio between the BX ids in the different trigger classes:");
1537 Printf(" B/E = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassE], ratioToB[kClassE] );
1538 Printf(" B/A = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassA], ratioToB[kClassA] );
1539 Printf(" B/C = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassC], ratioToB[kClassC] );
1540 Printf(" B/AC = %d/%d = %f", nBXIds[kClassB],nBXIds[kClassAC],ratioToB[kClassAC]);
1541 Int_t nHistStat = 2;
1542
1543 // 1. loop over all cols
1544 for(Int_t iHistStat = 0; iHistStat < nHistStat; iHistStat++){
1545 Int_t ncol = fHistStatistics[iHistStat]->GetNbinsX();
1546 Float_t good1 = 0;
1547 for(Int_t icol = 1; icol <= ncol; icol++) {
1548 Int_t nEvents[kNClasses] = {0}; // number of events should be reset at every column
1549 // For all trigger classes, add up over row matching trigger mask (as selected before)
1550 for(Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1551 for(Int_t irow = 0; irow < nrows[iTrigClass]; irow++) {
1552 nEvents[iTrigClass] += (Int_t) fHistStatistics[iHistStat]->GetBinContent(icol,rows[iTrigClass][irow]);
141265a2 1553 }
8dec6e35 1554 // cout << "Events " << classFlags[iTrigClass] << " ("<<icol<<") " << nEvents[iTrigClass] << endl;
1555 }
1556 if (nEvents[kClassB]>0) {
1557 Float_t acc = ratioToB[kClassE]*nEvents[kClassE];
7c55ebd9 1558 Double_t accErr = TMath::Sqrt(ratioToB[kClassE]*ratioToB[kClassE]*nEvents[kClassE]);
8dec6e35 1559 // Int_t bg = cint1A + cint1C - 2*acc;
141265a2 1560
8dec6e35 1561 // If intensity measurements are available, they already
1562 // contain the scaling for BX ratios, so we reset the
1563 // ratioToB entries
1779d797 1564 if(icol == 1) {
1565 if(fBIFactorAC > 0 || fBIFactorA > 0 || fBIFactorC > 0) {
7c55ebd9 1566 if (fBIFactorAC <= 0 && (fBIFactorA <= 0 || fBIFactorC <= 0)) {
1779d797 1567 AliError("Not all intensities set!, assuming equal intensities");
1568 fBIFactorA = 1;
1569 fBIFactorC = 1;
1570 fBIFactorAC = 1;
1571 } else {
1572 AliInfo("Using ratio of number of bunch crossing embedded in the intensity measurements");
1573 ratioToB[kClassA] = ratioToB[kClassA] >0 ? 1 : 0;
1574 ratioToB[kClassC] = ratioToB[kClassC] >0 ? 1 : 0;
1575 ratioToB[kClassAC] = ratioToB[kClassAC] >0 ? 1 : 0;
1576 AliInfo(Form(" - BI Factor A: %f", fBIFactorA ));
1577 AliInfo(Form(" - BI Factor C: %f", fBIFactorC ));
1578 AliInfo(Form(" - BI Factor AC: %f", fBIFactorAC ));
1579
1580 }
1581 } else {
1582 AliWarning("Intensities not set!, assuming equal intensities");
8dec6e35 1583 fBIFactorA = 1;
1584 fBIFactorC = 1;
1585 fBIFactorAC = 1;
8dec6e35 1586 }
8dec6e35 1587 }
8dec6e35 1588 // Assuming that for a given class the triggers are either recorded as A+C or AC
1589 Float_t bg = nEvents[kClassAC] > 0 ?
1590 fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc):
1591 fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) +
1592 fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) ;
1593
1594 // cout << "-----------------------" << endl;
1595 // cout << "Factors: " << fBIFactorA << " " << fBIFactorC << " " << fBIFactorAC << endl;
1596 // cout << "Ratios: " << ratioToB[kClassA] << " " << ratioToB[kClassC] << " " << ratioToB[kClassAC] << endl;
1597 // cout << "Evts: " << nEvents[kClassA] << " " << nEvents[kClassC] << " " << nEvents[kClassAC] << " " << nEvents[kClassB] << endl;
1598 // cout << "Acc: " << acc << endl;
1599 // cout << "BG: " << bg << endl;
1600 // cout << " " << fBIFactorA* (ratioToB[kClassA]*nEvents[kClassA]-acc) <<endl;
1601 // cout << " " << fBIFactorC* (ratioToB[kClassC]*nEvents[kClassC]-acc) <<endl;
1602 // cout << " " << fBIFactorAC*(ratioToB[kClassAC]*nEvents[kClassAC] - 2*acc) << endl;
1603 // cout << "-----------------------" << endl;
1604
1605 Float_t good = Float_t(nEvents[kClassB]) - bg - acc;
1606 if (icol ==1) good1 = good;
1607 // Float_t errGood = TMath::Sqrt(2*(nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassE]));// Error on the number of goods assuming only bg fluctuates
1608 // DeltaG^2 = B + FA^2 A + FC^2 C + Ratio^2 (FA+FC-1)^2 E.
1609 Float_t errGood = nEvents[kClassAC] > 0 ?
1610 TMath::Sqrt( nEvents[kClassB] +
1611 fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC] +
1612 ratioToB[kClassE] * ratioToB[kClassE] *
1613 (fBIFactorAC - 1)*(fBIFactorAC - 1)*nEvents[kClassE]) :
1614 TMath::Sqrt( nEvents[kClassB] +
1615 fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA] +
1616 fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC] +
1617 ratioToB[kClassE] * ratioToB[kClassE] *
1618 (fBIFactorA + fBIFactorC - 1)*(fBIFactorA + fBIFactorC - 1)*nEvents[kClassE]);
1619
1620 Float_t errBG = nEvents[kClassAC] > 0 ?
1621 TMath::Sqrt(fBIFactorAC*fBIFactorAC*ratioToB[kClassAC]*ratioToB[kClassAC]*nEvents[kClassAC]+
1622 4*ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorAC*fBIFactorAC)*nEvents[kClassE]) :
1623 TMath::Sqrt(fBIFactorA*fBIFactorA*ratioToB[kClassA]*ratioToB[kClassA]*nEvents[kClassA]+
1624 fBIFactorC*fBIFactorC*ratioToB[kClassC]*ratioToB[kClassC]*nEvents[kClassC]+
1625 ratioToB[kClassE]*ratioToB[kClassE]*(fBIFactorA+fBIFactorC)*(fBIFactorA+fBIFactorC)*nEvents[kClassE]);
85c71ba7 1626
1627
8dec6e35 1628 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllB, nEvents[kClassB]);
1629 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllAC,nEvents[kClassA]+nEvents[kClassC]+nEvents[kClassAC]);
1630 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAllE, nEvents[kClassE]);
1631
1632 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBG,bg);
1633 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowBG,errBG);
1634 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAcc,acc);
7c55ebd9 1635 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowAcc,accErr);
8dec6e35 1636 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGood,good);
1637 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowGood,errGood);
85c71ba7 1638
1639#ifdef VERBOSE_STAT
8dec6e35 1640 //kStatRowBG=0,kStatRowAcc,kStatRowBGFrac,kStatRowAccFrac,kStatRowErrGoodFrac,kStatRowGoodFrac,kStatRowGood,kStatRowErrGood
1641 Float_t accFrac = Float_t(acc) / nEvents[kClassB] *100;
7c55ebd9 1642 Float_t errAccFrac= Float_t(accErr) / nEvents[kClassB] *100;
8dec6e35 1643 Float_t bgFrac = Float_t(bg) / nEvents[kClassB] *100;
1644 Float_t goodFrac = Float_t(good) / good1 *100;
1645 Float_t errGoodFrac = errGood/good1 * 100;
1646 Float_t errFracBG = bg > 0 ? TMath::Sqrt((errBG/bg)*(errBG/bg) + 1/nEvents[kClassB])*bgFrac : 0;
1647 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowBGFrac,bgFrac);
1648 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowBGFrac,errFracBG);
1649 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowAccFrac,accFrac);
1650 fHistStatistics[iHistStat]->SetBinError (icol,fBGStatOffset+kStatRowAccFrac,errAccFrac);
1651 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowGoodFrac,goodFrac);
1652 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGoodFrac,errGoodFrac);
1653 fHistStatistics[iHistStat]->SetBinContent(icol,fBGStatOffset+kStatRowErrGood,errGood);
85c71ba7 1654#endif
85c71ba7 1655 }
1656 }
8dec6e35 1657 }
1658 for (Int_t iTrigClass = 0; iTrigClass < kNClasses; iTrigClass++){
1659 delete [] rows[iTrigClass];
85c71ba7 1660 }
891c67bd 1661 } // end of ComputeBackground
85c71ba7 1662
1663 fHistStatistics[0]->Write();
1664 fHistStatistics[1]->Write();
8e58a7b9 1665 if(fHistBunchCrossing ) fHistBunchCrossing ->Write();
1666 if(fHistTriggerPattern) fHistTriggerPattern->Write();
61899827 1667
296dd262 1668 Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries();
1669 for (Int_t i=0; i < count; i++)
8dec6e35 1670 {
1671 TString triggerClass = "trigger_histograms_";
1672 if (i < fCollTrigClasses.GetEntries())
1673 triggerClass += ((TObjString*) fCollTrigClasses.At(i))->String();
1674 else
1675 triggerClass += ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String();
1676
1677 gDirectory->mkdir(triggerClass);
1678 gDirectory->cd(triggerClass);
1679
1680 static_cast<AliTriggerAnalysis*> (fTriggerAnalysis.At(i))->SaveHistograms();
1681
1682 gDirectory->cd("..");
1683 }
1ea7a921 1684
61899827 1685 if (folder)
1686 gDirectory->cd("..");
7c55ebd9 1687
61899827 1688}
85c71ba7 1689
141265a2 1690Int_t AliPhysicsSelection::GetStatRow(const char * triggerBXClass, UInt_t offlineTriggerType, UInt_t ** rowIDs) const {
1691 // Puts inside the array rowIDs the row number for a given offline
1692 // trigger in a given bx class. Returns the total number of lines
1693 // matching the selection
1694 // triggerBXClass can be either "A", "AC", "B" or "E"
1695 // offlineTriggerType is one of the types defined in AliVEvent
1696 // User should delete rowIDs if no longer needed
1697
1698 if(!fHistStatistics[0]) {
1699 AliWarning("Not initialized, returning 0");
1700 return 0;
1701 }
1702 const Int_t nrows = fHistStatistics[0]->GetNbinsY();
1703
1704 // allocate memory for at maximum nrows
1705 Int_t nMatches = 0;
1706 (*rowIDs) = new UInt_t[nrows];
1707
7c55ebd9 1708
1709 // Loop over rows and find matching ones, using the PS OADB
1710 // FIXME: check BG estimates
141265a2 1711 for(Int_t irow = 1; irow <= nrows; irow++){
8dec6e35 1712 TString triggerClassCurrent = fHistStatistics[0]->GetYaxis()->GetBinLabel(irow);
7c55ebd9 1713 TPRegexp trigType (".*\\&(\\d+).*");
1714 TObjArray * arr = trigType.MatchS(triggerClassCurrent.Data());
1715 if(arr->GetEntries() > 1){
1716 UInt_t tType = ((TObjString*)arr->At(1))->GetString().Atoi();
1717
1718 if (tType == offlineTriggerType && fPSOADB->GetBeamSide(triggerClassCurrent.Data()) == triggerBXClass) {
1719 (*rowIDs)[nMatches] = irow;
1720 nMatches++;
141265a2 1721 }
7c55ebd9 1722
141265a2 1723 }
7c55ebd9 1724 delete arr;
1725
85c71ba7 1726 }
141265a2 1727
1728 return nMatches;
1729}
85c71ba7 1730
141265a2 1731void AliPhysicsSelection::SetBIFactors(const AliESDEvent * aESD) {
1732 // Set factors for realtive bunch intesities
1733 if(!aESD) {
1734 AliFatal("ESD not given");
1735 }
1736 Int_t run = aESD->GetRunNumber();
1737 if (run > 105268) {
1738 // intensities stored in the ESDs
1739 const AliESDRun* esdRun = aESD->GetESDRun();
1740 Double_t intAB = esdRun->GetMeanIntensityIntecting(0);
1741 Double_t intCB = esdRun->GetMeanIntensityIntecting(1);
1742 Double_t intAA = esdRun->GetMeanIntensityNonIntecting(0);
1743 Double_t intCC = esdRun->GetMeanIntensityNonIntecting(1);
1744
1745 // cout << "INT " <<intAB <<endl;
1746 // cout << "INT " <<intCB <<endl;
1747 // cout << "INT " <<intAA <<endl;
1748 // cout << "INT " <<intCC <<endl;
1749
d0b66831 1750 if (intAB > 0 && intAA > 0) {
141265a2 1751 fBIFactorA = intAB/intAA;
1752 } else {
8dec6e35 1753 AliWarning("Cannot set fBIFactorA");
141265a2 1754 }
1755
d0b66831 1756 if (intCB > 0 && intCC > 0) {
141265a2 1757 fBIFactorC = intCB/intCC;
1758 } else {
8dec6e35 1759 AliWarning("Cannot set fBIFactorC");
141265a2 1760 }
1761
d0b66831 1762 if (intAB > 0 && intAA > 0 &&
1763 intCB > 0 && intCC > 0) {
141265a2 1764 fBIFactorAC = (intAB+intCB)/(intAA+intCC);
1765 } else {
8dec6e35 1766 AliWarning("Cannot set fBIFactorAC");
141265a2 1767 }
1768
1769 }
1770 else {
1771 // First runs. Intensities hardcoded
1772 switch(run) {
1773 case 104155:
1774 fBIFactorA = 0.961912722908;
1775 fBIFactorC = 1.04992336081;
1776 break;
1777 case 104157:
1778 fBIFactorA = 0.947312854998;
1779 fBIFactorC = 1.01599706417;
1780 break;
1781 case 104159:
1782 fBIFactorA = 0.93659320151;
1783 fBIFactorC = 0.98580804207;
1784 break;
1785 case 104160:
1786 fBIFactorA = 0.929664189926;
1787 fBIFactorC = 0.963467679851;
1788 break;
1789 case 104315:
1790 fBIFactorA = 1.08939104979;
1791 fBIFactorC = 0.931113921925;
1792 break;
1793 case 104316:
1794 fBIFactorA = 1.08351880974;
1795 fBIFactorC = 0.916068345845;
1796 break;
1797 case 104320:
1798 fBIFactorA = 1.07669281245;
1799 fBIFactorC = 0.876818744763;
1800 break;
1801 case 104321:
1802 fBIFactorA = 1.00971079602;
1803 fBIFactorC = 0.773781299076;
1804 break;
1805 case 104792:
1806 fBIFactorA = 0.787215863962;
1807 fBIFactorC = 0.778253173071;
1808 break;
1809 case 104793:
1810 fBIFactorA = 0.692211363661;
1811 fBIFactorC = 0.733152456667;
1812 break;
1813 case 104799:
1814 fBIFactorA = 1.04027825161;
1815 fBIFactorC = 1.00530825942;
1816 break;
1817 case 104800:
1818 fBIFactorA = 1.05309910671;
1819 fBIFactorC = 1.00376801855;
1820 break;
1821 case 104801:
1822 fBIFactorA = 1.0531231922;
1823 fBIFactorC = 0.992439666758;
1824 break;
1825 case 104802:
1826 fBIFactorA = 1.04191478134;
1827 fBIFactorC = 0.979368585208;
1828 break;
1829 case 104803:
1830 fBIFactorA = 1.03121314094;
1831 fBIFactorC = 0.973379962609;
1832 break;
1833 case 104824:
1834 fBIFactorA = 0.969945926722;
1835 fBIFactorC = 0.39549745806;
1836 break;
1837 case 104825:
1838 fBIFactorA = 0.968627213937;
1839 fBIFactorC = 0.310100412205;
1840 break;
1841 case 104841:
1842 fBIFactorA = 0.991601393212;
1843 fBIFactorC = 0.83762204722;
1844 break;
1845 case 104845:
1846 fBIFactorA = 0.98040863886;
1847 fBIFactorC = 0.694824205793;
1848 break;
1849 case 104867:
1850 fBIFactorA = 1.10646173412;
1851 fBIFactorC = 0.841407246916;
1852 break;
1853 case 104876:
1854 fBIFactorA = 1.12063452421;
1855 fBIFactorC = 0.78726542895;
1856 break;
1857 case 104890:
1858 fBIFactorA = 1.02346137453;
1859 fBIFactorC = 1.03355663595;
1860 break;
1861 case 104892:
1862 fBIFactorA = 1.05406025913;
1863 fBIFactorC = 1.00029166135;
1864 break;
1865 case 105143:
1866 fBIFactorA = 0.947343384349;
1867 fBIFactorC = 0.972637444408;
1868 break;
1869 case 105160:
1870 fBIFactorA = 0.908854622177;
1871 fBIFactorC = 0.958851103977;
1872 break;
1873 case 105256:
1874 fBIFactorA = 0.810076150206;
1875 fBIFactorC = 0.884663561883;
1876 break;
1877 case 105257:
1878 fBIFactorA = 0.80974912303;
1879 fBIFactorC = 0.878859123479;
1880 break;
1881 case 105268:
1882 fBIFactorA = 0.809052110679;
1883 fBIFactorC = 0.87233890989;
1884 break;
1885 default:
1886 fBIFactorA = 1;
1887 fBIFactorC = 1;
1888 }
1889 }
85c71ba7 1890
1891}
7c55ebd9 1892
1893const char * AliPhysicsSelection::GetTriggerString(TObjString * obj) {
1894 // Returns a formed objstring
1895 static TString retString;
1896
1897 retString.Form("%s%s",
1898 obj->String().Data(),
1899 fUseBXNumbers ? fFillOADB->GetBXIDs(fPSOADB->GetBeamSide(obj->String().Data())) : ""
1900 );
1901
1902 if (fMC) {
1903 TPRegexp stripClasses("\\+\\S* ");
1904 stripClasses.Substitute(retString,"","g");
1905 stripClasses=TPRegexp("\\-\\S* ");
1906 stripClasses.Substitute(retString,"","g");
1907 }
1908
1909 return retString.Data();
1910}
1911
1912void AliPhysicsSelection::AddCollisionTriggerClass(const char* className){
1913 AliError("This method is deprecated! Will be removed soon! Please use SetCustomOADBObjects() instead!");
1914 if(!fPSOADB) {
1915 fPSOADB = new AliOADBPhysicsSelection("CustomPS");
1916 fPSOADB->SetHardwareTrigger ( 0,"SPDGFO >= 1 || V0A || V0C");
1917 fPSOADB->SetOfflineTrigger ( 0,"(SPDGFO >= 1 || V0A || V0C) && !V0ABG && !V0CBG");
1918 }
1919
1920 // Strip all which is not needed, if BX ids are provided, they are still used here
1921 // offline trigger and logics are appended automagically, so we strip-em out if they are provided
1922 TString classNameStripped = className;
1923 if(classNameStripped.Index("*")>0)
1924 classNameStripped.Remove(classNameStripped.Index("*")); // keep only the class name (no bx, offline trigger...)
1925 if(classNameStripped.Index("&")>0)
1926 classNameStripped.Remove(classNameStripped.Index("&")); // keep only the class name (no bx, offline trigger...)
1927
1928 fPSOADB->AddCollisionTriggerClass ( AliVEvent::kUserDefined,classNameStripped.Data(),"B",0);
1929
1930 fUsingCustomClasses = kTRUE;
1931
1932
1933}
1934
1935void AliPhysicsSelection::AddBGTriggerClass(const char* className){
1936 // Add custom BG trigger class
1937
1938 AliError("This method is deprecated! Will be removed soon! Please use SetCustomOADBObjects() instead!");
1939 if(!fPSOADB) {
1940 fPSOADB = new AliOADBPhysicsSelection("CustomPS");
1941 fPSOADB->SetHardwareTrigger ( 0,"SPDGFO >= 1 || V0A || V0C");
1942 fPSOADB->SetOfflineTrigger ( 0,"(SPDGFO >= 1 || V0A || V0C) && !V0ABG && !V0CBG");
1943 }
1944
1945 // Strip all which is not needed, if BX ids are provided, they are still used here
1946 // offline trigger and logics are appended automagically, so we strip-em out if they are provided
1947 TString classNameStripped = className;
1948 if(classNameStripped.Index("*")>0)
1949 classNameStripped.Remove(classNameStripped.Index("*")); // keep only the class name (no bx, offline trigger...)
1950 if(classNameStripped.Index("&")>0)
1951 classNameStripped.Remove(classNameStripped.Index("&")); // keep only the class name (no bx, offline trigger...)
1952
1953 fPSOADB->AddBGTriggerClass ( AliVEvent::kUserDefined,classNameStripped.Data(),"AC",0);
1954
1955 fUsingCustomClasses = kTRUE;
1956
1957}