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