Adding the correction class for the proton spectra - first preliminary version

diff --git a/PWG2/PWG2spectraLinkDef.h b/PWG2/PWG2spectraLinkDef.h
index cd4375d1d1cf7bc6da4f1f665517ef1e62981879..a2c6c59a7cd005a07fe8023a5edab2c45c5ce533 100644 (file)
--- a/PWG2/PWG2spectraLinkDef.h
+++ b/PWG2/PWG2spectraLinkDef.h
@@ -18,6 +18,7 @@
 #pragma link C++ class AliProtonFeedDownAnalysisTask+;
 #pragma link C++ class AliProtonFeedDownAnalysis+;
 #pragma link C++ class AliProtonAbsorptionCorrection+;
+#pragma link C++ class AliProtonSpectraCorrection+;
 #pragma link C++ class AliAnalysisCentralCutMC+;
 #pragma link C++ class AliAnalysisCentralCutESD+;
 #pragma link C++ class AliAnalysisCentralCutEvtMC+;

diff --git a/PWG2/SPECTRA/AliProtonAbsorptionCorrection.h b/PWG2/SPECTRA/AliProtonAbsorptionCorrection.h
index 8a7315e7452bccd0e2d2f5f1756b1d9ee2e81381..5276caea0b826f23bd930ecd6ca7684e632784f6 100644 (file)
--- a/PWG2/SPECTRA/AliProtonAbsorptionCorrection.h
+++ b/PWG2/SPECTRA/AliProtonAbsorptionCorrection.h
@@ -37,7 +37,7 @@ class AliProtonAbsorptionCorrection : public TObject {
     kStepGenerated       = 0,\r
     kStepReconstructible = 1,\r
     kStepReconstructed   = 2,\r
-    kNSteps = 5\r
+    kNSteps = 3\r
   };\r
 \r
   AliProtonAbsorptionCorrection();\r

diff --git a/PWG2/SPECTRA/AliProtonSpectraCorrection.cxx b/PWG2/SPECTRA/AliProtonSpectraCorrection.cxx
new file mode 100644 (file)
index 0000000..9703fba
--- /dev/null
+++ b/PWG2/SPECTRA/AliProtonSpectraCorrection.cxx
@@ -0,0 +1,322 @@
+#include <Riostream.h>
+#include <TFile.h>
+#include <TSystem.h>
+#include <TF1.h>
+#include <TH2D.h>
+#include <TH1D.h>
+#include <TH1I.h>
+#include <TParticle.h>
+
+#include <AliExternalTrackParam.h>
+#include <AliAODEvent.h>
+#include <AliESDEvent.h>
+//#include <AliLog.h>
+#include <AliPID.h>
+#include <AliStack.h>
+#include <AliCFContainer.h>
+#include <AliCFEffGrid.h>
+#include <AliCFDataGrid.h>
+#include <AliCFManager.h>
+#include <AliCFTrackKineCuts.h>
+#include <AliCFParticleGenCuts.h>
+#include <AliCFAcceptanceCuts.h>
+#include <AliMCEvent.h>
+//#include <AliESDVertex.h>
+class AliLog;
+class AliESDVertex;
+
+#include "AliProtonSpectraCorrection.h"
+#include "AliProtonAnalysisBase.h"
+
+ClassImp(AliProtonSpectraCorrection)
+
+//____________________________________________________________________//
+AliProtonSpectraCorrection::AliProtonSpectraCorrection() : 
+  TObject(), fProtonAnalysisBase(0),
+  fNBinsY(0), fMinY(0), fMaxY(0),
+  fNBinsPt(0), fMinPt(0), fMaxPt(0),
+  fCFManagerProtons(0), fCFManagerAntiProtons(0) {
+  //fProtonContainer(0), fAntiProtonContainer(0) {
+  //Default constructor
+}
+
+//____________________________________________________________________//
+AliProtonSpectraCorrection::~AliProtonSpectraCorrection() {
+  //Default destructor
+  if(fCFManagerProtons) delete fCFManagerProtons;
+  if(fCFManagerAntiProtons) delete fCFManagerAntiProtons;
+  if(fProtonAnalysisBase) delete fProtonAnalysisBase;
+  //if(fProtonContainer) delete fProtonContainer;
+  //if(fAntiProtonContainer) delete fAntiProtonContainer;
+}
+
+//____________________________________________________________________//
+void AliProtonSpectraCorrection::InitAnalysisHistograms(Int_t nbinsY, 
+                                                          Float_t fLowY, 
+                                                          Float_t fHighY, 
+                                                          Int_t nbinsPt, 
+                                                          Float_t fLowPt, 
+                                                          Float_t fHighPt) {
+  //Initializes the histograms
+  fNBinsY = nbinsY;
+  fMinY = fLowY;
+  fMaxY = fHighY;
+  fNBinsPt = nbinsPt;
+  fMinPt = fLowPt;
+  fMaxPt = fHighPt;
+  const Int_t    mintrackrefsTPC = 1;
+
+  //=========================================================//
+  //setting up the containers
+  Int_t iBin[2];
+  iBin[0] = nbinsY;
+  iBin[1] = nbinsPt;
+  Double_t *binLimY = new Double_t[nbinsY+1];
+  Double_t *binLimPt = new Double_t[nbinsPt+1];
+  //values for bin lower bounds
+  for(Int_t i = 0; i <= nbinsY; i++) 
+    binLimY[i]=(Double_t)fLowY  + (fHighY - fLowY)  /nbinsY*(Double_t)i;
+  for(Int_t i = 0; i <= nbinsPt; i++) 
+    binLimPt[i]=(Double_t)fLowPt  + (fHighPt - fLowPt)  /nbinsPt*(Double_t)i;
+
+  //Proton container
+  AliCFContainer *containerProtons = new AliCFContainer("containerProtons",
+                                                       "container for protons",
+                                                       kNSteps,2,iBin);
+  containerProtons->SetBinLimits(0,binLimY); //rapidity or eta
+  containerProtons->SetBinLimits(1,binLimPt); //pT
+
+  //Anti-proton container
+  AliCFContainer *containerAntiProtons = new AliCFContainer("containerAntiProtons",
+                                                           "container for antiprotons",
+                                                           kNSteps,2,iBin);
+  containerAntiProtons->SetBinLimits(0,binLimY); //rapidity or eta
+  containerAntiProtons->SetBinLimits(1,binLimPt); //pT
+  
+  //=========================================================//
+  //Setting up the criteria for the generated particles
+  AliCFTrackKineCuts *mcKineCutsProtons = new AliCFTrackKineCuts("mcKineCutsProtons",
+                                                                "MC-level kinematic cuts");
+  mcKineCutsProtons->SetPtRange(fMinPt,fMaxPt);
+  if(fProtonAnalysisBase->GetEtaMode()) 
+    mcKineCutsProtons->SetEtaRange(fMinY,fMaxY);
+  else
+    mcKineCutsProtons->SetRapidityRange(fMinY,fMaxY);
+  mcKineCutsProtons->SetChargeMC(1.0);
+
+  AliCFTrackKineCuts *mcKineCutsAntiProtons = new AliCFTrackKineCuts("mcKineCutsAntiProtons",
+                                                                    "MC-level kinematic cuts");
+  mcKineCutsAntiProtons->SetPtRange(fMinPt,fMaxPt);
+  if(fProtonAnalysisBase->GetEtaMode()) 
+    mcKineCutsAntiProtons->SetEtaRange(fMinY,fMaxY);
+  else
+    mcKineCutsAntiProtons->SetRapidityRange(fMinY,fMaxY);
+  mcKineCutsAntiProtons->SetChargeMC(-1.0);
+
+  AliCFParticleGenCuts* mcGenCutsProtons = new AliCFParticleGenCuts("mcGenCutsProtons",
+                                                                   "MC particle generation cuts");
+  mcGenCutsProtons->SetRequireIsPrimary();
+  mcGenCutsProtons->SetRequirePdgCode(2212);
+  AliCFParticleGenCuts* mcGenCutsAntiProtons = new AliCFParticleGenCuts("mcGenCutsAntiProtons",
+                                                                       "MC particle generation cuts");
+  mcGenCutsAntiProtons->SetRequireIsPrimary();
+  mcGenCutsAntiProtons->SetRequirePdgCode(-2212);
+
+  TObjArray* mcListProtons = new TObjArray(0);
+  mcListProtons->AddLast(mcKineCutsProtons);
+  mcListProtons->AddLast(mcGenCutsProtons);
+  TObjArray* mcListAntiProtons = new TObjArray(0);
+  mcListAntiProtons->AddLast(mcKineCutsAntiProtons);
+  mcListAntiProtons->AddLast(mcGenCutsAntiProtons);
+
+  //Setting up the criteria for the reconstructible particles
+  AliCFAcceptanceCuts *mcAccCuts = new AliCFAcceptanceCuts("mcAccCuts",
+                                                          "Acceptance cuts");
+  mcAccCuts->SetMinNHitTPC(mintrackrefsTPC);
+  TObjArray* accList = new TObjArray(0);
+  accList->AddLast(mcAccCuts);
+
+  //____________________________________________//
+  //Setting up the criteria for the reconstructed tracks
+  //____________________________________________//
+  AliCFTrackKineCuts *recKineCutsProtons = new AliCFTrackKineCuts("recKineCutsProtons",
+                                                                 "rec-level kine cuts");
+  recKineCutsProtons->SetPtRange(fMinPt,fMaxPt);
+  if(fProtonAnalysisBase->GetEtaMode()) 
+    recKineCutsProtons->SetEtaRange(fMinY,fMaxY);
+  else
+    recKineCutsProtons->SetRapidityRange(fMinY,fMaxY);
+  recKineCutsProtons->SetChargeRec(1.0);
+
+  //____________________________________________//
+  AliCFTrackKineCuts *recKineCutsAntiProtons = new AliCFTrackKineCuts("recKineCutsAntiProtons",
+                                                                     "rec-level kine cuts");
+  recKineCutsAntiProtons->SetPtRange(fMinPt,fMaxPt);
+  if(fProtonAnalysisBase->GetEtaMode()) 
+    recKineCutsAntiProtons->SetEtaRange(fMinY,fMinY);
+  else
+    recKineCutsAntiProtons->SetRapidityRange(fMinY,fMaxY);
+  recKineCutsAntiProtons->SetChargeRec(-1.0);
+
+  //____________________________________________//
+  TObjArray* recListProtons = new TObjArray(0);
+  recListProtons->AddLast(recKineCutsProtons);
+  recListProtons->AddLast(mcGenCutsProtons);
+
+  TObjArray* recListAntiProtons = new TObjArray(0);
+  recListAntiProtons->AddLast(recKineCutsAntiProtons);
+  recListAntiProtons->AddLast(mcGenCutsAntiProtons);
+
+  //=========================================================//
+  //CF manager - Protons
+  fCFManagerProtons = new AliCFManager();
+  fCFManagerProtons->SetParticleContainer(containerProtons);
+  fCFManagerProtons->SetParticleCutsList(AliCFManager::kPartGenCuts,mcListProtons);
+  fCFManagerProtons->SetParticleCutsList(AliCFManager::kPartAccCuts,accList);
+  fCFManagerProtons->SetParticleCutsList(AliCFManager::kPartRecCuts,recListProtons);
+
+  //CF manager - Protons
+  fCFManagerAntiProtons = new AliCFManager();
+  fCFManagerAntiProtons->SetParticleContainer(containerAntiProtons);
+  fCFManagerAntiProtons->SetParticleCutsList(AliCFManager::kPartGenCuts,mcListAntiProtons);
+  fCFManagerAntiProtons->SetParticleCutsList(AliCFManager::kPartAccCuts,accList);
+  fCFManagerAntiProtons->SetParticleCutsList(AliCFManager::kPartRecCuts,recListAntiProtons);
+}
+
+//_________________________________________________________________________//
+void AliProtonSpectraCorrection::FillCorrectionMaps(AliESDEvent *esd, 
+                                                   const AliESDVertex *vertex,
+                                                   AliMCEvent *mcEvent) {
+  //Function to fill the correction containers
+  fCFManagerProtons->SetEventInfo(mcEvent);
+  fCFManagerAntiProtons->SetEventInfo(mcEvent);
+ 
+  //Dummy container
+  Double_t containerInput[2];
+  //__________________________________________________________//
+  //loop on the MC event
+  for (Int_t ipart = 0; ipart < mcEvent->GetNumberOfTracks(); ipart++) { 
+    AliMCParticle *mcPart  = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(ipart));
+
+    //Protons
+    //check the MC-level cuts
+    if (fCFManagerProtons->CheckParticleCuts(AliCFManager::kPartGenCuts,
+                                            mcPart)) {
+      containerInput[0] = (Float_t)mcPart->Eta();
+      containerInput[1] = (Float_t)mcPart->Pt();
+      //fill the container for Gen-level selection
+      fCFManagerProtons->GetParticleContainer()->Fill(containerInput,
+                                                     kStepGenerated);
+      //check the Acceptance-level cuts
+      if (fCFManagerProtons->CheckParticleCuts(AliCFManager::kPartAccCuts,
+                                              mcPart)) {
+       //fill the container for Acceptance-level selection
+       fCFManagerProtons->GetParticleContainer()->Fill(containerInput,
+                                                       kStepReconstructible);
+      }//acceptance cuts - protons
+    }//MC level cuts - protons
+
+    //Antiprotons
+    //check the MC-level cuts
+    if (fCFManagerAntiProtons->CheckParticleCuts(AliCFManager::kPartGenCuts,
+                                                mcPart)) {
+      containerInput[0] = (Float_t)mcPart->Eta();
+      containerInput[1] = (Float_t)mcPart->Pt();
+      //fill the container for Gen-level selection
+      fCFManagerAntiProtons->GetParticleContainer()->Fill(containerInput,
+                                                         kStepGenerated);
+      //check the Acceptance-level cuts
+      if (fCFManagerAntiProtons->CheckParticleCuts(AliCFManager::kPartAccCuts,
+                                                  mcPart)) {
+       //fill the container for Acceptance-level selection
+       fCFManagerAntiProtons->GetParticleContainer()->Fill(containerInput,
+                                                           kStepReconstructible);
+      }//acceptance cuts - antiprotons
+    }//MC level cuts - antiprotons
+  }//loop over MC particles
+  
+  
+  //__________________________________________________________//
+  //ESD track loop
+  for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
+    AliESDtrack *track = dynamic_cast<AliESDtrack *>(esd->GetTrack(iTrack));
+    if(!track) continue;
+
+    // is track associated to particle ?
+    Int_t label = track->GetLabel();
+    if (label<0) continue;
+    AliMCParticle *mcPart  = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(label));
+
+    if((fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kTPC)||(fProtonAnalysisBase->GetAnalysisMode()==AliProtonAnalysisBase::kHybrid)) {
+      AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
+      if(!tpcTrack) continue;
+    }//Hybrid or standalone TPC
+    
+    //Protons
+    // check if this track was part of the signal - primaries
+    if (fCFManagerProtons->CheckParticleCuts(AliCFManager::kPartGenCuts,
+                                            mcPart)) {
+      //fill the container - reconstructed protons
+      containerInput[0] = mcPart->Eta();
+      containerInput[1] = mcPart->Pt();
+      fCFManagerProtons->GetParticleContainer()->Fill(containerInput,
+                                                     kStepReconstructed);
+      //fill the container - identified protons
+      if(fProtonAnalysisBase->IsProton(track)) {
+       containerInput[0] = mcPart->Eta();
+       containerInput[1] = mcPart->Pt();
+       fCFManagerProtons->GetParticleContainer()->Fill(containerInput,
+                                                       kStepIdentified);
+
+       //fill the container - survived protons
+       //track cuts
+       if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;
+       //track outside the analyzed y-Pt
+       if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; 
+       containerInput[0] = mcPart->Eta();
+       containerInput[1] = mcPart->Pt();
+       fCFManagerProtons->GetParticleContainer()->Fill(containerInput,
+                                                       kStepSelected);
+      }
+    }//MC primaries - protons
+    
+    //Antiprotons    
+    // check if this track was part of the signal - primaries
+    if (fCFManagerAntiProtons->CheckParticleCuts(AliCFManager::kPartGenCuts,
+                                                mcPart)) {
+      //fill the container - reconstructed antiprotons
+      containerInput[0] = mcPart->Eta();
+      containerInput[1] = mcPart->Pt();
+      fCFManagerAntiProtons->GetParticleContainer()->Fill(containerInput,
+                                                         kStepReconstructed);
+
+      //fill the container - identified antiprotons
+      if(fProtonAnalysisBase->IsProton(track)) {
+       containerInput[0] = mcPart->Eta();
+       containerInput[1] = mcPart->Pt();
+       fCFManagerAntiProtons->GetParticleContainer()->Fill(containerInput,
+                                                           kStepIdentified);
+
+       //fill the container - survived antiprotons
+       //track cuts
+       if(!fProtonAnalysisBase->IsAccepted(esd,vertex,track)) continue;
+       //track outside the analyzed y-Pt
+       if(!fProtonAnalysisBase->IsInPhaseSpace(track)) continue; 
+       containerInput[0] = mcPart->Eta();
+       containerInput[1] = mcPart->Pt();
+       fCFManagerAntiProtons->GetParticleContainer()->Fill(containerInput,
+                                                           kStepSelected);
+      }
+    }//MC primaries - antiprotons
+  }//track loop
+  
+  //if(fProtonAnalysisBase->GetDebugMode())
+  //Printf("Initial number of tracks: %d | Identified (anti)protons: %d - %d | Survived (anti)protons: %d - %d",nTracks,nIdentifiedProtons,nIdentifiedAntiProtons,nSurvivedProtons,nSurvivedAntiProtons);
+}
+
+//_________________________________________________________________________//
+void AliProtonSpectraCorrection::FillCorrectionMaps(AliAODEvent *fAOD) {
+  // Analysis from AOD: to be implemented...
+  // in the near future.
+  fAOD->Print();
+}

diff --git a/PWG2/SPECTRA/AliProtonSpectraCorrection.h b/PWG2/SPECTRA/AliProtonSpectraCorrection.h
new file mode 100644 (file)
index 0000000..8e9832b
--- /dev/null
+++ b/PWG2/SPECTRA/AliProtonSpectraCorrection.h
@@ -0,0 +1,84 @@
+#ifndef ALIPROTONSPECTRACORRECTION_H\r
+#define ALIPROTONSPECTRACORRECTION_H\r
+\r
+//-------------------------------------------------------------------------\r
+//               Class AliProtonSpectraCorrection\r
+//   This is the class for the absorption corrections used for \r
+//   the baryon (proton) ratio analysis\r
+//\r
+//    Origin: Panos Christakoglou | Panos.Christakoglou@cern.ch\r
+//-------------------------------------------------------------------------\r
+\r
+#include "TObject.h"\r
+#include "TH1I.h"\r
+#include "AliCFContainer.h"\r
+#include "AliCFManager.h"\r
+\r
+class TF1;\r
+class TH2D;\r
+class TH1F;\r
+class TList;\r
+\r
+class AliPID;\r
+class AliCFDataGrid;\r
+class AliAODEvent;\r
+class AliAODtrack;\r
+class AliESDEvent;\r
+class AliESDtrack;\r
+class AliExternalTrackParam;\r
+class AliStack;\r
+class AliESDVertex;\r
+class AliProtonAnalysisBase;\r
+class AliMCEvent;\r
+\r
+class AliProtonSpectraCorrection : public TObject {\r
+ public:\r
+  enum {\r
+    kStepGenerated       = 0,\r
+    kStepReconstructible = 1,\r
+    kStepReconstructed   = 2,\r
+    kStepIdentified      = 3,\r
+    kStepSelected        = 4,\r
+    kNSteps = 5\r
+  };\r
+\r
+  AliProtonSpectraCorrection();\r
+  virtual ~AliProtonSpectraCorrection();\r
+  \r
+  void SetBaseAnalysis(AliProtonAnalysisBase * const baseAnalysis) {\r
+    fProtonAnalysisBase = baseAnalysis;}\r
+  AliProtonAnalysisBase *GetProtonAnalysisBaseObject() const {\r
+    return fProtonAnalysisBase;}\r
+               \r
+  void InitAnalysisHistograms(Int_t nbinsY, Float_t fLowY, Float_t fHighY, \r
+                             Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);\r
+  void FillCorrectionMaps(AliESDEvent *fESD, \r
+                         const AliESDVertex *vertex,\r
+                         AliMCEvent *mcEvent);\r
+  void FillCorrectionMaps(AliAODEvent *fAOD);\r
+               \r
+  AliCFContainer *GetProtonContainer() const {\r
+    return fCFManagerProtons->GetParticleContainer();}\r
+  AliCFContainer *GetAntiProtonContainer() const {\r
+    return fCFManagerAntiProtons->GetParticleContainer();}\r
+  \r
+ private:\r
+  AliProtonSpectraCorrection(const AliProtonSpectraCorrection&); // Not implemented\r
+  AliProtonSpectraCorrection& operator=(const AliProtonSpectraCorrection&); // Not implemented\r
+  \r
+  AliProtonAnalysisBase *fProtonAnalysisBase;//base analysis object\r
+  \r
+  Int_t fNBinsY; //number of bins in y or eta\r
+  Double_t fMinY, fMaxY; //min & max value of y or eta\r
+  Int_t fNBinsPt;  //number of bins in pT\r
+  Double_t fMinPt, fMaxPt; //min & max value of pT\r
+  \r
+  //Analysis containers\r
+  AliCFManager   *fCFManagerProtons;      // CF manager protons\r
+  AliCFManager   *fCFManagerAntiProtons;  // CF manager antiprotons\r
+    \r
+  ClassDef(AliProtonSpectraCorrection,1);\r
+};\r
+\r
+#endif\r
+\r

diff --git a/PWG2/libPWG2spectra.pkg b/PWG2/libPWG2spectra.pkg
index eaae933b5305c9800c9f64721fd7e7dccaf86ace..42f618cc71f5c102435b36e53eecfcea3ec81dca 100644 (file)
--- a/PWG2/libPWG2spectra.pkg
+++ b/PWG2/libPWG2spectra.pkg
@@ -14,6 +14,7 @@ SRCS= SPECTRA/AliProtonAnalysisBase.cxx \
       SPECTRA/AliProtonFeedDownAnalysisTask.cxx \
       SPECTRA/AliProtonFeedDownAnalysis.cxx \
       SPECTRA/AliProtonAbsorptionCorrection.cxx \
+      SPECTRA/AliProtonSpectraCorrection.cxx \
       SPECTRA/AliAnalysisCentralCutMC.cxx \
       SPECTRA/AliAnalysisCentralCutESD.cxx \
       SPECTRA/AliAnalysisCentralCutEvtMC.cxx \