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