PWG2/EBYE/AliAnalysisTaskBF.cxx

   1 #include "TChain.h"\r
   2 #include "TList.h"\r
   3 #include "TCanvas.h"\r
   4 #include "TLorentzVector.h"\r
   5 #include "TGraphErrors.h"\r
   6 #include "TH1F.h"\r
   7 #include "TH2F.h"\r
   8 \r
   9 #include "AliAnalysisTaskSE.h"\r
  10 #include "AliAnalysisManager.h"\r
  11 \r
  12 #include "AliESDVertex.h"\r
  13 #include "AliESDEvent.h"\r
  14 #include "AliESDInputHandler.h"\r
  15 #include "AliAODEvent.h"\r
  16 #include "AliAODTrack.h"\r
  17 #include "AliAODInputHandler.h"\r
  18 #include "AliMCEventHandler.h"\r
  19 #include "AliMCEvent.h"\r
  20 #include "AliStack.h"\r
  21 #include "AliESDtrackCuts.h"\r
  22 \r
  23 #include "AliAnalysisTaskBF.h"\r
  24 #include "AliBalance.h"\r
  25 \r
  26 \r
  27 // Analysis task for the BF code\r
  28 // Authors: Panos Cristakoglou@cern.ch\r
  29 \r
  30 ClassImp(AliAnalysisTaskBF)\r
  31 \r
  32 //________________________________________________________________________\r
  33 AliAnalysisTaskBF::AliAnalysisTaskBF(const char *name) \r
  34 : AliAnalysisTaskSE(name), \r
  35   fBalance(0),\r
  36   fShuffledBalance(0),\r
  37   fList(0),\r
  38   fListBF(0),\r
  39   fHistEventStats(0),\r
  40   fHistTrackStats(0),\r
  41   fHistVx(0),\r
  42   fHistVy(0),\r
  43   fHistVz(0),\r
  44   fHistClus(0),\r
  45   fHistDCA(0),\r
  46   fHistChi2(0),\r
  47   fHistPt(0),\r
  48   fHistEta(0),\r
  49   fHistPhi(0),\r
  50   fHistV0M(0),\r
  51   fHistN(0),\r
  52   fESDtrackCuts(0),\r
  53   fCentralityEstimator("VOM"),\r
  54   fCentralityPercentileMin(0.), \r
  55   fCentralityPercentileMax(5.),\r
  56   fUseOfflineTrigger(kFALSE),\r
  57   fVxMax(0.3),\r
  58   fVyMax(0.3),\r
  59   fVzMax(10.),\r
  60   fPtMin(0.3),\r
  61   fPtMax(1.5),\r
  62   fEtaMin(-0.8),\r
  63   fEtaMax(-0.8),\r
  64   fDCAxyCut(2.4),\r
  65   fDCAzCut(3.2){\r
  66   // Constructor\r
  67   for(Int_t i = 0; i < ANALYSIS_TYPES; i++){\r
  68     for (Int_t j = 0; j < 3; j++){\r
  69       fHistBF[i][j] = NULL;\r
  70       fHistShuffledBF[i][j] = NULL;\r
  71     }\r
  72   }\r
  73 \r
  74   // Define input and output slots here\r
  75   // Input slot #0 works with a TChain\r
  76   DefineInput(0, TChain::Class());\r
  77   // Output slot #0 writes into a TH1 container\r
  78   DefineOutput(1, AliBalance::Class());\r
  79   DefineOutput(2, AliBalance::Class());\r
  80   DefineOutput(3, TList::Class());\r
  81   DefineOutput(4, TList::Class());\r
  82 }\r
  83 \r
  84 \r
  85 //________________________________________________________________________\r
  86 void AliAnalysisTaskBF::UserCreateOutputObjects() {\r
  87   // Create histograms\r
  88   // Called once\r
  89   if(!fBalance) {\r
  90     fBalance = new AliBalance();\r
  91     fBalance->SetAnalysisLevel("ESD");\r
  92     fBalance->SetNumberOfBins(-1,16);\r
  93     fBalance->SetInterval(-0.8,0.8,-1,0.,1.6);\r
  94   }\r
  95   if(!fShuffledBalance) {\r
  96     fShuffledBalance = new AliBalance();\r
  97     fShuffledBalance->SetAnalysisLevel("ESD");\r
  98     fShuffledBalance->SetNumberOfBins(-1,16);\r
  99     fShuffledBalance->SetInterval(-0.8,0.8,-1,0.,1.6);\r
 100   }\r
 101 \r
 102   //QA list\r
 103   fList = new TList();\r
 104   fList->SetName("listQA");\r
 105   fList->SetOwner();\r
 106 \r
 107   //Balance Function list\r
 108   fListBF = new TList();\r
 109   fListBF->SetName("listBF");\r
 110   fListBF->SetOwner();\r
 111 \r
 112   //Event stats.\r
 113   TString gCutName[4] = {"Total","Offline trigger",\r
 114                          "Vertex","Analyzed"};\r
 115   fHistEventStats = new TH1F("fHistEventStats",\r
 116                              "Event statistics;;N_{events}",\r
 117                              4,0.5,4.5);\r
 118   for(Int_t i = 1; i <= 4; i++)\r
 119     fHistEventStats->GetXaxis()->SetBinLabel(i,gCutName[i-1].Data());\r
 120   fList->Add(fHistEventStats);\r
 121 \r
 122   fHistTrackStats = new TH1F("fHistTrackStats","Event statistics;TriggerBit;N_{events}",130,0,130);\r
 123   fList->Add(fHistTrackStats);\r
 124 \r
 125   // Vertex distributions\r
 126   fHistVx = new TH1F("fHistVx","Primary vertex distribution - x coordinate;V_{x} (cm);Entries",100,-0.5,0.5);\r
 127   fList->Add(fHistVx);\r
 128   fHistVy = new TH1F("fHistVy","Primary vertex distribution - y coordinate;V_{y} (cm);Entries",100,-0.5,0.5);\r
 129   fList->Add(fHistVy);\r
 130   fHistVz = new TH1F("fHistVz","Primary vertex distribution - z coordinate;V_{z} (cm);Entries",100,-20.,20.);\r
 131   fList->Add(fHistVz);\r
 132 \r
 133   // QA histograms\r
 134   fHistClus = new TH2F("fHistClus","# Cluster (TPC vs. ITS)",10,0,10,200,0,200);\r
 135   fList->Add(fHistClus);\r
 136   fHistChi2 = new TH1F("fHistChi2","Chi2/NDF distribution",200,0,10);\r
 137   fList->Add(fHistChi2);\r
 138   fHistDCA  = new TH2F("fHistDCA","DCA (xy vs. z)",400,-5,5,400,-5,5); \r
 139   fList->Add(fHistDCA);\r
 140   fHistPt   = new TH1F("fHistPt","p_{T} distribution",200,0,10);\r
 141   fList->Add(fHistPt);\r
 142   fHistEta  = new TH1F("fHistEta","#eta distribution",200,-2,2);\r
 143   fList->Add(fHistEta);\r
 144   fHistPhi  = new TH1F("fHistPhi","#phi distribution",200,-20,380);\r
 145   fList->Add(fHistPhi);\r
 146   fHistV0M  = new TH2F("fHistV0M","V0 Multiplicity C vs. A",500, 0, 20000, 500, 0, 20000);\r
 147   fList->Add(fHistV0M);\r
 148 \r
 149 \r
 150   if(fESDtrackCuts) fList->Add(fESDtrackCuts);\r
 151 \r
 152 \r
 153   //balance function histograms\r
 154   TString hname;\r
 155   for(Int_t i = 0; i < ANALYSIS_TYPES; i++){\r
 156     for (Int_t j = 0; j < 3; j++){\r
 157       hname = "BF";\r
 158       hname+=i;\r
 159       hname+=j;\r
 160       fHistBF[i][j] = new TH1F(hname,hname,fBalance->GetNumberOfBins(i),fBalance->GetP2Start(i),fBalance->GetP2Stop(i));\r
 161       fListBF->Add(fHistBF[i][j]);\r
 162       hname = "ShuffledBF";\r
 163       hname+=i;\r
 164       hname+=j;\r
 165       fHistShuffledBF[i][j] = new TH1F(hname,hname,fShuffledBalance->GetNumberOfBins(i),fShuffledBalance->GetP2Start(i),fShuffledBalance->GetP2Stop(i));\r
 166       fListBF->Add(fHistShuffledBF[i][j]);\r
 167     }\r
 168   }\r
 169   fHistN = new TH1F("fN","fN",2,0,1);\r
 170   fListBF->Add(fHistN);\r
 171 \r
 172   // Post output data.\r
 173   //PostData(1, fBalance);\r
 174   PostData(3, fList);\r
 175   PostData(4, fListBF);\r
 176   \r
 177 }\r
 178 \r
 179 //________________________________________________________________________\r
 180 void AliAnalysisTaskBF::UserExec(Option_t *) {\r
 181   // Main loop\r
 182   // Called for each event\r
 183   TString gAnalysisLevel = fBalance->GetAnalysisLevel();\r
 184 \r
 185   TObjArray *array         = new TObjArray();\r
 186 \r
 187   // vector holding the charges of all tracks\r
 188   vector<Int_t> chargeVectorShuffle;   // this will be shuffled\r
 189   vector<Int_t> chargeVector;          // to remember the original charge ( set back after shuffling )\r
 190   \r
 191   //ESD analysis\r
 192   if(gAnalysisLevel == "ESD") {\r
 193     AliESDEvent* gESD = dynamic_cast<AliESDEvent*>(InputEvent()); // from TaskSE\r
 194     if (!gESD) {\r
 195       Printf("ERROR: gESD not available");\r
 196       return;\r
 197     }\r
 198 \r
 199     fHistEventStats->Fill(1); //all events\r
 200     Bool_t isSelected = kTRUE;\r
 201     if(fUseOfflineTrigger)\r
 202       isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();\r
 203     if(isSelected) {\r
 204       fHistEventStats->Fill(2); //triggered events\r
 205 \r
 206       //Centrality stuff\r
 207       AliCentrality *centrality = gESD->GetCentrality();\r
 208       //Int_t nCentrality = 0;\r
 209       //nCentrality = centrality->GetCentralityClass5(fCentralityEstimator.Data());\r
 210       //cout<<nCentrality<<" "<<centrality->IsEventInCentralityClass(fCentralityPercentileMin,fCentralityPercentileMax,fCentralityEstimator.Data())<<endl;\r
 211 \r
 212       // take only events inside centrality class\r
 213       if(centrality->IsEventInCentralityClass(fCentralityPercentileMin,\r
 214                                               fCentralityPercentileMax,\r
 215                                               fCentralityEstimator.Data())){\r
 216 \r
 217         // centrality QA (V0M)\r
 218         fHistV0M->Fill(gESD->GetVZEROData()->GetMTotV0A(), gESD->GetVZEROData()->GetMTotV0C());\r
 219         \r
 220         const AliESDVertex *vertex = gESD->GetPrimaryVertex();\r
 221         if(vertex) {\r
 222           if(vertex->GetNContributors() > 0) {\r
 223             if(vertex->GetZRes() != 0) {\r
 224               fHistEventStats->Fill(3); //events with a proper vertex\r
 225               if(TMath::Abs(vertex->GetXv()) < fVxMax) {\r
 226                 if(TMath::Abs(vertex->GetYv()) < fVyMax) {\r
 227                   if(TMath::Abs(vertex->GetZv()) < fVzMax) {\r
 228                     fHistEventStats->Fill(4); //analayzed events\r
 229                     fHistVx->Fill(vertex->GetXv());\r
 230                     fHistVy->Fill(vertex->GetYv());\r
 231                     fHistVz->Fill(vertex->GetZv());\r
 232                     \r
 233                     //Printf("There are %d tracks in this event", gESD->GetNumberOfTracks());\r
 234                     for (Int_t iTracks = 0; iTracks < gESD->GetNumberOfTracks(); iTracks++) {\r
 235                       AliESDtrack* track = dynamic_cast<AliESDtrack *>(gESD->GetTrack(iTracks));\r
 236                       if (!track) {\r
 237                         Printf("ERROR: Could not receive track %d", iTracks);\r
 238                         continue;\r
 239                       } \r
 240 \r
 241                       // take only TPC only tracks (HOW IS THIS DONE IN ESDs???)\r
 242                       //if(!track->IsTPCOnly()) continue;\r
 243 \r
 244                       //ESD track cuts\r
 245                       if(fESDtrackCuts) \r
 246                         if(!fESDtrackCuts->AcceptTrack(track)) continue;\r
 247 \r
 248                       // fill QA histograms\r
 249                       Float_t b[2];\r
 250                       Float_t bCov[3];\r
 251                       track->GetImpactParameters(b,bCov);\r
 252                       if (bCov[0]<=0 || bCov[2]<=0) {\r
 253                         AliDebug(1, "Estimated b resolution lower or equal zero!");\r
 254                         bCov[0]=0; bCov[2]=0;\r
 255                       }\r
 256 \r
 257                       fHistClus->Fill(track->GetITSclusters(0),track->GetTPCclusters(0));\r
 258                       fHistDCA->Fill(b[1],b[0]);\r
 259                       fHistPt->Fill(track->Pt());\r
 260                       fHistEta->Fill(track->Eta());\r
 261                       fHistPhi->Fill(track->Phi()*TMath::RadToDeg());\r
 262                       \r
 263                       // fill BF array\r
 264                       array->Add(track);\r
 265 \r
 266                       // fill charge vector\r
 267                       chargeVector.push_back(track->Charge());\r
 268                       chargeVectorShuffle.push_back(track->Charge());\r
 269       \r
 270                       \r
 271                     } //track loop\r
 272                   }//Vz cut\r
 273                 }//Vy cut\r
 274               }//Vx cut\r
 275             }//proper vertex resolution\r
 276           }//proper number of contributors\r
 277         }//vertex object valid\r
 278       }//centrality\r
 279     }//triggered event \r
 280   }//ESD analysis\r
 281   \r
 282 \r
 283   //AOD analysis (vertex and track cuts also here!!!!)\r
 284   else if(gAnalysisLevel == "AOD") {\r
 285     AliAODEvent* gAOD = dynamic_cast<AliAODEvent*>(InputEvent()); // from TaskSE\r
 286     if(!gAOD) {\r
 287       Printf("ERROR: gAOD not available");\r
 288       return;\r
 289     }\r
 290 \r
 291     fHistEventStats->Fill(1); //all events\r
 292     Bool_t isSelected = kTRUE;\r
 293     if(fUseOfflineTrigger)\r
 294       isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();\r
 295     if(isSelected) {\r
 296       fHistEventStats->Fill(2); //triggered events\r
 297 \r
 298                   \r
 299       //Centrality stuff (centrality in AOD header)\r
 300       AliAODHeader *aodHeader = gAOD->GetHeader();\r
 301       Float_t fCentrality     = aodHeader->GetCentralityP()->GetCentralityPercentile("V0M");\r
 302       //cout<< aodHeader->GetCentralityP()->GetCentralityPercentile("V0M")<<" "<<aodHeader->GetCentralityP()->GetCentralityPercentile("CL1")<<" "<<aodHeader->GetCentralityP()->GetCentralityPercentile("TRK")<<endl;\r
 303       // take only events inside centrality class\r
 304       if(fCentrality > fCentralityPercentileMin && fCentrality < fCentralityPercentileMax){\r
 305 \r
 306         // centrality QA (V0M)\r
 307         fHistV0M->Fill(gAOD->GetVZEROData()->GetMTotV0A(), gAOD->GetVZEROData()->GetMTotV0C());\r
 308       \r
 309         const AliAODVertex *vertex = gAOD->GetPrimaryVertex();\r
 310 \r
 311         if(vertex) {\r
 312           Double32_t fCov[6];\r
 313           vertex->GetCovarianceMatrix(fCov);\r
 314                   \r
 315           if(vertex->GetNContributors() > 0) {\r
 316             if(fCov[5] != 0) {\r
 317               fHistEventStats->Fill(3); //events with a proper vertex\r
 318               if(TMath::Abs(vertex->GetX()) < fVxMax) {\r
 319                 if(TMath::Abs(vertex->GetY()) < fVyMax) {\r
 320                   if(TMath::Abs(vertex->GetZ()) < fVzMax) {\r
 321                     fHistEventStats->Fill(4); //analayzed events\r
 322                     fHistVx->Fill(vertex->GetX());\r
 323                     fHistVy->Fill(vertex->GetY());\r
 324                     fHistVz->Fill(vertex->GetZ());\r
 325 \r
 326                     //Printf("There are %d tracks in this event", gAOD->GetNumberOfTracks());\r
 327                     for (Int_t iTracks = 0; iTracks < gAOD->GetNumberOfTracks(); iTracks++) {\r
 328                       AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(gAOD->GetTrack(iTracks));\r
 329                       if (!aodTrack) {\r
 330                         Printf("ERROR: Could not receive track %d", iTracks);\r
 331                         continue;\r
 332                       }\r
 333 \r
 334                       // AOD track cuts\r
 335                       \r
 336                       // For ESD Filter Information: ANALYSIS/macros/AddTaskESDfilter.C\r
 337                       // take only TPC only tracks \r
 338                       fHistTrackStats->Fill(aodTrack->GetFilterMap());\r
 339                       if(!aodTrack->TestFilterBit(128)) continue;\r
 340 \r
 341                       Float_t pt  = aodTrack->Pt();\r
 342                       Float_t eta = aodTrack->Eta();\r
 343 \r
 344                       Float_t DCAxy = aodTrack->DCA();      // this is the DCA from global track (not exactly what is cut on)\r
 345                       Float_t DCAz  = aodTrack->ZAtDCA();   // this is the DCA from global track (not exactly what is cut on)\r
 346                       \r
 347                       \r
 348                       // Kinematics cuts from ESD track cuts\r
 349                       if( pt < fPtMin || pt > fPtMax)      continue;\r
 350                       if( eta < fEtaMin || eta > fEtaMax)  continue;\r
 351 \r
 352                       // Extra DCA cuts (for systematic studies [!= -1])\r
 353                       if( fDCAxyCut != -1 && fDCAxyCut != -1){\r
 354                         if(TMath::Sqrt((DCAxy*DCAxy)/(fDCAxyCut*fDCAxyCut)+(DCAz*DCAz)/(fDCAzCut*fDCAzCut)) > 1 ){\r
 355                           continue;  // 2D cut\r
 356                         }\r
 357                       }\r
 358 \r
 359                       // fill QA histograms\r
 360                       fHistClus->Fill(aodTrack->GetITSNcls(),aodTrack->GetTPCNcls());\r
 361                       fHistDCA->Fill(DCAz,DCAxy);\r
 362                       fHistChi2->Fill(aodTrack->Chi2perNDF());\r
 363                       fHistPt->Fill(pt);\r
 364                       fHistEta->Fill(eta);\r
 365                       fHistPhi->Fill(aodTrack->Phi()*TMath::RadToDeg());\r
 366                       \r
 367                       // fill BF array\r
 368                       array->Add(aodTrack);\r
 369 \r
 370                       // fill charge vector\r
 371                       chargeVector.push_back(aodTrack->Charge());\r
 372                       chargeVectorShuffle.push_back(aodTrack->Charge());\r
 373       \r
 374 \r
 375                     } //track loop\r
 376                   }//Vz cut\r
 377                 }//Vy cut\r
 378               }//Vx cut\r
 379             }//proper vertex resolution\r
 380           }//proper number of contributors\r
 381         }//vertex object valid\r
 382       }//centrality\r
 383     }//triggered event \r
 384   }//AOD analysis\r
 385 \r
 386   //MC analysis\r
 387   else if(gAnalysisLevel == "MC") {\r
 388     \r
 389     AliMCEvent*  mcEvent = MCEvent(); \r
 390     if (!mcEvent) {\r
 391       Printf("ERROR: mcEvent not available");\r
 392       return;\r
 393     }\r
 394     \r
 395     Printf("There are %d tracks in this event", mcEvent->GetNumberOfPrimaries());\r
 396     for (Int_t iTracks = 0; iTracks < mcEvent->GetNumberOfPrimaries(); iTracks++) {\r
 397       AliMCParticle* track = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(iTracks));\r
 398       if (!track) {\r
 399         Printf("ERROR: Could not receive particle %d", iTracks);\r
 400         continue;\r
 401       }\r
 402       array->Add(track);\r
 403 \r
 404 \r
 405       // fill charge vector\r
 406       chargeVector.push_back(track->Charge());\r
 407       chargeVectorShuffle.push_back(track->Charge());\r
 408 \r
 409     } //track loop\r
 410   }//MC analysis\r
 411   \r
 412 \r
 413   // calculate balance function\r
 414   fBalance->CalculateBalance(array);\r
 415 \r
 416 \r
 417 \r
 418   // shuffle charges\r
 419   random_shuffle( chargeVectorShuffle.begin(), chargeVectorShuffle.end() );\r
 420  \r
 421   for(Int_t iArray = 0; iArray < array->GetEntries(); iArray++){\r
 422 \r
 423     // setting the charge in this way only possible for AOD tracks \r
 424     // --> shuffling only for AODs up to now\r
 425     if(gAnalysisLevel == "AOD") {\r
 426       AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(array->At(iArray));\r
 427       if (!aodTrack) {\r
 428         Printf("ERROR: Could not receive track %d", iArray);\r
 429         continue;\r
 430       }\r
 431 \r
 432       aodTrack->SetCharge(chargeVectorShuffle.at(iArray));\r
 433     }\r
 434   }\r
 435         \r
 436   //calculate shuffled balance function\r
 437   fShuffledBalance->CalculateBalance(array);\r
 438 \r
 439   // set back the charges!\r
 440   for(Int_t iArray = 0; iArray < array->GetEntries(); iArray++){\r
 441 \r
 442     // setting the charge in this way only possible for AOD tracks \r
 443     // --> shuffling only for AODs up to now\r
 444     if(gAnalysisLevel == "AOD") {\r
 445       AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(array->At(iArray));\r
 446       if (!aodTrack) {\r
 447         Printf("ERROR: Could not receive track %d", iArray);\r
 448         continue;\r
 449       }\r
 450 \r
 451       aodTrack->SetCharge(chargeVector.at(iArray));\r
 452     }\r
 453   }\r
 454 \r
 455   \r
 456   delete array;\r
 457   \r
 458 }      \r
 459 \r
 460 //________________________________________________________________________\r
 461 void  AliAnalysisTaskBF::FinishTaskOutput(){\r
 462   //Printf("END BF");\r
 463 \r
 464   //fBalance = dynamic_cast<AliBalance*> (GetOutputData(1));\r
 465   if (!fBalance) {\r
 466     Printf("ERROR: fBalance not available");\r
 467     return;\r
 468   }  \r
 469   if (!fShuffledBalance) {\r
 470     Printf("ERROR: fShuffledBalance not available");\r
 471     return;\r
 472   }\r
 473   \r
 474   for(Int_t a = 0; a < ANALYSIS_TYPES; a++){\r
 475     for(Int_t iBin = 1; iBin <= fBalance->GetNumberOfBins(a); iBin++){\r
 476 \r
 477       //Printf("%d %d  ->   %f",a,iBin,fShuffledBalance->GetNpn(a,iBin-1));\r
 478       //Printf("%d %d  ->   %f",a,iBin,fBalance->GetNpn(a,iBin-1));\r
 479 \r
 480       fHistBF[a][0]->SetBinContent(iBin,fBalance->GetNnn(a,iBin-1));\r
 481       fHistBF[a][1]->SetBinContent(iBin,fBalance->GetNpn(a,iBin-1));\r
 482       fHistBF[a][2]->SetBinContent(iBin,fBalance->GetNpp(a,iBin-1));    \r
 483       \r
 484       fHistShuffledBF[a][0]->SetBinContent(iBin,fShuffledBalance->GetNnn(a,iBin-1));\r
 485       fHistShuffledBF[a][1]->SetBinContent(iBin,fShuffledBalance->GetNpn(a,iBin-1));\r
 486       fHistShuffledBF[a][2]->SetBinContent(iBin,fShuffledBalance->GetNpp(a,iBin-1));\r
 487       \r
 488       \r
 489     }\r
 490     fHistN->SetBinContent(1,fBalance->GetNn(a));\r
 491     fHistN->SetBinContent(2,fBalance->GetNp(a));  \r
 492   }\r
 493 \r
 494 }\r
 495 \r
 496 //________________________________________________________________________\r
 497 void AliAnalysisTaskBF::Terminate(Option_t *) {\r
 498   // Draw result to the screen\r
 499   // Called once at the end of the query\r
 500 \r
 501   // not implemented ...\r
 502   \r
 503 }\r