Adding binning for singly and doubly diffractive and nondiffractive events

diff --git a/PWG4/CMakelibPWG4totEt.pkg b/PWG4/CMakelibPWG4totEt.pkg
index 9c676c169eb510db220c1a4e43132e4b1723afba..cdc075fc4c79daaa5122b66ce87d1a30588a179d 100644 (file)
--- a/PWG4/CMakelibPWG4totEt.pkg
+++ b/PWG4/CMakelibPWG4totEt.pkg
@@ -53,4 +53,4 @@ set ( DHDR  PWG4totEtLinkDef.h)
 
 string ( REPLACE ".cxx" ".h" EXPORT "${SRCS}" )
 
-set ( EINCLUDE ANALYSIS PWG4/totEt STEER/STEERBase)
+set ( EINCLUDE ANALYSIS PWG0 PWG4/totEt STEER/STEERBase)

diff --git a/PWG4/totEt/AliAnalysisHadEtMonteCarlo.cxx b/PWG4/totEt/AliAnalysisHadEtMonteCarlo.cxx
index 8f2607134e140a6a98aa1a320fd0cc96680aedea..3856787c362a1969b8f990eb0f9d5c920c875f64 100644 (file)
--- a/PWG4/totEt/AliAnalysisHadEtMonteCarlo.cxx
+++ b/PWG4/totEt/AliAnalysisHadEtMonteCarlo.cxx
@@ -28,6 +28,9 @@
 #include "AliAnalysisEtCommon.h"
 #include "AliCentrality.h"
 #include "AliLog.h"
+#include "AliPWG0Helper.h"
+//class AliPWG0Helper;
+//#include "$ALICE_ROOT/PWG0/AliPWG0Helper.h"
 
 using namespace std;
 
@@ -942,6 +945,7 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
       AliFatal("ERROR: MC Event does not exist");
       return 0;
     }
+
     // Let's play with the stack!
     AliStack *stack = mcEvent->Stack();
 
@@ -1527,6 +1531,21 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
     if(fSimTotEt>0.0)FillHisto1D("SimTotEt",fSimTotEt,1.0);
     if(fSimHadEt>0.0)FillHisto1D("SimHadEt",fSimHadEt,1.0);
     if(fSimPiKPEt>0.0)FillHisto1D("SimPiKPEt",fSimPiKPEt,1.0);
+    if(AliPWG0Helper::GetEventProcessType(mcEvent->Header()) == AliPWG0Helper::kND){
+      FillHisto1D("SimHadEtND",fSimHadEt,1.0);
+      FillHisto1D("SimTotEtND",fSimHadEt,1.0);
+      FillHisto1D("NEventsND",0.5,1);
+    }
+    if(AliPWG0Helper::GetEventProcessType(mcEvent->Header()) == AliPWG0Helper::kSD){
+      FillHisto1D("SimHadEtSD",fSimHadEt,1.0);
+      FillHisto1D("SimTotEtSD",fSimHadEt,1.0);
+      FillHisto1D("NEventsSD",0.5,1);
+    }
+    if(AliPWG0Helper::GetEventProcessType(mcEvent->Header()) == AliPWG0Helper::kDD){
+      FillHisto1D("SimHadEtDD",fSimHadEt,1.0);
+      FillHisto1D("SimTotEtDD",fSimHadEt,1.0);
+      FillHisto1D("NEventsDD",0.5,1);
+    }
     if(fCentBin != -1){//if we have Pb+Pb and a centrality bin was found
       if(fSimTotEt>0.0) FillHisto1D(Form("SimTotEtCB%i",fCentBin),fSimTotEt,1.0);
       if(fSimHadEt>0.0) FillHisto1D(Form("SimHadEtCB%i",fCentBin),fSimHadEt,1.0);
@@ -1904,6 +1923,12 @@ void AliAnalysisHadEtMonteCarlo::CreateHistograms(){
   CreateHisto1D("SimPiKPEt","Simulated #pi,K,p E_{T}","Simulated #pi,K,p E_{T}","Number of events",nbinsEt,minEt,maxEt);
   CreateHisto1D("SimTotEt","Simulated Total E_{T}","Simulated Total E_{T}","Number of events",nbinsEt*4,minEt,maxEt);
   CreateHisto1D("SimHadEt","Simulated Hadronic E_{T}","Simulated Hadronic E_{T}","Number of events",nbinsEt*4,minEt,maxEt);
+  CreateHisto1D("SimTotEtND","Simulated Total E_{T}","Simulated Total E_{T} for non-diffractive events","Number of events",nbinsEt*4,minEt,maxEt);
+  CreateHisto1D("SimHadEtND","Simulated Hadronic E_{T}","Simulated Hadronic E_{T} for non-diffractive events","Number of events",nbinsEt*4,minEt,maxEt);
+  CreateHisto1D("SimTotEtSD","Simulated Total E_{T}","Simulated Total E_{T} for singly diffractive events","Number of events",nbinsEt*4,minEt,maxEt);
+  CreateHisto1D("SimHadEtSD","Simulated Hadronic E_{T}","Simulated Hadronic E_{T} for singly diffractive events","Number of events",nbinsEt*4,minEt,maxEt);
+  CreateHisto1D("SimTotEtDD","Simulated Total E_{T}","Simulated Total E_{T} for doubly diffractive events","Number of events",nbinsEt*4,minEt,maxEt);
+  CreateHisto1D("SimHadEtDD","Simulated Hadronic E_{T}","Simulated Hadronic E_{T} for doubly diffractive events","Number of events",nbinsEt*4,minEt,maxEt);
   if(fDataSet==20100){
     Int_t width = 5;
     if(fNCentBins<21) width = 10;
@@ -2091,6 +2116,9 @@ void AliAnalysisHadEtMonteCarlo::CreateHistograms(){
   delete sEMCAL;
   delete sPHOS;
   CreateIntHisto1D("NEvents","Number of events","number of events","Number of events",1,0,1);
+  CreateIntHisto1D("NEventsSD","Number of events","number of singly diffractive events","Number of events",1,0,1);
+  CreateIntHisto1D("NEventsDD","Number of events","number of doubly diffractive events","Number of events",1,0,1);
+  CreateIntHisto1D("NEventsND","Number of events","number of non-diffractive events","Number of events",1,0,1);
   CreateResolutionPtHisto2D("presolutionTPC","p resolution","p^{rec}","(p^{sim}-p^{rec})/p^{rec}");
   CreateResolutionPtHisto2D("pTresolutionTPC","p_{T} resolution","p_{T}^{rec}","(p_{T}^{sim}-p_{T}^{rec})/p_{T}^{rec}");
   CreateResolutionPtHisto2D("ETresolutionTPC","E_{T} resolution","E_{T}^{rec}","(E_{T}^{sim}-E_{T}^{rec})/E_{T}^{rec}");

diff --git a/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx b/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx
index 3a1363f9cff4d25d7a9e50067a7b6f73365c6c16..829e009d3fb419070cfaa1641618befde939ac51 100644 (file)
--- a/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx
+++ b/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx
@@ -28,6 +28,7 @@
 #include "AliAnalysisHadEt.h"
 #include "AliCentrality.h"
 #include "AliLog.h"
+#include "AliPWG0Helper.h"
 
 using namespace std;
 
@@ -88,7 +89,7 @@ AliAnalysisHadEtReconstructed::~AliAnalysisHadEtReconstructed()
   delete fCorrections;
 }
 
-Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
+Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev, Int_t eventtype)
 { // analyse ESD event
   ResetEventValues();
   if(!ev){
@@ -298,6 +299,39 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
       }
     delete list;
   }
+  Int_t nondiff = (Int_t) AliPWG0Helper::kND;
+  Int_t doublediff = (Int_t) AliPWG0Helper::kDD;
+  Int_t singlediff = (Int_t) AliPWG0Helper::kSD;
+  if(eventtype == nondiff && fGoodEvent){
+    FillHisto1D("RecoHadEtFullAcceptanceTPCND",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceTPCND",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceITSND",GetCorrectedHadEtFullAcceptanceITS(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceITSND",GetCorrectedTotEtFullAcceptanceITS(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceTPCNoPIDND",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceTPCNoPIDND",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceITSNoPIDND",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceITSNoPIDND",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
+  }
+  if(eventtype == doublediff){
+    FillHisto1D("RecoHadEtFullAcceptanceTPCDD",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceTPCDD",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceITSDD",GetCorrectedHadEtFullAcceptanceITS(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceITSDD",GetCorrectedTotEtFullAcceptanceITS(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceTPCNoPIDDD",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceTPCNoPIDDD",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceITSNoPIDDD",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceITSNoPIDDD",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
+  }
+  if(eventtype == singlediff){
+    FillHisto1D("RecoHadEtFullAcceptanceTPCSD",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceTPCSD",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceITSSD",GetCorrectedHadEtFullAcceptanceITS(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceITSSD",GetCorrectedTotEtFullAcceptanceITS(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceTPCNoPIDSD",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceTPCNoPIDSD",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
+    FillHisto1D("RecoHadEtFullAcceptanceITSNoPIDSD",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
+    FillHisto1D("RecoTotEtFullAcceptanceITSNoPIDSD",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
+  }
   if(GetCorrectedHadEtFullAcceptanceTPC()>0.0 && fGoodEvent)FillHisto1D("RecoHadEtFullAcceptanceTPC",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
   if(GetCorrectedTotEtFullAcceptanceTPC()>0.0 && fGoodEvent)FillHisto1D("RecoTotEtFullAcceptanceTPC",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
   if(GetCorrectedHadEtFullAcceptanceTPCAssumingPion()>0.0 && fGoodEvent)FillHisto1D("RecoHadEtFullAcceptanceTPCAssumingPion",GetCorrectedHadEtFullAcceptanceTPCAssumingPion(),1.0);
@@ -645,6 +679,19 @@ void AliAnalysisHadEtReconstructed::CreateHistograms(){//Creating histograms and
          snprintf(histotitle,200,"Reconstructed %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
          snprintf(xtitle,50,"Reconstructed %s",etstring->Data());
          CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
+         if(type==0){//full acceptance only
+           snprintf(xtitle,50,"Reconstructed %s",etstring->Data());
+
+           snprintf(histoname,200,"Reco%s%sAcceptance%s%sND",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
+           snprintf(histotitle,200,"Reconstructed non-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
+           CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
+           snprintf(histoname,200,"Reco%s%sAcceptance%s%sDD",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
+           snprintf(histotitle,200,"Reconstructed doubly-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
+           CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
+           snprintf(histoname,200,"Reco%s%sAcceptance%s%sSD",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
+           snprintf(histotitle,200,"Reconstructed singly-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
+           CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
+         }
          if(fDataSet==20100 && type ==0 &&pid==1){//If this is Pb+Pb and full acceptance with pid
            Int_t width = 5;
            if(fNCentBins<21) width = 10;

diff --git a/PWG4/totEt/AliAnalysisHadEtReconstructed.h b/PWG4/totEt/AliAnalysisHadEtReconstructed.h
index 210fb8ff9d15dca4531944381591c0cbf7ee8795..4f39f5fa86e54bb66bc9e4a97afefceef672be0f 100644 (file)
--- a/PWG4/totEt/AliAnalysisHadEtReconstructed.h
+++ b/PWG4/totEt/AliAnalysisHadEtReconstructed.h
@@ -10,6 +10,7 @@
 #define ALIANALYSISHADETRECONSTRUCTED_H
 
 #include "AliAnalysisHadEt.h"
+//#include "PWG0/AliPWG0Helper.h"
 
 class AliVParticle;
 class AliAnalysisHadEtCorrections;
@@ -24,7 +25,8 @@ public:
     AliAnalysisHadEtReconstructed();
     virtual ~AliAnalysisHadEtReconstructed();
    
-    virtual Int_t AnalyseEvent(AliVEvent* event);
+    virtual Int_t AnalyseEvent(AliVEvent* event, Int_t eventtype);
+    virtual Int_t AnalyseEvent(AliVEvent* event){return AnalyseEvent(event,-1);}
 
     //the "Corrected" variables are only corrected for the track-by-track fCorrections
     Float_t GetCorrectedHadEtFullAcceptanceTPC() const {return fCorrHadEtFullAcceptanceTPC*fCorrectedHadEtFullAcceptanceTPC;}

diff --git a/PWG4/totEt/AliAnalysisTaskHadEt.cxx b/PWG4/totEt/AliAnalysisTaskHadEt.cxx
index d2a425e4e7bdc35cd8fece6149318781b278d287..ac5e8a2f05493d168de7719e91e05f2a7e7fa497 100644 (file)
--- a/PWG4/totEt/AliAnalysisTaskHadEt.cxx
+++ b/PWG4/totEt/AliAnalysisTaskHadEt.cxx
@@ -23,6 +23,7 @@
 #include "AliAnalysisTaskHadEt.h"
 #include "AliAnalysisHadEtReconstructed.h"
 #include "AliAnalysisHadEtMonteCarlo.h"
+#include "AliPWG0Helper.h"
 
 #include <iostream>
 
@@ -109,6 +110,7 @@ void AliAnalysisTaskHadEt::UserCreateOutputObjects()
 //     fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
 //   }
   if(fRecAnalysis->DataSet()==2010 || fRecAnalysis->DataSet()==20111||fRecAnalysis->DataSet()==2009){
+    AliAnalysisTaskSE::        SelectCollisionCandidates(AliVEvent::kINT7 ) ;
     if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
     else{
       if(fRecAnalysis->DataSet()==2009){cout<<"Setting track cuts for the 2010 p+p collisions at 900 GeV"<<endl;}
@@ -161,7 +163,7 @@ if (!fESDEvent) {
   Printf("ERROR: Could not retrieve event");
   return;
  }
-//cout<<"AliAnalysisHadEtReconstructed 90"<<endl;
+//cout<<"AliAnalysisTaskHadEt 165"<<endl;
 
 Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber()); // Check if the physics selection is valid for this run
 
@@ -171,9 +173,10 @@ if(res == 0 && cent){
   
   //cout<<"New Event"<<endl;  
 
-  fRecAnalysis->AnalyseEvent(fESDEvent);
-
   AliMCEvent* mcEvent = MCEvent();
+  Int_t eventtype = (Int_t) AliPWG0Helper::GetEventProcessType(mcEvent->Header());
+  fRecAnalysis->AnalyseEvent(fESDEvent,eventtype);
+
 // if (!mcEvent) {
 //   Printf("ERROR: Could not retrieve MC event");
 //  }

diff --git a/PWG4/totEt/AliAnalysisTaskHadEt.h b/PWG4/totEt/AliAnalysisTaskHadEt.h
index 3f7d0bd1f000bbc59e6280de2d6d327370ec2054..6c08a3801f8489911b5d7fd60684e5a8d5b488af 100644 (file)
--- a/PWG4/totEt/AliAnalysisTaskHadEt.h
+++ b/PWG4/totEt/AliAnalysisTaskHadEt.h
@@ -16,7 +16,7 @@ class TH2F;
 class TList;\r
 \r
 #include "AliAnalysisTaskTransverseEnergy.h"\r
-\r
+class AliPWG0Helper;\r
 \r
 class AliAnalysisTaskHadEt : public AliAnalysisTaskTransverseEnergy {\r
 public:\r

diff --git a/PWG4/totEt/AliAnalysisTaskTransverseEnergy.cxx b/PWG4/totEt/AliAnalysisTaskTransverseEnergy.cxx
index 11ff532b84622971b4bc5db65d9c7be75c3f3a7f..c5c01ddcc1d3ba6710938c9d5d87daaea9e412e1 100644 (file)
--- a/PWG4/totEt/AliAnalysisTaskTransverseEnergy.cxx
+++ b/PWG4/totEt/AliAnalysisTaskTransverseEnergy.cxx
@@ -6,6 +6,7 @@
 #include "AliPhysicsSelection.h"
 #include "AliCentrality.h"
 #include "AliESDEvent.h"
+
 //_________________________________________________________________________
 //  Utility Class for transverse energy studies
 //  Base class for Et tasks
@@ -18,6 +19,7 @@
 #include "TH2F.h"
 #include <iostream>
 
+
 ClassImp(AliAnalysisTaskTransverseEnergy)
 
 AliAnalysisTaskTransverseEnergy::AliAnalysisTaskTransverseEnergy(const char* name, Bool_t isMc) :