1 /**************************************************************************
2 * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
16 //*****************************************************
17 // Class AliCentralitySelectionTask
18 // Class to analyze determine centrality
19 // author: Alberica Toia
20 //*****************************************************
22 #include "AliCentralitySelectionTask.h"
31 #include <TObjString.h>
35 #include <TDirectory.h>
39 #include "AliAnalysisManager.h"
40 #include "AliVEvent.h"
42 #include "AliESDEvent.h"
43 #include "AliESDHeader.h"
44 #include "AliESDInputHandler.h"
45 #include "AliESDZDC.h"
46 #include "AliESDFMD.h"
47 #include "AliESDVZERO.h"
48 #include "AliCentrality.h"
49 #include "AliESDtrackCuts.h"
50 #include "AliMultiplicity.h"
51 #include "AliAODHandler.h"
52 #include "AliAODEvent.h"
53 #include "AliESDVertex.h"
54 #include "AliAODVertex.h"
55 #include "AliAODMCHeader.h"
56 #include "AliMCEvent.h"
57 #include "AliMCEventHandler.h"
58 #include "AliMCParticle.h"
60 #include "AliHeader.h"
61 #include "AliAODMCParticle.h"
62 #include "AliAnalysisTaskSE.h"
63 #include "AliGenEventHeader.h"
64 #include "AliGenHijingEventHeader.h"
65 #include "AliPhysicsSelectionTask.h"
66 #include "AliPhysicsSelection.h"
67 #include "AliBackgroundSelection.h"
68 #include "AliESDUtils.h"
70 ClassImp(AliCentralitySelectionTask)
73 //________________________________________________________________________
74 AliCentralitySelectionTask::AliCentralitySelectionTask():
76 fAnalysisInput("ESD"),
116 fHOutCentV0MvsFMD(0),
117 fHOutCentTKLvsV0M(0),
118 fHOutCentZEMvsZDC(0),
119 fHOutCentV0MvsCentCL1(0),
120 fHOutCentV0MvsCentTRK(0),
121 fHOutCentTRKvsCentCL1(0),
129 fHOutMultV0MvsZDN(0),
130 fHOutMultZEMvsZDN(0),
131 fHOutMultV0MvsZDC(0),
132 fHOutMultZEMvsZDC(0),
133 fHOutMultV0MvsCL1(0),
134 fHOutMultV0MvsTRK(0),
135 fHOutMultTRKvsCL1(0),
136 fHOutCentV0Mqual1(0),
137 fHOutCentTRKqual1(0),
138 fHOutCentCL1qual1(0),
139 fHOutCentV0Mqual2(0),
140 fHOutCentTRKqual2(0),
141 fHOutCentCL1qual2(0),
145 // Default constructor
146 AliInfo("Centrality Selection enabled.");
150 for (Int_t i=0; i < 2667; i++) {
151 fV0MScaleFactor[i]=0.0;
152 fSPDScaleFactor[i]=0.0;
153 fTPCScaleFactor[i]=0.0;
154 fV0MScaleFactorMC[i]=0.0;
158 fBranchNames="ESD:AliESDRun.,AliESDHeader.,AliESDZDC.,AliESDFMD.,AliESDVZERO."
159 ",SPDVertex.,TPCVertex.,PrimaryVertex.,AliMultiplicity.,Tracks ";
162 //________________________________________________________________________
163 AliCentralitySelectionTask::AliCentralitySelectionTask(const char *name):
164 AliAnalysisTaskSE(name),
165 fAnalysisInput("ESD"),
205 fHOutCentV0MvsFMD(0),
206 fHOutCentTKLvsV0M(0),
207 fHOutCentZEMvsZDC(0),
208 fHOutCentV0MvsCentCL1(0),
209 fHOutCentV0MvsCentTRK(0),
210 fHOutCentTRKvsCentCL1(0),
218 fHOutMultV0MvsZDN(0),
219 fHOutMultZEMvsZDN(0),
220 fHOutMultV0MvsZDC(0),
221 fHOutMultZEMvsZDC(0),
222 fHOutMultV0MvsCL1(0),
223 fHOutMultV0MvsTRK(0),
224 fHOutMultTRKvsCL1(0),
225 fHOutCentV0Mqual1(0),
226 fHOutCentTRKqual1(0),
227 fHOutCentCL1qual1(0),
228 fHOutCentV0Mqual2(0),
229 fHOutCentTRKqual2(0),
230 fHOutCentCL1qual2(0),
234 // Default constructor
238 AliInfo("Centrality Selection enabled.");
239 DefineOutput(1, TList::Class());
240 for (Int_t i=0; i<2667; i++) {
241 fV0MScaleFactor[i]=0.0;
242 fSPDScaleFactor[i]=0.0;
243 fTPCScaleFactor[i]=0.0;
244 fV0MScaleFactorMC[i]=0.0;
248 fBranchNames="ESD:AliESDRun.,AliESDHeader.,AliESDZDC.,AliESDFMD.,AliESDVZERO."
249 ",SPDVertex.,TPCVertex.,PrimaryVertex.,AliMultiplicity.,Tracks ";
252 //________________________________________________________________________
253 AliCentralitySelectionTask& AliCentralitySelectionTask::operator=(const AliCentralitySelectionTask& c)
255 // Assignment operator
257 AliAnalysisTaskSE::operator=(c);
262 //________________________________________________________________________
263 AliCentralitySelectionTask::AliCentralitySelectionTask(const AliCentralitySelectionTask& ana):
264 AliAnalysisTaskSE(ana),
265 fAnalysisInput(ana.fDebug),
266 fIsMCInput(ana.fIsMCInput),
270 fCurrentRun(ana.fCurrentRun),
272 fLowRunN(ana.fLowRunN),
273 fHighRunN(ana.fHighRunN),
274 fUseScaling(ana.fUseScaling),
275 fUseCleaning(ana.fUseCleaning),
276 fTrackCuts(ana.fTrackCuts),
278 fOutliersCut(ana.fOutliersCut),
279 fQuality(ana.fQuality),
280 fCentV0M(ana.fCentV0M),
281 fCentFMD(ana.fCentFMD),
282 fCentTRK(ana.fCentTRK),
283 fCentTKL(ana.fCentTKL),
284 fCentCL0(ana.fCentCL0),
285 fCentCL1(ana.fCentCL1),
286 fCentV0MvsFMD(ana.fCentV0MvsFMD),
287 fCentTKLvsV0M(ana.fCentTKLvsV0M),
288 fCentZEMvsZDC(ana.fCentZEMvsZDC),
289 fHtempV0M(ana.fHtempV0M),
290 fHtempFMD(ana.fHtempFMD),
291 fHtempTRK(ana.fHtempTRK),
292 fHtempTKL(ana.fHtempTKL),
293 fHtempCL0(ana.fHtempCL0),
294 fHtempCL1(ana.fHtempCL1),
295 fHtempV0MvsFMD(ana.fHtempV0MvsFMD),
296 fHtempTKLvsV0M(ana.fHtempTKLvsV0M),
297 fHtempZEMvsZDC(ana.fHtempZEMvsZDC),
298 fOutputList(ana.fOutputList),
299 fHOutCentV0M (ana.fHOutCentV0M ),
300 fHOutCentFMD (ana.fHOutCentFMD ),
301 fHOutCentTRK (ana.fHOutCentTRK ),
302 fHOutCentTKL (ana.fHOutCentTKL ),
303 fHOutCentCL0 (ana.fHOutCentCL0 ),
304 fHOutCentCL1 (ana.fHOutCentCL1 ),
305 fHOutCentV0MvsFMD(ana.fHOutCentV0MvsFMD),
306 fHOutCentTKLvsV0M(ana.fHOutCentTKLvsV0M),
307 fHOutCentZEMvsZDC(ana.fHOutCentZEMvsZDC),
308 fHOutCentV0MvsCentCL1(ana.fHOutCentV0MvsCentCL1),
309 fHOutCentV0MvsCentTRK(ana.fHOutCentV0MvsCentTRK),
310 fHOutCentTRKvsCentCL1(ana.fHOutCentTRKvsCentCL1),
311 fHOutMultV0M(ana.fHOutMultV0M),
312 fHOutMultV0R(ana.fHOutMultV0R),
313 fHOutMultFMD(ana.fHOutMultFMD),
314 fHOutMultTRK(ana.fHOutMultTRK),
315 fHOutMultTKL(ana.fHOutMultTKL),
316 fHOutMultCL0(ana.fHOutMultCL0),
317 fHOutMultCL1(ana.fHOutMultCL1),
318 fHOutMultV0MvsZDN(ana.fHOutMultV0MvsZDN),
319 fHOutMultZEMvsZDN(ana.fHOutMultZEMvsZDN),
320 fHOutMultV0MvsZDC(ana.fHOutMultV0MvsZDC),
321 fHOutMultZEMvsZDC(ana.fHOutMultZEMvsZDC),
322 fHOutMultV0MvsCL1(ana.fHOutMultV0MvsCL1),
323 fHOutMultV0MvsTRK(ana.fHOutMultV0MvsTRK),
324 fHOutMultTRKvsCL1(ana.fHOutMultTRKvsCL1),
325 fHOutCentV0Mqual1(ana.fHOutCentV0Mqual1),
326 fHOutCentTRKqual1(ana.fHOutCentTRKqual1),
327 fHOutCentCL1qual1(ana.fHOutCentCL1qual1),
328 fHOutCentV0Mqual2(ana.fHOutCentV0Mqual2),
329 fHOutCentTRKqual2(ana.fHOutCentTRKqual2),
330 fHOutCentCL1qual2(ana.fHOutCentCL1qual2),
331 fHOutQuality(ana.fHOutQuality),
332 fHOutVertex(ana.fHOutVertex)
335 for (Int_t i=0; i<2667; i++) {
336 fV0MScaleFactor[i]=0.0;
337 fSPDScaleFactor[i]=0.0;
338 fTPCScaleFactor[i]=0.0;
339 fV0MScaleFactorMC[i]=0.0;
344 //________________________________________________________________________
345 AliCentralitySelectionTask::~AliCentralitySelectionTask()
348 if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) delete fOutputList;
349 if (fTrackCuts) delete fTrackCuts;
352 //________________________________________________________________________
353 void AliCentralitySelectionTask::UserCreateOutputObjects()
355 // Create the output containers
356 if(fDebug>1) printf("AnalysisCentralitySelectionTask::UserCreateOutputObjects() \n");
357 AliLog::SetClassDebugLevel("AliCentralitySelectionTask", AliLog::kInfo);
359 fOutputList = new TList();
360 fOutputList->SetOwner();
361 fHOutCentV0M = new TH1F("fHOutCentV0M","fHOutCentV0M; Centrality V0",505,0,101);
362 fHOutCentFMD = new TH1F("fHOutCentFMD","fHOutCentFMD; Centrality FMD",505,0,101);
363 fHOutCentTRK = new TH1F("fHOutCentTRK","fHOutCentTRK; Centrality TPC",505,0,101);
364 fHOutCentTKL = new TH1F("fHOutCentTKL","fHOutCentTKL; Centrality tracklets",505,0,101);
365 fHOutCentCL0 = new TH1F("fHOutCentCL0","fHOutCentCL0; Centrality SPD inner",505,0,101);
366 fHOutCentCL1 = new TH1F("fHOutCentCL1","fHOutCentCL1; Centrality SPD outer",505,0,101);
367 fHOutCentV0MvsFMD= new TH1F("fHOutCentV0MvsFMD","fHOutCentV0MvsFMD; Centrality V0 vs FMD",505,0,101);
368 fHOutCentTKLvsV0M= new TH1F("fHOutCentTKLvsV0M","fHOutCentTKLvsV0M; Centrality tracklets vs V0",505,0,101);
369 fHOutCentZEMvsZDC= new TH1F("fHOutCentZEMvsZDC","fHOutCentZEMvsZDC; Centrality ZEM vs ZDC",505,0,101);
370 fHOutCentV0MvsCentCL1= new TH2F("fHOutCentV0MvsCentCL1","fHOutCentV0MvsCentCL1; Cent V0 vs Cent SPD",505,0,101,505,0,101);
371 fHOutCentV0MvsCentTRK= new TH2F("fHOutCentV0MvsCentTRK","fHOutCentV0MvsCentTRK; Cent V0 vs Cent TPC",505,0,101,505,0,101);
372 fHOutCentTRKvsCentCL1= new TH2F("fHOutCentTRKvsCentCL1","fHOutCentTRKvsCentCL1; Cent TPC vs Cent SPD",505,0,101,505,0,101);
374 fHOutMultV0M = new TH1F("fHOutMultV0M","fHOutMultV0M; Multiplicity V0",25000,0,25000);
375 fHOutMultV0R = new TH1F("fHOutMultV0R","fHOutMultV0R; Multiplicity V0",30000,0,30000);
376 fHOutMultFMD = new TH1F("fHOutMultFMD","fHOutMultFMD; Multiplicity FMD",24000,0,24000);
377 fHOutMultTRK = new TH1F("fHOutMultTRK","fHOutMultTRK; Multiplicity TPC",4000,0,4000);
378 fHOutMultTKL = new TH1F("fHOutMultTKL","fHOutMultTKL; Multiplicity tracklets",5000,0,5000);
379 fHOutMultCL0 = new TH1F("fHOutMultCL0","fHOutMultCL0; Multiplicity SPD inner",7000,0,7000);
380 fHOutMultCL1 = new TH1F("fHOutMultCL1","fHOutMultCL1; Multiplicity SPD outer",7000,0,7000);
381 fHOutMultV0MvsZDN = new TH2F("fHOutMultV0MvsZDN","fHOutMultV0MvsZDN; Multiplicity V0; Energy ZDC-N",500,0,25000,500,0,180000);
382 fHOutMultZEMvsZDN = new TH2F("fHOutMultZEMvsZDN","fHOutMultZEMvsZDN; Energy ZEM; Energy ZDC-N",500,0,2500,500,0,180000);
383 fHOutMultV0MvsZDC = new TH2F("fHOutMultV0MvsZDC","fHOutMultV0MvsZDC; Multiplicity V0; Energy ZDC",500,0,25000,500,0,200000);
384 fHOutMultZEMvsZDC = new TH2F("fHOutMultZEMvsZDC","fHOutMultZEMvsZDC; Energy ZEM; Energy ZDC",500,0,2500,500,0,200000);
385 fHOutMultV0MvsCL1 = new TH2F("fHOutMultV0MvsCL1","fHOutMultV0MvsCL1; Multiplicity V0; Multiplicity SPD outer",2500,0,25000,700,0,7000);
386 fHOutMultV0MvsTRK = new TH2F("fHOutMultV0MvsTRK","fHOutMultV0MvsTRK; Multiplicity V0; Multiplicity TPC",2500,0,25000,400,0,4000);
387 fHOutMultTRKvsCL1 = new TH2F("fHOutMultTRKvsCL1","fHOutMultTRKvsCL1; Multiplicity TPC; Multiplicity SPD outer",400,0,4000,700,0,7000);
389 fHOutCentV0Mqual1 = new TH1F("fHOutCentV0M_qual1","fHOutCentV0M_qual1; Centrality V0",505,0,101);
390 fHOutCentTRKqual1 = new TH1F("fHOutCentTRK_qual1","fHOutCentTRK_qual1; Centrality TPC",505,0,101);
391 fHOutCentCL1qual1 = new TH1F("fHOutCentCL1_qual1","fHOutCentCL1_qual1; Centrality SPD outer",505,0,101);
393 fHOutCentV0Mqual2 = new TH1F("fHOutCentV0M_qual2","fHOutCentV0M_qual2; Centrality V0",505,0,101);
394 fHOutCentTRKqual2 = new TH1F("fHOutCentTRK_qual2","fHOutCentTRK_qual2; Centrality TPC",505,0,101);
395 fHOutCentCL1qual2 = new TH1F("fHOutCentCL1_qual2","fHOutCentCL1_qual2; Centrality SPD outer",505,0,101);
397 fHOutQuality = new TH1F("fHOutQuality", "fHOutQuality", 10,-0.5,9.5);
398 fHOutVertex = new TH1F("fHOutVertex", "fHOutVertex", 100,-20,20);
400 fOutputList->Add( fHOutCentV0M );
401 fOutputList->Add( fHOutCentFMD );
402 fOutputList->Add( fHOutCentTRK );
403 fOutputList->Add( fHOutCentTKL );
404 fOutputList->Add( fHOutCentCL0 );
405 fOutputList->Add( fHOutCentCL1 );
406 fOutputList->Add( fHOutCentV0MvsFMD);
407 fOutputList->Add( fHOutCentTKLvsV0M);
408 fOutputList->Add( fHOutCentZEMvsZDC);
409 fOutputList->Add( fHOutCentV0MvsCentCL1);
410 fOutputList->Add( fHOutCentV0MvsCentTRK);
411 fOutputList->Add( fHOutCentTRKvsCentCL1);
412 fOutputList->Add( fHOutMultV0M);
413 fOutputList->Add( fHOutMultV0R);
414 fOutputList->Add( fHOutMultFMD);
415 fOutputList->Add( fHOutMultTRK);
416 fOutputList->Add( fHOutMultTKL);
417 fOutputList->Add( fHOutMultCL0);
418 fOutputList->Add( fHOutMultCL1);
419 fOutputList->Add( fHOutMultV0MvsZDN);
420 fOutputList->Add( fHOutMultZEMvsZDN);
421 fOutputList->Add( fHOutMultV0MvsZDC);
422 fOutputList->Add( fHOutMultZEMvsZDC);
423 fOutputList->Add( fHOutMultV0MvsCL1);
424 fOutputList->Add( fHOutMultV0MvsTRK);
425 fOutputList->Add( fHOutMultTRKvsCL1);
426 fOutputList->Add( fHOutCentV0Mqual1 );
427 fOutputList->Add( fHOutCentTRKqual1 );
428 fOutputList->Add( fHOutCentCL1qual1 );
429 fOutputList->Add( fHOutCentV0Mqual2 );
430 fOutputList->Add( fHOutCentTRKqual2 );
431 fOutputList->Add( fHOutCentCL1qual2 );
432 fOutputList->Add( fHOutQuality );
433 fOutputList->Add( fHOutVertex );
436 fTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
438 PostData(1, fOutputList);
441 if (fIsMCInput) MyInitScaleFactorMC();
444 //________________________________________________________________________
445 void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
447 // Execute analysis for current event:
448 if(fDebug>1) printf(" **** AliCentralitySelectionTask::UserExec() \n");
450 Float_t zncEnergy = 0.; // ZNC Energy
451 Float_t zpcEnergy = 0.; // ZPC Energy
452 Float_t znaEnergy = 0.; // ZNA Energy
453 Float_t zpaEnergy = 0.; // ZPA Energy
454 Float_t zem1Energy = 0.; // ZEM1 Energy
455 Float_t zem2Energy = 0.; // ZEM2 Energy
456 Bool_t zdcEnergyCal = kFALSE; // if zdc is calibrated (in pass2)
458 Int_t nTracks = 0; // no. tracks
459 Int_t nTracklets = 0; // no. tracklets
460 Int_t nClusters[6] = {0}; // no. clusters on 6 ITS layers
461 Int_t nChips[2]; // no. chips on 2 SPD layers
462 Float_t spdCorr =0; // corrected spd2 multiplicity
464 Float_t multV0A = 0; // multiplicity from V0 reco side A
465 Float_t multV0C = 0; // multiplicity from V0 reco side C
466 Float_t multFMDA = 0; // multiplicity from FMD on detector A
467 Float_t multFMDC = 0; // multiplicity from FMD on detector C
469 Short_t v0Corr = 0; // corrected V0 multiplicity
470 Short_t v0CorrResc = 0; // corrected and rescaled V0 multiplicity
472 Float_t zvtx =0; // z-vertex SPD
474 AliCentrality *esdCent = 0;
476 if(fAnalysisInput.CompareTo("ESD")==0){
478 AliVEvent* event = InputEvent();
479 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
481 AliError("No ESD Event");
489 AliError("Centrality File not available for this run");
493 esdCent = esd->GetCentrality();
496 AliESDVZERO* esdV0 = esd->GetVZEROData();
497 multV0A=esdV0->GetMTotV0A();
498 multV0C=esdV0->GetMTotV0C();
501 v0Corr = (Short_t)AliESDUtils::GetCorrV0(esd,v0CorrR);
502 v0CorrResc = (Short_t)v0CorrR;
505 const AliESDVertex* vtxESD = esd->GetPrimaryVertexSPD();
506 zvtx = vtxESD->GetZ();
508 // ***** CB info (tracklets, clusters, chips)
509 //nTracks = event->GetNumberOfTracks();
510 nTracks = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
512 const AliMultiplicity *mult = esd->GetMultiplicity();
514 nTracklets = mult->GetNumberOfTracklets();
516 for(Int_t ilay=0; ilay<6; ilay++){
517 nClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
520 for(Int_t ilay=0; ilay<2; ilay++){
521 nChips[ilay] = mult->GetNumberOfFiredChips(ilay);
524 spdCorr = AliESDUtils::GetCorrSPD2(nClusters[1],zvtx);
527 AliESDFMD *fmd = esd->GetFMDData();
528 Float_t totalMultA = 0;
529 Float_t totalMultC = 0;
530 const Float_t fFMDLowCut = 0.4;
532 for(UShort_t det=1;det<=3;det++) {
533 Int_t nRings = (det==1 ? 1 : 2);
534 for (UShort_t ir = 0; ir < nRings; ir++) {
535 Char_t ring = (ir == 0 ? 'I' : 'O');
536 UShort_t nsec = (ir == 0 ? 20 : 40);
537 UShort_t nstr = (ir == 0 ? 512 : 256);
538 for(UShort_t sec =0; sec < nsec; sec++) {
539 for(UShort_t strip = 0; strip < nstr; strip++) {
541 Float_t fmdMult = fmd->Multiplicity(det,ring,sec,strip);
542 if(fmdMult == 0 || fmdMult == AliESDFMD::kInvalidMult) continue;
544 Float_t nParticles=0;
546 if(fmdMult > fFMDLowCut) {
550 if (det<3) totalMultA = totalMultA + nParticles;
551 else totalMultC = totalMultC + nParticles;
557 multFMDA = totalMultA;
558 multFMDC = totalMultC;
561 AliESDZDC *esdZDC = esd->GetESDZDC();
562 zdcEnergyCal = esdZDC->AliESDZDC::TestBit(AliESDZDC::kEnergyCalibratedSignal);
564 zncEnergy = (Float_t) (esdZDC->GetZDCN1Energy());
565 zpcEnergy = (Float_t) (esdZDC->GetZDCP1Energy());
566 znaEnergy = (Float_t) (esdZDC->GetZDCN2Energy());
567 zpaEnergy = (Float_t) (esdZDC->GetZDCP2Energy());
569 zncEnergy = (Float_t) (esdZDC->GetZDCN1Energy())/8.;
570 zpcEnergy = (Float_t) (esdZDC->GetZDCP1Energy())/8.;
571 znaEnergy = (Float_t) (esdZDC->GetZDCN2Energy())/8.;
572 zpaEnergy = (Float_t) (esdZDC->GetZDCP2Energy())/8.;
574 zem1Energy = (Float_t) (esdZDC->GetZDCEMEnergy(0))/8.;
575 zem2Energy = (Float_t) (esdZDC->GetZDCEMEnergy(1))/8.;
578 else if(fAnalysisInput.CompareTo("AOD")==0){
579 //AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
581 printf(" AOD analysis not yet implemented!!!\n\n");
587 // ***** Scaling for pass2
592 // ***** Scaling for MC
595 Float_t tempScalefactorV0M = MyGetScaleFactorMC(fCurrentRun);
596 v0Corr = Short_t((multV0A+multV0C) * tempScalefactorV0M);
598 // ***** Scaling for Data
600 Float_t tempScalefactorV0M = MyGetScaleFactor(fCurrentRun,0);
601 Float_t tempScalefactorSPD = MyGetScaleFactor(fCurrentRun,1);
602 Float_t tempScalefactorTPC = MyGetScaleFactor(fCurrentRun,2);
603 v0Corr = Short_t(v0Corr / tempScalefactorV0M);
604 spdCorr = spdCorr / tempScalefactorSPD;
605 nTracks = Int_t(nTracks / tempScalefactorTPC);
608 // ***** Centrality Selection
609 if(fHtempV0M) fCentV0M = fHtempV0M->GetBinContent(fHtempV0M->FindBin((v0Corr)));
610 if(fHtempFMD) fCentFMD = fHtempFMD->GetBinContent(fHtempFMD->FindBin((multFMDA+multFMDC)));
611 if(fHtempTRK) fCentTRK = fHtempTRK->GetBinContent(fHtempTRK->FindBin(nTracks));
612 if(fHtempTKL) fCentTKL = fHtempTKL->GetBinContent(fHtempTKL->FindBin(nTracklets));
613 if(fHtempCL0) fCentCL0 = fHtempCL0->GetBinContent(fHtempCL0->FindBin(nClusters[0]));
614 if(fHtempCL1) fCentCL1 = fHtempCL1->GetBinContent(fHtempCL1->FindBin(spdCorr));
616 if(fHtempV0MvsFMD) fCentV0MvsFMD = fHtempV0MvsFMD->GetBinContent(fHtempV0MvsFMD->FindBin((multV0A+multV0C)));
617 if(fHtempTKLvsV0M) fCentTKLvsV0M = fHtempTKLvsV0M->GetBinContent(fHtempTKLvsV0M->FindBin(nTracklets));
618 if(fHtempZEMvsZDC) fCentZEMvsZDC = fHtempZEMvsZDC->GetBinContent(fHtempZEMvsZDC->FindBin(zem1Energy+zem2Energy,zncEnergy+znaEnergy+zpcEnergy+zpaEnergy));
627 if (TMath::Abs(zvtx)>fZVCut) fQuality += 1;
631 if (IsOutlierV0MSPD(spdCorr, v0Corr, int(fCentV0M))) fQuality += 2;
633 if (IsOutlierV0MTPC(nTracks, v0Corr, int(fCentV0M))) fQuality += 4;
635 if (IsOutlierV0MZDC((zncEnergy+znaEnergy+zpcEnergy+zpaEnergy), v0Corr) &&
636 (zdcEnergyCal==kFALSE) && !(fIsMCInput)) fQuality += 8;
637 if (IsOutlierV0MZDCECal((zncEnergy+znaEnergy+zpcEnergy+zpaEnergy), v0Corr) &&
638 ((zdcEnergyCal==kTRUE) || (fIsMCInput))) fQuality += 8;
645 esdCent->SetQuality(fQuality);
646 esdCent->SetCentralityV0M(fCentV0M);
647 esdCent->SetCentralityFMD(fCentFMD);
648 esdCent->SetCentralityTRK(fCentTRK);
649 esdCent->SetCentralityTKL(fCentTKL);
650 esdCent->SetCentralityCL0(fCentCL0);
651 esdCent->SetCentralityCL1(fCentCL1);
652 esdCent->SetCentralityV0MvsFMD(fCentV0MvsFMD);
653 esdCent->SetCentralityTKLvsV0M(fCentTKLvsV0M);
654 esdCent->SetCentralityZEMvsZDC(fCentZEMvsZDC);
657 fHOutQuality->Fill(fQuality);
658 fHOutVertex->Fill(zvtx);
660 fHOutMultV0MvsZDN->Fill(v0Corr,(zncEnergy+znaEnergy));
661 fHOutMultZEMvsZDN->Fill((zem1Energy+zem2Energy),(zncEnergy+znaEnergy));
662 fHOutMultV0MvsZDC->Fill(v0Corr,(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy));
663 fHOutMultZEMvsZDC->Fill((zem1Energy+zem2Energy),(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy));
664 fHOutMultV0MvsCL1->Fill(v0Corr,spdCorr);
665 fHOutMultV0MvsTRK->Fill(v0Corr,nTracks);
668 fHOutCentV0M->Fill(fCentV0M);
669 fHOutCentFMD->Fill(fCentFMD);
670 fHOutCentTRK->Fill(fCentTRK);
671 fHOutCentTKL->Fill(fCentTKL);
672 fHOutCentCL0->Fill(fCentCL0);
673 fHOutCentCL1->Fill(fCentCL1);
674 fHOutCentV0MvsFMD->Fill(fCentV0MvsFMD);
675 fHOutCentTKLvsV0M->Fill(fCentTKLvsV0M);
676 fHOutCentZEMvsZDC->Fill(fCentZEMvsZDC);
677 fHOutCentV0MvsCentCL1->Fill(fCentV0M,fCentCL1);
678 fHOutCentV0MvsCentTRK->Fill(fCentV0M,fCentTRK);
679 fHOutCentTRKvsCentCL1->Fill(fCentTRK,fCentCL1);
680 fHOutMultV0M->Fill(v0Corr);
681 fHOutMultV0R->Fill(multV0A+multV0C);
682 fHOutMultFMD->Fill((multFMDA+multFMDC));
683 fHOutMultTRK->Fill(nTracks);
684 fHOutMultTKL->Fill(nTracklets);
685 fHOutMultCL0->Fill(nClusters[0]);
686 fHOutMultCL1->Fill(spdCorr);
687 fHOutMultTRKvsCL1->Fill(nTracks,spdCorr);
688 } else if (fQuality ==1) {
689 fHOutCentV0Mqual1->Fill(fCentV0M);
690 fHOutCentTRKqual1->Fill(fCentTRK);
691 fHOutCentCL1qual1->Fill(fCentCL1);
693 fHOutCentV0Mqual2->Fill(fCentV0M);
694 fHOutCentTRKqual2->Fill(fCentTRK);
695 fHOutCentCL1qual2->Fill(fCentCL1);
698 PostData(1, fOutputList);
701 //________________________________________________________________________
702 void AliCentralitySelectionTask::ReadCentralityHistos(TString fCentfilename)
704 // Read centrality histograms
705 TDirectory *owd = gDirectory;
706 // Check if the file is present
707 TString path = gSystem->ExpandPathName(fCentfilename.Data());
708 if (gSystem->AccessPathName(path)) {
709 AliError(Form("File %s does not exist", path.Data()));
712 fFile = TFile::Open(fCentfilename);
714 fHtempV0M = (TH1F*) (fFile->Get("hmultV0_percentile"));
715 fHtempFMD = (TH1F*) (fFile->Get("hmultFMD_percentile"));
716 fHtempTRK = (TH1F*) (fFile->Get("hNtracks_percentile"));
717 fHtempTKL = (TH1F*) (fFile->Get("hNtracklets_percentile"));
718 fHtempCL0 = (TH1F*) (fFile->Get("hNclusters0_percentile"));
719 fHtempCL1 = (TH1F*) (fFile->Get("hNclusters1_percentile"));
721 if (!fHtempV0M) AliWarning(Form("Calibration for V0M does not exist in %s", path.Data()));
722 if (!fHtempFMD) AliWarning(Form("Calibration for FMD does not exist in %s", path.Data()));
723 if (!fHtempTRK) AliWarning(Form("Calibration for TRK does not exist in %s", path.Data()));
724 if (!fHtempTKL) AliWarning(Form("Calibration for TKL does not exist in %s", path.Data()));
725 if (!fHtempCL0) AliWarning(Form("Calibration for CL0 does not exist in %s", path.Data()));
726 if (!fHtempCL1) AliWarning(Form("Calibration for CL1 does not exist in %s", path.Data()));
731 //________________________________________________________________________
732 void AliCentralitySelectionTask::ReadCentralityHistos2(TString fCentfilename2)
734 // Read centrality histograms
735 TDirectory *owd = gDirectory;
736 TString path = gSystem->ExpandPathName(fCentfilename2.Data());
737 if (gSystem->AccessPathName(path)) {
738 AliError(Form("File %s does not exist", path.Data()));
741 fFile2 = TFile::Open(fCentfilename2);
743 fHtempV0MvsFMD = (TH1F*) (fFile2->Get("hmultV0vsmultFMD_all_percentile"));
744 fHtempTKLvsV0M = (TH1F*) (fFile2->Get("hNtrackletsvsmultV0_all_percentile"));
745 fHtempZEMvsZDC = (TH2F*) (fFile2->Get("hEzemvsEzdc_all_percentile"));
747 if (!fHtempV0MvsFMD) AliWarning(Form("Calibration for V0MvsFMD does not exist in %s", path.Data()));
748 if (!fHtempTKLvsV0M) AliWarning(Form("Calibration for TKLvsV0M does not exist in %s", path.Data()));
749 if (!fHtempZEMvsZDC) AliWarning(Form("Calibration for ZEMvsZDC does not exist in %s", path.Data()));
754 //________________________________________________________________________
755 void AliCentralitySelectionTask::Terminate(Option_t */*option*/)
757 // Terminate analysis
758 if (fFile && fFile->IsOpen())
760 if (fFile2 && fFile2->IsOpen())
763 //________________________________________________________________________
764 Int_t AliCentralitySelectionTask::SetupRun(AliESDEvent* const esd)
766 // Setup files for run
771 // check if something to be done
772 if (fCurrentRun == esd->GetRunNumber())
775 fCurrentRun = esd->GetRunNumber();
777 AliInfo(Form("Setup Centrality Selection for run %d\n",fCurrentRun));
779 // CHANGE HERE FOR RUN RANGES
780 if ( fCurrentRun <= 137165 ) fRunNo = 137161;
781 else fRunNo = 137366;
782 // CHANGE HERE FOR RUN RANGES
787 fileName=(Form("%s/COMMON/CENTRALITY/data/AliCentralityBy1D_%d.root", AliAnalysisManager::GetOADBPath(), fRunNo));
788 fileName2=(Form("%s/COMMON/CENTRALITY/data/AliCentralityByFunction_%d.root", AliAnalysisManager::GetOADBPath(), fRunNo));
789 } else if (fPass==2) {
790 fileName=(Form("%s/COMMON/CENTRALITY/data/AliCentralityBy1D_%d.root", AliAnalysisManager::GetOADBPath(), fRunNo));
791 fileName2=(Form("%s/COMMON/CENTRALITY/data/AliCentralityByFunction_%d.root", AliAnalysisManager::GetOADBPath(), fRunNo));
794 AliInfo(Form("Centrality Selection for run %d and pass %d is initialized with %s", fCurrentRun, fPass, fileName.Data()));
795 ReadCentralityHistos(fileName.Data());
796 ReadCentralityHistos2(fileName2.Data());
797 if (!fFile && !fFile2) {
798 AliError(Form("Run %d not known to centrality selection!", fCurrentRun));
804 //________________________________________________________________________
805 Bool_t AliCentralitySelectionTask::IsOutlierV0MSPD(Float_t spd, Float_t v0, Int_t cent) const
808 Float_t val= -0.143789 + 0.288874 * v0;
809 Float_t spdSigma[101]={231.483, 189.446, 183.359, 179.923, 174.229, 170.309, 165.021,
810 160.84, 159.33, 154.453, 151.644, 148.337, 145.215, 142.353,
811 139.351, 136, 133.838, 129.885, 127.36, 125.032, 122.21, 120.3,
812 117.766, 114.77, 113.1, 110.268, 107.463, 105.293, 102.845,
813 100.835, 98.9632, 97.3287, 93.6887, 92.1066, 89.3224, 87.8382,
814 86.04, 83.6431, 81.9655, 80.0491, 77.8208, 76.4716, 74.2165,
815 72.2752, 70.4875, 68.9414, 66.8622, 65.022, 63.5134, 61.8228,
816 59.7166, 58.5008, 56.2789, 54.9615, 53.386, 51.2165, 49.4842,
817 48.259, 47.1129, 45.3115, 43.8486, 41.9207, 40.5754, 39.3872,
818 38.1897, 36.5401, 35.1283, 33.9702, 32.6429, 31.3612, 29.5876,
819 28.9319, 27.564, 26.0443, 25.2836, 23.9753, 22.8936, 21.5665,
820 20.7048, 19.8016, 18.7095, 18.1144, 17.2095, 16.602, 16.3233,
821 15.7185, 15.3006, 14.7432, 14.4174, 14.0805, 13.7638, 13.7638,
822 13.7638, 13.7638, 13.7638, 13.7638, 13.7638, 13.7638, 13.7638, 18.0803, 18.0803};
824 if ( TMath::Abs(spd-val) > fOutliersCut*spdSigma[cent] )
830 //________________________________________________________________________
831 Bool_t AliCentralitySelectionTask::IsOutlierV0MTPC(Int_t tracks, Float_t v0, Int_t cent) const
834 Float_t val = -0.540691 + 0.128358 * v0;
835 Float_t tpcSigma[101]={106.439, 89.2834, 86.7568, 85.3641, 83.379, 81.6093, 79.3189,
836 78.0616, 77.2167, 75.0021, 73.9957, 72.0926, 71.0442, 69.8395,
837 68.1169, 66.6676, 66.0038, 64.2284, 63.3845, 61.7439, 60.642,
838 59.5383, 58.3696, 57.0227, 56.0619, 54.7108, 53.8382, 52.3398,
839 51.5297, 49.9488, 49.1126, 48.208, 46.8566, 45.7724, 44.7829,
840 43.8726, 42.7499, 41.9307, 40.6874, 39.9619, 38.5534, 38.0884,
841 36.6141, 35.7482, 34.8804, 34.1769, 33.1278, 32.3435, 31.4783,
842 30.2587, 29.4741, 28.8575, 27.9298, 26.9752, 26.1675, 25.1234,
843 24.4702, 23.6843, 22.9764, 21.8579, 21.2924, 20.3241, 19.8296,
844 19.2465, 18.4474, 17.7216, 16.8956, 16.342, 15.626, 15.0329,
845 14.3911, 13.9301, 13.254, 12.6745, 12.2436, 11.7776, 11.1795,
846 10.673, 10.27, 9.95646, 9.50939, 9.26162, 8.95315, 8.73439,
847 8.67375, 8.43029, 8.34818, 8.33484, 8.40709, 8.3974, 8.32814,
848 8.32814, 8.32814, 8.32814, 8.32814, 8.32814, 8.32814, 8.32814, 8.32814, 12.351, 12.351};
850 if ( TMath::Abs(tracks-val) > fOutliersCut*tpcSigma[cent] )
856 //________________________________________________________________________
857 Bool_t AliCentralitySelectionTask::IsOutlierV0MZDC(Float_t /*zdc*/, Float_t /*v0*/) const
860 // Float_t val1 = 6350. - 0.26 * v0;
861 // Float_t val2 = 5580.;
862 // if ((zdc > val1) || (zdc > val2))
868 //________________________________________________________________________
869 Bool_t AliCentralitySelectionTask::IsOutlierV0MZDCECal(Float_t /*zdc*/, Float_t /*v0*/) const
875 //________________________________________________________________________
876 Float_t AliCentralitySelectionTask::MyGetScaleFactor(Int_t runnumber, Int_t flag) const
878 // Get scaling factor
879 if (! (runnumber >= fLowRunN && runnumber <=fHighRunN)) {
880 cout << "MyGetScaleFactor error in run number range " << runnumber << endl;
884 Float_t scalefactor=0.0;
886 scalefactor = fV0MScaleFactor[runnumber - fLowRunN]; // subtracting reference offset index
888 scalefactor = fSPDScaleFactor[runnumber - fLowRunN]; // subtracting reference offset index
890 scalefactor = fTPCScaleFactor[runnumber - fLowRunN]; // subtracting reference offset index
896 //________________________________________________________________________
897 Float_t AliCentralitySelectionTask::MyGetScaleFactorMC(Int_t runnumber) const
899 // Get MC scaling factor
900 if (! (runnumber >= fLowRunN && runnumber <=fHighRunN)) {
901 cout << "MyGetScaleFactor error in run number range " << runnumber << endl;
905 Float_t scalefactor= fV0MScaleFactorMC[runnumber - fLowRunN]; // subtracting reference offset index
910 //________________________________________________________________________
911 void AliCentralitySelectionTask::MyInitScaleFactor ()
913 // Initialize the scaling factors
914 for (int i=0; i<=(fHighRunN-fLowRunN); i++) fV0MScaleFactor[i] = 0.0;
915 for (int i=0; i<=(fHighRunN-fLowRunN); i++) fSPDScaleFactor[i] = 0.0;
916 for (int i=0; i<=(fHighRunN-fLowRunN); i++) fTPCScaleFactor[i] = 0.0;
918 // scale factors determined from <V0 charge> on a run-by-run basis
919 fV0MScaleFactor[310] = 1.;
920 fV0MScaleFactor[311] = 1.;
921 fV0MScaleFactor[514] = 1.0046;
922 fV0MScaleFactor[515] = 0.983535;
923 fV0MScaleFactor[579] = 0.988185;
924 fV0MScaleFactor[580] = 0.983351;
925 fV0MScaleFactor[581] = 0.989013;
926 fV0MScaleFactor[583] = 0.990056;
927 fV0MScaleFactor[588] = 0.974438;
928 fV0MScaleFactor[589] = 0.981572;
929 fV0MScaleFactor[590] = 0.989316;
930 fV0MScaleFactor[592] = 0.98345;
931 fV0MScaleFactor[688] = 0.993647;
932 fV0MScaleFactor[690] = 0.994758;
933 fV0MScaleFactor[693] = 0.989569;
934 fV0MScaleFactor[698] = 0.993119;
935 fV0MScaleFactor[744] = 0.989583;
936 fV0MScaleFactor[757] = 0.990377;
937 fV0MScaleFactor[787] = 0.990176;
938 fV0MScaleFactor[788] = 0.98723;
939 fV0MScaleFactor[834] = 1.00403;
940 fV0MScaleFactor[835] = 0.994376;
941 fV0MScaleFactor[840] = 0.99759;
942 fV0MScaleFactor[842] = 1.01031;
943 fV0MScaleFactor[900] = 0.996216;
944 fV0MScaleFactor[901] = 0.994205;
945 fV0MScaleFactor[992] = 0.998479;
946 fV0MScaleFactor[997] = 1.00078;
947 fV0MScaleFactor[1299] = 1.00515;
948 fV0MScaleFactor[1303] = 1.00094;
949 fV0MScaleFactor[1339] = 0.986596;
950 fV0MScaleFactor[1346] = 0.972226;
951 fV0MScaleFactor[1349] = 0.960358;
952 fV0MScaleFactor[1350] = 0.970023;
953 fV0MScaleFactor[1374] = 1.00575;
954 fV0MScaleFactor[1545] = 1.00471;
955 fV0MScaleFactor[1587] = 1.00611;
956 fV0MScaleFactor[1588] = 1.00976;
957 fV0MScaleFactor[1618] = 1.00771;
958 fV0MScaleFactor[1682] = 1.01622;
959 fV0MScaleFactor[1727] = 1.01305;
960 fV0MScaleFactor[1728] = 1.00388;
961 fV0MScaleFactor[1731] = 1.00673;
962 fV0MScaleFactor[1732] = 1.00916;
963 fV0MScaleFactor[1770] = 1.0092;
964 fV0MScaleFactor[1773] = 1.00728;
965 fV0MScaleFactor[1786] = 1.01655;
966 fV0MScaleFactor[1787] = 1.00672;
967 fV0MScaleFactor[1801] = 0.983339;
968 fV0MScaleFactor[1802] = 1.00754;
969 fV0MScaleFactor[1811] = 1.00608;
970 fV0MScaleFactor[1815] = 1.01227;
971 fV0MScaleFactor[1879] = 0.99907;
972 fV0MScaleFactor[1881] = 0.995696;
973 fV0MScaleFactor[2186] = 1.00559;
974 fV0MScaleFactor[2187] = 1.00631;
975 fV0MScaleFactor[2254] = 1.01512;
976 fV0MScaleFactor[2256] = 0.998727;
977 fV0MScaleFactor[2321] = 1.00701;
978 fSPDScaleFactor[310] = 1.00211;
979 fSPDScaleFactor[311] = 1.00067;
980 fSPDScaleFactor[514] = 1.02268;
981 fSPDScaleFactor[515] = 0.994902;
982 fSPDScaleFactor[579] = 1.00215;
983 fSPDScaleFactor[580] = 0.993421;
984 fSPDScaleFactor[581] = 1.00129;
985 fSPDScaleFactor[583] = 1.00242;
986 fSPDScaleFactor[588] = 0.984762;
987 fSPDScaleFactor[589] = 0.994355;
988 fSPDScaleFactor[590] = 1.00073;
989 fSPDScaleFactor[592] = 0.995889;
990 fSPDScaleFactor[688] = 0.994532;
991 fSPDScaleFactor[690] = 0.998307;
992 fSPDScaleFactor[693] = 0.994052;
993 fSPDScaleFactor[698] = 0.993224;
994 fSPDScaleFactor[744] = 0.993279;
995 fSPDScaleFactor[757] = 0.992494;
996 fSPDScaleFactor[787] = 0.992678;
997 fSPDScaleFactor[788] = 0.996563;
998 fSPDScaleFactor[834] = 1.01116;
999 fSPDScaleFactor[835] = 0.993108;
1000 fSPDScaleFactor[840] = 0.997574;
1001 fSPDScaleFactor[842] = 1.01829;
1002 fSPDScaleFactor[900] = 0.999438;
1003 fSPDScaleFactor[901] = 0.995849;
1004 fSPDScaleFactor[992] = 0.999227;
1005 fSPDScaleFactor[997] = 1.00575;
1006 fSPDScaleFactor[1299] = 0.99877;
1007 fSPDScaleFactor[1303] = 0.999682;
1008 fSPDScaleFactor[1339] = 0.978198;
1009 fSPDScaleFactor[1346] = 0.964178;
1010 fSPDScaleFactor[1349] = 0.959439;
1011 fSPDScaleFactor[1350] = 0.956945;
1012 fSPDScaleFactor[1374] = 0.994434;
1013 fSPDScaleFactor[1545] = 1.0016;
1014 fSPDScaleFactor[1587] = 1.00153;
1015 fSPDScaleFactor[1588] = 1.00698;
1016 fSPDScaleFactor[1618] = 1.00554;
1017 fSPDScaleFactor[1682] = 1.0123;
1018 fSPDScaleFactor[1727] = 1.011;
1019 fSPDScaleFactor[1728] = 1.00143;
1020 fSPDScaleFactor[1731] = 1.00486;
1021 fSPDScaleFactor[1732] = 1.00646;
1022 fSPDScaleFactor[1770] = 1.00515;
1023 fSPDScaleFactor[1773] = 1.00485;
1024 fSPDScaleFactor[1786] = 1.01215;
1025 fSPDScaleFactor[1787] = 1.00419;
1026 fSPDScaleFactor[1801] = 0.983327;
1027 fSPDScaleFactor[1802] = 1.00529;
1028 fSPDScaleFactor[1811] = 1.00367;
1029 fSPDScaleFactor[1815] = 1.01045;
1030 fSPDScaleFactor[1879] = 0.996374;
1031 fSPDScaleFactor[1881] = 0.988827;
1032 fSPDScaleFactor[2186] = 1.00354;
1033 fSPDScaleFactor[2187] = 1.00397;
1034 fSPDScaleFactor[2254] = 1.01138;
1035 fSPDScaleFactor[2256] = 0.996641;
1036 fSPDScaleFactor[2321] = 1.00357;
1037 fTPCScaleFactor[310] = 1.00434;
1038 fTPCScaleFactor[311] = 1.0056;
1039 fTPCScaleFactor[514] = 1.02185;
1040 fTPCScaleFactor[515] = 1.0036;
1041 fTPCScaleFactor[579] = 1.00607;
1042 fTPCScaleFactor[580] = 1.00183;
1043 fTPCScaleFactor[581] = 1.00693;
1044 fTPCScaleFactor[583] = 1.00746;
1045 fTPCScaleFactor[588] = 0.990524;
1046 fTPCScaleFactor[589] = 0.998582;
1047 fTPCScaleFactor[590] = 1.00618;
1048 fTPCScaleFactor[592] = 1.00088;
1049 fTPCScaleFactor[688] = 1.00598;
1050 fTPCScaleFactor[690] = 1.00658;
1051 fTPCScaleFactor[693] = 1.00144;
1052 fTPCScaleFactor[698] = 1.00279;
1053 fTPCScaleFactor[744] = 1.00122;
1054 fTPCScaleFactor[757] = 1.002;
1055 fTPCScaleFactor[787] = 0.997818;
1056 fTPCScaleFactor[788] = 0.994583;
1057 fTPCScaleFactor[834] = 1.01508;
1058 fTPCScaleFactor[835] = 1.00218;
1059 fTPCScaleFactor[840] = 1.00569;
1060 fTPCScaleFactor[842] = 1.01789;
1061 fTPCScaleFactor[900] = 1.00739;
1062 fTPCScaleFactor[901] = 1.00462;
1063 fTPCScaleFactor[992] = 1.00502;
1064 fTPCScaleFactor[997] = 1.00943;
1065 fTPCScaleFactor[1299] = 1.00438;
1066 fTPCScaleFactor[1303] = 0.996701;
1067 fTPCScaleFactor[1339] = 0.978641;
1068 fTPCScaleFactor[1346] = 0.968906;
1069 fTPCScaleFactor[1349] = 0.954311;
1070 fTPCScaleFactor[1350] = 0.958764;
1071 fTPCScaleFactor[1374] = 0.997899;
1072 fTPCScaleFactor[1545] = 0.992;
1073 fTPCScaleFactor[1587] = 0.992635;
1074 fTPCScaleFactor[1588] = 1.00207;
1075 fTPCScaleFactor[1618] = 1.00126;
1076 fTPCScaleFactor[1682] = 1.00324;
1077 fTPCScaleFactor[1727] = 1.00042;
1078 fTPCScaleFactor[1728] = 0.978881;
1079 fTPCScaleFactor[1731] = 0.999818;
1080 fTPCScaleFactor[1732] = 1.00109;
1081 fTPCScaleFactor[1770] = 0.99935;
1082 fTPCScaleFactor[1773] = 0.998531;
1083 fTPCScaleFactor[1786] = 0.999125;
1084 fTPCScaleFactor[1787] = 0.998479;
1085 fTPCScaleFactor[1801] = 0.9775;
1086 fTPCScaleFactor[1802] = 0.999095;
1087 fTPCScaleFactor[1811] = 0.998197;
1088 fTPCScaleFactor[1815] = 1.00413;
1089 fTPCScaleFactor[1879] = 0.990916;
1090 fTPCScaleFactor[1881] = 0.987241;
1091 fTPCScaleFactor[2186] = 1.00048;
1092 fTPCScaleFactor[2187] = 1.00057;
1093 fTPCScaleFactor[2254] = 1.00588;
1094 fTPCScaleFactor[2256] = 0.991503;
1095 fTPCScaleFactor[2321] = 1.00057;
1098 // set all missing values to the value of the run before it ....
1099 for (int i=0; i<=(fHighRunN-fLowRunN); i++) {
1100 if (fV0MScaleFactor[i] == 0.0) {
1102 fV0MScaleFactor[i] = 1.00;
1104 // search for last run number with non-zero value
1105 for (int j=i-1;j>=0;j--) {
1106 if (fV0MScaleFactor[j] != 0.0) {
1107 fV0MScaleFactor[i] = fV0MScaleFactor[j];
1113 } // end loop over checking all run-numbers
1115 for (int i=0; i<=(fHighRunN-fLowRunN); i++) {
1116 if (fSPDScaleFactor[i] == 0.0) {
1118 fSPDScaleFactor[i] = 1.00;
1120 for (int j=i-1;j>=0;j--) {
1121 if (fSPDScaleFactor[j] != 0.0) {
1122 fSPDScaleFactor[i] = fSPDScaleFactor[j];
1130 for (int i=0; i<=(fHighRunN-fLowRunN); i++) {
1131 if (fTPCScaleFactor[i] == 0.0) {
1133 fTPCScaleFactor[i] = 1.00;
1135 for (int j=i-1;j>=0;j--) {
1136 if (fTPCScaleFactor[j] != 0.0) {
1137 fTPCScaleFactor[i] = fTPCScaleFactor[j];
1146 // for (int i=0; i<=(fHighRunN-fLowRunN); i++) cout << "Scale Factor = " << fV0MScaleFactor[i] << " for Run " << i+fLowRunN << endl;
1153 //________________________________________________________________________
1154 void AliCentralitySelectionTask::MyInitScaleFactorMC()
1156 // Initialize the MC scaling factors
1157 for (int i=0; i<(fHighRunN-fLowRunN); i++) fV0MScaleFactorMC[i] = 0.0;
1158 // scale factors determined from <V0 charge> on a run-by-run basis
1159 fV0MScaleFactorMC[0] = 0.75108;
1160 // set all missing values to the value of the run before it ....
1161 for (int i=0; i<=(fHighRunN-fLowRunN); i++) {
1162 if (fV0MScaleFactorMC[i] == 0.0) {
1164 fV0MScaleFactorMC[i] = 1.00;
1166 // search for last run number with non-zero value
1167 for (int j=i-1;j>=0;j--) {
1168 if (fV0MScaleFactorMC[j] != 0.0) {
1169 fV0MScaleFactorMC[i] = fV0MScaleFactorMC[j];
1175 } // end loop over checking all run-numbers
1178 // for (int i=0; i<=(fHighRunN-fLowRunN); i++) cout << "Scale Factor = " << fV0MScaleFactorMC[i] << " for Run " << i+fLowRunN << endl;