AliPhysics  1168478 (1168478)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliForwardMultiplicityBase.cxx
Go to the documentation of this file.
1 //====================================================================
2 //
3 // Base class for classes that calculate the multiplicity in the
4 // forward regions event-by-event
5 //
6 // Inputs:
7 // - AliESDEvent
8 //
9 // Outputs:
10 // - AliAODForwardMult
11 //
12 // Histograms
13 //
14 // Corrections used
17 #include "AliForwardUtil.h"
18 #include "AliFMDCorrELossFit.h"
19 #include "AliLog.h"
20 #include "AliAODHandler.h"
21 #include "AliInputEventHandler.h"
22 #include "AliAnalysisManager.h"
23 #include "AliFMDEventInspector.h"
24 // #include "AliMultEventClassifier.h"
25 #include "AliFMDESDFixer.h"
26 #include "AliFMDSharingFilter.h"
28 #include "AliFMDCorrector.h"
29 #include "AliFMDHistCollector.h"
30 #include "AliFMDEventPlaneFinder.h"
31 #include "AliESDEvent.h"
32 #include <TROOT.h>
33 #include <TSystem.h>
34 #include <TAxis.h>
35 #include <TProfile.h>
36 #include <THStack.h>
37 #include <iostream>
38 #include <iomanip>
39 #define AOD_SLOT 3
40 #ifdef POST_AOD
41 # define DEFINE(N) DefineOutput(N,AliAODForwardMult::Class())
42 # define POST(N) PostData(N,fAODFMD)
43 #else
44 # define DEFINE(N) do { } while(false)
45 # define POST(N) do { } while(false)
46 #endif
47 
48 //====================================================================
50  : AliBaseESDTask(name, "AliForwardMultiplicityBase",
51  &(AliForwardCorrectionManager::Instance())),
52  fEnableLowFlux(false),
53  fStorePerRing(false),
54  fHData(0),
55  fHistos(),
56  fAODFMD(false),
57  fAODEP(false),
58  // fAODRef(),
59  fRingSums(),
60  fDoTiming(false),
61  fHTiming(0),
62  fHStatus(0),
63  fAddMask(AliAODForwardMult::kInel)
64 {
65  DGUARD(fDebug, 3,"Named CTOR of AliForwardMultiplicityBase %s",name);
66 
68 }
69 
70 
71 //____________________________________________________________________
72 void
74 {
75  //
76  // Set debug level
77  //
78  // Parameters:
79  // dbg debug level
80  //
82  GetSharingFilter() .SetDebug(dbg);
84  GetCorrections() .SetDebug(dbg);
85  GetHistCollector() .SetDebug(dbg);
87 }
88 
89 //____________________________________________________________________
90 Bool_t
92 {
93  //
94  // Create output objects
95  //
96  //
97  DGUARD(fDebug,1,"Create user ouput");
99  if (!fEnableLowFlux)
101  if (!GetESDFixer().IsUseNoiseCorrection())
103  if (!GetCorrections().IsUseVertexBias())
105  if (!GetCorrections().IsUseAcceptance())
107  if (!GetCorrections().IsUseMergingEfficiency())
109  fNeededCorrections = what;
110 
111  // GetMultEventClassifier().CreateOutputObjects(fList);
118 
119  TAxis tmp(1, 0, 1);
120  fHistos.Init(tmp);
121 
122  if (fDebug > 1) fDoTiming = true;
123  if (fDoTiming) {
124  fHTiming = new TProfile("timing", "Timing of task",
125  kTimingTotal, 0.5, kTimingTotal+.5);
126  fHTiming->SetDirectory(0);
127  fHTiming->SetFillColor(kRed+1);
128  fHTiming->SetFillStyle(3001);
129  fHTiming->SetMarkerStyle(20);
130  fHTiming->SetMarkerColor(kBlack);
131  fHTiming->SetLineColor(kBlack);
132  fHTiming->SetXTitle("Part");
133  fHTiming->SetYTitle("#LTt_{part}#GT [CPU]");
134  fHTiming->SetStats(0);
135  TAxis* xaxis = fHTiming->GetXaxis();
136  xaxis->SetBinLabel(kTimingEventInspector,
137  GetEventInspector() .GetName());
138  xaxis->SetBinLabel(kTimingSharingFilter,
139  GetSharingFilter() .GetName());
140  xaxis->SetBinLabel(kTimingDensityCalculator,
141  GetDensityCalculator().GetName());
142  xaxis->SetBinLabel(kTimingCorrections,
143  GetCorrections() .GetName());
144  xaxis->SetBinLabel(kTimingHistCollector,
145  GetHistCollector() .GetName());
146  xaxis->SetBinLabel(kTimingEventPlaneFinder,
147  GetEventPlaneFinder() .GetName());
148  xaxis->SetBinLabel(kTimingTotal, "Total");
149  fList->Add(fHTiming);
150  }
151  fHStatus = new TH1I("status", "Status of task",16, .5, 16.5);
152  fHStatus->SetDirectory(0);
153  fHStatus->SetFillColor(kCyan+2);
154  fHStatus->SetFillStyle(3001);
155  fHStatus->SetLineColor(kBlack);
156  fHStatus->SetMarkerStyle(20);
157  fHStatus->SetMarkerColor(kBlack);
158  fHStatus->SetYTitle("Events");
159  TAxis* a = fHStatus->GetXaxis();
160  a->SetBinLabel(kStatusNoEvent, "No event");
161  a->SetBinLabel(kStatusNoTrigger, "No triggers");
162  a->SetBinLabel(kStatusNoSPD, "No SPD (not used)");
163  a->SetBinLabel(kStatusNoFMD, "No FMD");
164  a->SetBinLabel(kStatusNoVertex, "No Vertex");
165  a->SetBinLabel(kStatusPileup, "Pile-up");
166  a->SetBinLabel(kStatusSPDOutlier, "SPD-outlier");
167  a->SetBinLabel(kStatusIPzOutOfRange, "IP_{z} out of range");
168  a->SetBinLabel(kStatusFailSharing, "Merger failed");
169  a->SetBinLabel(kStatusFailDensity, "N_{ch} estimator failed");
170  a->SetBinLabel(kStatusFailEventPlane, "#Phi_{R} estimator failed");
171  a->SetBinLabel(kStatusOutlier, "Too many outliers");
172  a->SetBinLabel(kStatusFailCorrector, "Corrector failed");
173  a->SetBinLabel(kStatusFailCollector, "Histogram collector failed");
174  a->SetBinLabel(kStatusNotAdded, "Not added");
175  a->SetBinLabel(kStatusAllThrough, "All through");
176  fList->Add(fHStatus);
177 
178  POST(AOD_SLOT);
179  return true;
180 }
181 //____________________________________________________________________
182 void
184 {
185  TObject* obj = &fAODFMD; ah->AddBranch("AliAODForwardMult", &obj);
186  TObject* epobj = &fAODEP; ah->AddBranch("AliAODForwardEP", &epobj);
187  // TObject* rmobj = &fAODRef; ah->AddBranch("AliAODMultEventClass", &rmobj);
188 
189  if (!fStorePerRing) return;
190 
191  AliWarning("Per-ring histograms in AOD\n"
192  "*********************************************************\n"
193  "* For each event 5 additional 2D histogram are stored *\n"
194  "* in separate branches of the AODs. This will increase *\n"
195  "* the size of the AODs - proceed with caution *\n"
196  "*********************************************************");
197  TObject* hists[] = { fHistos.fFMD1i,
200  for (Int_t i = 0; i < 5; i++) {
201  ah->AddBranch("TH2D", &(hists[i]));
202  }
203 }
204 
205 //____________________________________________________________________
206 Bool_t
208 {
209  //
210  // Initialise the sub objects and stuff. Called on first event
211  //
212  //
213  DGUARD(fDebug,1,"Initialize sub-algorithms");
214 
215  // Force this here so we select the proper quality
217 
218  UInt_t what = fNeededCorrections;
219  // Check that we have the energy loss fits, needed by
220  // AliFMDSharingFilter
221  // AliFMDDensityCalculator
223  AliFatal(Form("No energy loss fits"));
224 
225  // Check that we have the double hit correction - (optionally) used by
226  // AliFMDDensityCalculator
228  AliFatal("No double hit corrections");
229 
230  // Check that we have the secondary maps, needed by
231  // AliFMDCorrector
232  // AliFMDHistCollector
234  !fcm.GetSecondaryMap())
235  AliFatal("No secondary corrections");
236 
237  // Check that we have the vertex bias correction, needed by
238  // AliFMDCorrector
240  AliFatal("No event vertex bias corrections");
241 
242  // Check that we have the merging efficiencies, optionally used by
243  // AliFMDCorrector
245  !fcm.GetMergingEfficiency())
246  AliFatal("No merging efficiencies");
247 
248  // Check that we have the acceptance correction, needed by
249  // AliFMDCorrector
251  AliFatal("No acceptance corrections");
252 
253  // const AliFMDCorrELossFit* fits = fcm.GetELossFit();
254  // fits->CacheBins(GetDensityCalculator().GetMinQuality());
255 
256  InitMembers(eta,vertex);
257 
261  GetHistCollector() .SetupForData(vertex,eta);
262 
265 
267  GetCorrections().IsUseSecondaryMap());
269  GetCorrections().IsUseVertexBias());
271  GetCorrections().IsUseAcceptance());
273  GetCorrections().IsUseMergingEfficiency());
275  GetHistCollector().GetMergeMethod() ==
277  return true;
278 }
279 
280 //____________________________________________________________________
281 void
283 {
284  fHistos.ReInit(eta);
285  fAODFMD.Init(eta);
286  fAODEP.Init(eta);
287  fRingSums.Init(eta);
288 
289  fHData = static_cast<TH2D*>(fAODFMD.GetHistogram().Clone("d2Ndetadphi"));
290  fHData->SetStats(0);
291  fHData->SetDirectory(0);
292  fList->Add(fHData);
293 
294  TList* rings = new TList;
295  rings->SetName("ringSums");
296  rings->SetOwner();
297  fList->Add(rings);
298 
299  rings->Add(fRingSums.Get(1, 'I'));
300  rings->Add(fRingSums.Get(2, 'I'));
301  rings->Add(fRingSums.Get(2, 'O'));
302  rings->Add(fRingSums.Get(3, 'I'));
303  rings->Add(fRingSums.Get(3, 'O'));
304  fRingSums.Get(1, 'I')->SetMarkerColor(AliForwardUtil::RingColor(1, 'I'));
305  fRingSums.Get(2, 'I')->SetMarkerColor(AliForwardUtil::RingColor(2, 'I'));
306  fRingSums.Get(2, 'O')->SetMarkerColor(AliForwardUtil::RingColor(2, 'O'));
307  fRingSums.Get(3, 'I')->SetMarkerColor(AliForwardUtil::RingColor(3, 'I'));
308  fRingSums.Get(3, 'O')->SetMarkerColor(AliForwardUtil::RingColor(3, 'O'));
309 }
310 //____________________________________________________________________
311 Bool_t
313 {
314  POST(AOD_SLOT);
315  return true;
316 }
317 //____________________________________________________________________
318 Bool_t
320 {
321  //
322  // End of job
323  //
324  // Parameters:
325  // option Not used
326  //
327  DGUARD(fDebug,1,"Processing the merged results");
328 
329  TList* list = fList;
330  TList* output = fResults;
331  Double_t nTr = 0, nTrVtx = 0, nAcc = 0;
332  MakeSimpledNdeta(list, output, nTr, nTrVtx, nAcc);
333  AliInfoF("\n"
334  "\t# events w/trigger: %f\n"
335  "\t# events w/trigger+vertex: %f\n"
336  "\t# events accepted by cuts: %f",
337  nTr, nTrVtx, nAcc);
338 
339  EstimatedNdeta(list, output);
340 
341  GetSharingFilter() .Terminate(list,output,Int_t(nTr));
342  GetDensityCalculator().Terminate(list,output,Int_t(nTrVtx));
343  GetCorrections() .Terminate(list,output,Int_t(nTrVtx));
344 
345  TProfile* timing = static_cast<TProfile*>(list->FindObject("timing"));
346  Int_t nTiming = (timing ? timing->GetBinContent(timing->GetNbinsX()) : 0);
347  if (timing && nTiming > 0) {
348  TProfile* p = static_cast<TProfile*>(timing->Clone());
349  p->SetDirectory(0);
350  p->Scale(100. / nTiming);
351  p->SetYTitle("#LTt_{part}#GT/#LTt_{total}#GT [%]");
352  p->SetTitle("Relative timing of task");
353  output->Add(p);
354  }
355  return true;
356 }
357 
358 //____________________________________________________________________
359 void
361  TList* output) const
362 {
363  MakeRingdNdeta(input, "ringSums", output, "ringResults");
364 }
365 
366 //____________________________________________________________________
367 Bool_t
369  TList* output,
370  Double_t& nTr,
371  Double_t& nTrVtx,
372  Double_t& nAcc)
373 {
374  // Get our histograms from the container
375  TH1I* hEventsTr = 0;
376  TH1I* hEventsTrVtx = 0;
377  TH1I* hEventsAcc = 0;
378  TH1I* hTriggers = 0;
379  TH1* hStatus = dynamic_cast<TH1*>(input->FindObject("status"));
380  if (!GetEventInspector().FetchHistograms(input,
381  hEventsTr,
382  hEventsTrVtx,
383  hEventsAcc,
384  hTriggers)) {
385  AliError(Form("Didn't get histograms from event selector "
386  "(hEventsTr=%p,hEventsTrVtx=%p,hEventsAcc=%p,hTriggers=%p)",
387  hEventsTr, hEventsTrVtx, hEventsAcc, hTriggers));
388  input->ls();
389  return false;
390  }
391  nTr = hEventsTr->Integral();
392  nTrVtx = hEventsTrVtx->Integral();
393  nAcc = hEventsAcc->Integral();
394  Double_t vtxEff = nTrVtx / nTr;
395  Double_t vtxEff2 = 0;
396  if (hStatus) {
397  Double_t nTrg = hStatus->Integral(3,15);
398  Double_t nTrgVtx = hStatus->Integral(6,15);
399  vtxEff2 = (nTrg > 0 ? nTrgVtx / nTrg : 0);
400  }
401 
402  TH2D* hData = static_cast<TH2D*>(input->FindObject("d2Ndetadphi"));
403  if (!hData) {
404  AliError(Form("Couldn't get our summed histogram from output "
405  "list %s (d2Ndetadphi=%p)", input->GetName(), hData));
406  input->ls();
407  return false;
408  }
409 
410  Int_t nY = hData->GetNbinsY();
411  TH1D* dNdeta = hData->ProjectionX("dNdeta", 1, nY, "e");
412  TH1D* dNdeta_ = hData->ProjectionX("dNdeta_", 1, nY, "e");
413  TH1D* norm = hData->ProjectionX("norm", 0, 0, "");
414  TH1D* phi = hData->ProjectionX("phi", nY+1, nY+1, "");
415  dNdeta->SetTitle("dN_{ch}/d#eta in the forward regions");
416  dNdeta->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
417  dNdeta->SetMarkerColor(kRed+1);
418  dNdeta->SetMarkerStyle(20);
419  dNdeta->SetDirectory(0);
420 
421  dNdeta_->SetTitle("dN_{ch}/d#eta in the forward regions");
422  dNdeta_->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
423  dNdeta_->SetMarkerColor(kMagenta+1);
424  dNdeta_->SetMarkerStyle(21);
425  dNdeta_->SetDirectory(0);
426 
427  norm->SetTitle("Normalization to #eta coverage");
428  norm->SetYTitle("#eta coverage");
429  norm->SetLineColor(kBlue+1);
430  norm->SetMarkerColor(kBlue+1);
431  norm->SetMarkerStyle(21);
432  norm->SetFillColor(kBlue+1);
433  norm->SetFillStyle(3005);
434  norm->SetDirectory(0);
435 
436  phi->SetTitle("Normalization to #phi acceptance");
437  phi->SetYTitle("#phi acceptance");
438  phi->SetLineColor(kGreen+1);
439  phi->SetMarkerColor(kGreen+1);
440  phi->SetMarkerStyle(20);
441  phi->SetFillColor(kGreen+1);
442  phi->SetFillStyle(3004);
443  // phi->Scale(1. / nAcc);
444  phi->SetDirectory(0);
445 
446  // dNdeta->Divide(norm);
447  dNdeta->Divide(phi);
448  dNdeta->SetStats(0);
449  dNdeta->Scale(vtxEff, "width");
450 
451  dNdeta_->Divide(norm);
452  dNdeta_->SetStats(0);
453  dNdeta_->Scale(vtxEff, "width");
454 
455  AliInfoF("All\n"
456  "\tNormalization eta: %d\n"
457  "\tNormalization phi: %d\n"
458  "\tVertex efficiency: %f (%f)",
459  Int_t(norm->GetMaximum()), Int_t(phi->GetMaximum()),
460  vtxEff, vtxEff2);
461  output->Add(dNdeta);
462  output->Add(dNdeta_);
463  output->Add(norm);
464  output->Add(phi);
465 
466  return true;
467 }
468 
469 
470 //____________________________________________________________________
471 void
473  const char* inName,
474  TList* output,
475  const char* outName,
476  Int_t style) const
477 {
478  // Make dN/deta for each ring found in the input list.
479  //
480  // A stack of all the dN/deta is also made for easy drawing.
481  //
482  // Note, that the distributions are normalised to the number of
483  // observed events only - they should be corrected for
484  DGUARD(fDebug,3,"Make first-shot ring dN/deta");
485 
486  if (!input) return;
487  TList* list = static_cast<TList*>(input->FindObject(inName));
488  if (!list) {
489  AliWarning(Form("No list %s found in %s", inName, input->GetName()));
490  return;
491  }
492 
493  TList* out = new TList;
494  out->SetName(outName);
495  out->SetOwner();
496  output->Add(out);
497 
498  THStack* dndetaRings = new THStack("all", "dN/d#eta per ring");
499  const char* names[] = { "FMD1I", "FMD2I", "FMD2O", "FMD3I", "FMD3O", 0 };
500  const char** ptr = names;
501 
502  while (*ptr) {
503  TList* thisList = new TList;
504  thisList->SetOwner();
505  thisList->SetName(*ptr);
506  out->Add(thisList);
507 
508  TH2D* h = static_cast<TH2D*>(list->FindObject(Form("%s_cache", *ptr)));
509  if (!h) {
510  AliWarning(Form("Didn't find %s_cache in %s", *ptr, list->GetName()));
511  ptr++;
512  continue;
513  }
514  TH2D* sumPhi = static_cast<TH2D*>(h->Clone("sum_phi"));
515  sumPhi->SetDirectory(0);
516  thisList->Add(sumPhi);
517 
518  TH2D* sumEta = static_cast<TH2D*>(h->Clone("sum_eta"));
519  sumEta->SetDirectory(0);
520  thisList->Add(sumEta);
521 
522  Int_t nY = sumEta->GetNbinsY();
523  TH1D* etaCov =static_cast<TH1D*>(h->ProjectionX("etaCov", 0, 0, ""));
524  TH1D* phiAcc =static_cast<TH1D*>(h->ProjectionX("phiAcc", nY+1, nY+1, ""));
525 
526  etaCov->SetTitle("Normalization to #eta coverage");
527  etaCov->SetYTitle("#eta coverage");
528  etaCov->SetMarkerColor(kBlue+1);
529  etaCov->SetFillColor(kBlue+1);
530  etaCov->SetFillStyle(3005);
531  etaCov->SetDirectory(0);
532 
533  phiAcc->SetTitle("Normalization to #phi acceptance");
534  phiAcc->SetYTitle("#phi acceptance");
535  phiAcc->SetMarkerColor(kGreen+1);
536  phiAcc->SetFillColor(kGreen+1);
537  phiAcc->SetFillStyle(3004);
538  // phiAcc->Scale(1. / nAcc);
539  phiAcc->SetDirectory(0);
540 
541  // Double_t s = (etaCov->GetMaximum() > 0 ? 1. / etaCov->GetMaximum() : 1);
542  for (Int_t i = 1; i <= sumEta->GetNbinsX(); i++) {
543  for (Int_t j = 1; j <= nY; j++) {
544  Double_t c = sumEta->GetBinContent(i, j);
545  Double_t e = sumEta->GetBinError(i, j);
546  Double_t a = etaCov->GetBinContent(i);
547  Double_t p = phiAcc->GetBinContent(i);
548  // Double_t t = p; // * a
549  sumEta->SetBinContent(i, j, a <= 0 ? 0 : c / a);
550  sumEta->SetBinError( i, j, a <= 0 ? 0 : e / a);
551  sumPhi->SetBinContent(i, j, p <= 0 ? 0 : c / p);
552  sumPhi->SetBinError( i, j, p <= 0 ? 0 : e / p);
553  }
554  }
555  // etaCov->Scale(s);
556  // phiAcc->Scale(s);
557 
558  TH1D* resPhi =static_cast<TH1D*>(sumPhi->ProjectionX("dndeta_phi",
559  1,nY,"e"));
560  resPhi->SetMarkerStyle(style);
561  resPhi->SetDirectory(0);
562  resPhi->Scale(1, "width");
563 
564  TH1D* resEta =static_cast<TH1D*>(sumEta->ProjectionX("dndeta_eta",
565  1,nY,"e"));
566  resEta->SetMarkerStyle(style);
567  resEta->SetDirectory(0);
568  resEta->Scale(1, "width");
569 
570  thisList->Add(resEta);
571  thisList->Add(etaCov);
572  thisList->Add(resPhi);
573  thisList->Add(phiAcc);
574  dndetaRings->Add(resPhi);
575 
576  DMSG(fDebug,1, "%s Normalization eta=%8d phi=%8d",
577  ptr, Int_t(etaCov->GetMaximum()), Int_t(phiAcc->GetMaximum()));
578 
579  ptr++;
580  }
581  out->Add(dndetaRings);
582 }
583 #define PFB(N,FLAG) \
584  do { \
585  AliForwardUtil::PrintName(N); \
586  std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
587  } while(false)
588 #define PFV(N,VALUE) \
589  do { \
590  AliForwardUtil::PrintName(N); \
591  std::cout << (VALUE) << std::endl; } while(false)
592 //____________________________________________________________________
593 void
595 {
596  //
597  // Print information
598  //
599  // Parameters:
600  // option Not used
601  //
602  AliBaseESDTask::Print(option);
603  gROOT->IncreaseDirLevel();
604  PFB("Enable low flux code", fEnableLowFlux);
605  PFB("Store per-ring hists", fStorePerRing);
606  PFB("Make timing histogram", fDoTiming);
607  PFV("Trigger mask for adding", AliAODForwardMult::GetTriggerString(fAddMask));
608  // gROOT->IncreaseDirLevel();
609  // GetMultEventClassifier().Print(option);
610  GetESDFixer() .Print(option);
611  GetSharingFilter() .Print(option);
612  GetDensityCalculator() .Print(option);
613  GetCorrections() .Print(option);
614  GetHistCollector() .Print(option);
615  GetEventPlaneFinder() .Print(option);
616  // gROOT->DecreaseDirLevel();
617  gROOT->DecreaseDirLevel();
618 }
619 
620 
621 //
622 // EOF
623 //
virtual void SetupForData(const TAxis &etaAxis)
virtual void CreateBranches(AliAODHandler *ah)
double Double_t
Definition: External.C:58
virtual void Terminate(const TList *dir, TList *output, Int_t nEvents)
const AliFMDCorrDoubleHit * GetDoubleHit() const
void Print(Option_t *option="") const
virtual void SetupForData(const TAxis &etaAxis)
#define PFV(N, VALUE)
void ReInit(const TAxis &etaAxis)
virtual AliFMDSharingFilter & GetSharingFilter()=0
virtual AliFMDESDFixer & GetESDFixer()=0
virtual void Print(Option_t *option="") const
void SetupForData(const TAxis &axis)
virtual void CreateOutputObjects(TList *dir)
TList * list
TDirectory file where lists per trigger are stored in train ouput.
virtual AliFMDHistCollector & GetHistCollector()=0
virtual void Print(Option_t *option="") const
#define DMSG(L, N, F,...)
TCanvas * c
Definition: TestFitELoss.C:172
virtual void Terminate(const TList *dir, TList *output, Int_t nEvents)
virtual void Terminate(const TList *dir, TList *output, Int_t nEvents)
virtual AliFMDDensityCalculator & GetDensityCalculator()=0
void Init(const TAxis &etaAxis)
virtual void CreateOutputObjects(TList *dir)
Bool_t FetchHistograms(const TList *d, TH1I *&hEventsTr, TH1I *&hEventsTrVtx, TH1I *&hEventsAcc, TH1I *&hTriggers) const
virtual AliFMDEventInspector & GetEventInspector()=0
virtual AliFMDEventPlaneFinder & GetEventPlaneFinder()=0
int Int_t
Definition: External.C:63
static Color_t RingColor(UShort_t d, Char_t r)
void Init(const TAxis &etaAxis)
Definition: External.C:204
unsigned int UInt_t
Definition: External.C:33
virtual Bool_t MakeSimpledNdeta(const TList *input, TList *output, Double_t &nTr, Double_t &nTrVtx, Double_t &nAcc)
virtual Bool_t PreData(const TAxis &vertex, const TAxis &eta)
#define DEFINE(N)
void Print(Option_t *option="") const
Various utilities used in PWGLF/FORWARD.
virtual void Print(Option_t *option="") const
const AliFMDCorrMergingEfficiency * GetMergingEfficiency() const
virtual void CreateOutputObjects(TList *dir)
Definition: External.C:228
Definition: External.C:212
void Print(Option_t *option="") const
#define POST(N)
virtual void SetDebug(Int_t dbg)
virtual void CreateOutputObjects(TList *dir)
const AliFMDCorrELossFit * GetELossFit() const
static const Char_t * GetTriggerString(UInt_t mask, const char *sep="&")
#define DGUARD(L, N, F,...)
void SetDebug(Int_t dbg=1)
void CreateOutputObjects(TList *l)
virtual void SetDebug(Int_t dbg=1)
virtual void EstimatedNdeta(const TList *input, TList *output) const
virtual void CreateOutputObjects(TList *dir)
TH2D * Get(UShort_t d, Char_t r) const
void SetDebug(Int_t dbg=1)
virtual void InitMembers(const TAxis &pe, const TAxis &pv)
const AliFMDCorrAcceptance * GetAcceptance() const
virtual void Print(Option_t *option="") const
void Init(const TAxis &etaAxis)
virtual void MakeRingdNdeta(const TList *input, const char *inName, TList *output, const char *outName, Int_t style=20) const
const AliFMDCorrVertexBias * GetVertexBias() const
virtual void SetupForData(const TAxis &etaAxis)
Int_t GetRunNumber(TString)
Definition: PlotMuonQA.C:2235
const char Option_t
Definition: External.C:48
UInt_t fNeededCorrections
virtual AliFMDCorrector & GetCorrections()=0
bool Bool_t
Definition: External.C:53
const AliFMDCorrSecondaryMap * GetSecondaryMap() const
virtual void SetupForData(const TAxis &vtxAxis, const TAxis &etaAxis)
#define AOD_SLOT
#define PFB(N, FLAG)
void Print(Option_t *option="") const
Definition: External.C:196
static AliForwardCorrectionManager & Instance()
const TH2D & GetHistogram() const