PWG2/FORWARD/analysis2/AddTaskCentralMult.C

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