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