- added analysis task with some global track properties retrieved from AliESDtrack...

- updated macro

diff --git a/HLT/QA/tasks/AliAnalysisTaskHLT.cxx b/HLT/QA/tasks/AliAnalysisTaskHLT.cxx
new file mode 100644 (file)
index 0000000..67191ed
--- /dev/null
+++ b/HLT/QA/tasks/AliAnalysisTaskHLT.cxx
@@ -0,0 +1,502 @@
+// $Id$\r
+\r
+//**************************************************************************\r
+//* This file is property of and copyright by the ALICE HLT Project        *\r
+//* ALICE Experiment at CERN, All rights reserved.                         *\r
+//*                                                                        *\r
+//* Primary Authors: Zhongbao Yin <zbyin@mail.ccnu.edu.cn>,                *\r
+//*                  Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *\r
+//*                  for The ALICE HLT Project.                            *\r
+//*                                                                        *\r
+//* Permission to use, copy, modify and distribute this software and its   *\r
+//* documentation strictly for non-commercial purposes is hereby granted   *\r
+//* without fee, provided that the above copyright notice appears in all   *\r
+//* copies and that both the copyright notice and this permission notice   *\r
+//* appear in the supporting documentation. The authors make no claims     *\r
+//* about the suitability of this software for any purpose. It is          *\r
+//* provided "as is" without express or implied warranty.                  *\r
+//**************************************************************************\r
+\r
+/** @file   AliAnalysisTaskHLT.cxx  \r
+    @author Kalliopi Kanaki\r
+    @date \r
+    @brief\r
+*/\r
+\r
+\r
+#include <iostream>\r
+\r
+#include "TChain.h"\r
+#include "TTree.h"\r
+#include "TH1F.h"\r
+#include "TH2F.h"\r
+#include "TCanvas.h"\r
+#include "TVector3.h"\r
+#include "TString.h"\r
+#include "TObjArray.h"\r
+#include "TFile.h"\r
+\r
+#include "AliESDEvent.h"\r
+#include "AliESDRun.h"\r
+#include "AliESDInputHandler.h"\r
+\r
+#include "AliAnalysisTask.h"\r
+#include "AliAnalysisManager.h"\r
+#include "AliAnalysisTaskHLT.h"\r
+\r
+\r
+ClassImp(AliAnalysisTaskHLT)\r
+\r
+//======================================================================================================\r
+ \r
+  AliAnalysisTaskHLT::AliAnalysisTaskHLT(const char *name)\r
+    :\r
+     AliAnalysisTaskSE(name)\r
+    ,fESDRun(0)\r
+    ,fOutputList(0)\r
+    ,fHistTrigger(0)\r
+    ,fHistHLTTrigger(0)    \r
+    ,fMomentum_off(0)  \r
+    ,fDCA_off(0)       \r
+    ,fNcluster_off(0)  \r
+    ,fdEdx_off(0)      \r
+    ,fdEdx_vs_P_off(0) \r
+    ,fPhi_off(0)       \r
+    ,fTheta_off(0)     \r
+    ,fMult_off(0)      \r
+    ,fXYvertex_off(0)  \r
+    ,fZvertex_off(0)       \r
+    \r
+    ,fMomentum_hlt(0)\r
+    ,fDCA_hlt(0)  \r
+    ,fNcluster_hlt(0)\r
+    ,fdEdx_hlt(0)    \r
+    ,fdEdx_vs_P_hlt(0)\r
+    ,fPhi_hlt(0)     \r
+    ,fTheta_hlt(0)  \r
+    ,fMult_hlt(0)   \r
+    ,fXYvertex_hlt(0)\r
+    ,fZvertex_hlt(0)\r
+    \r
+//     ,fDCA_off_trig(0)\r
+//     ,fNcluster_off_trig(0)\r
+//     \r
+//     ,fDCA_hlt_trig(0)\r
+//     ,fNcluster_hlt_trig(0)\r
+\r
+{\r
+  // Constructor\r
+\r
+  // Define input and output slots here\r
+  // Input slot #0 works with a TChain\r
+  // DefineInput(0, TChain::Class());\r
+  // Output slot #0 writes into a TH1 container\r
+\r
+  DefineOutput(1, TList::Class());\r
+}\r
+\r
+const Float_t AliAnalysisTaskHLT::fgkEtaMin = -0.12;  \r
+const Float_t AliAnalysisTaskHLT::fgkEtaMax =  0.12;  \r
+const Float_t AliAnalysisTaskHLT::fgkPhiMin[5]   = {3.83972, 4.18879, 4.53786, 4.88692, 5.23599};  \r
+const Float_t AliAnalysisTaskHLT::fgkPhiMax[5]   = {4.18879, 4.53786, 4.88692, 5.23599, 5.58505};  \r
+const Float_t AliAnalysisTaskHLT::fgkNormX[5]    = {-0.642788, -0.34202, 0, 0.34202, 0.642788};  \r
+const Float_t AliAnalysisTaskHLT::fgkNormY[5]    = {-0.766044, -0.939693, -1, -0.939693, -0.766044};  \r
+const Float_t AliAnalysisTaskHLT::fgkInitPosX[5] = {-295.682, -157.329, 0, 157.329, 295.682};  \r
+const Float_t AliAnalysisTaskHLT::fgkInitPosY[5] = {-352.38, -432.259, -460, -432.259, -352.38};\r
+\r
+//----------------------------------------------------------------------------------------------------\r
+\r
+void AliAnalysisTaskHLT::UserCreateOutputObjects(){\r
+// Create histograms\r
+\r
+  OpenFile(1);\r
+\r
+  fOutputList = new TList();\r
+  fOutputList->SetName(GetName());\r
+\r
+  /*\r
+  //0 mistriggered, 1 Good triggered, 2, triggered, 3 fake trigger, \r
+  //4 events with offline track, 5 total events processed,\r
+  //6 offline track thru CE, 7 online track to CE\r
+  fHistTrigger = new TH1F("fHistTrigger", "Trigger Status", 8, -0.5, 7.5);\r
+  fHistTrigger->GetXaxis()->SetTitle("");\r
+  fHistTrigger->GetYaxis()->SetTitle("Events");\r
+  fHistTrigger->SetMarkerStyle(kFullCircle);\r
+  fHistTrigger->SetStats(0);\r
+  fHistTrigger->SetFillColor(2);\r
+  //fHistTrigger->SetDrawOption("B TEXT60");\r
+\r
+  //Set bin labels\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(1,"missed");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(2,"triggerWofflTrk");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(3,"triggered");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(4,"triggerWOofflTrk");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(5,"NevWofflTrk");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(6,"Nevt");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(7,"offlTrkThruCE");\r
+  (fHistTrigger->GetXaxis())->SetBinLabel(8,"onlTrkThruCE"); \r
+  */\r
+\r
+  fHistTrigger = new TH1F("fHistTrigger", "CTP trigger counter", 64, 0, 64);\r
+  fHistTrigger->GetXaxis()->SetTitle("");  \r
+  fHistTrigger->GetYaxis()->SetTitle("#Events"); \r
+\r
+  fHistHLTTrigger = new TH1F("fHistHLTTrigger", "HLT CTP trigger counter", 64, 0, 64); \r
+  fHistHLTTrigger->GetXaxis()->SetTitle("");\r
+  fHistHLTTrigger->GetYaxis()->SetTitle("#Events");  \r
+\r
+  \r
+  \r
+  fMomentum_off = new TH1F("fMomentum_off", "momentum (offline)",300, 0., 100);\r
+  fMomentum_hlt = new TH1F("fMomentum_hlt", "momentum (HLT)",    300, 0., 100);\r
+ \r
+  fDCA_off = new TH1F("fDCA_off","DCA to beam line (offline)",250, 0, 250);\r
+  fDCA_hlt = new TH1F("fDCA_hlt","DCA to beam line (HLT)",    250, 0, 250);\r
+ \r
+  fNcluster_off = new TH1F("fNcluster_off","clusters per track (offline)",200, 0, 200);\r
+  fNcluster_hlt = new TH1F("fNcluster_hlt","clusters per track (HLT)",    200, 0, 200);\r
+ \r
+  fdEdx_off = new TH1F("fdEdx_off","energy loss (offline)",500, 0, 500);\r
+  fdEdx_hlt = new TH1F("fdEdx_hlt","energy loss (HLT)",    500, 0, 500);\r
+ \r
+  fdEdx_vs_P_off = new TH2F("fdEdx_vs_P_off","dE/dx vs. momentum (offline)",100, 0., 100., 500, 0., 500.);\r
+  fdEdx_vs_P_hlt = new TH2F("fdEdx_vs_P_hlt","dE/dx vs. momentum (HLT)",    100, 0., 100., 500, 0., 500.);\r
+\r
+  fPhi_off = new TH1F("fPhi_off","azimuthal angle distribution",360,0,360);\r
+  fPhi_hlt = new TH1F("fPhi_hlt","azimuthal angle distribution",360,0,360);\r
+  \r
+  fTheta_off = new TH1F("fTheta_off","polar angle distribution",360,-180,180);\r
+  fTheta_hlt = new TH1F("fTheta_hlt","polar angle distribution",360,-180,180);\r
+  \r
+  fMult_off = new TH1F("fMult_off","track multiplicity (offline)",100,0,100);\r
+  fMult_hlt = new TH1F("fMult_hlt","track multiplicity (HLT)",    100,0,100);\r
+  \r
+  fXYvertex_off = new TH2F("fXYvertex_off","XY primary vertex (offline)",60,-15,15,80,-20,20);\r
+  fXYvertex_hlt = new TH2F("fXYvertex_hlt","XY primary vertex (HLT)",    60,-15,15,80,-20,20);\r
+  \r
+  fZvertex_off = new TH1F("fZvertex_off","Z primary vertex (offline)",80,-20,20);\r
+  fZvertex_hlt = new TH1F("fZvertex_hlt","Z primary vertex (HLT)",    80,-20,20);\r
+ \r
+\r
+//---------------------- add histograms to the output TList ------------------//\r
+\r
+  fOutputList->Add(fHistTrigger);\r
+  fOutputList->Add(fHistHLTTrigger);\r
+\r
+  fOutputList->Add(fMomentum_off);\r
+  fOutputList->Add(fDCA_off);    \r
+  fOutputList->Add(fNcluster_off); \r
+  fOutputList->Add(fdEdx_off);   \r
+  fOutputList->Add(fdEdx_vs_P_off);\r
+  fOutputList->Add(fPhi_off);    \r
+  fOutputList->Add(fTheta_off);    \r
+  fOutputList->Add(fMult_off);   \r
+  fOutputList->Add(fXYvertex_off); \r
+  fOutputList->Add(fZvertex_off);  \r
+  \r
+  fOutputList->Add(fMomentum_hlt); \r
+  fOutputList->Add(fDCA_hlt);    \r
+  fOutputList->Add(fNcluster_hlt); \r
+  fOutputList->Add(fdEdx_hlt);   \r
+  fOutputList->Add(fdEdx_vs_P_hlt);\r
+  fOutputList->Add(fPhi_hlt);    \r
+  fOutputList->Add(fTheta_hlt);    \r
+  fOutputList->Add(fMult_hlt);   \r
+  fOutputList->Add(fXYvertex_hlt); \r
+  fOutputList->Add(fZvertex_hlt);  \r
+  \r
+}\r
+\r
+void AliAnalysisTaskHLT::NotifyRun(){\r
+// This will not work if the active trigger classes change from run to run.\r
+// Then one has to know all trigger classes before processing the data.\r
+\r
+  AliESDEvent *esdOFF = dynamic_cast<AliESDEvent*>(InputEvent());\r
+  TString trgClasses = esdOFF->GetESDRun()->GetActiveTriggerClasses(); \r
+ \r
+  /*\r
+  TObjArray * trgClsArray = trgClasses.Tokenize(" ");\r
+  cout<<trgClsArray->GetEntries()<<endl;\r
+\r
+  if(!fTrgClsArray){\r
+    fTrgClsArray = trgClsArray;\r
+    for(Int_t i = 0; i < fTrgClsArray->GetEntries(); i++){  \r
+      TString str = ((TObjString *)fTrgClsArray->At(i))->GetString();  \r
+      (fHistTrigger->GetXaxis())->SetBinLabel(i+1, str.Data());  \r
+      (fHistHLTTrigger->GetXaxis())->SetBinLabel(i+1, str.Data());  \r
+    }  \r
+  }else{\r
+    for(Int_t i = 0; i < trgClsArray->GetEntries(); i++){\r
+      \r
+    }\r
+  }\r
+  */\r
+\r
+  fTrgClsArray = trgClasses.Tokenize(" ");\r
+  //cout<<fTrgClsArray->GetEntries()<<endl; \r
+    \r
+  for(Int_t i=0; i<fTrgClsArray->GetEntries(); i++){ \r
+      TString str = ((TObjString *)fTrgClsArray->At(i))->GetString(); \r
+      (fHistTrigger->GetXaxis())->SetBinLabel(i+1, str.Data()); \r
+      (fHistHLTTrigger->GetXaxis())->SetBinLabel(i+1, str.Data()); \r
+  }   \r
+  esdOFF = NULL;\r
+}\r
+\r
+void AliAnalysisTaskHLT::UserExec(Option_t *){\r
+\r
+  AliESDEvent *esdOFF = dynamic_cast<AliESDEvent*>(InputEvent());\r
+  \r
+  if(!esdOFF){\r
+      Printf("ERROR: fESD not available");\r
+      return;\r
+  }\r
+  \r
+  AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>(fInputHandler);\r
+  AliESDEvent *esdHLT = NULL;   \r
+  if(esdH) esdHLT = esdH->GetHLTEvent();\r
+    \r
+  if(!esdHLT){\r
+      Printf("ERROR: HLTesd not available");\r
+      return;\r
+  }\r
+\r
+  Double_t bfield = esdOFF->GetMagneticField();\r
+  \r
+  Double_t pos[] = { 0., 0., 0.};\r
+  AliVertex *vtx = new AliVertex(pos, 0., 0);\r
+  \r
+  //Fill CTP Trigger stuff\r
+  //fHistTrigger->Fill(esdOFF->GetTriggerMask());\r
+  \r
+  for(Int_t i=0; i<fTrgClsArray->GetEntries(); i++){\r
+      if((esdOFF->GetFiredTriggerClasses()).Contains(((TObjString *)fTrgClsArray->At(i))->GetString()))  fHistTrigger->Fill(i);\r
+  }\r
+\r
+\r
+\r
+\r
+\r
+  \r
+  fMult_hlt->Fill( esdHLT->GetNumberOfTracks() );\r
+\r
+  //---------------- loop over HLT ESD tree -------------//\r
+  \r
+  for(Int_t i=0; i<esdHLT->GetNumberOfTracks(); i++){ \r
+  \r
+      AliESDtrack *esdtrackHLT = esdHLT->GetTrack(i); \r
+      if(esdtrackHLT){ \r
+         \r
+        fNcluster_hlt->Fill(esdtrackHLT->GetTPCNcls()); \r
+               \r
+        //Double_t dz[2]    = {-999., -999.};   \r
+        //Double_t covar[3] = {0.,0.,0.};               \r
+        //esdtrackHLT->PropagateToDCA(vtx, bfield, 250., dz, covar);  \r
+        //fHistOnlDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1])); // z resolution \r
+         \r
+         fDCA_hlt->Fill( TMath::Abs(esdtrackHLT->GetD(0., 0., bfield)) ); \r
+         fMomentum_hlt->Fill( TMath::Abs(esdtrackHLT->P()) ); \r
+         fdEdx_hlt->Fill( esdtrackHLT->GetTPCsignal() );\r
+         fdEdx_vs_P_hlt->Fill( TMath::Abs(esdtrackHLT->P()), esdtrackHLT->GetTPCsignal() );         \r
+         fPhi_hlt->Fill(esdtrackHLT->Phi()*TMath::RadToDeg());\r
+         fTheta_hlt->Fill(esdtrackHLT->Theta()*TMath::RadToDeg());\r
+        \r
+        fXYvertex_hlt->Fill( esdHLT->GetPrimaryVertex()->GetX(), esdHLT->GetPrimaryVertex()->GetY() );\r
+        fZvertex_hlt->Fill( esdHLT->GetPrimaryVertex()->GetZ() );\r
+      } \r
+  } \r
+  \r
+  fMult_off->Fill( esdOFF->GetNumberOfTracks() );\r
+  \r
+  //----------------- loop over OFFLINE ESD tree ----------------//\r
+  \r
+  for(Int_t i=0; i<esdOFF->GetNumberOfTracks(); i++){ \r
+     \r
+      AliESDtrack *esdtrackOFF = esdOFF->GetTrack(i); \r
+      if(esdtrackOFF){ \r
+         \r
+        fNcluster_off->Fill(esdtrackOFF->GetTPCNcls()); \r
+               \r
+        //Double_t dz[2]    = {-999., -999.};   \r
+        //Double_t covar[3] = {0.,0.,0.};               \r
+        //esdtrackOFF->PropagateToDCA(vtx, bfield, 250., dz, covar);  \r
+        //fHistOfflDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1])); // z resolution \r
+         \r
+         fDCA_off->Fill( TMath::Abs(esdtrackOFF->GetD(0., 0., bfield)) ); \r
+         fMomentum_off->Fill( TMath::Abs(esdtrackOFF->P()) ); \r
+         fdEdx_off->Fill( esdtrackOFF->GetTPCsignal() );\r
+         fdEdx_vs_P_off->Fill( TMath::Abs(esdtrackOFF->P()), esdtrackOFF->GetTPCsignal() );         \r
+         fPhi_off->Fill(esdtrackOFF->Phi()*TMath::RadToDeg());\r
+         fTheta_off->Fill(esdtrackOFF->Theta()*TMath::RadToDeg());\r
+        \r
+        fXYvertex_off->Fill( esdOFF->GetPrimaryVertex()->GetX(), esdOFF->GetPrimaryVertex()->GetY() );\r
+        fZvertex_off->Fill( esdOFF->GetPrimaryVertex()->GetZ() );\r
+      } \r
+     \r
+//       AliESDtrack *esdTrk = esdOFF->GetTrack(i);      \r
+//       Double_t dz[2] = {-999., -999.};  \r
+//       Double_t covar[3] = {0};\r
+//       esdTrk->PropagateToDCA(vtx, bfield, 250., dz, covar);\r
+//       fHistOfflDZTrig->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1]));\r
+//    \r
+//       fHistOfflDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1]));\r
+// \r
+//       fHistOfflTrkDCATrig->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield)));\r
+//       fDCA_off->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield))); \r
+// \r
+//       if(esdTrk->GetTPCNcls()>0){\r
+//              fHistOfflTrkNclsTrig->Fill(esdTrk->GetTPCNcls()); \r
+//              fHistOfflTrkNcls->Fill(esdTrk->GetTPCNcls());\r
+//       }\r
+// \r
+//       fHistOfflTrkPTrig->Fill(TMath::Abs(esdTrk->P()));\r
+//       fHistOfflTrkP->Fill(TMath::Abs(esdTrk->P()));\r
+//       fHistOffldEdx->Fill( esdTrk->GetTPCsignal());\r
+//       fHistOffldEdxVsP->Fill(TMath::Abs(esdTrk->P()), esdTrk->GetTPCsignal());\r
+  }\r
+\r
+\r
+//   if(esdHLT->IsHLTTriggerFired()){\r
+//      \r
+//      for(Int_t i=0; i<fTrgClsArray->GetEntries(); i++){ \r
+//          if((esdOFF->GetFiredTriggerClasses()).Contains(((TObjString *)fTrgClsArray->At(i))->GetString())) fHistHLTTrigger->Fill(i);\r
+//      } \r
+//      \r
+//      for(Int_t i=0; i<esdHLT->GetNumberOfTracks(); i++){\r
+//          AliESDtrack * esdtrackHLT = esdHLT->GetTrack(i);\r
+//         \r
+//       if(esdtrackHLT->GetTPCNcls()>0){\r
+//      fNcluster_hlt->Fill(esdtrackHLT->GetTPCNcls());\r
+//      fNcluster_hlt_trig->Fill(esdtrackHLT->GetTPCNcls());\r
+//       }\r
+//     \r
+//       Double_t dz[2] = {-999., -999.};  \r
+//       Double_t covar[3] = {0.};\r
+//       \r
+//       esdtrackHLT->PropagateToDCA(vtx, bfield, 250., dz, covar); \r
+//       fHistOnlDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1])); \r
+//       \r
+//       if(esdtrackHLT){\r
+//      fDCA_hlt->Fill(TMath::Abs(esdtrackHLT->GetD(0., 0., bfield)));\r
+//      fMomentum_hlt->Fill(TMath::Abs(esdtrackHLT->P()));\r
+//      fdEdx_hlt->Fill(esdtrackHLT->GetTPCsignal());\r
+//      fdEdx_vs_P_hlt->Fill(TMath::Abs(esdtrackHLT->P()), esdtrackHLT->GetTPCsignal()); \r
+//      fDCA_hlt_trig->Fill(TMath::Abs(esdtrackHLT->GetD(0., 0., bfield)));\r
+//       }\r
+//      }\r
+//   } else {\r
+//     for(Int_t i=0; i<esdHLT->GetNumberOfTracks(); i++){ \r
+//     \r
+//         AliESDtrack *esdtrackHLT = esdHLT->GetTrack(i); \r
+//         if(esdtrackHLT->GetTPCNcls()>0) fNcluster_hlt->Fill(esdtrackHLT->GetTPCNcls()); \r
+//                   \r
+//         Double_t dz[2] = {-999., -999.};   \r
+//         Double_t covar[3] = {0.}; \r
+//       \r
+//         esdtrackHLT->PropagateToDCA(vtx, bfield, 250., dz, covar);  \r
+//         fHistOnlDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1]));  \r
+//       \r
+//         if(esdtrackHLT){ \r
+//        fDCA_hlt->Fill(TMath::Abs(esdtrackHLT->GetD(0., 0., bfield))); \r
+//        fMomentum_hlt->Fill(TMath::Abs(esdtrackHLT->P())); \r
+//        fdEdx_hlt->Fill( esdtrackHLT->GetTPCsignal());\r
+//        fdEdx_vs_P_hlt->Fill(TMath::Abs(esdtrackHLT->P()), esdtrackHLT->GetTPCsignal());\r
+//        \r
+//        fPhi_hlt->Fill(esdtrackHLT->Phi()*TMath::RadToDeg());\r
+//        fTheta_hlt->Fill(esdtrackHLT->Theta()*TMath::RadToDeg());\r
+//         } \r
+//     } \r
+//   }\r
+\r
+\r
+//   if(esdHLT->IsHLTTriggerFired()){\r
+// \r
+//      for(Int_t i=0; i<esdOFF->GetNumberOfTracks(); i++){ \r
+//         \r
+//      AliESDtrack *esdTrk = esdOFF->GetTrack(i);      \r
+//          Double_t dz[2] = {-999., -999.};  \r
+//          Double_t covar[3] = {0};\r
+//          esdTrk->PropagateToDCA(vtx, bfield, 250., dz, covar);\r
+//          fHistOfflDZTrig->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1]));\r
+//       \r
+//          fHistOfflDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1]));\r
+//       \r
+//          /*\r
+//          Double_t pnt[3] = {0., 0., 0.};\r
+//          Double_t norm[3] = {0., 0., 1.};\r
+//          if(esdTrk->Intersect(pnt, norm, bfield)){\r
+//                if(TMath::Sqrt(pnt[0]*pnt[0]+pnt[1]*pnt[1]) < 250) {\r
+//                  fNtracksThruZ0++;\r
+//                  fNtracksThruZ0Trig++;\r
+//                  fHistTrigger->Fill(6., 1);\r
+//                  fHistTrigger->Fill(7., 1);\r
+//                }\r
+//          }\r
+//          */\r
+// \r
+//          fHistOfflTrkDCATrig->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield)));\r
+//          fDCA_off->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield))); \r
+// \r
+//          if(esdTrk->GetTPCNcls()>0){\r
+//         fHistOfflTrkNclsTrig->Fill(esdTrk->GetTPCNcls()); \r
+//         fHistOfflTrkNcls->Fill(esdTrk->GetTPCNcls());\r
+//          }\r
+// \r
+//          fHistOfflTrkPTrig->Fill(TMath::Abs(esdTrk->P()));\r
+//          fHistOfflTrkP->Fill(TMath::Abs(esdTrk->P()));\r
+//          fHistOffldEdx->Fill( esdTrk->GetTPCsignal());\r
+//          fHistOffldEdxVsP->Fill(TMath::Abs(esdTrk->P()), esdTrk->GetTPCsignal());\r
+//      }\r
+//   } else {\r
+// \r
+//     for(Int_t i=0; i<esdOFF->GetNumberOfTracks(); i++){ \r
+//       \r
+//         AliESDtrack * esdTrk = esdOFF->GetTrack(i); \r
+//         Double_t dz[2] = {0};  \r
+//         Double_t covar[3] = {0};\r
+//         esdTrk->PropagateToDCA(vtx, bfield, 250., dz, covar); \r
+//         fHistOfflDZNoTrig->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1])); \r
+// \r
+//         fHistOfflDZ->Fill(TMath::Abs(dz[0]), TMath::Abs(dz[1]));\r
+//         \r
+//         fHistOfflTrkDCANoTrig->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield)));\r
+//       \r
+//         if(esdTrk->GetTPCNcls()>0) fHistOfflTrkNclsNoTrig->Fill(esdTrk->GetTPCNcls()); \r
+//       \r
+//         if(esdTrk->GetTPCNcls()>=60) fHistOfflTrkDCANoTrigNclsCut1->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield)));\r
+//         else fHistOfflTrkDCANoTrigNclsCut2->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield)));\r
+//       \r
+//         fDCA_off->Fill(TMath::Abs(esdTrk->GetD(0., 0., bfield)));\r
+//         fHistOfflTrkNcls->Fill(esdTrk->GetTPCNcls());\r
+//       \r
+//         fHistOfflTrkPNoTrig->Fill(TMath::Abs(esdTrk->P()));\r
+//         fHistOfflTrkP->Fill(TMath::Abs(esdTrk->P()));\r
+//         fHistOffldEdx->Fill( esdTrk->GetTPCsignal());\r
+//         fHistOffldEdxVsP->Fill(TMath::Abs(esdTrk->P()), esdTrk->GetTPCsignal());\r
+//     \r
+//     fPhi_off->Fill(esdTrk->Phi()*TMath::RadToDeg());\r
+//     fTheta_off->Fill(esdTrk->Theta()*TMath::RadToDeg());\r
+//     }       \r
+//   }\r
+\r
+  fNevt++;\r
+  delete vtx;\r
+\r
+  // Post output data.\r
+  PostData(1, fOutputList);\r
+}\r
+\r
+void AliAnalysisTaskHLT::Terminate(Option_t *){\r
+  /*\r
+  Printf("Number of tracks thru CE: %d", fNtracksThruZ0);\r
+  Printf("Number of tracks thru CE from triggered events: %d", \r
+        fNtracksThruZ0Trig);\r
+  */\r
+\r
+  // Draw result to the screen\r
+  // Called once at the end of the query\r
+\r
+  //  TCanvas *c1 = new TCanvas("AliAnalysisTaskHLT","Trigger",10,10,510,510);\r
+  //fHistTrigger->DrawCopy("E");\r
+  \r
+}\r

diff --git a/HLT/QA/tasks/AliAnalysisTaskHLT.h b/HLT/QA/tasks/AliAnalysisTaskHLT.h
new file mode 100644 (file)
index 0000000..46ec500
--- /dev/null
+++ b/HLT/QA/tasks/AliAnalysisTaskHLT.h
@@ -0,0 +1,115 @@
+// $Id$\r
+\r
+#ifndef ALIANALYSISTASKHLT_H\r
+#define ALIANALYSISTASKHLT_H\r
+\r
+//* This file is property of and copyright by the ALICE HLT Project *\r
+//* ALICE Experiment at CERN, All rights reserved.                  *\r
+//* See cxx source for full Copyright notice                        *\r
+\r
+/** @file AliAnalysisTaskHLT.h\r
+    @author Kalliopi Kanaki\r
+    @date   \r
+    @brief An analysis task to compare the offline and HLT esd trees\r
+*/\r
+\r
+// forward declarations\r
+class TH1F;\r
+class TH2F;\r
+class TList;\r
+class AliESDEvent;\r
+class AliESDtrack;\r
+class AliESDRun;\r
+class TObjArray;\r
+\r
+#include "AliAnalysisTaskSE.h"\r
+\r
+class AliAnalysisTaskHLT : public AliAnalysisTaskSE {\r
+ \r
+  public:  \r
+    AliAnalysisTaskHLT(const char *name);\r
+    virtual ~AliAnalysisTaskHLT() {}\r
+    virtual void  UserCreateOutputObjects();\r
+    virtual void  UserExec(Option_t *option);\r
+    virtual void  Terminate(Option_t *);\r
+    virtual void  NotifyRun();\r
+\r
+ private:\r
+\r
+    /** copy constructor */\r
+    AliAnalysisTaskHLT(const AliAnalysisTaskHLT&); \r
+    /** assignment operator */\r
+    AliAnalysisTaskHLT& operator=(const AliAnalysisTaskHLT&); \r
+\r
+    AliESDRun *fESDRun;\r
+    TList *fOutputList;\r
+\r
+    TH1F *fHistTrigger, *fHistHLTTrigger; //! trigger counters \r
+       \r
+    TH1F *fMomentum_off;   //! momentum     \r
+    TH1F *fDCA_off;        //! track DCA to beam line  \r
+    TH1F *fNcluster_off;   //! #clusters per track\r
+    TH1F *fdEdx_off;       //! TPC signal (offline)\r
+    TH2F *fdEdx_vs_P_off;  //! dE/dx versus momentum for offline TPC tracks\r
+    TH1F *fPhi_off;        //! azimuthal angle distribution\r
+    TH1F *fTheta_off;      //! polar angle distribution\r
+    TH1F *fMult_off;       //! track multiplicity of the event\r
+    TH2F *fXYvertex_off;   //! XY primary vertex distribution\r
+    TH1F *fZvertex_off;    //! Z primary vertex distribution\r
+    \r
+    TH1F  *fMomentum_hlt; \r
+    TH1F  *fDCA_hlt;     \r
+    TH1F  *fNcluster_hlt; \r
+    TH1F  *fdEdx_hlt;    \r
+    TH2F  *fdEdx_vs_P_hlt;\r
+    TH1F  *fPhi_hlt;     \r
+    TH1F  *fTheta_hlt;    \r
+    TH1F  *fMult_hlt;    \r
+    TH2F  *fXYvertex_hlt; \r
+    TH1F  *fZvertex_hlt;  \r
+   \r
+//     TH1F *fDCA_off_trig,      *fDCA_hlt_trig;      //! track DCA to beam line for triggered events\r
+//     TH1F *fNcluster_off_trig, *fNcluster_hlt_trig; //! #clusters per track for triggered events\r
+   \r
+   \r
+   \r
+   \r
+//     TH1F *fHistOfflTrkDCANoTrigNclsCut1; //! with cut on #clusters>=60\r
+//     TH1F *fHistOfflTrkDCANoTrigNclsCut2; //! with cut on #clusters<60\r
+//     \r
+//     TH1F *fHistOfflResPtInv; //! resolution on 1/pt for offline tracks\r
+//     TH1F *fHistOnlResPtInv; //! resoltion on 1/pt for online tracks\r
+// \r
+//     TH1F *fHistOffldZ;  //! resolution on z \r
+//     TH1F *fHistOnldZ;   //! resolution on z \r
+// \r
+//     TH1F *fHistOffldX; //! resolution on r \r
+//     TH1F *fHistOnldX;  //! resolution on r \r
+//     \r
+//     TH1F *fHistOfflPhi;  //! resolution on azimuthal angle \r
+//     TH1F *fHistOnlPhi;  //! resolution on azimuthal angle \r
+// \r
+//     TH1F *fHistOfflTheta; //! resolution on polar angle \r
+//     TH1F *fHistOnlTheta; //! resolution on polar angle \r
+// \r
+//     TH2F *fHistOnlDZ;  //! online trigger tracks distance to beam and Z to IP\r
+//     TH2F *fHistOfflDZ; //! offline tracks distance to beam and Z to IP\r
+//     TH2F *fHistOfflDZTrig; //!\r
+//     TH2F *fHistOfflDZNoTrig; //!\r
+\r
+    Int_t fNevt;\r
+    TObjArray *fTrgClsArray;\r
+\r
+    static const Float_t fgkPhiMin[5];\r
+    static const Float_t fgkPhiMax[5];\r
+    static const Float_t fgkEtaMin;\r
+    static const Float_t fgkEtaMax;\r
+    static const Float_t fgkNormX[5];\r
+    static const Float_t fgkNormY[5];\r
+    static const Float_t fgkInitPosX[5];\r
+    static const Float_t fgkInitPosY[5];\r
+\r
+    ClassDef(AliAnalysisTaskHLT, 0);\r
+};\r
+\r
+#endif\r

diff --git a/HLT/QA/tasks/macros/compare-HLT-offline-local.C b/HLT/QA/tasks/macros/compare-HLT-offline-local.C
index e6c6649ab3ec8982af2a458ab601bedf443bd01d..7d5f9f54e128573a807560aecdc3cd27dc48bcf9 100644 (file)
--- a/HLT/QA/tasks/macros/compare-HLT-offline-local.C
+++ b/HLT/QA/tasks/macros/compare-HLT-offline-local.C
@@ -40,7 +40,7 @@ void compare_HLT_offline_local(const char* detectorTask="all"){
   gROOT->ProcessLine(".include $ALICE_ROOT/include");
 
   
-  Bool_t bAll=kFALSE, bTPC=kFALSE, bPHOS=kFALSE, bITS=kFALSE;
+  Bool_t bAll=kFALSE, bTPC=kFALSE, bPHOS=kFALSE, bITS=kFALSE, bGLOBAL=kFALSE;
  
   TString allArgs = detectorTask;
   TString argument;
@@ -54,23 +54,25 @@ void compare_HLT_offline_local(const char* detectorTask="all"){
          if(argument.CompareTo("tpc", TString::kIgnoreCase)==0){
            bTPC = kTRUE;
            continue;
-         } 
-       
+         }        
          if(argument.CompareTo("phos", TString::kIgnoreCase)==0){
            bPHOS = kTRUE;
            continue;
-         }
-         
+         }         
         if(argument.CompareTo("its", TString::kIgnoreCase)==0){
            bITS = kTRUE;
            continue;
-         }
-        
+         }     
+        if(argument.CompareTo("global", TString::kIgnoreCase)==0){
+           bGLOBAL = kTRUE;
+           continue;
+         }        
         if(argument.CompareTo("all",TString::kIgnoreCase)==0){
-           bTPC  = kTRUE;
-           bPHOS = kTRUE;
-           bITS  = kTRUE;
-           bAll  = kTRUE;
+           bTPC    = kTRUE;
+           bPHOS   = kTRUE;
+           bITS    = kTRUE;
+           bGLOBAL = kTRUE;
+           bAll    = kTRUE;
            continue;
          }
          else break;
@@ -79,9 +81,10 @@ void compare_HLT_offline_local(const char* detectorTask="all"){
     
   
   //-------------- Compile the analysis tasks ---------- //
-  if(bTPC)  gROOT->LoadMacro("AliAnalysisTaskHLTTPC.cxx+"); 
-  if(bPHOS) gROOT->LoadMacro("AliAnalysisTaskHLTPHOS.cxx+"); 
-  if(bITS)  gROOT->LoadMacro("AliAnalysisTaskHLTITS.cxx+");
+  if(bTPC)    gROOT->LoadMacro("AliAnalysisTaskHLTTPC.cxx+"); 
+  if(bPHOS)   gROOT->LoadMacro("AliAnalysisTaskHLTPHOS.cxx+"); 
+  if(bITS)    gROOT->LoadMacro("AliAnalysisTaskHLTITS.cxx+");
+  if(bGLOBAL) gROOT->LoadMacro("AliAnalysisTaskHLT.cxx+");
 
   
   AliTagAnalysis *TagAna = new AliTagAnalysis("ESD"); 
@@ -151,6 +154,14 @@ void compare_HLT_offline_local(const char* detectorTask="all"){
      mgr->ConnectInput(taskITS,0,mgr->GetCommonInputContainer());
      mgr->ConnectOutput(taskITS,1,coutput3);
   }
+ 
+  if(bGLOBAL){
+     AliAnalysisTaskHLT *taskGLOBAL = new AliAnalysisTaskHLT("offhlt_comparison_GLOBAL");
+     mgr->AddTask(taskGLOBAL);
+     AliAnalysisDataContainer *coutput4 =  mgr->CreateContainer("global_histograms",TList::Class(), AliAnalysisManager::kOutputContainer, "HLT-OFFLINE-GLOBAL-comparison.root");  
+     mgr->ConnectInput(taskGLOBAL,0,mgr->GetCommonInputContainer());
+     mgr->ConnectOutput(taskGLOBAL,1,coutput4);
+  }
   
   if (!mgr->InitAnalysis()) return;
   mgr->PrintStatus();