fixing coding violations moved event shape calculation to helper task
authorkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Oct 2009 12:08:12 +0000 (12:08 +0000)
committerkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Oct 2009 12:08:12 +0000 (12:08 +0000)
PWG4/JetTasks/AliAnalysisHelperJetTasks.cxx
PWG4/JetTasks/AliAnalysisHelperJetTasks.h
PWG4/JetTasks/AliAnalysisTaskJetCorrections.cxx
PWG4/JetTasks/AliAnalysisTaskJetCorrections.h
PWG4/JetTasks/AliAnalysisTaskThreeJets.cxx
PWG4/JetTasks/AliAnalysisTaskThreeJets.h

index 45acfc2..6dea29c 100644 (file)
@@ -18,7 +18,9 @@
 #include <fstream>
 #include <iostream>
 #include "AliAnalysisHelperJetTasks.h"
-
+#include "TMatrixDSym.h"
+#include "TMatrixDSymEigen.h"
+#include "TVector.h"
 
 ClassImp(AliAnalysisHelperJetTasks)
 
@@ -371,3 +373,172 @@ Bool_t AliAnalysisHelperJetTasks::PythiaInfoFromFile(const char* currFile,Float_
   }
   return kTRUE;
 }
+
+
+Bool_t AliAnalysisHelperJetTasks::GetThrustAxis(TVector3 &n01, TVector3 * pTrack, const Int_t &nTracks)
+{
+  //
+  // fetch the thrust axis
+  // sona.pochybova@cern.ch
+
+  const Int_t kTracks = 1000;
+  if(nTracks>kTracks)return kFALSE;
+
+  TVector3 psum;
+  Double_t psum1 = 0;
+  Double_t psum2 = 0;
+  Double_t thrust[kTracks];
+  Double_t th = -3;
+  Double_t tpom = -1;
+  Int_t j = 0;
+
+  
+  //  for(Int_t j = 0; j < nTracks; j++)
+  while(TMath::Abs(th-tpom) > 10e-7 && j < nTracks)
+    {
+      th = tpom;
+      psum.SetXYZ(0., 0., 0.);
+      psum1 = 0;
+      psum2 = 0;
+      for(Int_t i = 0; i < nTracks; i++)
+       {
+         psum1 += (TMath::Abs(n01.Dot(pTrack[i])));
+         psum2 += pTrack[i].Mag();
+         
+         if (n01.Dot(pTrack[i]) > 0) psum += pTrack[i];
+         if (n01.Dot(pTrack[i]) < 0) psum -= pTrack[i];
+       }
+      
+      thrust[j] = psum1/psum2;
+      
+      //      if(th == thrust[j]) 
+      //       break;
+      
+      tpom = thrust[j];
+      
+      n01 = psum.Unit();
+      j++;
+    }
+  return kTRUE;
+}
+
+//___________________________________________________________________________________________________________
+
+Bool_t AliAnalysisHelperJetTasks::GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes)
+{       
+  // ***
+  // Event shape calculation
+  // sona.pochybova@cern.ch
+
+  const Int_t kTracks = 1000;
+  if(nTracks>kTracks)return kFALSE;
+
+  TVector3 psum;
+  TVector3 pTrackPerp[kTracks];
+  Double_t psum1 = 0;
+  Double_t psum2 = 0;
+  Double_t thrust[kTracks];
+  Double_t th = -3;
+  Double_t tpom = -1;
+
+  //Sphericity calculation
+  TMatrixDSym m(3);
+  Double_t s00 = 0;
+  Double_t s01 = 0;
+  Double_t s02 = 0;
+  
+  Double_t s10 = 0;
+  Double_t s11 = 0;
+  Double_t s12 = 0;
+  
+  Double_t s20 = 0;
+  Double_t s21 = 0;
+  Double_t s22 = 0;
+  
+  Double_t ptot = 0;
+  
+  Double_t c = -10;
+
+//
+//loop for thrust calculation  
+//
+  Int_t k = 0;
+  while(TMath::Abs(th-tpom) > 10e-7 && k < nTracks)
+    {  
+      th = tpom;
+      psum.SetXYZ(0., 0., 0.);
+      psum1 = 0;
+      psum2 = 0;
+      for(Int_t i = 0; i < nTracks; i++)
+       {
+         pTrackPerp[i].SetXYZ(pTrack[i].X(), pTrack[i].Y(), 0);
+
+         psum1 += (TMath::Abs(n01.Dot(pTrackPerp[i])));
+         psum2 += pTrackPerp[i].Mag();
+
+         if (n01.Dot(pTrackPerp[i]) > 0) psum += pTrackPerp[i];
+         if (n01.Dot(pTrackPerp[i]) < 0) psum -= pTrackPerp[i];
+       }
+      
+      thrust[k] = psum1/psum2;
+      
+      tpom = thrust[k];
+      n01 = psum.Unit();
+      k++;
+//      Printf("========== %d +++ th :: %f, tpom :: %f=============\n", k, th, tpom);
+    }
+
+  eventShapes[0] = th;
+
+//
+//other event shapes variables
+//
+  for(Int_t j = 0; j < nTracks; j++)
+    {  
+      s00 = s00 + (pTrack[j].Px()*pTrack[j].Px())/pTrack[j].Mag();
+      s01 = s01 + (pTrack[j].Px()*pTrack[j].Py())/pTrack[j].Mag();
+      s02 = s02 + (pTrack[j].Px()*pTrack[j].Pz())/pTrack[j].Mag();
+      
+      s10 = s10 + (pTrack[j].Py()*pTrack[j].Px())/pTrack[j].Mag();
+      s11 = s11 + (pTrack[j].Py()*pTrack[j].Py())/pTrack[j].Mag();
+      s12 = s12 + (pTrack[j].Py()*pTrack[j].Pz())/pTrack[j].Mag();
+      
+      s20 = s20 + (pTrack[j].Pz()*pTrack[j].Px())/pTrack[j].Mag();
+      s21 = s21 + (pTrack[j].Pz()*pTrack[j].Py())/pTrack[j].Mag();
+      s22 = s22 + (pTrack[j].Pz()*pTrack[j].Pz())/pTrack[j].Mag();
+      
+      ptot += pTrack[j].Mag();
+    }
+
+  if(ptot > 0.)
+    {
+      m(0,0) = s00/ptot;
+      m(0,1) = s01/ptot;
+      m(0,2) = s02/ptot;
+
+      m(1,0) = s10/ptot;
+      m(1,1) = s11/ptot;
+      m(1,2) = s12/ptot;
+
+      m(2,0) = s20/ptot;
+      m(2,1) = s21/ptot;
+      m(2,2) = s22/ptot;
+
+      TMatrixDSymEigen eigen(m);
+      TVectorD eigenVal = eigen.GetEigenValues();
+
+      Double_t sphericity = (3/2)*(eigenVal(2)+eigenVal(1));
+      eventShapes[1] = sphericity;
+
+      Double_t aplanarity = (3/2)*(eigenVal(2));
+      eventShapes[2] = aplanarity;
+
+      c = 3*(eigenVal(0)*eigenVal(1)+eigenVal(0)*eigenVal(2)+eigenVal(1)*eigenVal(2));
+      eventShapes[3] = c;
+    }
+  return kTRUE;
+}
+  
+
+
+ //__________________________________________________________________________________________________________________________
index 1132410..e73de68 100644 (file)
@@ -1,12 +1,12 @@
 #ifndef  ALIANALYSISHELPERJETTASKS_H
 #define  ALIANALYSISHELPERJETTASKS_H
-
-
 #include "TObject.h"
+
 class AliMCEvent;
 class AliAODJet;
 class TString;
 class AliGenPythiaEventHeader;
+class TVector3;
 
 // Helper Class that contains a lot of usefull static functions (i.e. for Flavor selection.
 
@@ -27,8 +27,8 @@ class AliAnalysisHelperJetTasks : public TObject {
 
   static void MergeOutput(char* cFiles, char* cList = "pwg4spec"); // Merges the files in the input text file  needs the two histograms fh1PtHard_Trials, fh1Xsec and the name of the input list
   static Bool_t PythiaInfoFromFile(const char* currFile,Float_t &fXsec,Float_t &fTrials);// get the cross section and the trails either from pyxsec.root or from pysec_hists.root
-
-  
+  static Bool_t GetThrustAxis(TVector3 &n01, TVector3 * pTrack, const Int_t &nTracks);
+  static Bool_t GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes);
   enum {kMaxJets = 6}; //  needed for array size not to fragemnt memory on the heap by many new/delete 
   private:
   
index 67c11dd..ce6a721 100644 (file)
@@ -1,6 +1,6 @@
 // **************************************
 // Task used for estimating a charged to neutral correction
-// 
+// sona.pochybova@cern.ch
 // *******************************************
 
 
index 226068e..7191fe4 100644 (file)
@@ -73,52 +73,51 @@ class AliAnalysisTaskJetCorrections : public AliAnalysisTaskSE
   Double_t fR; // radius\r
   TList * fList; // output list\r
  \r
-  Int_t fGlobVar; //\r
-  Double_t fXsection; //\r
-\r
-\r
-  TH1F * fhEGen; //\r
-  TH1F * fhERec; //\r
-  TH1F * fhEGenRest; //\r
-  TH1F * fhERecRest; //\r
-  TH1F * fhEsumGenRest; //\r
-  TH1F * fhEsumRecRest; //\r
-\r
-  TH2F * fhE2vsE1Gen; //\r
-  TH2F * fhE2vsE1Rec; //\r
-  TH2F * fhE2E1vsEsumGen; //\r
-  TH2F * fhE2E1vsEsumRec; //\r
-  TH2F * fhE2E1vsE1Gen; //\r
-  TH2F * fhE2E1vsE1Rec; //\r
-  TH2F * fhE2E1vsdPhiGen; //\r
-  TH2F * fhE2E1vsdPhiRec; //\r
-\r
-  TH2F * fhTrackBalance2; //\r
-  TH2F * fhTrackBalance3; //\r
-\r
-  TH2F * fhEt1Et22; //\r
-  TH2F * fhEt1Et23; //\r
-\r
-  TProfile * fhECorrJet10[3]; //\r
-  TProfile * fhECorrJet05[3]; //\r
-  TProfile * fhECorrJet01[3]; //\r
-  TProfile * fhECorrJet001[3]; //\r
+  Int_t fGlobVar; // switch enabling checking out just one event\r
+  Double_t fXsection; // cross-section \r
+\r
+\r
+  TH1F * fhEGen; // generated energy histogram\r
+  TH1F * fhERec; // reconstructed energy histogram\r
+  TH1F * fhEGenRest; // generated energy in the rest frame of three-jet events\r
+  TH1F * fhERecRest; // generated energy in the rest frame of three-jet events\r
+  TH1F * fhEsumGenRest; //generated summed energy in the rest frame of three-jet events\r
+  TH1F * fhEsumRecRest; // reconstructed summed energy in the rest frame of three-jet events\r
+\r
+  TH2F * fhE2vsE1Gen; // leading vs next-to leading jet energy, generated\r
+  TH2F * fhE2vsE1Rec; // leading vs next-to leading jet energy, reconstruted\r
+  TH2F * fhE2E1vsEsumGen; // E2,E1 diference vs. summed energy, generated\r
+  TH2F * fhE2E1vsEsumRec; // E2, E1 difference vs summed jet energy, reconstructed\r
+  TH2F * fhE2E1vsE1Gen; // E2, E1 difference vs E1, generated\r
+  TH2F * fhE2E1vsE1Rec; // E2, E1 diference vs E1, reeconstructed\r
+  TH2F * fhE2E1vsdPhiGen; // E2, E1 difference vs dPhi, generated\r
+  TH2F * fhE2E1vsdPhiRec; // E2, E1 difference vs dPhi, reconstrted\r
+\r
+  TH2F * fhTrackBalance2; // track balance in 2-jet events\r
+  TH2F * fhTrackBalance3; // track balance in 3-jet events\r
+\r
+  TH2F * fhEt1Et22; // Et1,2 in back-to-back cones in 2-jet events\r
+  TH2F * fhEt1Et23; // Et1,2 in back-to-back cones in 3-jet events\r
+\r
+  TProfile * fhECorrJet10[3]; // corr. factor for jets matched within dR = 1.\r
+  TProfile * fhECorrJet05[3]; // corr. factor for jets matched within dR = .5\r
+  TProfile * fhECorrJet01[3]; // corr. factor for jets matched within dR = .1\r
+  TProfile * fhECorrJet001[3]; // corr. factor for jets matched within dR = .01\r
   \r
-  TProfile * fhdEvsErec10[3]; //\r
-  TProfile * fhdEvsErec05[3]; //\r
-  TProfile * fhdEvsErec01[3]; //\r
-  TProfile * fhdEvsErec001[3]; //\r
-\r
-  TH2F * fhdPhidEta10[3]; //\r
-  TH2F * fhdPhidEta05[3]; //\r
-  TH2F * fhdPhidEta01[3]; //\r
-  TH2F * fhdPhidEta001[3]; //\r
-\r
-  TH2F * fhdPhidEtaPt10[3]; //\r
-  TH2F * fhdPhidEtaPt05[3]; //\r
-  TH2F * fhdPhidEtaPt01[3]; //\r
-  TH2F * fhdPhidEtaPt001[3]; //\r
-\r
+  TProfile * fhdEvsErec10[3]; // energy difference vs rec. energy, dR = 1.\r
+  TProfile * fhdEvsErec05[3]; // energy difference vs rec. energy, dR = .5\r
+  TProfile * fhdEvsErec01[3]; // energy difference vs rec. energy, dR = .1\r
+  TProfile * fhdEvsErec001[3]; // energy difference vs rec. energy, dR = .01\r
+\r
+  TH2F * fhdPhidEta10[3]; // dPhi vs dEta of particles, dR = 1.\r
+  TH2F * fhdPhidEta05[3]; // dPhi vs dEta of particles, dR = .5\r
+  TH2F * fhdPhidEta01[3]; // dPhi vs dEta of particles, dR = .1\r
+  TH2F * fhdPhidEta001[3]; // dPhi vs dEta of particles, dR = .01\r
+\r
+  TH2F * fhdPhidEtaPt10[3]; // Pt weighted dPhi vs dEta of particles, dR = 1.\r
+  TH2F * fhdPhidEtaPt05[3]; // Pt weighted dPhi vs dEta of particles, dR = .5\r
+  TH2F * fhdPhidEtaPt01[3]; // Pt weighted dPhi vs dEta of particles, dR = .1\r
+  TH2F * fhdPhidEtaPt001[3]; // Pt weighted dPhi vs dEta of particles, dR = .01\r
   ClassDef(AliAnalysisTaskJetCorrections, 1)\r
 };\r
 \r
index 8ae04a3..58fe1e5 100644 (file)
@@ -740,7 +740,7 @@ void AliAnalysisTaskThreeJets::UserExec(Option_t * )
     { 
 //       if(fGlobVar == 1)
 //     {
-      GetEventShapes(n01MC, pTrackMC, nAccTr, eventShapes);
+      AliAnalysisHelperJetTasks::GetEventShapes(n01MC, pTrackMC, nAccTr, eventShapes);
 //     }
       
       Double_t s = eventShapes[1];
@@ -972,7 +972,7 @@ void AliAnalysisTaskThreeJets::UserExec(Option_t * )
     {
 //       if(fGlobVar == 1)
 //     {
-      GetEventShapes(n01, pTrack, nTracks, eventShapesRec);
+      AliAnalysisHelperJetTasks::GetEventShapes(n01, pTrack, nTracks, eventShapesRec);
 //     }
 //       fGlobVar = 0;      
 //       Double_t Max3 = TMath::Max(eventShapesRec0[0],eventShapesRec1[0]);
@@ -1180,159 +1180,6 @@ Bool_t AliAnalysisTaskThreeJets::IsPrimChar(TParticle* aParticle, Int_t aTotalPr
 //______________________________________________________________________________________________________
 
 
-void AliAnalysisTaskThreeJets::GetThrustAxis(TVector3 &n01, TVector3 * pTrack, const Int_t &nTracks)
-{
-  //
-  // fetch the thrust axis
-  //
-  TVector3 psum;
-  Double_t psum1 = 0;
-  Double_t psum2 = 0;
-  Double_t thrust[kTracks];
-  Double_t th = -3;
-  Double_t tpom = -1;
-  Int_t j = 0;
-
-  
-  //  for(Int_t j = 0; j < nTracks; j++)
-  while(TMath::Abs(th-tpom) > 10e-7 && j < nTracks)
-    {
-      th = tpom;
-      psum.SetXYZ(0., 0., 0.);
-      psum1 = 0;
-      psum2 = 0;
-      for(Int_t i = 0; i < nTracks; i++)
-       {
-         psum1 += (TMath::Abs(n01.Dot(pTrack[i])));
-         psum2 += pTrack[i].Mag();
-         
-         if (n01.Dot(pTrack[i]) > 0) psum += pTrack[i];
-         if (n01.Dot(pTrack[i]) < 0) psum -= pTrack[i];
-       }
-      
-      thrust[j] = psum1/psum2;
-      
-      //      if(th == thrust[j]) 
-      //       break;
-      
-      tpom = thrust[j];
-      
-      n01 = psum.Unit();
-      j++;
-    }
-}
-
-//___________________________________________________________________________________________________________
-
-void AliAnalysisTaskThreeJets::GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes)
-{       
-  TVector3 psum;
-  TVector3 pTrackPerp[kTracks];
-  Double_t psum1 = 0;
-  Double_t psum2 = 0;
-  Double_t thrust[kTracks];
-  Double_t th = -3;
-  Double_t tpom = -1;
-
-  //Sphericity calculation
-  TMatrixDSym m(3);
-  Double_t s00 = 0;
-  Double_t s01 = 0;
-  Double_t s02 = 0;
-  
-  Double_t s10 = 0;
-  Double_t s11 = 0;
-  Double_t s12 = 0;
-  
-  Double_t s20 = 0;
-  Double_t s21 = 0;
-  Double_t s22 = 0;
-  
-  Double_t ptot = 0;
-  
-  Double_t c = -10;
-
-//
-//loop for thrust calculation  
-//
-  Int_t k = 0;
-  while(TMath::Abs(th-tpom) > 10e-7 && k < nTracks)
-    {  
-      th = tpom;
-      psum.SetXYZ(0., 0., 0.);
-      psum1 = 0;
-      psum2 = 0;
-      for(Int_t i = 0; i < nTracks; i++)
-       {
-         pTrackPerp[i].SetXYZ(pTrack[i].X(), pTrack[i].Y(), 0);
-
-         psum1 += (TMath::Abs(n01.Dot(pTrackPerp[i])));
-         psum2 += pTrackPerp[i].Mag();
-
-         if (n01.Dot(pTrackPerp[i]) > 0) psum += pTrackPerp[i];
-         if (n01.Dot(pTrackPerp[i]) < 0) psum -= pTrackPerp[i];
-       }
-      
-      thrust[k] = psum1/psum2;
-      
-      tpom = thrust[k];
-      n01 = psum.Unit();
-      k++;
-//      Printf("========== %d +++ th :: %f, tpom :: %f=============\n", k, th, tpom);
-    }
-
-  eventShapes[0] = th;
-
-//
-//other event shapes variables
-//
-  for(Int_t j = 0; j < nTracks; j++)
-    {  
-      s00 = s00 + (pTrack[j].Px()*pTrack[j].Px())/pTrack[j].Mag();
-      s01 = s01 + (pTrack[j].Px()*pTrack[j].Py())/pTrack[j].Mag();
-      s02 = s02 + (pTrack[j].Px()*pTrack[j].Pz())/pTrack[j].Mag();
-      
-      s10 = s10 + (pTrack[j].Py()*pTrack[j].Px())/pTrack[j].Mag();
-      s11 = s11 + (pTrack[j].Py()*pTrack[j].Py())/pTrack[j].Mag();
-      s12 = s12 + (pTrack[j].Py()*pTrack[j].Pz())/pTrack[j].Mag();
-      
-      s20 = s20 + (pTrack[j].Pz()*pTrack[j].Px())/pTrack[j].Mag();
-      s21 = s21 + (pTrack[j].Pz()*pTrack[j].Py())/pTrack[j].Mag();
-      s22 = s22 + (pTrack[j].Pz()*pTrack[j].Pz())/pTrack[j].Mag();
-      
-      ptot += pTrack[j].Mag();
-    }
-
-  if(ptot < 10e-10 && ptot > 0.)
-    {
-      m(0,0) = s00/ptot;
-      m(0,1) = s01/ptot;
-      m(0,2) = s02/ptot;
-
-      m(1,0) = s10/ptot;
-      m(1,1) = s11/ptot;
-      m(1,2) = s12/ptot;
-
-      m(2,0) = s20/ptot;
-      m(2,1) = s21/ptot;
-      m(2,2) = s22/ptot;
-
-      TMatrixDSymEigen eigen(m);
-      TVectorD eigenVal = eigen.GetEigenValues();
-
-      Double_t sphericity = (3/2)*(eigenVal(2)+eigenVal(1));
-      eventShapes[1] = sphericity;
-
-      Double_t aplanarity = (3/2)*(eigenVal(2));
-      eventShapes[2] = aplanarity;
-
-      c = 3*(eigenVal(0)*eigenVal(1)+eigenVal(0)*eigenVal(2)+eigenVal(1)*eigenVal(2));
-      eventShapes[3] = c;
-    }
-}
-  
-
-
 //__________________________________________________________________________________________________________________________
 
 Double_t AliAnalysisTaskThreeJets::Exponent(Double_t x,const Double_t * const par) const
index 0aa2d63..40077fd 100644 (file)
@@ -51,15 +51,9 @@ class AliAnalysisTaskThreeJets : public AliAnalysisTaskSE
   virtual void SetBranchGen(const char* c){fBranchGen = c;}\r
   virtual void SetBranchRec(const char* c){fBranchRec = c;}\r
 \r
-/*   virtual void SetUseBkg(Bool_t b) {fUseBkg = b;} */\r
-/*   virtual void SetUseSimTPC(Bool_t b) {fUseFastTPC = b;} */\r
-\r
   virtual void FillTopology(TH2F * Dalitz, TH1F * fhMu34, TH1F * fhMu45, TH1F * fhMu35, Double_t * x, TVector3 * pRest, Double_t xsection);\r
 \r
   virtual Double_t SetR(Double_t b){fR = b; return fR;} \r
-//  TArrayD * GetThrustParamMC(AliMCEvent* mcEvent, Int_t  nstudymin, Double_t ptcutoff, Double_t etacutoff, Bool_t chom, TArrayD * evsh);\r
-  virtual void GetThrustAxis(TVector3 &n01, TVector3 * p_track,const Int_t &nTracks);\r
-  virtual void GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes);\r
   virtual Bool_t IsPrimChar(TParticle* aParticle, Int_t aTotalPrimaries, Bool_t adebug);\r
 \r
   Double_t Exponent(Double_t x,const Double_t * const par) const;\r
@@ -89,58 +83,58 @@ class AliAnalysisTaskThreeJets : public AliAnalysisTaskSE
   Int_t fGlobVar; // globvar\r
   Double_t fXsection; // xsectio\r
 \r
-  TH2F * fhX3X4Rec; //\r
-  TH2F * fhX3X4Gen; //\r
+TH2F * fhX3X4Rec; // Dalitz variables, reconstructed\r
+  TH2F * fhX3X4Gen; // Dalitz variables, generated\r
   \r
-  TH1F * fhMu35Rec; //\r
-  TH1F * fhMu34Rec; //\r
-  TH1F * fhMu45Rec; //\r
+  TH1F * fhMu35Rec; // scaled masses, 35, reconstructed\r
+  TH1F * fhMu34Rec; // scaled masses, 34, reconstructed\r
+  TH1F * fhMu45Rec; // scaled masses, 45, reconstructed\r
   \r
-  TH1F * fhMu35Gen; //\r
-  TH1F * fhMu34Gen; //\r
-  TH1F * fhMu45Gen; //\r
+  TH1F * fhMu35Gen; // scaled masses, 35, generated\r
+  TH1F * fhMu34Gen; // scaled masses, 34, generated\r
+  TH1F * fhMu45Gen; // scaled masses, 45, generated\r
 \r
-  TH1I * fhInOut; //\r
-  TH1F * fhThrustRec2; //\r
-  TH1F * fhThrustRec3; // \r
+  TH1I * fhInOut; // number of gen. vs number of rec.\r
+  TH1F * fhThrustRec2; // thrust for reco 2-jet events\r
+  TH1F * fhThrustRec3; // thrust for reco 3-jet events\r
 \r
-  TH1F * fhThrustGen2; //\r
-  TH1F * fhThrustGen3; // \r
+  TH1F * fhThrustGen2; // thrust for gen 2-jet events\r
+  TH1F * fhThrustGen3; // thrust for gen 3-jet events\r
 \r
-  TH1F * fhCGen2; //\r
-  TH1F * fhCGen3; // \r
+  TH1F * fhCGen2; // C-variable for gen 2-jets\r
+  TH1F * fhCGen3; // C-variable for gen 3-jets\r
 \r
-  TH1F * fhSGen2; //\r
-  TH1F * fhSGen3; // \r
+  TH1F * fhSGen2; // Sphericity for gen 2-jets\r
+  TH1F * fhSGen3; // Sphericity for gen 3-jets\r
 \r
-  TH1F * fhAGen2; // \r
-  TH1F * fhAGen3; //\r
+  TH1F * fhAGen2; // A-variable for gen 2-jets\r
+TH1F * fhAGen3; // A-variable for gen 3-jets\r
 \r
-  TH1F * fhCRec2; // \r
-  TH1F * fhCRec3; // \r
+  TH1F * fhCRec2; // C-variable for reco 2-jets\r
+  TH1F * fhCRec3; // C-variable for reco 3-jets\r
 \r
-  TH1F * fhSRec2; //\r
-  TH1F * fhSRec3; //\r
+  TH1F * fhSRec2; // Sphericity for reco 2-jets\r
+  TH1F * fhSRec3; // Sphericity for reco 3-jets\r
 \r
-  TH1F * fhARec2; //\r
-  TH1F * fhARec3; //\r
+  TH1F * fhARec2; // A-variable for reco 2-jets\r
+  TH1F * fhARec3; // A-variable for reco 3-jets\r
 \r
-  TH2F * fhX3; //\r
-  TH2F * fhX4; //\r
-  TH2F * fhX5; //\r
+  TH2F * fhX3; // dX3 vs X3 rec\r
+  TH2F * fhX4; // dX4 vs X4 rec\r
+  TH2F * fhX5; // dX5 vs X5 rec\r
 \r
-  TProfile * fhXSec; //\r
-  TH2F * fhX3X4Rec60; //\r
-  TH2F * fhX3X4Rec60100; //\r
-  TH2F * fhX3X4Rec100; //\r
-  TH2F * fhX3X4Gen60; //\r
-  TH2F * fhX3X4Gen60100; //\r
-  TH2F * fhX3X4Gen100; //\r
+  TProfile * fhXSec; // cross-section vs PtHard\r
+  TH2F * fhX3X4Rec60; // Dalitz plane for Esum < 60, reco\r
+  TH2F * fhX3X4Rec60100; // Dalitz plane for 60 < Esum < 100, reco\r
+  TH2F * fhX3X4Rec100; // Dalitz plane for Esum > 100, reco^M \r
+  TH2F * fhX3X4Gen60; // Dalitz plane for Esum < 60, gen\r
+  TH2F * fhX3X4Gen60100; // Dalitz plane for 60 < Esum < 100, gen\r
+  TH2F * fhX3X4Gen100; // Dalitz plane for Esum > 100, gen\r
 \r
-  TH2F * fhdPhiThrustGen; //\r
-  TH2F * fhdPhiThrustGenALL; //\r
-  TH2F * fhdPhiThrustRec; //\r
-  TH2F * fhdPhiThrustRecALL; //\r
+  TH2F * fhdPhiThrustGen; // energy distribution with rspct to thrust axis, gen, 2-jets\r
+  TH2F * fhdPhiThrustGenALL; // energy distribution with rspct to thrust axis, gen 3-jets\r
+  TH2F * fhdPhiThrustRec; // energy distribution with rspct to thrust axis, reco, 2-jets\r
+  TH2F * fhdPhiThrustRecALL; // energy distribution with rspct to thrust axis, reco, 3-jets\r
 \r
   ClassDef(AliAnalysisTaskThreeJets, 1)\r
 };\r