Additions in the BF code: Control plots, two particle correlation histograms, enablin...

diff --git a/PWG2/EBYE/AliAnalysisTaskBF.cxx b/PWG2/EBYE/AliAnalysisTaskBF.cxx
index fcdd836a7457496add06a391aacd9d429a012e99..3c1f6e3b57ced7918922085bfbd88e9d253fa219 100755 (executable)
--- a/PWG2/EBYE/AliAnalysisTaskBF.cxx
+++ b/PWG2/EBYE/AliAnalysisTaskBF.cxx
@@ -30,14 +30,18 @@ ClassImp(AliAnalysisTaskBF)
 
 //________________________________________________________________________
 AliAnalysisTaskBF::AliAnalysisTaskBF(const char *name) 
-  : AliAnalysisTaskSE(name), 
-    fBalance(0),
-    fList(0),
-    fHistEventStats(0),
-    fESDtrackCuts(0),
-    fVxMax(0.3),
-    fVyMax(0.3),
-    fVzMax(10.) {
+: AliAnalysisTaskSE(name), 
+  fBalance(0),
+  fList(0),
+  fHistEventStats(0),
+  fHistVx(0),
+  fHistVy(0),
+  fHistVz(0),
+  fESDtrackCuts(0),
+  fUseOfflineTrigger(kFALSE),
+  fVxMax(0.3),
+  fVyMax(0.3),
+  fVzMax(10.) {
   // Constructor
 
   // Define input and output slots here
@@ -60,9 +64,11 @@ void AliAnalysisTaskBF::UserCreateOutputObjects() {
     fBalance->SetInterval(-0.9,0.9);
   }
 
+  //QA list
   fList = new TList();
   fList->SetName("listQA");
 
+  //Event stats.
   TString gCutName[4] = {"Total","Offline trigger",
                          "Vertex","Analyzed"};
   fHistEventStats = new TH1F("fHistEventStats",
@@ -72,6 +78,14 @@ void AliAnalysisTaskBF::UserCreateOutputObjects() {
     fHistEventStats->GetXaxis()->SetBinLabel(i,gCutName[i-1].Data());
   fList->Add(fHistEventStats);
 
+  //Vertex distributions
+  fHistVx = new TH1F("fHistVx","Primary vertex distribution - x coordinate;V_{x} (cm);Entries",100,-0.5,0.5);
+  fList->Add(fHistVx);
+  fHistVy = new TH1F("fHistVy","Primary vertex distribution - y coordinate;V_{y} (cm);Entries",100,-0.5,0.5);
+  fList->Add(fHistVy);
+  fHistVz = new TH1F("fHistVz","Primary vertex distribution - z coordinate;V_{z} (cm);Entries",100,-20.,20.);
+  fList->Add(fHistVz);
+
   if(fESDtrackCuts) fList->Add(fESDtrackCuts);
 
   // Post output data.
@@ -96,7 +110,9 @@ void AliAnalysisTaskBF::UserExec(Option_t *) {
     }
 
     fHistEventStats->Fill(1); //all events
-    Bool_t isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
+    Bool_t isSelected = kTRUE;
+    if(fUseOfflineTrigger)
+      isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
     if(isSelected) {
       fHistEventStats->Fill(2); //triggered events
 
@@ -109,8 +125,11 @@ void AliAnalysisTaskBF::UserExec(Option_t *) {
              if(TMath::Abs(vertex->GetYv()) < fVyMax) {
                if(TMath::Abs(vertex->GetZv()) < fVzMax) {
                  fHistEventStats->Fill(4); //analayzed events
-       
-                 Printf("There are %d tracks in this event", gESD->GetNumberOfTracks());
+                 fHistVx->Fill(vertex->GetXv());
+                 fHistVy->Fill(vertex->GetYv());
+                 fHistVz->Fill(vertex->GetZv());
+
+                 //Printf("There are %d tracks in this event", gESD->GetNumberOfTracks());
                  for (Int_t iTracks = 0; iTracks < gESD->GetNumberOfTracks(); iTracks++) {
                    AliESDtrack* track = gESD->GetTrack(iTracks);
                    if (!track) {

diff --git a/PWG2/EBYE/AliAnalysisTaskBF.h b/PWG2/EBYE/AliAnalysisTaskBF.h
index 05588c4424b6b60881f4ae090a92791c1cbd2dd7..8f5aca2b80e74cc50423e41e53395d007afae17d 100755 (executable)
--- a/PWG2/EBYE/AliAnalysisTaskBF.h
+++ b/PWG2/EBYE/AliAnalysisTaskBF.h
@@ -31,21 +31,28 @@ class AliAnalysisTaskBF : public AliAnalysisTaskSE {
     fVzMax = vz;\r
   }\r
 \r
+  void UseOfflineTrigger() {fUseOfflineTrigger = kTRUE;}\r
+\r
  private:\r
   AliBalance *fBalance; //BF object\r
   TList *fList; //fList object\r
   TH1F *fHistEventStats; //event stats\r
+  TH1F *fHistVx; //x coordinate of the primary vertex\r
+  TH1F *fHistVy; //y coordinate of the primary vertex\r
+  TH1F *fHistVz; //z coordinate of the primary vertex\r
 \r
   AliESDtrackCuts *fESDtrackCuts; //ESD track cuts\r
 \r
+  Bool_t fUseOfflineTrigger;//Usage of the offline trigger selection\r
+\r
   Double_t fVxMax;//vxmax\r
-  Double_t fVyMax;//vxmax\r
-  Double_t fVzMax;//vxmax\r
+  Double_t fVyMax;//vymax\r
+  Double_t fVzMax;//vzmax\r
 \r
   AliAnalysisTaskBF(const AliAnalysisTaskBF&); // not implemented\r
   AliAnalysisTaskBF& operator=(const AliAnalysisTaskBF&); // not implemented\r
   \r
-  ClassDef(AliAnalysisTaskBF, 2); // example of analysis\r
+  ClassDef(AliAnalysisTaskBF, 3); // example of analysis\r
 };\r
 \r
 #endif\r

diff --git a/PWG2/EBYE/AliBalance.cxx b/PWG2/EBYE/AliBalance.cxx
index e21fd2edcff6ce62ae8082a10f94193737c189c5..5e4a6441190bd80fcfd0cb4a9ca6541140be6c15 100644 (file)
--- a/PWG2/EBYE/AliBalance.cxx
+++ b/PWG2/EBYE/AliBalance.cxx
@@ -28,6 +28,7 @@
 #include <TObjArray.h>
 #include <TGraphErrors.h>
 #include <TString.h>
+#include <TH1F.h>
 
 #include "AliVParticle.h"
 #include "AliMCParticle.h"
@@ -43,7 +44,13 @@ AliBalance::AliBalance() :
   TObject(), 
   fAnalysisLevel("ESD"), fNumberOfBins(0),
   fAnalysisType(0), fAnalyzedEvents(0), fP2Start(0),
-  fP2Stop(0), fP2Step(0), fNn(0), fNp(0) {
+  fP2Stop(0), fP2Step(0), fNn(0), fNp(0),
+  fHistfNnn(new TH1F("fHistfNnn","(--) component;;Entries",
+                    fNumberOfBins,fP2Start,fP2Stop)),
+  fHistfNpp(new TH1F("fHistfNpp","(++) component;;Entries",
+                    fNumberOfBins,fP2Start,fP2Stop)),
+  fHistfNpn(new TH1F("fHistfNpn","(+-) component;;Entries",
+                    fNumberOfBins,fP2Start,fP2Stop)) {
   // Default constructor
   for(Int_t i = 0; i < MAXIMUM_NUMBER_OF_STEPS; i++) {
     fNpp[i] = .0;
@@ -52,6 +59,46 @@ AliBalance::AliBalance() :
     fB[i] = 0.0;
     ferror[i] = 0.0;
   } 
+
+  switch(fAnalysisType) {
+  case 0:
+    fHistfNnn->GetXaxis()->SetTitle("#Delta y");
+    fHistfNpp->GetXaxis()->SetTitle("#Delta y");
+    fHistfNpn->GetXaxis()->SetTitle("#Delta y");
+    break;
+  case 1:
+    fHistfNnn->GetXaxis()->SetTitle("#Delta #eta");
+    fHistfNpp->GetXaxis()->SetTitle("#Delta #eta");
+    fHistfNpn->GetXaxis()->SetTitle("#Delta #eta");
+    break;
+  case 2:
+    fHistfNnn->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    break;
+  case 3:
+    fHistfNnn->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    break;
+  case 4:
+    fHistfNnn->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    break;
+  case 5:
+    fHistfNnn->GetXaxis()->SetTitle("q_{inv.} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{inv.} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{inv.} (GeV/c)");
+    break;
+  case 6:
+    fHistfNnn->GetXaxis()->SetTitle("#Delta #phi");
+    fHistfNpp->GetXaxis()->SetTitle("#Delta #phi");
+    fHistfNpn->GetXaxis()->SetTitle("#Delta #phi");
+    break;
+  default:
+    break;
+  }
 }
 
 //____________________________________________________________________//
@@ -60,7 +107,13 @@ AliBalance::AliBalance(Double_t p2Start, Double_t p2Stop, Int_t p2Bins) :
   fNumberOfBins(p2Bins), fAnalysisType(0), 
   fAnalyzedEvents(0), fP2Start(p2Start), fP2Stop(p2Stop), 
   fP2Step(TMath::Abs(fP2Start - fP2Stop) / (Double_t)fNumberOfBins), 
-  fNn(0), fNp(0) {
+  fNn(0), fNp(0),
+  fHistfNnn(new TH1F("fHistfNnn","(--) component;;Entries",
+                    fNumberOfBins,fP2Start,fP2Stop)),
+  fHistfNpp(new TH1F("fHistfNpp","(++) component;;Entries",
+                    fNumberOfBins,fP2Start,fP2Stop)),
+  fHistfNpn(new TH1F("fHistfNpn","(+-) component;;Entries",
+                    fNumberOfBins,fP2Start,fP2Stop)) {
   // Constructor
   for(Int_t i = 0; i < MAXIMUM_NUMBER_OF_STEPS; i++) {
     fNpp[i] = .0;
@@ -69,6 +122,46 @@ AliBalance::AliBalance(Double_t p2Start, Double_t p2Stop, Int_t p2Bins) :
     fB[i] = 0.0;
     ferror[i] = 0.0;
   } 
+
+  switch(fAnalysisType) {
+  case 0:
+    fHistfNnn->GetXaxis()->SetTitle("#Delta y");
+    fHistfNpp->GetXaxis()->SetTitle("#Delta y");
+    fHistfNpn->GetXaxis()->SetTitle("#Delta y");
+    break;
+  case 1:
+    fHistfNnn->GetXaxis()->SetTitle("#Delta #eta");
+    fHistfNpp->GetXaxis()->SetTitle("#Delta #eta");
+    fHistfNpn->GetXaxis()->SetTitle("#Delta #eta");
+    break;
+  case 2:
+    fHistfNnn->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    break;
+  case 3:
+    fHistfNnn->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    break;
+  case 4:
+    fHistfNnn->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    break;
+  case 5:
+    fHistfNnn->GetXaxis()->SetTitle("q_{inv.} (GeV/c)");
+    fHistfNpp->GetXaxis()->SetTitle("q_{inv.} (GeV/c)");
+    fHistfNpn->GetXaxis()->SetTitle("q_{inv.} (GeV/c)");
+    break;
+  case 6:
+    fHistfNnn->GetXaxis()->SetTitle("#Delta #phi");
+    fHistfNpp->GetXaxis()->SetTitle("#Delta #phi");
+    fHistfNpn->GetXaxis()->SetTitle("#Delta #phi");
+    break;
+  default:
+    break;
+  }
 }
 
 //____________________________________________________________________//
@@ -81,7 +174,10 @@ AliBalance::AliBalance(const AliBalance& balance):
   fP2Stop(balance.fP2Stop),
   fP2Step(balance.fP2Step),
   fNn(balance.fNn),
-  fNp(balance.fNp) {
+  fNp(balance.fNp),
+  fHistfNnn(balance.fHistfNnn), 
+  fHistfNpp(balance.fHistfNpp), 
+  fHistfNpn(balance.fHistfNpn) {
   //copy constructor
   for(Int_t i = 0; i < MAXIMUM_NUMBER_OF_STEPS; i++) {
     fNpp[i] = .0;
@@ -95,6 +191,9 @@ AliBalance::AliBalance(const AliBalance& balance):
 //____________________________________________________________________//
 AliBalance::~AliBalance() {
   // Destructor
+  if(fHistfNnn) delete fHistfNnn;
+  if(fHistfNpp) delete fHistfNpp;
+  if(fHistfNpn) delete fHistfNpn;
 }
 
 //____________________________________________________________________//
@@ -177,7 +276,7 @@ void AliBalance::SetAnalysisType(Int_t iType) {
 }
 
 //____________________________________________________________________//
-const char* AliBalance::GetAnalysisType() {
+void AliBalance::PrintAnalysisSettings() {
   //0:y - 1:eta - 2:Qlong - 3:Qout - 4:Qside - 5:Qinv - 6:phi
   TString analysisType;
   switch(fAnalysisType) {
@@ -205,12 +304,15 @@ const char* AliBalance::GetAnalysisType() {
   default:
     break;
   }
-  analysisType += "\nInterval: ";
-  analysisType += fP2Start; analysisType += " - "; analysisType += fP2Stop;
-  analysisType += "\nSteps: "; analysisType += fP2Step;
-  analysisType += "\nBins: "; analysisType += fNumberOfBins;
-
-  return analysisType.Data();
+  
+  Printf("======================================");
+  Printf("Analysis level: %s",fAnalysisLevel.Data());
+  Printf("Analysis type: %s",analysisType.Data());
+  Printf("Analyzed interval (min.): %lf",fP2Start);
+  Printf("Analyzed interval (max.): %lf",fP2Stop);
+  Printf("Number of bins: %d",fNumberOfBins);
+  Printf("Step: %lf",fP2Step);
+  Printf("======================================");
 }
 
 //____________________________________________________________________//
@@ -607,20 +709,20 @@ TGraphErrors *AliBalance::DrawBalance() {
     gr->GetYaxis()->SetTitle("B(#Delta #eta)");
   }
   if(fAnalysisType==2) {
-    gr->GetXaxis()->SetTitle("Q_{long} [GeV]");
-    gr->GetYaxis()->SetTitle("B(Q_{long})");
+    gr->GetXaxis()->SetTitle("q_{long} (GeV/c)");
+    gr->GetYaxis()->SetTitle("B(q_{long}) [(GeV/c)^{-1}]");
   }
   if(fAnalysisType==3) {
-    gr->GetXaxis()->SetTitle("Q_{out} [GeV]");
-    gr->GetYaxis()->SetTitle("B(Q_{out})");
+    gr->GetXaxis()->SetTitle("q_{out} (GeV/c)");
+    gr->GetYaxis()->SetTitle("B(q_{out}) [(GeV/c)^{-1}]");
   }
   if(fAnalysisType==4) {
-    gr->GetXaxis()->SetTitle("Q_{side} [GeV]");
-    gr->GetYaxis()->SetTitle("B(Q_{side})");
+    gr->GetXaxis()->SetTitle("q_{side} (GeV/c)");
+    gr->GetYaxis()->SetTitle("B(q_{side}) [(GeV/c)^{-1}]");
   }
   if(fAnalysisType==5) {
-    gr->GetXaxis()->SetTitle("Q_{inv} [GeV]");
-    gr->GetYaxis()->SetTitle("B(Q_{inv})");
+    gr->GetXaxis()->SetTitle("q_{inv} (GeV/c)");
+    gr->GetYaxis()->SetTitle("B(q_{inv}) [(GeV/c)^{-1}]");
   }
   if(fAnalysisType==6) {
     gr->GetXaxis()->SetTitle("#Delta #phi");

diff --git a/PWG2/EBYE/AliBalance.h b/PWG2/EBYE/AliBalance.h
index d00fb0f18152e4d70b54efea4cdef86c0744f3b7..d1fc67203b74eb3039b7f08ea03bb13e1dd72218 100644 (file)
--- a/PWG2/EBYE/AliBalance.h
+++ b/PWG2/EBYE/AliBalance.h
@@ -19,7 +19,7 @@
 
 class TGraphErrors;
 class TObjArray;
-//class TString;
+class TH1F;
 
 class AliBalance : public TObject {
  public:
@@ -34,8 +34,8 @@ class AliBalance : public TObject {
   void SetInterval(Double_t p2Start, Double_t p2Stop);
 
   Int_t GetNumberOfBins() {return fNumberOfBins;}
-  const char* GetAnalysisType();
   const char* GetAnalysisLevel() {return fAnalysisLevel.Data();}
+  Int_t GetNumberOfAnalyzedEvent() {return fAnalyzedEvents;}
 
   void SetNp(Int_t np) {fNp = np;}
   void SetNn(Int_t nn) {fNn = nn;}
@@ -49,6 +49,10 @@ class AliBalance : public TObject {
   Double_t GetNpp(Int_t p2) const { return 1.0*fNpp[p2]; }
   Double_t GetNpn(Int_t p2) const { return 1.0*fNpn[p2]; }
  
+  TH1F *GetHistNnn() {return fHistfNnn;}
+  TH1F *GetHistNpp() {return fHistfNpp;}
+  TH1F *GetHistNpn() {return fHistfNpn;}
+
   void CalculateBalance(TObjArray *gTrackArray);
   
   Double_t GetBalance(Int_t p2);
@@ -56,6 +60,7 @@ class AliBalance : public TObject {
 
   TGraphErrors *DrawBalance();
   void PrintResults();
+  void PrintAnalysisSettings();
 
   void Merge(AliBalance *b);
 
@@ -74,7 +79,11 @@ class AliBalance : public TObject {
   
   Double_t fB[MAXIMUM_NUMBER_OF_STEPS]; //BF matrix
   Double_t ferror[MAXIMUM_NUMBER_OF_STEPS]; //error of the BF
-   
+  
+  TH1F *fHistfNnn; //N(--) in a histo
+  TH1F *fHistfNpp; //N(++) in a histo
+  TH1F *fHistfNpn; //N(+-) in a histo
+
   AliBalance & operator=(const AliBalance & ) {return *this;}
 
   ClassDef(AliBalance, 1)