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