PWGLF/FORWARD/analysis2/AddTaskCentralTracks.C

   1 /**
   2  * @file   AddTaskCentralTracks.C
   3  * @author Christian Holm Christensen <cholm@dalsgaard.hehi.nbi.dk>
   4  * @date   Fri Jan 28 10:22:26 2011
   5  *
   6  * @brief Class and script to add a multiplicity task for the central
   7  *        @f$\eta@f$ region
   8  *
   9  * @ingroup pwglf_forward_scripts_tasks
  10  *
  11  */
  12 #include <AliAnalysisTaskSE.h>
  13 #include <AliESDtrackCuts.h>
  14 class TList;
  15 class TH2D;
  16 class TH1D;
  17
  18 /**
  19  * Task to determine the charged particle pseudo density from tracks
  20  * and tracklets.
  21  *
  22  * This class determines
  23  * @f[
  24  *   \left.\frac{d^2N_{ch}}{d\eta d\phi}\right|_{central}
  25  * @f]
  26  * from tracks and tracklets.
  27  *
  28  * First, global tracks are investigated. The requirements on global
  29  * tracks are
  30  * - @f$ n_{TPC clusters} \ge 70@f$
  31  * - @f$ \chi^2_{TPC cluster} \le 4@f$
  32  * - No daughter kinks
  33  * - Re-fit of TPC tracks
  34  * - Re-fit of ITS tracks
  35  * - No requirement on SPD clusters
  36  *
  37  * Secondly, ITS stand-alone tracks are investigated.  The
  38  * requirements on ITS standalone tracks are
  39  * - Re-fit of ITS tracks
  40  * - No requirement on SPD clusters
  41  *
  42  * Tracks that does not meet these quality conditions are flagged as
  43  * rejected.
  44  *
  45  * Both kinds of tracks (global and ITS standalone) have requirements
  46  * on the distance of closest approach (DCA) to the interaction
  47  * vertex @f$(v_x,v_y,v_z)@f$.
  48  *
  49  * For tracks with SPD clusters:
  50  * - @f$ DCA_{xy} < 0.0182+0.0350/p_t^{1.01}@f$
  51  * - @f$ DCA_{z} < 0.5@f$
  52  *
  53  * For tracks without SPD clusters
  54  * - @f$ DCA_{xy} < 1.5(0.0182+0.0350/p_t^{1.01})@f$
  55  * - @f$ DCA_{z} < 0.5@f$
  56  *
  57  * Tracks that does not meet these DCA requirements are flagged as
  58  * secondaries.
  59  *
  60  * Thirdly, the number of SPD tracklets are investigated.  If the
  61  * tracklet is associated with a track, and that track has already
  62  * been used, then that tracklet is ignored
  63  *
  64  * An @f$(\eta,\phi)@f$ per-event histogram is then filled from these
  65  * tracks and tracklets, and that histogram is stored in the output
  66  * AOD event.
  67  *
  68  * Furthermore, a number of diagnostics @f$\eta@f$ histograms are filled:
  69  * - @f$\eta@f$ of all accepted tracks and tracklets
  70  * - @f$\eta@f$ of accepted global tracks
  71  * - @f$\eta@f$ of accepted ITS tracks
  72  * - @f$\eta@f$ of accepted SPD tracklets
  73  *
  74  * At the end of the job, these histograms are normalized to the
  75  * number of accepted events and bin width to provide an estimate of
  76  * the @f$dN_{ch}/d\eta@f$
  77  *
  78  * Only minimum bias events with a @f$v_z@f$ within the defined cut
  79  * are analysed.
  80  *
  81  * @deprecated This class is deprecated
  82  * @ingroup pwglf_forward_aod
  83  */
  84 class CentralMultTask : public AliAnalysisTaskSE
  85 {
  86 public:
  87   enum {
  88     kValidTrigger = 0x1,
  89     kValidVertex  = 0x2
  90   };
  91   /**
  92    * Constructor
  93    *
  94    */
  95   CentralMultTask();
  96   /**
  97    * Constructor
  98    *
  99    * @param name    Name of task
 100    * @param maxEta  Set @f$\eta@f$ range
 101    * @param maxVtx  Set @f$v_z@f$ range
 102    */
 103   CentralMultTask(const char* name,
 104                   Double_t maxEta=2,
 105                   Double_t maxVtx=10);
 106   /**
 107    * Destructor
 108    *
 109    */
 110   virtual ~CentralMultTask();
 111   /**
 112    * Whether to use tracklets
 113    *
 114    * @param use IF true, use tracklets
 115    */
 116   void SetUseTracklets(Bool_t use) { fUseTracklets = use; }
 117   /**
 118    * Initialise on master - does nothing
 119    *
 120    */
 121   virtual void   Init() {}
 122   /**
 123    * Create output objects.
 124    *
 125    * This is called once per slave process
 126    */
 127   virtual void UserCreateOutputObjects();
 128   /**
 129    * Process a single event
 130    *
 131    * @param option Not used
 132    */
 133   virtual void UserExec(Option_t* option);
 134   /**
 135    * Called at end of event processing.
 136    *
 137    * This is called once in the master
 138    *
 139    * @param option Not used
 140    */
 141   virtual void Terminate(Option_t* option);
 142 protected:
 143   /**
 144    * Check if this event is within cuts
 145    *
 146    * @param esd Event
 147    * @param vz  Vertex @f$ z@f$ coordinate
 148    *
 149    * @return true if this event is to be considered
 150    */
 151   UShort_t CheckEvent(const AliESDEvent& esd, Double_t& vz);
 152
 153   TH2D*           fHist;      // Per-event d2n/deta/dphi
 154   TH1D*           fAll;       // Summed d2n/deta/dphi - all track(let)s
 155   TH1D*           fGlobal;    // Summed d2n/deta/dphi - global tracks
 156   TH1D*           fITS;       // Summed d2n/deta/dphi - ITS tracks
 157   TH1D*           fTracklets; // Summed d2n/deta/dphi - SPD tracklets
 158   TH1D*           fNEventsTr; // Number of triggered events per vertex bin
 159   TH1D*           fNEventsVtx;// Number of triggered+vertex events per vertex
 160   TList*          fOutput;    // Output list
 161   AliESDtrackCuts fQGlo;      // Quality cut on ITS+TPC
 162   AliESDtrackCuts fQITS;      // Quality cut on ITS standalone (not ITS+TPC)
 163   AliESDtrackCuts fDCAwSPD;   // DCA for traks with SPD hits
 164   AliESDtrackCuts fDCAwoSPD;  // DCA for traks without SPD hits
 165   AliESDtrackCuts fIsPrimary; // Primary particle
 166   Bool_t          fUseTracklets; // Whether to count tracklets or not
 167   Bool_t          fDebug;     // Debug flag
 168
 169   ClassDef(CentralMultTask,1); // Determine multiplicity in central area
 170 };
 171
 172 //====================================================================
 173 #include <TMath.h>
 174 #include <TH2D.h>
 175 #include <TH1D.h>
 176 #include <THStack.h>
 177 #include <TList.h>
 178 #include <AliAnalysisManager.h>
 179 #include <AliESDEvent.h>
 180 #include <AliAODHandler.h>
 181 #include <AliAODEvent.h>
 182 #include <AliESDInputHandler.h>
 183 #include <AliESDtrack.h>
 184 #include <AliMultiplicity.h>
 185
 186 //____________________________________________________________________
 187 inline CentralMultTask::CentralMultTask()
 188   : AliAnalysisTaskSE(),
 189     fHist(0),
 190     fAll(0),
 191     fGlobal(0),
 192     fITS(0),
 193     fTracklets(0),
 194     fNEventsTr(0),
 195     fNEventsVtx(0),
 196     fOutput(0),
 197     fUseTracklets(false),
 198     fDebug(false)
 199 {}
 200
 201 //____________________________________________________________________
 202 inline CentralMultTask::CentralMultTask(const char* /* name */,
 203                                         Double_t maxEta,
 204                                         Double_t maxVtx)
 205   : AliAnalysisTaskSE("Central"),
 206     fHist(0),
 207     fAll(0),
 208     fGlobal(0),
 209     fITS(0),
 210     fTracklets(0),
 211     fNEventsTr(0),
 212     fNEventsVtx(0),
 213     fOutput(0),
 214     fUseTracklets(true),
 215     fDebug(false)
 216 {
 217   Int_t nBins = 40;
 218   fHist = new TH2D("Central", "d^{2}N_{ch}/d#etad#phi in central region",
 219                    nBins, -maxEta, maxEta, 20, 0, 2*TMath::Pi());
 220   fHist->SetDirectory(0);
 221   fHist->SetXTitle("#eta");
 222   fHist->SetYTitle("#phi [radians]");
 223   fHist->SetZTitle("d^{2}N_{ch}/d#etad#phi");
 224   fHist->SetStats(0);
 225   fHist->Sumw2();
 226
 227   fAll = new TH1D("all", "Central region", nBins, -maxEta, maxEta);
 228   fAll->SetDirectory(0);
 229   fAll->SetXTitle("#eta");
 230   fAll->SetYTitle("dN_{ch}/d#eta");
 231   fAll->Sumw2();
 232   fAll->SetFillColor(kGray);
 233   fAll->SetFillStyle(3001);
 234   fAll->SetMarkerStyle(28);
 235   fAll->SetMarkerColor(kGray);
 236   fAll->SetStats(0);
 237
 238   fGlobal = static_cast<TH1D*>(fAll->Clone("global"));
 239   fGlobal->SetTitle("Global tracks");
 240   fGlobal->SetDirectory(0);
 241   fGlobal->Sumw2();
 242   fGlobal->SetFillColor(kRed+1);
 243   fGlobal->SetFillStyle(3001);
 244   fGlobal->SetMarkerStyle(28);
 245   fGlobal->SetMarkerColor(kRed+1);
 246   fGlobal->SetStats(0);
 247
 248   fITS = static_cast<TH1D*>(fAll->Clone("its"));
 249   fITS->SetTitle("ITS tracks");
 250   fITS->SetDirectory(0);
 251   fITS->Sumw2();
 252   fITS->SetFillColor(kGreen+1);
 253   fITS->SetFillStyle(3001);
 254   fITS->SetMarkerStyle(28);
 255   fITS->SetMarkerColor(kGreen+1);
 256   fITS->SetStats(0);
 257
 258   fTracklets = static_cast<TH1D*>(fAll->Clone("tracklets"));
 259   fTracklets->SetTitle("SPD tracklets");
 260   fTracklets->SetDirectory(0);
 261   fTracklets->Sumw2();
 262   fTracklets->SetFillColor(kBlue+1);
 263   fTracklets->SetFillStyle(3001);
 264   fTracklets->SetMarkerStyle(28);
 265   fTracklets->SetMarkerColor(kBlue+1);
 266   fTracklets->SetStats(0);
 267
 268   fNEventsTr = new TH1D("nEventsTr",
 269                         "Events per vertex bin", 10, -maxVtx, maxVtx);
 270   fNEventsTr->SetXTitle("v_{z}");
 271   fNEventsTr->SetYTitle("Events");
 272   fNEventsTr->SetDirectory(0);
 273
 274   fNEventsVtx = new TH1D("nEventsVtx",
 275                          "Events per vertex bin", 10, -maxVtx, maxVtx);
 276   fNEventsVtx->SetXTitle("v_{z}");
 277   fNEventsVtx->SetYTitle("Events");
 278   fNEventsVtx->SetDirectory(0);
 279
 280   // --- Global (ITS+TPC) track quality cuts
 281   // TPC
 282   fQGlo.SetMinNClustersTPC(70);
 283   fQGlo.SetMaxChi2PerClusterTPC(4);
 284   fQGlo.SetAcceptKinkDaughters(kFALSE);
 285   fQGlo.SetRequireTPCRefit(kTRUE);
 286   // ITS
 287   fQGlo.SetRequireITSRefit(kTRUE);
 288   fQGlo.SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kOff);
 289   fQGlo.SetEtaRange(-maxEta, maxEta);
 290
 291   // --- ITS standalone track quality cuts
 292   fQITS.SetRequireITSRefit(kTRUE);
 293   fQITS.SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kOff);
 294   fQITS.SetEtaRange(-maxEta, maxEta);
 295
 296   // -- Distance-of-Closest-Approach cuts for tracks w/ITS hits
 297   fDCAwSPD.SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 298                                     AliESDtrackCuts::kAny);
 299   fDCAwSPD.SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
 300   fDCAwSPD.SetMaxDCAToVertexZ(0.5);
 301   fDCAwSPD.SetEtaRange(-maxEta, maxEta);
 302
 303   // -- Distance-of-Closest-Approach cuts for tracks w/o ITS hits
 304   fDCAwoSPD.SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 305                                      AliESDtrackCuts::kNone);
 306   fDCAwoSPD.SetMaxDCAToVertexXYPtDep("1.5*(0.0182+0.0350/pt^1.01)");
 307   fDCAwoSPD.SetMaxDCAToVertexZ(0.5);
 308   fDCAwoSPD.SetEtaRange(-maxEta, maxEta);
 309
 310   // -- Primary track cut
 311   // https://twiki.cern.ch/twiki/bin/view/ALICE/SelectionOfPrimaryTracksForPpDataAnalysis
 312   // Quality
 313   fIsPrimary.SetMinNClustersTPC(70);
 314   fIsPrimary.SetMaxChi2PerClusterTPC(4);
 315   fIsPrimary.SetAcceptKinkDaughters(kFALSE);
 316   fIsPrimary.SetRequireTPCRefit(kTRUE);
 317   fIsPrimary.SetRequireITSRefit(kTRUE);
 318   fIsPrimary.SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 319                                       AliESDtrackCuts::kAny);
 320   //  Dca:
 321   fIsPrimary.SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
 322   fIsPrimary.SetMaxDCAToVertexZ(2);
 323   fIsPrimary.SetDCAToVertex2D(kFALSE);
 324   fIsPrimary.SetRequireSigmaToVertex(kFALSE);
 325
 326   // Output slot #1 writes into a TH1 container
 327   DefineOutput(1, TList::Class());
 328 }
 329
 330 //____________________________________________________________________
 331 inline CentralMultTask::~CentralMultTask()
 332 {
 333   if (fHist)      delete fHist;
 334   if (fAll)       delete fAll;
 335   if (fGlobal)    delete fGlobal;
 336   if (fITS)       delete fITS;
 337   if (fTracklets) delete fTracklets;
 338 }
 339
 340 //________________________________________________________________________
 341 inline void
 342 CentralMultTask::UserCreateOutputObjects()
 343 {
 344   // Create histograms
 345   // Called once (on the worker node)
 346
 347   fOutput = new TList;
 348   fOutput->SetName(GetName());
 349   fOutput->SetOwner();
 350
 351   fOutput->Add(fAll);
 352   fOutput->Add(fGlobal);
 353   fOutput->Add(fITS);
 354   fOutput->Add(fTracklets);
 355   fOutput->Add(fNEventsTr);
 356   fOutput->Add(fNEventsVtx);
 357
 358   AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
 359   AliAODHandler*      ah =
 360     dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
 361   if (!ah) AliFatal("No AOD output handler set in analysis manager");
 362
 363   ah->AddBranch("TH2D", &fHist);
 364
 365   // Post data for ALL output slots >0 here, to get at least an empty histogram
 366   PostData(1, fOutput);
 367 }
 368
 369 //____________________________________________________________________
 370 inline UShort_t
 371 CentralMultTask::CheckEvent(const AliESDEvent& esd, Double_t& vz)
 372 {
 373   // Do some fast cuts first
 374   vz = 0;
 375
 376   // Get the analysis manager - should always be there
 377   AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
 378   if (!am) {
 379     AliWarning("No analysis manager defined!");
 380     return 0;
 381   }
 382
 383   // Get the input handler - should always be there
 384   AliInputEventHandler* ih =
 385     static_cast<AliInputEventHandler*>(am->GetInputEventHandler());
 386   if (!ih) {
 387     AliWarning("No input handler");
 388     return 0;
 389   }
 390
 391   // Trigger mask
 392   UInt_t    mask     = ih->IsEventSelected();
 393   Bool_t   isMinBias = (mask == AliVEvent::kMB) ? 1 : 0;
 394   UShort_t ret       = 0;
 395   if (isMinBias) ret |= kValidTrigger;
 396
 397   // check for good reconstructed vertex
 398   if (!(esd.GetPrimaryVertex()->GetStatus())) {
 399     if (fDebug)
 400       AliWarning("Primary vertex has bad status");
 401     return ret;
 402   }
 403   if (!(esd.GetPrimaryVertexSPD()->GetStatus())) {
 404     if (fDebug)
 405       AliWarning("Primary SPD vertex has bad status");
 406     return ret;
 407   }
 408
 409   // if vertex is from spd vertexZ, require more stringent cut
 410   if (esd.GetPrimaryVertex()->IsFromVertexerZ()) {
 411     if (esd.GetPrimaryVertex()->GetDispersion() > 0.02 ||
 412         esd.GetPrimaryVertex()->GetZRes()       > 0.25) {
 413       if (fDebug)
 414         AliWarning(Form("Primary vertex dispersion=%f (0.02) zres=%f (0.05)",
 415                         esd.GetPrimaryVertex()->GetDispersion(),
 416                         esd.GetPrimaryVertex()->GetZRes()));
 417       return ret;
 418     }
 419   }
 420   // One can add a cut on the vertex z position here
 421   vz = esd.GetPrimaryVertex()->GetZ();
 422   Double_t vl = fNEventsVtx->GetXaxis()->GetXmin();
 423   Double_t vh = fNEventsVtx->GetXaxis()->GetXmax();
 424   if (vz <  vl || vz > vh) {
 425     if (fDebug)
 426       AliWarning(Form("Primary vertex vz=%f out of range [%f,%f]", vz, vl, vh));
 427     return ret;
 428   }
 429   ret |= kValidVertex;
 430
 431   return ret;
 432 }
 433
 434 //____________________________________________________________________
 435 inline void
 436 CentralMultTask::UserExec(Option_t *)
 437 {
 438   // Main loop
 439   AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
 440   if (!esd) {
 441     AliError("Cannot get the ESD event");
 442     return;
 443   }
 444
 445   fHist->Reset();
 446
 447   // Check event
 448   Double_t vz         = 0;
 449   UShort_t eventFlags = CheckEvent(*esd, vz);
 450   if (!(eventFlags & kValidTrigger))
 451     return; // No trigger
 452   else {
 453     fNEventsTr->Fill(vz);
 454     if (eventFlags & kValidVertex)
 455       fNEventsVtx->Fill(vz);
 456     else
 457       return; // No trigger or no vertex
 458   }
 459
 460
 461   // flags for secondary and rejected tracks
 462   // set this bit in ESD tracks if it is rejected by a cut
 463   const int kRejBit = BIT(15);
 464   // set this bit in ESD tracks if it is secondary according to a cut
 465   const int kSecBit = BIT(16);
 466
 467   Int_t total      = 0;
 468   Int_t nESDTracks = esd->GetNumberOfTracks();
 469   // Loop over ESD tracks
 470   for(Int_t i = 0; i < nESDTracks; i++){ // flag the tracks
 471
 472     AliESDtrack* track = esd->GetTrack(i);
 473
 474     // if track is a secondary from a V0, flag as a secondary
 475     if (track->IsOn(AliESDtrack::kMultInV0)) {
 476       track->SetBit(kSecBit);
 477       continue;
 478     }
 479
 480     Double_t eta = track->Eta();
 481     Double_t phi = track->Phi();
 482     // check tracks with ITS part
 483     if (track->IsOn(AliESDtrack::kITSin)) {
 484
 485       // Check ITS pure stand-alone - and if it is, reject it
 486       if (track->IsOn(AliESDtrack::kITSpureSA)) {
 487         track->SetBit(kRejBit);
 488         continue;
 489       }
 490
 491       // Check DCA - if not close enough reject it as secondary
 492       if (!fDCAwSPD.AcceptTrack(track) &&
 493           !fDCAwoSPD.AcceptTrack(track)) {
 494         track->SetBit(kSecBit);
 495         continue;
 496       }
 497
 498       // Check if this is an ITS complementary - no TPC in
 499       if (!track->IsOn(AliESDtrack::kTPCin)) {
 500         if (fQITS.AcceptTrack(track)) { // Check ITS quality
 501           fITS->Fill(eta);
 502           fAll->Fill(eta);
 503         }
 504         else
 505           track->SetBit(kRejBit);
 506       }
 507       else { // Not ITS SA or TPC+ITS
 508         if (fQGlo.AcceptTrack(track)) { // Check ITS quality
 509           fGlobal->Fill(eta);
 510           fAll->Fill(eta);
 511         }
 512         else
 513           track->SetBit(kRejBit);
 514       }
 515       if (track->IsOn(kSecBit) || track->IsOn(kRejBit)) continue;
 516
 517       // fill d2n/detadphi
 518       fHist->Fill(eta, phi);
 519     }
 520   }
 521
 522   // Get multiplicity from SPD tracklets
 523   const AliMultiplicity* spdmult = esd->GetMultiplicity();
 524   for (Int_t i=0; i<spdmult->GetNumberOfTracklets(); ++i){
 525     // if counting tracks+tracklets,
 526     // check if clusters were already used in tracks
 527     Int_t id1,id2;
 528     spdmult->GetTrackletTrackIDs(i,0,id1,id2);
 529     AliESDtrack* tr1 = id1>=0 ? esd->GetTrack(id1) : 0;
 530     AliESDtrack* tr2 = id2>=0 ? esd->GetTrack(id2) : 0;
 531     //
 532     if ((tr1 && tr1->TestBit(kSecBit))  || // Flagged as secondary
 533         (tr2 && tr2->TestBit(kSecBit))  || // Flagged as secondary
 534         (tr1 && !tr1->TestBit(kRejBit)) || // already accounted for
 535         (tr2 && !tr2->TestBit(kRejBit)))   // already accounted for
 536       continue;
 537     ++total;
 538     Double_t eta = spdmult->GetEta(i);
 539     Double_t phi = spdmult->GetPhi(i);
 540
 541     // Increment d2n/detadphi from an SPD tracklet
 542     if (fUseTracklets) {
 543       fHist->Fill(eta, phi);
 544       fAll->Fill(eta);
 545       total++;
 546     }
 547     fTracklets->Fill(eta);
 548   }
 549   if (fDebug) AliInfo(Form("A total of %d tracks", total));
 550
 551   // NEW HISTO should be filled before this point, as PostData puts the
 552   // information for this iteration of the UserExec in the container
 553   PostData(1, fOutput);
 554 }
 555
 556
 557 //________________________________________________________________________
 558 inline void
 559 CentralMultTask::Terminate(Option_t *)
 560 {
 561   // Draw result to screen, or perform fitting, normalizations Called
 562   // once at the end of the query
 563
 564   fOutput = dynamic_cast<TList*> (GetOutputData(1));
 565   if(!fOutput) {
 566     AliError("Could not retrieve TList fOutput");
 567     return;
 568   }
 569
 570   TH1D* all       = static_cast<TH1D*>(fOutput->FindObject("all"));
 571   TH1D* global    = static_cast<TH1D*>(fOutput->FindObject("global"));
 572   TH1D* its       = static_cast<TH1D*>(fOutput->FindObject("its"));
 573   TH1D* tracklets = static_cast<TH1D*>(fOutput->FindObject("tracklets"));
 574   TH1D* eventsTr  = static_cast<TH1D*>(fOutput->FindObject("nEventsTr"));
 575   TH1D* eventsVtx = static_cast<TH1D*>(fOutput->FindObject("nEventsVtx"));
 576
 577   Int_t nTriggers  = eventsTr->GetEntries();
 578   Int_t nVertex    = eventsVtx->GetEntries();
 579   if (nTriggers <= 0 || nVertex <= 0) {
 580     AliWarning("No data in the events histogram!");
 581     nTriggers = 1;
 582   }
 583
 584   all      ->Scale(1. / nTriggers, "width");
 585   global   ->Scale(1. / nTriggers, "width");
 586   its      ->Scale(1. / nTriggers, "width");
 587   tracklets->Scale(1. / nTriggers, "width");
 588
 589   THStack* stack = new THStack("components", "Components");
 590   if (fUseTracklets) stack->Add(tracklets);
 591   stack->Add(global);
 592   stack->Add(its);
 593
 594   fOutput->Add(stack);
 595 }
 596
 597 //========================================================================
 598 /**
 599  * Add task to do central dN/deta from tracks/tracklets
 600  *
 601  * @deprecated This function is deprecated
 602  * @return Newly created task
 603  */
 604 inline AliAnalysisTask*
 605 AddTaskCentralTracks()
 606 {
 607   // analysis manager
 608   AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
 609
 610   // Make our object.  2nd argumenent is absolute max Eta
 611   // 3rd argument is absolute max Vz
 612   CentralMultTask* task = new CentralMultTask("Global", 2, 10);
 613   // if physics selection performed in UserExec(),
 614   // this line should be commented
 615   // task->SelectCollisionCandidates(AliVEvent::kMB);
 616   mgr->AddTask(task);
 617
 618   // create containers for input/output
 619   AliAnalysisDataContainer *output =
 620     mgr->CreateContainer("Central", TList::Class(),
 621                          AliAnalysisManager::kOutputContainer,
 622                          AliAnalysisManager::GetCommonFileName());
 623
 624   // connect input/output
 625   mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
 626   mgr->ConnectOutput(task, 1, output);
 627
 628   return task;
 629 }
 630
 631
 632 //________________________________________________________________________
 633 //
 634 // EOF
 635 //