AliPhysics  ff07904 (ff07904)
AliCentralMultiplicityTask.cxx
Go to the documentation of this file.
1 //====================================================================
2 //
3 // Base class for classes that calculate the multiplicity in the
4 // central region event-by-event
5 //
6 // Inputs:
7 // - AliESDEvent
8 //
9 // Outputs:
10 // - AliAODCentralMult
11 //
12 // Histograms
13 //
14 // Corrections used
19 #include "AliAODForwardMult.h"
20 #include "AliForwardUtil.h"
21 #include "AliLog.h"
22 #include "AliAODHandler.h"
23 #include "AliAnalysisManager.h"
24 #include "AliESDEvent.h"
25 #include "AliMultiplicity.h"
26 #include <TROOT.h>
27 #include <TSystem.h>
28 #include <TFile.h>
29 #include <TError.h>
30 #include <TSystem.h>
31 #include <TObjArray.h>
32 #include <iostream>
33 #include <iomanip>
34 
35 //====================================================================
37  : AliBaseESDTask(name, "AliCentralMultiplicityTask",
38  &(AliCentralCorrectionManager::Instance())),
39  fInspector("event"),
40  fAODCentral(kFALSE),
41  fUseSecondary(true),
42  fUseAcceptance(true),
43  fIvz(0),
44  fNClusterTracklet(0),
45  fClusterPerTracklet(0),
46  fNCluster(0),
47  fNTracklet(0),
48  fVtxList(0),
49  fStore(false),
50  fHData(0)
51 {
52  //
53  // Constructor
54  //
55  DGUARD(fDebug, 3,"Named CTOR of AliCentralMultiplicityTask: %s", name);
56  fBranchNames =
57  "ESD:AliESDRun.,AliESDHeader.,AliMultiplicity.,"
58  "SPDVertex.,PrimaryVertex.";
59 }
60 //____________________________________________________________________
62  : AliBaseESDTask(),
63  fInspector(),
64  fAODCentral(),
65  fUseSecondary(true),
66  fUseAcceptance(true),
67  fIvz(0),
70  fNCluster(0),
71  fNTracklet(0),
72  fVtxList(0),
73  fStore(false),
74  fHData(0)
75 {
76  //
77  // Constructor
78  //
79  DGUARD(fDebug, 3,"Default CTOR of AliCentralMultiplicityTask");
80 }
81 
82 //____________________________________________________________________
83 void
85 {
86  //
87  // Create output objects
88  //
89  //
90  DGUARD(fDebug,1,"Create user output in AliCentralMultiplicityTask");
91 
92  if (!ah)
93  //AliFatal("No AOD output handler set in analysis manager");
94  return;
95 
96  TObject* obj = &fAODCentral;
97  ah->AddBranch("AliAODCentralMult", &obj);
98 }
99 //____________________________________________________________________
100 Bool_t
102 {
105  return true;
106 }
107 
108 //____________________________________________________________________
109 Bool_t
111 {
112  // FindEtaLimits();
113  // unsigned short s = 1;
114  TH2D* hCoverage = new TH2D("coverage", "#eta coverage per v_{z}",
115  eta.GetNbins(), eta.GetXmin(), eta.GetXmax(),
116  vertex.GetNbins(),vertex.GetXmin(),
117  vertex.GetXmax());
118  hCoverage->SetDirectory(0);
119  hCoverage->SetXTitle("#eta");
120  hCoverage->SetYTitle("v_{z} [cm]");
121  hCoverage->SetZTitle("n_{bins}");
122 
123  fAODCentral.Init(eta);
124 
125  UShort_t nVz = vertex.GetNbins();
126  fVtxList = new TObjArray(nVz, 1);
127  fVtxList->SetName("centMultVtxBins");
128  fVtxList->SetOwner();
129 
130  // Bool_t store = false;
131  for (Int_t v = 1; v <= nVz; v++) {
132  VtxBin* bin = new VtxBin(v, vertex.GetBinLowEdge(v),
133  vertex.GetBinUpEdge(v));
134  bin->SetupForData(fList, hCoverage, fStore);
135  fVtxList->AddAt(bin, v);
136  }
137  fList->Add(hCoverage);
138 
139  // Bins are
140  TArrayD bins;
141  // N-bins, loweset order, higest order, return array
142  AliForwardUtil::MakeLogScale(300, 0, 5, bins);
143  fNClusterTracklet = new TH2D("nClusterVsnTracklet",
144  "Total number of cluster vs number of tracklets",
145  bins.GetSize()-1, bins.GetArray(),
146  bins.GetSize()-1, bins.GetArray());
147  fNClusterTracklet->SetDirectory(0);
148  fNClusterTracklet->SetXTitle("N_{free cluster}");
149  fNClusterTracklet->SetYTitle("N_{tracklet}");
150  fNClusterTracklet->SetStats(0);
151  fList->Add(fNClusterTracklet);
152 
153  Int_t nEta = 80;
154  Double_t lEta = 2;
155  fClusterPerTracklet = new TH2D("clusterPerTracklet",
156  "N_{free cluster}/N_{tracklet} vs. #eta",
157  nEta,-lEta,lEta, 101, -.05, 10.05);
158  fClusterPerTracklet->SetDirectory(0);
159  fClusterPerTracklet->SetXTitle("#eta");
160  fClusterPerTracklet->SetYTitle("N_{free cluster}/N_{tracklet}");
161  fClusterPerTracklet->SetStats(0);
163 
164  // Cache histograms
165  fNCluster = new TH1D("cacheCluster", "", nEta,-lEta,lEta);
166  fNCluster->SetDirectory(0);
167  fNCluster->Sumw2();
168 
169  fNTracklet = new TH1D("cacheTracklet", "", nEta,-lEta,lEta);
170  fNTracklet->SetDirectory(0);
171  fNTracklet->Sumw2();
172 
175 
176  fHData = static_cast<TH2D*>(fAODCentral.GetHistogram().Clone("d2Ndetadphi"));
177  fHData->SetStats(0);
178  fHData->SetDirectory(0);
179  fList->Add(fHData);
180 
181  // Initialize the inspecto
182  // fInspector.SetupForData(vertex);
183 
186 
187  return true;
188 }
189 //____________________________________________________________________
190 Bool_t
192 {
193  fAODCentral.Clear("");
194  return true;
195 }
196 //____________________________________________________________________
197 Bool_t
199 {
200  //
201  // Process each event
202  //
203  // Parameters:
204  // option Not used
205  //
206  DGUARD(fDebug,1,"Process event in AliCentralMultiplicityTask");
207  fIvz = 0;
208  Bool_t lowFlux = kFALSE;
209  UInt_t triggers = 0;
210  UShort_t ivz = 0;
211  TVector3 ip;
212  Double_t cent = -1;
213  UShort_t nClusters = 0;
214  UInt_t found = fInspector.Process(&esd, triggers, lowFlux,
215  ivz, ip, cent, nClusters);
216 
217  // No event or no trigger
218  if (found & AliFMDEventInspector::kNoEvent) return false;
219  if (found & AliFMDEventInspector::kNoTriggers) return false;
220 
221  // Make sure AOD is filled
223 
224  if (found & AliFMDEventInspector::kNoSPD) return false;
225  if (found & AliFMDEventInspector::kNoVertex) return false;
226  if (triggers & AliAODForwardMult::kPileUp) return false;
227  if (found & AliFMDEventInspector::kBadVertex) return false;
228 
229  //Doing analysis
230  const AliMultiplicity* spdmult = esd.GetMultiplicity();
231 
232  TH2D& aodHist = fAODCentral.GetHistogram();
233 
234  VtxBin* bin = static_cast<VtxBin*>(fVtxList->At(ivz));
235  if (!bin) return false;
236 
237  ProcessESD(aodHist, spdmult);
238  bin->Correct(aodHist, fUseSecondary, fUseAcceptance);
239 
240  if (triggers & AliAODForwardMult::kInel)
241  fHData->Add(&(fAODCentral.GetHistogram()));
242 
243  return true;
244 }
245 //____________________________________________________________________
246 void
248  const AliMultiplicity* spdmult) const
249 {
250  DGUARD(fDebug,1,"Process the ESD in AliCentralMultiplicityTask");
251  fNTracklet->Reset();
252  fNCluster->Reset();
253 
254  //Filling clusters in layer 1 used for tracklets...
255  for(Int_t j = 0; j< spdmult->GetNumberOfTracklets();j++) {
256  Double_t eta = spdmult->GetEta(j);
257  fNTracklet->Fill(eta);
258  aodHist.Fill(eta,spdmult->GetPhi(j));
259  }
260 
261  //...and then the unused ones in layer 1
262  for(Int_t j = 0; j< spdmult->GetNumberOfSingleClusters();j++) {
263  Double_t eta = -TMath::Log(TMath::Tan(spdmult->GetThetaSingle(j)/2.));
264  fNCluster->Fill(eta);
265  aodHist.Fill(eta, spdmult->GetPhiSingle(j));
266  }
267  fNClusterTracklet->Fill(fNCluster->GetEntries(),
268  fNTracklet->GetEntries());
269 
270  fNCluster->Divide(fNTracklet);
271  for (Int_t j = 1; j <= fNCluster->GetNbinsX(); j++)
272  fClusterPerTracklet->Fill(fNCluster->GetXaxis()->GetBinCenter(j),
273  fNCluster->GetBinContent(j));
274 
275 }
276 
277 //____________________________________________________________________
278 Bool_t
280 {
281  //
282  // End of job
283  //
284  // Parameters:
285  // option Not used
286  //
287  DGUARD(fDebug,1,"Process merged output in AliCentralMultiplicityTask");
288 
289  Double_t nTr = 0, nTrVtx = 0, nAcc = 0;
290  MakeSimpledNdeta(fList, fResults, nTr, nTrVtx, nAcc);
291  AliInfoF("\n"
292  "\t# events w/trigger: %f\n"
293  "\t# events w/trigger+vertex: %f\n"
294  "\t# events accepted by cuts: %f",
295  nTr, nTrVtx, nAcc);
296  return true;
297 }
298 
299 //____________________________________________________________________
300 Bool_t
302  TList* output,
303  Double_t& nTr,
304  Double_t& nTrVtx,
305  Double_t& nAcc)
306 {
307  // Get our histograms from the container
308  TH1I* hEventsTr = 0;
309  TH1I* hEventsTrVtx = 0;
310  TH1I* hEventsAcc = 0;
311  TH1I* hTriggers = 0;
312  if (!GetEventInspector().FetchHistograms(input,
313  hEventsTr,
314  hEventsTrVtx,
315  hEventsAcc,
316  hTriggers)) {
317  AliError(Form("Didn't get histograms from event selector "
318  "(hEventsTr=%p,hEventsTrVtx=%p,hEventsAcc=%p,hTriggers=%p)",
319  hEventsTr, hEventsTrVtx, hEventsAcc, hTriggers));
320  input->ls();
321  return false;
322  }
323  nTr = hEventsTr->Integral();
324  nTrVtx = hEventsTrVtx->Integral();
325  nAcc = hEventsAcc->Integral();
326  Double_t vtxEff = nTrVtx / nTr;
327  TH2D* hData = static_cast<TH2D*>(input->FindObject("d2Ndetadphi"));
328  if (!hData) {
329  AliError(Form("Couldn't get our summed histogram from output "
330  "list %s (d2Ndetadphi=%p)", input->GetName(), hData));
331  input->ls();
332  return false;
333  }
334 
335  Int_t nY = hData->GetNbinsY();
336  TH1D* dNdeta = hData->ProjectionX("dNdeta", 1, nY, "e");
337  TH1D* dNdeta_ = hData->ProjectionX("dNdeta_", 1, nY, "e");
338  TH1D* norm = hData->ProjectionX("norm", 0, 0, "");
339  TH1D* phi = hData->ProjectionX("phi", nY+1, nY+1, "");
340  dNdeta->SetTitle("dN_{ch}/d#eta in the forward regions");
341  dNdeta->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
342  dNdeta->SetMarkerColor(kRed+1);
343  dNdeta->SetMarkerStyle(20);
344  dNdeta->SetDirectory(0);
345 
346  dNdeta_->SetTitle("dN_{ch}/d#eta in the forward regions");
347  dNdeta_->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
348  dNdeta_->SetMarkerColor(kMagenta+1);
349  dNdeta_->SetMarkerStyle(21);
350  dNdeta_->SetDirectory(0);
351 
352  norm->SetTitle("Normalization to #eta coverage");
353  norm->SetYTitle("#eta coverage");
354  norm->SetLineColor(kBlue+1);
355  norm->SetMarkerColor(kBlue+1);
356  norm->SetMarkerStyle(21);
357  norm->SetFillColor(kBlue+1);
358  norm->SetFillStyle(3005);
359  norm->SetDirectory(0);
360 
361  phi->SetTitle("Normalization to #phi acceptance");
362  phi->SetYTitle("#phi acceptance");
363  phi->SetLineColor(kGreen+1);
364  phi->SetMarkerColor(kGreen+1);
365  phi->SetMarkerStyle(20);
366  phi->SetFillColor(kGreen+1);
367  phi->SetFillStyle(3004);
368  // phi->Scale(1. / nAcc);
369  phi->SetDirectory(0);
370 
371  // dNdeta->Divide(norm);
372  dNdeta->Divide(phi);
373  dNdeta->SetStats(0);
374  dNdeta->Scale(vtxEff, "width");
375 
376  dNdeta_->Divide(norm);
377  dNdeta_->SetStats(0);
378  dNdeta_->Scale(vtxEff, "width");
379 
380  output->Add(dNdeta);
381  output->Add(dNdeta_);
382  output->Add(norm);
383  output->Add(phi);
384 
385  return true;
386 }
387 
388 #define PF(N,V,...) \
389  AliForwardUtil::PrintField(N,V, ## __VA_ARGS__)
390 #define PFB(N,FLAG) \
391  do { \
392  AliForwardUtil::PrintName(N); \
393  std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
394  } while(false)
395 #define PFV(N,VALUE) \
396  do { \
397  AliForwardUtil::PrintName(N); \
398  std::cout << (VALUE) << std::endl; } while(false)
399 
400 //____________________________________________________________________
401 void
403 {
404  //
405  // Print information
406  //
407  // Parameters:
408  // option Not used
409  //
410  AliBaseESDTask::Print(option);
411  gROOT->IncreaseDirLevel();
412  PFB("Use secondary correction", fUseSecondary);
413  PFB("Use acceptance correction", fUseAcceptance);
414 
417  if (ccm.IsInit()) {
418  const AliCentralCorrSecondaryMap* secMap = ccm.GetSecondaryMap();
419  if (secMap) {
420  const TAxis& vaxis = secMap->GetVertexAxis();
421  // fVtxList->ls();
422  std::cout << " Eta ranges:\n"
423  << " Vertex | Eta bins\n"
424  << " bin range | \n"
425  << " ----------------+-----------" << std::endl;
426  for (Int_t v = 1; v <= vaxis.GetNbins(); v++) {
427  VtxBin* bin = static_cast<VtxBin*>(fVtxList->At(v));
428  if (!bin) continue;
429  bin->Print();
430  }
431  }
432  }
433  gROOT->DecreaseDirLevel();
434 }
435 
436 //====================================================================
438  Double_t minIpZ,
439  Double_t maxIpZ)
440  : fId(iVz),
441  fMinIpZ(minIpZ),
442  fMaxIpZ(maxIpZ),
443  fEtaMin(999),
444  fEtaMax(0),
445  fSec(0),
446  fAcc(0),
447  fHits(0)
448 {
449 }
450 //____________________________________________________________________
452  : TObject(o),
453  fId(o.fId),
454  fMinIpZ(o.fMinIpZ),
455  fMaxIpZ(o.fMaxIpZ),
456  fEtaMin(o.fEtaMin),
457  fEtaMax(o.fEtaMax),
458  fSec(o.fSec),
459  fAcc(o.fAcc),
460  fHits(o.fHits)
461 {
462 }
463 //____________________________________________________________________
466 {
467  if (&o == this) return *this;
468  fId = o.fId;
469  fMinIpZ = o.fMinIpZ;
470  fMaxIpZ = o.fMaxIpZ;
471  fEtaMin = o.fEtaMin;
472  fEtaMax = o.fEtaMax;
473  fSec = o.fSec;
474  fAcc = o.fAcc;
475  fHits = o.fHits;
476 
477  return *this;
478 }
479 
480 //____________________________________________________________________
481 const char*
483 {
484  return Form("%c%03d_%c%03d",
485  (fMinIpZ >= 0 ? 'p' : 'm'), Int_t(TMath::Abs(fMinIpZ)),
486  (fMaxIpZ >= 0 ? 'p' : 'm'), Int_t(TMath::Abs(fMaxIpZ)));
487 }
488 
489 //____________________________________________________________________
490 void
492  TH2* coverage,
493  Bool_t store)
494 {
495  TList* out = 0;
496  if (store) {
497  out = new TList;
498  out->SetName(GetName());
499  out->SetOwner();
500  l->Add(out);
501  }
502 
505 
506  // Clean-up
507  if (fSec) {
508  // delete fSec;
509  fSec = 0;
510  }
511  if (fAcc) {
512  // delete fAcc;
513  fAcc = 0;
514  }
515  // Get secondary correction and make a projection onto eta
516  TH2* sec = ccm.GetSecondaryMap()->GetCorrection(UShort_t(fId));
517  TH1* acc = ccm.GetAcceptance()->GetCorrection(UShort_t(fId));
518  fSec = static_cast<TH2*>(sec->Clone());
519  fAcc = static_cast<TH1*>(acc->Clone());
520  fSec->SetDirectory(0);
521  fAcc->SetDirectory(0);
522 
523  TH1D* proj = fSec->ProjectionX("secondary");
524  proj->SetDirectory(0);
525  proj->Scale(1. / fSec->GetNbinsY());
526 
527  // Find lower bound on eta
528  fEtaMin = proj->GetNbinsX();
529  for (Int_t e = 1; e <= proj->GetNbinsX(); e++) {
530  Double_t c = proj->GetBinContent(e);
531  if (c > .5 /*&& TMath::Abs(c - prev) < .1*c*/) {
532  fEtaMin = e;
533  break;
534  }
535  }
536  // Find upper bound on eta
537  fEtaMax = 1;
538  for (Int_t e = proj->GetNbinsX(); e >= 1; e--) {
539  Double_t c = proj->GetBinContent(e);
540  if (c > .5 /*&& TMath::Abs(c - prev) < .1*c*/) {
541  fEtaMax = e;
542  break;
543  }
544  }
545  // Fill our coverage histogram
546  for (Int_t nn = fEtaMin; nn<=fEtaMax; nn++) {
547  coverage->SetBinContent(nn,fId,1);
548  }
549 
550  if (!store) {
551  // If we're not asked to store anything, clean-up, and get out
552  delete proj;
553  return;
554  }
555 
556  // Modify the title of the projection
557  proj->SetTitle(Form("Projection of secondary correction "
558  "for %+5.1f<v_{z}<%+5.1f",fMinIpZ, fMaxIpZ));
559  proj->SetYTitle("#LT 2^{nd} correction#GT");
560  proj->SetMarkerStyle(20);
561  proj->SetMarkerColor(kBlue+1);
562  out->Add(proj);
563 
564  // Make some histograms to store diagnostics
565  TH2D* obg = static_cast<TH2D*>(fSec->Clone("secondaryMapFiducial"));
566  obg->SetTitle(Form("%s - fiducial volume", obg->GetTitle()));
567  obg->GetYaxis()->SetTitle("#varphi");
568  obg->SetDirectory(0);
569  out->Add(obg);
570 
571  TH1D* after = static_cast<TH1D*>(proj->Clone("secondaryFiducial"));
572  after->SetDirectory(0);
573  after->GetYaxis()->SetTitle("#LT 2^{nd} correction#GT");
574  after->SetTitle(Form("%s - fiducial volume", after->GetTitle()));
575  after->SetMarkerColor(kRed+1);
576  out->Add(after);
577 
578  if (fHits) {
579  // delete fHits;
580  fHits = 0;
581  }
582  fHits = static_cast<TH2D*>(fSec->Clone("hitMap"));
583  fHits->SetDirectory(0);
584  fHits->SetTitle(Form("d^{2}N/d#eta d#phi for %+5.1f<v_{z}<%+5.1f",
585  fMinIpZ, fMaxIpZ));
586  fHits->GetYaxis()->SetTitle("#varphi");
587  fHits->GetZaxis()->SetTitle("d^{2}N/d#eta d#varphi");
588  fHits->SetMarkerColor(kBlack);
589  fHits->SetMarkerStyle(1);
590  out->Add(fHits);
591 
592  // Get the acceptance, and store that
593  TH1D* accClone = static_cast<TH1D*>(fAcc->Clone("acceptance"));
594  accClone->SetTitle(Form("Acceptance for %+5.1f<v_{z}<%+5.1f",
595  fMinIpZ, fMaxIpZ));
596  accClone->SetDirectory(0);
597  out->Add(accClone);
598 
599  // Now zero content outside our eta range
600  for (Int_t e = 1; e < fEtaMin; e++) {
601  after->SetBinContent(e, 0);
602  after->SetBinError(e, 0);
603  for(Int_t nn =1; nn <=obg->GetNbinsY();nn++)
604  obg->SetBinContent(e,nn,0);
605  }
606 
607  for (Int_t e = fEtaMax+1; e <= proj->GetNbinsX(); e++) {
608  after->SetBinContent(e, 0);
609  after->SetBinError(e, 0);
610  for(Int_t nn =1; nn <=obg->GetNbinsY();nn++)
611  obg->SetBinContent(e,nn,0);
612  }
613 }
614 //____________________________________________________________________
615 void
617  Bool_t useSecondary,
618  Bool_t useAcceptance,
619  Bool_t sum) const
620 {
621  if (useSecondary && fSec) aodHist.Divide(fSec);
622 
623  Int_t nY = aodHist.GetNbinsY();
624  for(Int_t ix = 1; ix <= aodHist.GetNbinsX(); ix++) {
625  Bool_t fiducial = true;
626  if (ix < fEtaMin || ix > fEtaMax) fiducial = false;
627  // Bool_t etabinSeen = kFALSE;
628 
629  Double_t eta = aodHist.GetXaxis()->GetBinCenter(ix);
630  Int_t iax = fAcc->GetXaxis()->FindBin(eta);
631  Float_t accCor = fAcc->GetBinContent(iax);
632  // For test
633  // Float_t accErr = fAcc->GetBinError(ix);
634 
635  // Loop over phi
636  for(Int_t iy = 1; iy <= nY; iy++) {
637  // If outside our fiducial volume, zero content
638  if (!fiducial) {
639  aodHist.SetBinContent(ix, iy, 0);
640  aodHist.SetBinError(ix, iy, 0);
641  continue;
642  }
643  // Get currrent value
644  Float_t aodValue = aodHist.GetBinContent(ix,iy);
645  Float_t aodErr = aodHist.GetBinError(ix,iy);
646 
647  // Ignore very small values
648  if (aodValue < 0.000001) {
649  aodHist.SetBinContent(ix,iy, 0);
650  aodHist.SetBinError(ix,iy, 0);
651  continue;
652  }
653  if (!useAcceptance) continue;
654 
655  // Acceptance correction
656  Float_t accTmp = accCor;
657  if (accTmp < 0.000001) accTmp = 1;
658  Float_t aodNew = aodValue / accTmp ;
659  aodHist.SetBinContent(ix,iy, aodNew);
660  aodHist.SetBinError(ix,iy,aodErr);
661  // - Test -
662  // Float_t error = aodNew*TMath::Sqrt(TMath::Power(aodErr/aodValue,2) +
663  // TMath::Power(accErr/accCor,2) );
664  // test - aodHist.SetBinError(ix,iy,error);
665  } // for (iy)
666  //Filling underflow bin if we eta bin is in range
667  if (fiducial) {
668  aodHist.SetBinContent(ix,0, 1.);
669  aodHist.SetBinContent(ix,nY+1, accCor);
670  }
671  } // for (ix)
672  if (sum && fHits) fHits->Add(&aodHist);
673 }
674 
675 //____________________________________________________________________
676 void
678 {
679  std::cout << " "
680  << std::setw(2) << fId << " "
681  << std::setw(5) << fMinIpZ << "-"
682  << std::setw(5) << fMaxIpZ << " | "
683  << std::setw(3) << fEtaMin << "-"
684  << std::setw(3) << fEtaMax << std::endl;
685 }
686 
687 //
688 // EOF
689 //
const AliCentralCorrAcceptance * GetAcceptance() const
virtual void Print(Option_t *option="") const
virtual void ProcessESD(TH2D &hist, const AliMultiplicity *spdmult) const
double Double_t
Definition: External.C:58
virtual Bool_t IsInit() const
void SetupForData(TList *l, TH2 *coverage, Bool_t store=true)
virtual void Print(Option_t *option="") const
virtual void MarkEventForStore() const
TCanvas * c
Definition: TestFitELoss.C:172
void Correct(TH2D &aodHist, Bool_t useSecondary, Bool_t useAcceptance, Bool_t sum=true) const
virtual Bool_t Event(AliESDEvent &esd)
UInt_t Process(const AliESDEvent *event, UInt_t &triggers, Bool_t &lowFlux, UShort_t &ivz, TVector3 &ip, Double_t &cent, UShort_t &nClusters)
Per-event per bin.
int Int_t
Definition: External.C:63
Definition: External.C:204
unsigned int UInt_t
Definition: External.C:33
float Float_t
Definition: External.C:68
Various utilities used in PWGLF/FORWARD.
VtxBin(Int_t iVz=0, Double_t minIpZ=0, Double_t maxIpZ=0)
void Init(const TAxis &etaAxis)
Definition: External.C:228
Definition: External.C:212
TH1D * fNTracklet
Number of clusters.
TH2D * GetCorrection(Double_t v) const
Bool_t MakeSimpledNdeta(const TList *input, TList *output, Double_t &nTr, Double_t &nTrVtx, Double_t &nAcc)
#define DGUARD(L, N, F,...)
static TObject * MakeParameter(const char *name, UShort_t value)
const AliCentralCorrSecondaryMap * GetSecondaryMap() const
const TH2D & GetHistogram() const
TH1D * GetCorrection(Double_t v) const
virtual Bool_t PreData(const TAxis &v, const TAxis &e)
Definition: External.C:220
virtual void CreateBranches(AliAODHandler *ah)
static void MakeLogScale(Int_t nBins, Int_t minOrder, Int_t maxOrder, TArrayD &bins)
const TAxis & GetVertexAxis() const
unsigned short UShort_t
Definition: External.C:28
void Clear(Option_t *opt)
const char Option_t
Definition: External.C:48
UInt_t fNeededCorrections
TObjArray * fVtxList
number of tracklets
Bool_t fStore
Array of vertex bins.
bool Bool_t
Definition: External.C:53
AliFMDEventInspector & GetEventInspector()
static AliCentralCorrectionManager & Instance()
#define PFB(N, FLAG)
void Print(Option_t *option="") const
Definition: External.C:196