- new clesses added

A    PWG0/dNdPt/AliPtResolAnalysis.cxx
A    PWG0/dNdPt/AliPtResolAnalysisPbPb.cxx
A    PWG0/dNdPt/AliPtResolAnalysis.h
A    PWG0/dNdPt/AliPtResolAnalysisPbPb.h
M    PWG0/CMakelibPWG0dep.pkg
M    PWG0/PWG0depLinkDef.h

-- modifications by M.Knichel
M    PWG0/dNdPt/AlidNdPt.h
M    PWG0/dNdPt/AlidNdPtHelper.h
M    PWG0/dNdPt/AlidNdPtAnalysis.h
M    PWG0/dNdPt/AlidNdPtAnalysisPbPb.h
M    PWG0/dNdPt/AlidNdPtHelper.cxx
M    PWG0/dNdPt/AlidNdPt.cxx
M    PWG0/dNdPt/AlidNdPtAnalysis.cxx
M    PWG0/dNdPt/AlidNdPtAnalysisPbPb.cxx

diff --git a/PWG0/CMakelibPWG0dep.pkg b/PWG0/CMakelibPWG0dep.pkg
index e381770881dad642174985700ddf11e35f7df80e..176956ca27eca5d672f8c646bf22fdd83c766a93 100644 (file)
--- a/PWG0/CMakelibPWG0dep.pkg
+++ b/PWG0/CMakelibPWG0dep.pkg
@@ -25,7 +25,7 @@
 # SHLIBS - Shared Libraries and objects for linking (Executables only)           #
 #--------------------------------------------------------------------------------#
 
-set ( SRCS  dNdPt/AlidNdPtHelper.cxx dNdPt/AlidNdPtAnalysis.cxx dNdPt/AlidNdPtAnalysisPbPb.cxx dNdPt/AlidNdPtCorrection.cxx dNdPt/AlidNdPtAcceptanceCuts.cxx dNdPt/AlidNdPtEventCuts.cxx dNdPt/AlidNdPt.cxx dNdPt/AlidNdPtCutAnalysis.cxx dNdPt/AlidNdPtTask.cxx dNdPt/AlidNdPtBackgroundCuts.cxx dNdPt/AlidNdPtCutAnalysisPbPb.cxx dNdPt/AlidNdPtEfficiency.cxx)
+set ( SRCS  dNdPt/AlidNdPtHelper.cxx dNdPt/AlidNdPtAnalysis.cxx dNdPt/AlidNdPtAnalysisPbPb.cxx dNdPt/AlidNdPtCorrection.cxx dNdPt/AlidNdPtAcceptanceCuts.cxx dNdPt/AlidNdPtEventCuts.cxx dNdPt/AlidNdPt.cxx dNdPt/AlidNdPtCutAnalysis.cxx dNdPt/AlidNdPtTask.cxx dNdPt/AlidNdPtBackgroundCuts.cxx dNdPt/AlidNdPtCutAnalysisPbPb.cxx dNdPt/AlidNdPtEfficiency.cxx dNdPt/AliPtResolAnalysis.cxx dNdPt/AliPtResolAnalysisPbPb.cxx ) 
 
 string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 

diff --git a/PWG0/PWG0depLinkDef.h b/PWG0/PWG0depLinkDef.h
index 14ad288f3956e5bc2e0da380b8bc085de4bc02e7..d6aefa4bc572e8e418754ac9937519dd566c6d34 100644 (file)
--- a/PWG0/PWG0depLinkDef.h
+++ b/PWG0/PWG0depLinkDef.h
@@ -22,5 +22,7 @@
 
 #pragma link C++ class AlidNdPtBackgroundCuts+;
 #pragma link C++ class AlidNdPtEfficiency+;
+#pragma link C++ class AliPtResolAnalysis+;
+#pragma link C++ class AliPtResolAnalysisPbPb+;
 
 #endif

diff --git a/PWG0/dNdPt/AliPtResolAnalysis.cxx b/PWG0/dNdPt/AliPtResolAnalysis.cxx
new file mode 100644 (file)
index 0000000..dcac70b
--- /dev/null
+++ b/PWG0/dNdPt/AliPtResolAnalysis.cxx
@@ -0,0 +1,305 @@
+/**************************************************************************\r
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
+ *                                                                        *\r
+ * Author: The ALICE Off-line Project.                                    *\r
+ * Contributors are mentioned in the code where appropriate.              *\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
+// AliPtResolAnalysis class. \r
+// \r
+// a. functionality:\r
+// - fills analysis control histograms\r
+//\r
+// b. data members:\r
+// - control histograms\r
+//\r
+// Author: J.Otwinowski 04/11/2008 \r
+//------------------------------------------------------------------------------\r
+\r
+#include "TH1.h"\r
+#include "TH2.h"\r
+#include "TCanvas.h"\r
+#include "THnSparse.h"\r
+\r
+#include "AliHeader.h"  \r
+#include "AliInputEventHandler.h"  \r
+#include "AliAnalysisManager.h"  \r
+#include "AliGenEventHeader.h"  \r
+#include "AliStack.h"  \r
+#include "AliESDEvent.h"  \r
+#include "AliMCEvent.h"  \r
+#include "AliESDtrackCuts.h"  \r
+#include "AliLog.h" \r
+#include "AliMultiplicity.h"\r
+#include "AliTracker.h"\r
+\r
+#include "AlidNdPtEventCuts.h"\r
+#include "AlidNdPtAcceptanceCuts.h"\r
+#include "AliPhysicsSelection.h"\r
+#include "AliTriggerAnalysis.h"\r
+\r
+#include "AliPWG0Helper.h"\r
+#include "AlidNdPtHelper.h"\r
+#include "AliPtResolAnalysis.h"\r
+\r
+using namespace std;\r
+\r
+ClassImp(AliPtResolAnalysis)\r
+\r
+//_____________________________________________________________________________\r
+  AliPtResolAnalysis::AliPtResolAnalysis(): AlidNdPt(),\r
+  fAnalysisFolder(0),\r
+  fTrackParamHist(0)\r
+{\r
+  // default constructor\r
+  Init();\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliPtResolAnalysis::AliPtResolAnalysis(Char_t* name, Char_t* title): AlidNdPt(name,title),\r
+  fAnalysisFolder(0),\r
+  fTrackParamHist(0)\r
+{\r
+  Init();\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliPtResolAnalysis::~AliPtResolAnalysis() {\r
+  //\r
+  // destructor\r
+  //\r
+  if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;\r
+  if(fTrackParamHist) delete fTrackParamHist; fTrackParamHist=0;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliPtResolAnalysis::Init(){\r
+  //\r
+  // Generic histograms to be corrected\r
+  //\r
+  //1/pT:#sigma(1/pT)\r
+  Int_t binsTrackParamHist[2]={400,300};\r
+  Double_t minTrackParamHist[2]={0,0}; \r
+  Double_t maxTrackParamHist[2]={1,0.015};\r
+\r
+  fTrackParamHist = new THnSparseF("fTrackParamHist","1/pT:#sigma(1/pT)",2,binsTrackParamHist,minTrackParamHist,maxTrackParamHist);\r
+  fTrackParamHist->GetAxis(0)->SetTitle("1/pT (GeV/c)^{-1}");\r
+  fTrackParamHist->GetAxis(1)->SetTitle("#sigma(1/pT)" );\r
+  fTrackParamHist->Sumw2();\r
+  \r
+  // init folder\r
+  fAnalysisFolder = CreateFolder("folderdNdPt","Analysis dNdPt Folder");\r
+  \r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliPtResolAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mcEvent)\r
+{\r
+  //\r
+  // Process real and/or simulated events\r
+  //\r
+  if(!esdEvent) {\r
+    AliDebug(AliLog::kError, "esdEvent not available");\r
+    return;\r
+  }\r
+\r
+  // get selection cuts\r
+  AlidNdPtEventCuts *evtCuts = GetEventCuts(); \r
+  AlidNdPtAcceptanceCuts *accCuts = GetAcceptanceCuts(); \r
+  AliESDtrackCuts *esdTrackCuts = GetTrackCuts(); \r
+\r
+  if(!evtCuts || !accCuts  || !esdTrackCuts) {\r
+    AliDebug(AliLog::kError, "cuts not available");\r
+    return;\r
+  }\r
+\r
+  // trigger selection\r
+  Bool_t isEventTriggered = kTRUE;\r
+  AliPhysicsSelection *physicsSelection = NULL;\r
+  AliTriggerAnalysis* triggerAnalysis = NULL;\r
+\r
+  // \r
+  AliInputEventHandler* inputHandler = (AliInputEventHandler*) AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();\r
+  if (!inputHandler)\r
+  {\r
+    Printf("ERROR: Could not receive input handler");\r
+    return;\r
+  }\r
+\r
+  if(evtCuts->IsTriggerRequired())  \r
+  {\r
+    // always MB\r
+    isEventTriggered = inputHandler->IsEventSelected() & AliVEvent::kMB;\r
+\r
+    physicsSelection = static_cast<AliPhysicsSelection*> (inputHandler->GetEventSelection());\r
+    if(!physicsSelection) return;\r
+    //SetPhysicsTriggerSelection(physicsSelection);\r
+\r
+    if (isEventTriggered && (GetTrigger() == AliTriggerAnalysis::kV0AND)) {\r
+      // set trigger (V0AND)\r
+      triggerAnalysis = physicsSelection->GetTriggerAnalysis();\r
+      if(!triggerAnalysis) return;\r
+      isEventTriggered = triggerAnalysis->IsOfflineTriggerFired(esdEvent, GetTrigger());\r
+    }\r
+\r
+  // get reconstructed vertex  \r
+  const AliESDVertex* vtxESD = 0; \r
+  Bool_t isRecVertex = kFALSE;\r
+  if(evtCuts->IsRecVertexRequired()) \r
+  {\r
+    Bool_t bRedoTPCVertex = evtCuts->IsRedoTPCVertex();\r
+    Bool_t bUseConstraints = evtCuts->IsUseBeamSpotConstraint();\r
+    vtxESD = AlidNdPtHelper::GetVertex(esdEvent,evtCuts,accCuts,esdTrackCuts,GetAnalysisMode(),kFALSE,bRedoTPCVertex,bUseConstraints); \r
+    isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, esdEvent->GetPrimaryVertexSPD(), GetAnalysisMode(), kFALSE);\r
+  }\r
+\r
+  Bool_t isEventOK = evtCuts->AcceptEvent(esdEvent,mcEvent,vtxESD) && isRecVertex; \r
+  //printf("isEventOK %d, isEventTriggered %d \n",isEventOK, isEventTriggered);\r
+  //printf("GetAnalysisMode() %d \n",GetAnalysisMode());\r
+\r
+  //\r
+  TObjArray *allChargedTracks=0;\r
+  // check event cuts\r
+  if(isEventOK && isEventTriggered)\r
+  {\r
+    // get all charged tracks\r
+    allChargedTracks = AlidNdPtHelper::GetAllChargedTracks(esdEvent,GetAnalysisMode());\r
+    if(!allChargedTracks) return;\r
+\r
+    Int_t entries = allChargedTracks->GetEntries();\r
+    //printf("entries %d \n",entries);\r
+\r
+    // fill histograms\r
+    for(Int_t i=0; i<entries;++i) \r
+    {\r
+      AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);\r
+      if(!track) continue;\r
+      if(track->Charge()==0) continue;\r
+\r
+      // only postive charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kPlus && track->Charge() < 0) \r
+        continue;\r
+      \r
+      // only negative charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kMinus && track->Charge() > 0) \r
+        continue;\r
+\r
+      if(esdTrackCuts->AcceptTrack(track)) \r
+      {\r
+        if(accCuts->AcceptTrack(track)) \r
+        {\r
+         //Double_t x, par[5], cov[15];\r
+         //track->GetExternalParameters(x, p);\r
+         //track->GetExternalCovariance(cov);\r
+\r
+         Double_t v[2] = {track->OneOverPt(),TMath::Sqrt(track->GetSigma1Pt2())};\r
+         fTrackParamHist->Fill(v);\r
+        }\r
+      }  \r
+    }\r
+  }\r
+ }\r
+}\r
+\r
+//_____________________________________________________________________________\r
+Long64_t AliPtResolAnalysis::Merge(TCollection* const list) \r
+{\r
+  // Merge list of objects (needed by PROOF)\r
+\r
+  if (!list)\r
+  return 0;\r
+\r
+  if (list->IsEmpty())\r
+  return 1;\r
+\r
+  TIterator* iter = list->MakeIterator();\r
+  TObject* obj = 0;\r
+\r
+  //\r
+  //TList *collPhysSelection = new TList;\r
+\r
+  // collection of generated histograms\r
+\r
+  Int_t count=0;\r
+  while((obj = iter->Next()) != 0) {\r
+    AliPtResolAnalysis* entry = dynamic_cast<AliPtResolAnalysis*>(obj);\r
+    if (entry == 0) continue; \r
+    \r
+    //\r
+    fTrackParamHist->Add(entry->fTrackParamHist);\r
+  }\r
+\r
+return count;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliPtResolAnalysis::Analyse() \r
+{\r
+  // Analyse histograms\r
+  //\r
+  TH1::AddDirectory(kFALSE);\r
+  TObjArray *aFolderObj = new TObjArray;\r
+  \r
+  //\r
+  // Reconstructed event vertex\r
+  //\r
+  \r
+  // export objects to analysis folder\r
+  fAnalysisFolder = ExportToFolder(aFolderObj);\r
+\r
+  // delete only TObjArray\r
+  if(aFolderObj) delete aFolderObj;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+TFolder* AliPtResolAnalysis::ExportToFolder(TObjArray * const array) \r
+{\r
+  // recreate folder avery time and export objects to new one\r
+  //\r
+  AliPtResolAnalysis * comp=this;\r
+  TFolder *folder = comp->GetAnalysisFolder();\r
+\r
+  TString name, title;\r
+  TFolder *newFolder = 0;\r
+  Int_t i = 0;\r
+  Int_t size = array->GetSize();\r
+\r
+  if(folder) { \r
+     // get name and title from old folder\r
+     name = folder->GetName();  \r
+     title = folder->GetTitle();  \r
+\r
+        // delete old one\r
+     delete folder;\r
+\r
+        // create new one\r
+     newFolder = CreateFolder(name.Data(),title.Data());\r
+     newFolder->SetOwner();\r
+\r
+        // add objects to folder\r
+     while(i < size) {\r
+          newFolder->Add(array->At(i));\r
+          i++;\r
+        }\r
+  }\r
+\r
+return newFolder;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+TFolder* AliPtResolAnalysis::CreateFolder(TString name,TString title) { \r
+// create folder for analysed histograms\r
+//\r
+TFolder *folder = 0;\r
+  folder = new TFolder(name.Data(),title.Data());\r
+\r
+  return folder;\r
+}\r

diff --git a/PWG0/dNdPt/AliPtResolAnalysis.h b/PWG0/dNdPt/AliPtResolAnalysis.h
new file mode 100644 (file)
index 0000000..9418149
--- /dev/null
+++ b/PWG0/dNdPt/AliPtResolAnalysis.h
@@ -0,0 +1,67 @@
+#ifndef ALIPTRESOLANALYSIS_H
+#define ALIPTRESOLANALYSIS_H
+
+//------------------------------------------------------------------------------
+// AliPtResolAnalysis class used for dNdPt analysis. 
+// 
+// Author: J.Otwinowski 05/05/2011 
+//------------------------------------------------------------------------------
+
+class iostream;
+
+class TFile;
+class TCint;
+class TProfile;
+class TFolder;
+class TObjArray;
+class TString;
+class THnSparse;
+
+class AliESDtrackCuts;
+class AliVertexerTracks;
+class AliESD;
+class AliESDfriend;
+class AliESDfriendTrack;
+class AlidNdPtHelper;
+
+#include "AlidNdPt.h"
+
+class AliPtResolAnalysis : public AlidNdPt {
+public :
+  AliPtResolAnalysis(); 
+  AliPtResolAnalysis(Char_t* name, Char_t* title);
+  ~AliPtResolAnalysis();
+
+  // Init data members
+  virtual void Init();
+
+  // Process events
+  virtual void Process(AliESDEvent *const esdEvent=0, AliMCEvent *const mcEvent=0);
+
+  // Merge output objects (needed by PROOF) 
+  virtual Long64_t Merge(TCollection* const list);
+
+  // Analyse output histograms 
+  virtual void Analyse();
+
+  // Export objects to folder
+  virtual TFolder *ExportToFolder(TObjArray * const array=0);
+  TFolder* CreateFolder(TString name,TString title);
+
+  // Get analysis folder
+  TFolder* GetAnalysisFolder() const {return fAnalysisFolder;}
+  THnSparseF *GetTrackParamHist() const {return fTrackParamHist;} 
+
+private:
+
+  // analysis folder 
+  TFolder *fAnalysisFolder; // folder for analysed histograms
+  THnSparseF *fTrackParamHist;  //-> sigma(1/pT):1/pT
+
+  AliPtResolAnalysis(const AliPtResolAnalysis&); // not implemented
+  AliPtResolAnalysis& operator=(const AliPtResolAnalysis&); // not implemented
+
+  ClassDef(AliPtResolAnalysis,1);
+};
+
+#endif

diff --git a/PWG0/dNdPt/AliPtResolAnalysisPbPb.cxx b/PWG0/dNdPt/AliPtResolAnalysisPbPb.cxx
new file mode 100644 (file)
index 0000000..e9c9fad
--- /dev/null
+++ b/PWG0/dNdPt/AliPtResolAnalysisPbPb.cxx
@@ -0,0 +1,320 @@
+/**************************************************************************\r
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
+ *                                                                        *\r
+ * Author: The ALICE Off-line Project.                                    *\r
+ * Contributors are mentioned in the code where appropriate.              *\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
+// AliPtResolAnalysisPbPb class. \r
+// \r
+// a. functionality:\r
+// - fills analysis control histograms\r
+//\r
+// b. data members:\r
+// - control histograms\r
+//\r
+// Author: J.Otwinowski 04/11/2008 \r
+//------------------------------------------------------------------------------\r
+\r
+#include "TH1.h"\r
+#include "TH2.h"\r
+#include "TCanvas.h"\r
+#include "THnSparse.h"\r
+\r
+#include "AliHeader.h"  \r
+#include "AliInputEventHandler.h"  \r
+#include "AliAnalysisManager.h"  \r
+#include "AliGenEventHeader.h"  \r
+#include "AliStack.h"  \r
+#include "AliESDEvent.h"  \r
+#include "AliMCEvent.h"  \r
+#include "AliESDtrackCuts.h"  \r
+#include "AliLog.h" \r
+#include "AliMultiplicity.h"\r
+#include "AliTracker.h"\r
+#include "AliCentrality.h"\r
+\r
+#include "AlidNdPtEventCuts.h"\r
+#include "AlidNdPtAcceptanceCuts.h"\r
+#include "AliPhysicsSelection.h"\r
+#include "AliTriggerAnalysis.h"\r
+\r
+#include "AliPWG0Helper.h"\r
+#include "AlidNdPtHelper.h"\r
+#include "AliPtResolAnalysisPbPb.h"\r
+\r
+\r
+using namespace std;\r
+\r
+ClassImp(AliPtResolAnalysisPbPb)\r
+\r
+//_____________________________________________________________________________\r
+  AliPtResolAnalysisPbPb::AliPtResolAnalysisPbPb(): AlidNdPt(),\r
+  fAnalysisFolder(0),\r
+  fTrackParamHist(0),\r
+  fCentralityEstimator(0)\r
+{\r
+  // default constructor\r
+  Init();\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliPtResolAnalysisPbPb::AliPtResolAnalysisPbPb(Char_t* name, Char_t* title): AlidNdPt(name,title),\r
+  fAnalysisFolder(0),\r
+  fTrackParamHist(0),\r
+  fCentralityEstimator(0)\r
+{\r
+  Init();\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliPtResolAnalysisPbPb::~AliPtResolAnalysisPbPb() {\r
+  //\r
+  // destructor\r
+  //\r
+  if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;\r
+  if(fTrackParamHist) delete fTrackParamHist; fTrackParamHist=0;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliPtResolAnalysisPbPb::Init(){\r
+  //\r
+  // Generic histograms to be corrected\r
+  //\r
+  //1/pT:#sigma(1/pT):centrality\r
+  Int_t binsTrackParamHist[3]={400,300,11};\r
+  Double_t minTrackParamHist[3]={0,0,0}; \r
+  Double_t maxTrackParamHist[3]={1,0.015,100};\r
+\r
+  Double_t centrBins[12] = {0.0,5.,10.,20.,30.,40.,50.,60.,70.,80.,90.,100}; \r
+\r
+\r
+  fTrackParamHist = new THnSparseF("fTrackParamHist","1/pT:#sigma(1/pT):centrality",3,binsTrackParamHist,minTrackParamHist,maxTrackParamHist);\r
+  fTrackParamHist->SetBinEdges(2,centrBins);\r
+  fTrackParamHist->GetAxis(0)->SetTitle("1/pT (GeV/c)^{-1}");\r
+  fTrackParamHist->GetAxis(1)->SetTitle("#sigma(1/pT)" );\r
+  fTrackParamHist->GetAxis(2)->SetTitle("centrality" );\r
+  fTrackParamHist->Sumw2();\r
+  \r
+  // init folder\r
+  fAnalysisFolder = CreateFolder("folderdNdPt","Analysis dNdPt Folder");\r
+  \r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliPtResolAnalysisPbPb::Process(AliESDEvent *const esdEvent, AliMCEvent *const mcEvent)\r
+{\r
+  //\r
+  // Process real and/or simulated events\r
+  //\r
+  if(!esdEvent) {\r
+    AliDebug(AliLog::kError, "esdEvent not available");\r
+    return;\r
+  }\r
+\r
+  // get selection cuts\r
+  AlidNdPtEventCuts *evtCuts = GetEventCuts(); \r
+  AlidNdPtAcceptanceCuts *accCuts = GetAcceptanceCuts(); \r
+  AliESDtrackCuts *esdTrackCuts = GetTrackCuts(); \r
+\r
+  if(!evtCuts || !accCuts  || !esdTrackCuts) {\r
+    AliDebug(AliLog::kError, "cuts not available");\r
+    return;\r
+  }\r
+\r
+  // trigger selection\r
+  Bool_t isEventTriggered = kTRUE;\r
+  AliPhysicsSelection *physicsSelection = NULL;\r
+  AliTriggerAnalysis* triggerAnalysis = NULL;\r
+\r
+  // \r
+  AliInputEventHandler* inputHandler = (AliInputEventHandler*) AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();\r
+  if (!inputHandler)\r
+  {\r
+    Printf("ERROR: Could not receive input handler");\r
+    return;\r
+  }\r
+\r
+  if(evtCuts->IsTriggerRequired())  \r
+  {\r
+    // always MB\r
+    isEventTriggered = inputHandler->IsEventSelected() & AliVEvent::kMB;\r
+\r
+    physicsSelection = static_cast<AliPhysicsSelection*> (inputHandler->GetEventSelection());\r
+    if(!physicsSelection) return;\r
+    //SetPhysicsTriggerSelection(physicsSelection);\r
+\r
+    if (isEventTriggered && (GetTrigger() == AliTriggerAnalysis::kV0AND)) {\r
+      // set trigger (V0AND)\r
+      triggerAnalysis = physicsSelection->GetTriggerAnalysis();\r
+      if(!triggerAnalysis) return;\r
+      isEventTriggered = triggerAnalysis->IsOfflineTriggerFired(esdEvent, GetTrigger());\r
+    }\r
+\r
+\r
+   // centrality determination\r
+   Float_t centralityF = -1.;\r
+   AliCentrality *esdCentrality = esdEvent->GetCentrality();\r
+   centralityF = esdCentrality->GetCentralityPercentile(fCentralityEstimator.Data());\r
+\r
+  // get reconstructed vertex  \r
+  const AliESDVertex* vtxESD = 0; \r
+  Bool_t isRecVertex = kFALSE;\r
+  if(evtCuts->IsRecVertexRequired()) \r
+  {\r
+    Bool_t bRedoTPCVertex = evtCuts->IsRedoTPCVertex();\r
+    Bool_t bUseConstraints = evtCuts->IsUseBeamSpotConstraint();\r
+    vtxESD = AlidNdPtHelper::GetVertex(esdEvent,evtCuts,accCuts,esdTrackCuts,GetAnalysisMode(),kFALSE,bRedoTPCVertex,bUseConstraints); \r
+    isRecVertex = AlidNdPtHelper::TestRecVertex(vtxESD, esdEvent->GetPrimaryVertexSPD(), GetAnalysisMode(), kFALSE);\r
+  }\r
+\r
+  Bool_t isEventOK = evtCuts->AcceptEvent(esdEvent,mcEvent,vtxESD) && isRecVertex; \r
+  //printf("isEventOK %d, isEventTriggered %d \n",isEventOK, isEventTriggered);\r
+  //printf("GetAnalysisMode() %d \n",GetAnalysisMode());\r
+\r
+  //\r
+  TObjArray *allChargedTracks=0;\r
+  // check event cuts\r
+  if(isEventOK && isEventTriggered)\r
+  {\r
+    // get all charged tracks\r
+    allChargedTracks = AlidNdPtHelper::GetAllChargedTracks(esdEvent,GetAnalysisMode());\r
+    if(!allChargedTracks) return;\r
+\r
+    Int_t entries = allChargedTracks->GetEntries();\r
+    //printf("entries %d \n",entries);\r
+\r
+    // fill histograms\r
+    for(Int_t i=0; i<entries;++i) \r
+    {\r
+      AliESDtrack *track = (AliESDtrack*)allChargedTracks->At(i);\r
+      if(!track) continue;\r
+      if(track->Charge()==0) continue;\r
+\r
+      // only postive charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kPlus && track->Charge() < 0) \r
+        continue;\r
+      \r
+      // only negative charged \r
+      if(GetParticleMode() == AlidNdPtHelper::kMinus && track->Charge() > 0) \r
+        continue;\r
+\r
+      if(esdTrackCuts->AcceptTrack(track)) \r
+      {\r
+        if(accCuts->AcceptTrack(track)) \r
+        {\r
+         //Double_t x, par[5], cov[15];\r
+         //track->GetExternalParameters(x, p);\r
+         //track->GetExternalCovariance(cov);\r
+\r
+         Double_t v[3] = {track->OneOverPt(),TMath::Sqrt(track->GetSigma1Pt2()),centralityF};\r
+         fTrackParamHist->Fill(v);\r
+        }\r
+      }  \r
+    }\r
+  }\r
+ }\r
+}\r
+\r
+//_____________________________________________________________________________\r
+Long64_t AliPtResolAnalysisPbPb::Merge(TCollection* const list) \r
+{\r
+  // Merge list of objects (needed by PROOF)\r
+\r
+  if (!list)\r
+  return 0;\r
+\r
+  if (list->IsEmpty())\r
+  return 1;\r
+\r
+  TIterator* iter = list->MakeIterator();\r
+  TObject* obj = 0;\r
+\r
+  //\r
+  //TList *collPhysSelection = new TList;\r
+\r
+  // collection of generated histograms\r
+\r
+  Int_t count=0;\r
+  while((obj = iter->Next()) != 0) {\r
+    AliPtResolAnalysisPbPb* entry = dynamic_cast<AliPtResolAnalysisPbPb*>(obj);\r
+    if (entry == 0) continue; \r
+    \r
+    //\r
+    fTrackParamHist->Add(entry->fTrackParamHist);\r
+  }\r
+\r
+return count;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliPtResolAnalysisPbPb::Analyse() \r
+{\r
+  // Analyse histograms\r
+  //\r
+  TH1::AddDirectory(kFALSE);\r
+  TObjArray *aFolderObj = new TObjArray;\r
+  \r
+  //\r
+  // Reconstructed event vertex\r
+  //\r
+  \r
+  // export objects to analysis folder\r
+  fAnalysisFolder = ExportToFolder(aFolderObj);\r
+\r
+  // delete only TObjArray\r
+  if(aFolderObj) delete aFolderObj;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+TFolder* AliPtResolAnalysisPbPb::ExportToFolder(TObjArray * const array) \r
+{\r
+  // recreate folder avery time and export objects to new one\r
+  //\r
+  AliPtResolAnalysisPbPb * comp=this;\r
+  TFolder *folder = comp->GetAnalysisFolder();\r
+\r
+  TString name, title;\r
+  TFolder *newFolder = 0;\r
+  Int_t i = 0;\r
+  Int_t size = array->GetSize();\r
+\r
+  if(folder) { \r
+     // get name and title from old folder\r
+     name = folder->GetName();  \r
+     title = folder->GetTitle();  \r
+\r
+        // delete old one\r
+     delete folder;\r
+\r
+        // create new one\r
+     newFolder = CreateFolder(name.Data(),title.Data());\r
+     newFolder->SetOwner();\r
+\r
+        // add objects to folder\r
+     while(i < size) {\r
+          newFolder->Add(array->At(i));\r
+          i++;\r
+        }\r
+  }\r
+\r
+return newFolder;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+TFolder* AliPtResolAnalysisPbPb::CreateFolder(TString name,TString title) { \r
+// create folder for analysed histograms\r
+//\r
+TFolder *folder = 0;\r
+  folder = new TFolder(name.Data(),title.Data());\r
+\r
+  return folder;\r
+}\r

diff --git a/PWG0/dNdPt/AliPtResolAnalysisPbPb.h b/PWG0/dNdPt/AliPtResolAnalysisPbPb.h
new file mode 100644 (file)
index 0000000..47221d0
--- /dev/null
+++ b/PWG0/dNdPt/AliPtResolAnalysisPbPb.h
@@ -0,0 +1,72 @@
+#ifndef ALIPTRESOLANALYSISPBPB_H
+#define ALIPTRESOLANALYSISPBPB_H
+
+//------------------------------------------------------------------------------
+// AliPtResolAnalysisPbPb class used for dNdPt analysis. 
+// 
+// Author: J.Otwinowski 05/05/2011 
+//------------------------------------------------------------------------------
+
+class iostream;
+
+class TFile;
+class TCint;
+class TProfile;
+class TFolder;
+class TObjArray;
+class TString;
+class THnSparse;
+
+class AliESDtrackCuts;
+class AliVertexerTracks;
+class AliESD;
+class AliESDfriend;
+class AliESDfriendTrack;
+class AlidNdPtHelper;
+
+#include "AlidNdPt.h"
+
+class AliPtResolAnalysisPbPb : public AlidNdPt {
+public :
+  AliPtResolAnalysisPbPb(); 
+  AliPtResolAnalysisPbPb(Char_t* name, Char_t* title);
+  ~AliPtResolAnalysisPbPb();
+
+  // Init data members
+  virtual void Init();
+
+  // Process events
+  virtual void Process(AliESDEvent *const esdEvent=0, AliMCEvent *const mcEvent=0);
+
+  // Merge output objects (needed by PROOF) 
+  virtual Long64_t Merge(TCollection* const list);
+
+  // Analyse output histograms 
+  virtual void Analyse();
+
+  // Export objects to folder
+  virtual TFolder *ExportToFolder(TObjArray * const array=0);
+  TFolder* CreateFolder(TString name,TString title);
+
+  // Get analysis folder
+  TFolder* GetAnalysisFolder() const {return fAnalysisFolder;}
+  THnSparseF *GetTrackParamHist() const {return fTrackParamHist;} 
+
+  void SetCentralityEstimator(TString centEst="V0M") { fCentralityEstimator = centEst; }
+  TString GetCentralityEstimator() const {return fCentralityEstimator; }
+
+private:
+
+  // analysis folder 
+  TFolder *fAnalysisFolder; // folder for analysed histograms
+  THnSparseF *fTrackParamHist;  //-> sigma(1/pT):1/pT:centr
+
+  TString fCentralityEstimator;     // use centrality can be "VOM" (default), "FMD", "TRK", "TKL", "CL0", "CL1", "V0MvsFMD", "TKLvsV0M", "ZEMvsZDC"
+
+  AliPtResolAnalysisPbPb(const AliPtResolAnalysisPbPb&); // not implemented
+  AliPtResolAnalysisPbPb& operator=(const AliPtResolAnalysisPbPb&); // not implemented
+
+  ClassDef(AliPtResolAnalysisPbPb,1);
+};
+
+#endif

diff --git a/PWG0/dNdPt/AlidNdPt.cxx b/PWG0/dNdPt/AlidNdPt.cxx
index 4954a54fa03d312329a5e8c0539bd36d25f8767f..dc424736e199dc4899a65dd3d0687fd47b9ff039 100644 (file)
--- a/PWG0/dNdPt/AlidNdPt.cxx
+++ b/PWG0/dNdPt/AlidNdPt.cxx
@@ -110,3 +110,12 @@ Double_t * AlidNdPt::CreateLogAxis(Int_t nbins, Double_t xmin, Double_t xmax) {
 \r
 return xbins;\r
 }\r
+//_____________________________________________________________________________\r
+\r
+Double_t* AlidNdPt::CloneArray(Int_t n, Double_t* source)\r
+{\r
+    if (!source || n==0) return 0;\r
+    Double_t* dest = new Double_t[n];\r
+    for (Int_t i=0; i<n ; i++) { dest[i] = source[i]; }\r
+    return dest;\r
+}\r

diff --git a/PWG0/dNdPt/AlidNdPt.h b/PWG0/dNdPt/AlidNdPt.h
index 3050fd7986fd13a1f3063d34742f68fb6f398252..239be8bf34d5d7156f806a19aa329753f41023b5 100644 (file)
--- a/PWG0/dNdPt/AlidNdPt.h
+++ b/PWG0/dNdPt/AlidNdPt.h
@@ -70,6 +70,9 @@ public:
   AlidNdPtBackgroundCuts* GetBackgroundCuts() const             { return fdNdPtBackgroundCuts; }
   Double_t* CreateLogAxis(Int_t nbins, Double_t xmin, Double_t xmax);
 
+protected:
+   static Double_t* CloneArray(Int_t n, Double_t* source);
+
 private:
 
   AlidNdPt(const AlidNdPt&); // not implemented

diff --git a/PWG0/dNdPt/AlidNdPtAnalysis.cxx b/PWG0/dNdPt/AlidNdPtAnalysis.cxx
index b8ed4a88815e98843a35e071c457370faf153e54..a077fa52d10d3547e689c347d9adc174f64643ea 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtAnalysis.cxx
+++ b/PWG0/dNdPt/AlidNdPtAnalysis.cxx
@@ -374,65 +374,60 @@ AlidNdPtAnalysis::~AlidNdPtAnalysis() {
 \r
   //\r
   if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;\r
+  \r
+  if (fBinsMult) delete[] fBinsMult; fBinsMult=0;\r
+  if (fBinsPt) delete[] fBinsPt; fBinsPt=0;\r
+  if (fBinsPtCorr) delete[] fBinsPtCorr; fBinsPtCorr=0;\r
+  if (fBinsEta) delete[] fBinsEta; fBinsEta=0;\r
+  if (fBinsZv) delete[] fBinsMult; fBinsZv=0;\r
 }\r
 \r
 //_____________________________________________________________________________\r
-void AlidNdPtAnalysis::Init(){\r
-  \r
-  Int_t multNbins = 27;\r
-  Int_t ptNbinsTrackEventCorr = 36;\r
-  Int_t ptNbins = 68;\r
-  Int_t etaNbins = 30;\r
-  Int_t zvNbins = 12;\r
-\r
-  Double_t binsMultDefault[28] = {-0.5, 0.5 , 1.5 , 2.5 , 3.5 , 4.5 , 5.5 , 6.5 , 7.5 , 8.5,\r
+void AlidNdPtAnalysis::Init()\r
+{\r
+    //define default binning\r
+    Double_t binsMultDefault[28] = {-0.5, 0.5 , 1.5 , 2.5 , 3.5 , 4.5 , 5.5 , 6.5 , 7.5 , 8.5,\r
                                      9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5,\r
                                     19.5,20.5, 21.5, 22.5, 23.5, 24.5, 29.5, 149.5};\r
-\r
-  Double_t binsPtTrackEventCorrDefault[37] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,3.0,4.0,50.0};\r
-\r
-  Double_t binsPtDefault[69] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.5,5.0,5.5,6.0,6.5,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0,34.0,36.0,40.0,45.0,50.0};\r
-\r
-  Double_t binsEtaDefault[31] = {-1.5,-1.4,-1.3,-1.2,-1.1,-1.0,-0.9,-0.8,-0.7,-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5};\r
-\r
-  Double_t binsZvDefault[13] = {-30.,-25.,-20.,-15.,-10.,-5.,0.,5.,10.,15.,20.,25.,30.};\r
+    Double_t binsPtDefault[69] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.5,5.0,5.5,6.0,6.5,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0,34.0,36.0,40.0,45.0,50.0};\r
+    Double_t binsPtCorrDefault[37] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.4,2.6,3.0,4.0,50.0};    \r
+    Double_t binsEtaDefault[31] = {-1.5,-1.4,-1.3,-1.2,-1.1,-1.0,-0.9,-0.8,-0.7,-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5};\r
+    Double_t binsZvDefault[13] = {-30.,-25.,-20.,-15.,-10.,-5.,0.,5.,10.,15.,20.,25.,30.};\r
+\r
+   // if no binning is set, use the default\r
+   if (!fBinsMult)   { SetBinsMult(27,binsMultDefault); }\r
+   if (!fBinsPt)     { SetBinsPt(68,binsPtDefault); }\r
+   if (!fBinsPtCorr) { SetBinsPtCorr(36,binsPtCorrDefault); }\r
+   if (!fBinsEta)    { SetBinsEta(30,binsEtaDefault); }\r
+   if (!fBinsZv)     { SetBinsZv(12,binsZvDefault); }   \r
   \r
-  Double_t* binsMult = binsMultDefault;\r
-  Double_t* binsPtTrackEventCorr = binsPtTrackEventCorrDefault;\r
-  Double_t* binsPt = binsPtDefault;\r
-  Double_t* binsEta = binsEtaDefault;\r
-  Double_t* binsZv = binsZvDefault;  \r
-\r
-  if (fMultNbins > 0) { multNbins = fMultNbins; binsMult = fBinsMult; }\r
-  if (fPtNbins > 0) { ptNbins  = fPtNbins; binsPt = fBinsPt; }\r
-  if (fPtCorrNbins > 0) { ptNbinsTrackEventCorr  = fPtCorrNbins; binsPtTrackEventCorr = fBinsPtCorr;  }\r
-  if (fEtaNbins > 0) { etaNbins  = fEtaNbins; binsEta = fBinsEta; }\r
-  if (fZvNbins > 0) { zvNbins  = fZvNbins; binsZv = fBinsZv; }  \r
-\r
   //Int_t binsTrackMatrix[3]={zvNbins,ptNbins,etaNbins};\r
-  Int_t binsTrackEventCorrMatrix[3]={zvNbins,ptNbinsTrackEventCorr,etaNbins};\r
-\r
+  Int_t binsTrackEventCorrMatrix[3]={fZvNbins,fPtCorrNbins,fEtaNbins};\r
 \r
   //\r
   // Generic histograms to be corrected\r
   //\r
-  Int_t binsEventHist[2]={100,150};\r
-  Double_t minEventHist[2]={-25.,-0.5}; \r
-  Double_t maxEventHist[2]={25.,149.5}; \r
+  Int_t binsEventHist[2]={fZvNbins,fMultNbins};\r
+  //Double_t minEventHist[2]={-fBinsZv[0],fBinsMult[0]}; \r
+  //Double_t maxEventHist[2]={fBinsZv[fZvNbins],fBinsMult[fMultNbins]}; \r
 \r
-  fRecEventHist = new THnSparseF("fRecEventHist","Zv:multMB",2,binsEventHist,minEventHist,maxEventHist);\r
+  fRecEventHist = new THnSparseF("fRecEventHist","Zv:multMB",2,binsEventHist); //,minEventHist,maxEventHist);\r
+  fRecEventHist->SetBinEdges(0,fBinsZv);\r
+  fRecEventHist->SetBinEdges(1,fBinsMult);\r
   fRecEventHist->GetAxis(0)->SetTitle("Zv (cm)");\r
   fRecEventHist->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecEventHist->Sumw2();\r
 \r
   //\r
-  Int_t binsTrackHist[4]={100,ptNbins,etaNbins,150};\r
-  Double_t minTrackHist[4]={-25.,0.,-1.5,-0.5}; \r
-  Double_t maxTrackHist[4]={25.,50.,1.5,149.5}; \r
+  Int_t binsTrackHist[4]={fZvNbins,fPtNbins,fEtaNbins,fMultNbins};\r
+ // Double_t minTrackHist[4]={-25.,0.,-1.5,-0.5}; \r
+ // Double_t maxTrackHist[4]={25.,50.,1.5,149.5}; \r
 \r
-  fRecTrackHist = new THnSparseF("fRecTrackHist","Zv:pT:eta:multRec",4,binsTrackHist,minTrackHist,maxTrackHist);\r
-  fRecTrackHist->SetBinEdges(1,binsPt);\r
-  fRecTrackHist->SetBinEdges(2,binsEta);\r
+  fRecTrackHist = new THnSparseF("fRecTrackHist","Zv:pT:eta:multRec",4,binsTrackHist); //,minTrackHist,maxTrackHist);\r
+  fRecTrackHist->SetBinEdges(0,fBinsZv);\r
+  fRecTrackHist->SetBinEdges(1,fBinsPt);\r
+  fRecTrackHist->SetBinEdges(2,fBinsEta);\r
+  fRecTrackHist->SetBinEdges(3,fBinsMult);\r
   fRecTrackHist->GetAxis(0)->SetTitle("Zv (cm)");\r
   fRecTrackHist->GetAxis(1)->SetTitle("p_{T} (GeV/c)");\r
   fRecTrackHist->GetAxis(2)->SetTitle("#eta");\r
@@ -442,20 +437,23 @@ void AlidNdPtAnalysis::Init(){
   //\r
   // rec. vs MC correlation matrices\r
   //\r
-  Int_t binsMultTrueEventMatrix[3]={150,150,150};\r
-  Double_t minMultTrueEventMatrix[3]={-0.5,-0.5,-0.5}; \r
-  Double_t maxMultTrueEventMatrix[3]={149.5,149.5,149.5}; \r
-  fEventMultCorrelationMatrix = new THnSparseF("fEventMultCorrelationMatrix","mult:true_mult:multMB",3,binsMultTrueEventMatrix,minMultTrueEventMatrix,maxMultTrueEventMatrix);\r
+  Int_t binsMultTrueEventMatrix[3]={fMultNbins,fMultNbins,fMultNbins};\r
+//   Double_t minMultTrueEventMatrix[3]={-0.5,-0.5,-0.5}; \r
+//   Double_t maxMultTrueEventMatrix[3]={149.5,149.5,149.5}; \r
+  fEventMultCorrelationMatrix = new THnSparseF("fEventMultCorrelationMatrix","mult:true_mult:multMB",3,binsMultTrueEventMatrix); //,minMultTrueEventMatrix,maxMultTrueEventMatrix);\r
+  fEventMultCorrelationMatrix->SetBinEdges(0,fBinsMult);\r
+  fEventMultCorrelationMatrix->SetBinEdges(1,fBinsMult);\r
+  fEventMultCorrelationMatrix->SetBinEdges(2,fBinsMult);\r
   fEventMultCorrelationMatrix->GetAxis(0)->SetTitle("track multiplicity");\r
   fEventMultCorrelationMatrix->GetAxis(1)->SetTitle("true multiplicity");\r
   fEventMultCorrelationMatrix->GetAxis(2)->SetTitle("MB multiplicity");\r
   fEventMultCorrelationMatrix->Sumw2();\r
   \r
-  Int_t binsTrackPtCorrelationMatrix[3]={ptNbins,ptNbins,etaNbins};\r
+  Int_t binsTrackPtCorrelationMatrix[3]={fPtCorrNbins,fPtCorrNbins,fEtaNbins};\r
   fTrackPtCorrelationMatrix = new THnSparseF("fTrackPtCorrelationMatrix","Pt:mcPt:mcEta",3,binsTrackPtCorrelationMatrix);\r
-  fTrackPtCorrelationMatrix->SetBinEdges(0,binsPt);\r
-  fTrackPtCorrelationMatrix->SetBinEdges(1,binsPt);\r
-  fTrackPtCorrelationMatrix->SetBinEdges(2,binsEta);\r
+  fTrackPtCorrelationMatrix->SetBinEdges(0,fBinsPtCorr);\r
+  fTrackPtCorrelationMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fTrackPtCorrelationMatrix->SetBinEdges(2,fBinsEta);\r
   fTrackPtCorrelationMatrix->GetAxis(0)->SetTitle("Pt (GeV/c)");\r
   fTrackPtCorrelationMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fTrackPtCorrelationMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -464,120 +462,120 @@ void AlidNdPtAnalysis::Init(){
   //\r
   // Efficiency and contamination correction matrices\r
   //\r
-  Int_t binsEventMatrix[2]={zvNbins,multNbins};\r
-  Double_t minEventMatrix[2]={-25.,-0.5}; \r
-  Double_t maxEventMatrix[2]={25.,149.5}; \r
+  Int_t binsEventMatrix[2]={fZvNbins,fMultNbins};\r
+//   Double_t minEventMatrix[2]={-25.,-0.5}; \r
+//   Double_t maxEventMatrix[2]={25.,149.5}; \r
 \r
-  fGenEventMatrix = new THnSparseF("fGenEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fGenEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenEventMatrix->SetBinEdges(1,binsMult);\r
+  fGenEventMatrix = new THnSparseF("fGenEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fGenEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenEventMatrix->SetBinEdges(1,fBinsMult);\r
   fGenEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fGenEventMatrix->Sumw2();\r
   \r
-  fGenSDEventMatrix = new THnSparseF("fGenSDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fGenSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenSDEventMatrix->SetBinEdges(1,binsMult);\r
+  fGenSDEventMatrix = new THnSparseF("fGenSDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fGenSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenSDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fGenSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenSDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fGenSDEventMatrix->Sumw2();\r
   \r
-  fGenDDEventMatrix = new THnSparseF("fGenDDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fGenDDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenDDEventMatrix->SetBinEdges(1,binsMult);\r
+  fGenDDEventMatrix = new THnSparseF("fGenDDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fGenDDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenDDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fGenDDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenDDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fGenDDEventMatrix->Sumw2();\r
   \r
-  fGenNDEventMatrix = new THnSparseF("fGenNDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fGenNDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenNDEventMatrix->SetBinEdges(1,binsMult);\r
+  fGenNDEventMatrix = new THnSparseF("fGenNDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fGenNDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenNDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fGenNDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenNDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fGenNDEventMatrix->Sumw2();\r
 \r
-  fGenNSDEventMatrix = new THnSparseF("fGenNSDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fGenNSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenNSDEventMatrix->SetBinEdges(1,binsMult);\r
+  fGenNSDEventMatrix = new THnSparseF("fGenNSDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fGenNSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenNSDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fGenNSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenNSDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fGenNSDEventMatrix->Sumw2();\r
 \r
   //\r
-  fTriggerEventMatrix = new THnSparseF("fTriggerEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fTriggerEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerEventMatrix->SetBinEdges(1,binsMult);\r
+  fTriggerEventMatrix = new THnSparseF("fTriggerEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fTriggerEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerEventMatrix->SetBinEdges(1,fBinsMult);\r
   fTriggerEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fTriggerEventMatrix->Sumw2();\r
 \r
-  fTriggerSDEventMatrix = new THnSparseF("fTriggerSDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fTriggerSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerSDEventMatrix->SetBinEdges(1,binsMult);\r
+  fTriggerSDEventMatrix = new THnSparseF("fTriggerSDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fTriggerSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerSDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fTriggerSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerSDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fTriggerSDEventMatrix->Sumw2();\r
   \r
-  fTriggerDDEventMatrix = new THnSparseF("fTriggerDDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fTriggerDDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerDDEventMatrix->SetBinEdges(1,binsMult);\r
+  fTriggerDDEventMatrix = new THnSparseF("fTriggerDDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fTriggerDDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerDDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fTriggerDDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerDDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fTriggerDDEventMatrix->Sumw2();\r
   \r
-  fTriggerNDEventMatrix = new THnSparseF("fTriggerNDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fTriggerNDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerNDEventMatrix->SetBinEdges(1,binsMult);\r
+  fTriggerNDEventMatrix = new THnSparseF("fTriggerNDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fTriggerNDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerNDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fTriggerNDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerNDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fTriggerNDEventMatrix->Sumw2();\r
  \r
-  fTriggerNSDEventMatrix = new THnSparseF("fTriggerNSDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fTriggerNSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerNSDEventMatrix->SetBinEdges(1,binsMult);\r
+  fTriggerNSDEventMatrix = new THnSparseF("fTriggerNSDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fTriggerNSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerNSDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fTriggerNSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerNSDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fTriggerNSDEventMatrix->Sumw2();\r
  \r
   //\r
-  fRecEventMatrix = new THnSparseF("fRecEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fRecEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecEventMatrix->SetBinEdges(1,binsMult);\r
+  fRecEventMatrix = new THnSparseF("fRecEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fRecEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecEventMatrix->SetBinEdges(1,fBinsMult);\r
   fRecEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecEventMatrix->Sumw2();\r
 \r
-  fRecSDEventMatrix = new THnSparseF("fRecSDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fRecSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecSDEventMatrix->SetBinEdges(1,binsMult);\r
+  fRecSDEventMatrix = new THnSparseF("fRecSDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fRecSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecSDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fRecSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecSDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecSDEventMatrix->Sumw2();\r
   \r
-  fRecDDEventMatrix = new THnSparseF("fRecDDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fRecDDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecDDEventMatrix->SetBinEdges(1,binsMult);\r
+  fRecDDEventMatrix = new THnSparseF("fRecDDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fRecDDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecDDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fRecDDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecDDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecDDEventMatrix->Sumw2();\r
   \r
-  fRecNDEventMatrix = new THnSparseF("fRecNDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fRecNDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecNDEventMatrix->SetBinEdges(1,binsMult);\r
+  fRecNDEventMatrix = new THnSparseF("fRecNDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fRecNDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecNDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fRecNDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecNDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecNDEventMatrix->Sumw2();\r
  \r
-  fRecNSDEventMatrix = new THnSparseF("fRecNSDEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fRecNSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecNSDEventMatrix->SetBinEdges(1,binsMult);\r
+  fRecNSDEventMatrix = new THnSparseF("fRecNSDEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fRecNSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecNSDEventMatrix->SetBinEdges(1,fBinsMult);\r
   fRecNSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecNSDEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecNSDEventMatrix->Sumw2();\r
 \r
-  fRecCandleEventMatrix = new THnSparseF("fRecCandleEventMatrix","mcZv:multMB",2,binsEventMatrix,minEventMatrix,maxEventMatrix);\r
-  fRecCandleEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecCandleEventMatrix->SetBinEdges(1,binsMult);\r
+  fRecCandleEventMatrix = new THnSparseF("fRecCandleEventMatrix","mcZv:multMB",2,binsEventMatrix); //,minEventMatrix,maxEventMatrix);\r
+  fRecCandleEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecCandleEventMatrix->SetBinEdges(1,fBinsMult);\r
   fRecCandleEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecCandleEventMatrix->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecCandleEventMatrix->Sumw2();\r
@@ -587,45 +585,45 @@ void AlidNdPtAnalysis::Init(){
   //\r
 \r
   fGenTrackEventMatrix = new THnSparseF("fGenTrackEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenTrackEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenTrackEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenTrackEventMatrix->SetBinEdges(2,binsEta);\r
+  fGenTrackEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenTrackEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenTrackEventMatrix->SetBinEdges(2,fBinsEta);\r
   fGenTrackEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenTrackEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenTrackEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fGenTrackEventMatrix->Sumw2();\r
 \r
   fGenTrackSDEventMatrix = new THnSparseF("fGenTrackSDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenTrackSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenTrackSDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenTrackSDEventMatrix->SetBinEdges(2,binsEta);\r
+  fGenTrackSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenTrackSDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenTrackSDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fGenTrackSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenTrackSDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenTrackSDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fGenTrackSDEventMatrix->Sumw2();\r
 \r
   fGenTrackDDEventMatrix = new THnSparseF("fGenTrackDDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenTrackDDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenTrackDDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenTrackDDEventMatrix->SetBinEdges(2,binsEta);\r
+  fGenTrackDDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenTrackDDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenTrackDDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fGenTrackDDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenTrackDDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenTrackDDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fGenTrackDDEventMatrix->Sumw2();\r
 \r
   fGenTrackNDEventMatrix = new THnSparseF("fGenTrackNDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenTrackNDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenTrackNDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenTrackNDEventMatrix->SetBinEdges(2,binsEta);\r
+  fGenTrackNDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenTrackNDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenTrackNDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fGenTrackNDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenTrackNDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenTrackNDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fGenTrackNDEventMatrix->Sumw2();\r
 \r
   fGenTrackNSDEventMatrix = new THnSparseF("fGenTrackNSDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenTrackNSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fGenTrackNSDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenTrackNSDEventMatrix->SetBinEdges(2,binsEta);\r
+  fGenTrackNSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fGenTrackNSDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenTrackNSDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fGenTrackNSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenTrackNSDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenTrackNSDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -634,45 +632,45 @@ void AlidNdPtAnalysis::Init(){
 \r
   //\r
   fTriggerTrackEventMatrix = new THnSparseF("fTriggerTrackEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fTriggerTrackEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerTrackEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fTriggerTrackEventMatrix->SetBinEdges(2,binsEta);\r
+  fTriggerTrackEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerTrackEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fTriggerTrackEventMatrix->SetBinEdges(2,fBinsEta);\r
   fTriggerTrackEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerTrackEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fTriggerTrackEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fTriggerTrackEventMatrix->Sumw2();\r
 \r
   fTriggerTrackSDEventMatrix = new THnSparseF("fTriggerTrackSDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fTriggerTrackSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerTrackSDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fTriggerTrackSDEventMatrix->SetBinEdges(2,binsEta);\r
+  fTriggerTrackSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerTrackSDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fTriggerTrackSDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fTriggerTrackSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerTrackSDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fTriggerTrackSDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fTriggerTrackSDEventMatrix->Sumw2();\r
 \r
   fTriggerTrackDDEventMatrix = new THnSparseF("fTriggerTrackDDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fTriggerTrackDDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerTrackDDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fTriggerTrackDDEventMatrix->SetBinEdges(2,binsEta);\r
+  fTriggerTrackDDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerTrackDDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fTriggerTrackDDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fTriggerTrackDDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerTrackDDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fTriggerTrackDDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fTriggerTrackDDEventMatrix->Sumw2();\r
 \r
   fTriggerTrackNDEventMatrix = new THnSparseF("fTriggerTrackNDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fTriggerTrackNDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerTrackNDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fTriggerTrackNDEventMatrix->SetBinEdges(2,binsEta);\r
+  fTriggerTrackNDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerTrackNDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fTriggerTrackNDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fTriggerTrackNDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerTrackNDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fTriggerTrackNDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fTriggerTrackNDEventMatrix->Sumw2();\r
 \r
   fTriggerTrackNSDEventMatrix = new THnSparseF("fTriggerTrackNSDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fTriggerTrackNSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fTriggerTrackNSDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fTriggerTrackNSDEventMatrix->SetBinEdges(2,binsEta);\r
+  fTriggerTrackNSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fTriggerTrackNSDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fTriggerTrackNSDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fTriggerTrackNSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fTriggerTrackNSDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fTriggerTrackNSDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -680,45 +678,45 @@ void AlidNdPtAnalysis::Init(){
 \r
   //\r
   fRecTrackEventMatrix = new THnSparseF("fRecTrackEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecTrackEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecTrackEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecTrackEventMatrix->SetBinEdges(2,binsEta);\r
+  fRecTrackEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecTrackEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecTrackEventMatrix->SetBinEdges(2,fBinsEta);\r
   fRecTrackEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecTrackEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecTrackEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fRecTrackEventMatrix->Sumw2();\r
 \r
   fRecTrackSDEventMatrix = new THnSparseF("fRecTrackSDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecTrackSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecTrackSDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecTrackSDEventMatrix->SetBinEdges(2,binsEta);\r
+  fRecTrackSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecTrackSDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecTrackSDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fRecTrackSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecTrackSDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecTrackSDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fRecTrackSDEventMatrix->Sumw2();\r
 \r
   fRecTrackDDEventMatrix = new THnSparseF("fRecTrackDDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecTrackDDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecTrackDDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecTrackDDEventMatrix->SetBinEdges(2,binsEta);\r
+  fRecTrackDDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecTrackDDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecTrackDDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fRecTrackDDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecTrackDDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecTrackDDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fRecTrackDDEventMatrix->Sumw2();\r
 \r
   fRecTrackNDEventMatrix = new THnSparseF("fRecTrackNDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecTrackNDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecTrackNDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecTrackNDEventMatrix->SetBinEdges(2,binsEta);\r
+  fRecTrackNDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecTrackNDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecTrackNDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fRecTrackNDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecTrackNDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecTrackNDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
   fRecTrackNDEventMatrix->Sumw2();\r
 \r
   fRecTrackNSDEventMatrix = new THnSparseF("fRecTrackNSDEventMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecTrackNSDEventMatrix->SetBinEdges(0,binsZv);\r
-  fRecTrackNSDEventMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecTrackNSDEventMatrix->SetBinEdges(2,binsEta);\r
+  fRecTrackNSDEventMatrix->SetBinEdges(0,fBinsZv);\r
+  fRecTrackNSDEventMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecTrackNSDEventMatrix->SetBinEdges(2,fBinsEta);\r
   fRecTrackNSDEventMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecTrackNSDEventMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecTrackNSDEventMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -729,10 +727,10 @@ void AlidNdPtAnalysis::Init(){
   //\r
   //fGenTrackMatrix = new THnSparseF("fGenTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackMatrix);\r
   fGenTrackMatrix = new THnSparseF("fGenTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenTrackMatrix->SetBinEdges(0,binsZv);\r
+  fGenTrackMatrix->SetBinEdges(0,fBinsZv);\r
   //fGenTrackMatrix->SetBinEdges(1,binsPt);\r
-  fGenTrackMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenTrackMatrix->SetBinEdges(2,binsEta);\r
+  fGenTrackMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenTrackMatrix->SetBinEdges(2,fBinsEta);\r
   fGenTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenTrackMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -740,10 +738,10 @@ void AlidNdPtAnalysis::Init(){
 \r
   //fGenPrimTrackMatrix = new THnSparseF("fGenPrimTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackMatrix);\r
   fGenPrimTrackMatrix = new THnSparseF("fGenPrimTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fGenPrimTrackMatrix->SetBinEdges(0,binsZv);\r
+  fGenPrimTrackMatrix->SetBinEdges(0,fBinsZv);\r
   //fGenPrimTrackMatrix->SetBinEdges(1,binsPt);\r
-  fGenPrimTrackMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fGenPrimTrackMatrix->SetBinEdges(2,binsEta);\r
+  fGenPrimTrackMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fGenPrimTrackMatrix->SetBinEdges(2,fBinsEta);\r
   fGenPrimTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fGenPrimTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fGenPrimTrackMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -751,10 +749,10 @@ void AlidNdPtAnalysis::Init(){
 \r
   //fRecPrimTrackMatrix = new THnSparseF("fRecPrimTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackMatrix);\r
   fRecPrimTrackMatrix = new THnSparseF("fRecPrimTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecPrimTrackMatrix->SetBinEdges(0,binsZv);\r
+  fRecPrimTrackMatrix->SetBinEdges(0,fBinsZv);\r
   //fRecPrimTrackMatrix->SetBinEdges(1,binsPt);\r
-  fRecPrimTrackMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecPrimTrackMatrix->SetBinEdges(2,binsEta);\r
+  fRecPrimTrackMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecPrimTrackMatrix->SetBinEdges(2,fBinsEta);\r
   fRecPrimTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecPrimTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecPrimTrackMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -763,10 +761,10 @@ void AlidNdPtAnalysis::Init(){
   //\r
   //fRecTrackMatrix = new THnSparseF("fRecTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackMatrix);\r
   fRecTrackMatrix = new THnSparseF("fRecTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecTrackMatrix->SetBinEdges(0,binsZv);\r
+  fRecTrackMatrix->SetBinEdges(0,fBinsZv);\r
   //fRecTrackMatrix->SetBinEdges(1,binsPt);\r
-  fRecTrackMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecTrackMatrix->SetBinEdges(2,binsEta);\r
+  fRecTrackMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecTrackMatrix->SetBinEdges(2,fBinsEta);\r
   fRecTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecTrackMatrix->GetAxis(1)->SetTitle("Pt (GeV/c)");\r
   fRecTrackMatrix->GetAxis(2)->SetTitle("Eta");\r
@@ -774,10 +772,10 @@ void AlidNdPtAnalysis::Init(){
 \r
   //fRecSecTrackMatrix = new THnSparseF("fRecSecTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackMatrix);\r
   fRecSecTrackMatrix = new THnSparseF("fRecSecTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecSecTrackMatrix->SetBinEdges(0,binsZv);\r
+  fRecSecTrackMatrix->SetBinEdges(0,fBinsZv);\r
   //fRecSecTrackMatrix->SetBinEdges(1,binsPt);\r
-  fRecSecTrackMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecSecTrackMatrix->SetBinEdges(2,binsEta);\r
+  fRecSecTrackMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecSecTrackMatrix->SetBinEdges(2,fBinsEta);\r
   fRecSecTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecSecTrackMatrix->GetAxis(1)->SetTitle("Pt (GeV/c)");\r
   fRecSecTrackMatrix->GetAxis(2)->SetTitle("Eta");\r
@@ -786,10 +784,10 @@ void AlidNdPtAnalysis::Init(){
   //\r
   //fRecMultTrackMatrix = new THnSparseF("fRecMultTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackMatrix);\r
   fRecMultTrackMatrix = new THnSparseF("fRecMultTrackMatrix","mcZv:mcPt:mcEta",3,binsTrackEventCorrMatrix);\r
-  fRecMultTrackMatrix->SetBinEdges(0,binsZv);\r
+  fRecMultTrackMatrix->SetBinEdges(0,fBinsZv);\r
   //fRecMultTrackMatrix->SetBinEdges(1,binsPt);\r
-  fRecMultTrackMatrix->SetBinEdges(1,binsPtTrackEventCorr);\r
-  fRecMultTrackMatrix->SetBinEdges(2,binsEta);\r
+  fRecMultTrackMatrix->SetBinEdges(1,fBinsPtCorr);\r
+  fRecMultTrackMatrix->SetBinEdges(2,fBinsEta);\r
   fRecMultTrackMatrix->GetAxis(0)->SetTitle("mcZv (cm)");\r
   fRecMultTrackMatrix->GetAxis(1)->SetTitle("mcPt (GeV/c)");\r
   fRecMultTrackMatrix->GetAxis(2)->SetTitle("mcEta");\r
@@ -820,12 +818,14 @@ void AlidNdPtAnalysis::Init(){
   fRecEventHist1->Sumw2();\r
 \r
   //\r
-  Int_t binsRecEventHist2[3]={zvNbins,150,150};\r
-  Double_t minRecEventHist2[3]={-25.,-0.5,-0.5}; \r
-  Double_t maxRecEventHist2[3]={25.,149.5,149.5}; \r
+  Int_t binsRecEventHist2[3]={fZvNbins,fMultNbins,fMultNbins};\r
+//   Double_t minRecEventHist2[3]={-25.,-0.5,-0.5}; \r
+//   Double_t maxRecEventHist2[3]={25.,149.5,149.5}; \r
   \r
-  fRecEventHist2 = new THnSparseF("fRecEventHist2","Zv:multMB:mult",3,binsRecEventHist2,minRecEventHist2,maxRecEventHist2);\r
-  fRecEventHist2->SetBinEdges(0,binsZv);\r
+  fRecEventHist2 = new THnSparseF("fRecEventHist2","Zv:multMB:mult",3,binsRecEventHist2); //,minRecEventHist2,maxRecEventHist2);\r
+  fRecEventHist2->SetBinEdges(0,fBinsZv);\r
+  fRecEventHist2->SetBinEdges(1,fBinsMult);\r
+  fRecEventHist2->SetBinEdges(2,fBinsMult);\r
   fRecEventHist2->GetAxis(0)->SetTitle("Zv (cm)");\r
   fRecEventHist2->GetAxis(1)->SetTitle("multiplicity MB");\r
   fRecEventHist2->GetAxis(2)->SetTitle("multiplicity");\r
@@ -844,20 +844,22 @@ void AlidNdPtAnalysis::Init(){
   fRecMCEventHist1->Sumw2();\r
 \r
   //\r
-  Int_t binsRecMCEventHist2[3]={100,100,150};\r
+  Int_t binsRecMCEventHist2[3]={100,100,fMultNbins};\r
   Double_t minRecMCEventHist2[3]={-10.0*kFact,-10.0*kFact,0.0}; \r
   Double_t maxRecMCEventHist2[3]={10.0*kFact,10.0*kFact,149.50}; \r
 \r
   fRecMCEventHist2 = new THnSparseF("fRecMCEventHist2","Xv-mcXv:Zv-mcZv:mult",3,binsRecMCEventHist2,minRecMCEventHist2,maxRecMCEventHist2);\r
+  fRecMCEventHist2->SetBinEdges(2,fBinsMult);  \r
   fRecMCEventHist2->GetAxis(0)->SetTitle("Xv-mcXv (cm)");\r
   fRecMCEventHist2->GetAxis(1)->SetTitle("Zv-mcZv (cm)");\r
   fRecMCEventHist2->GetAxis(2)->SetTitle("multiplicity");\r
   fRecMCEventHist2->Sumw2();\r
 \r
-  Int_t binsRecMCEventHist3[2]={150,5};\r
+  Int_t binsRecMCEventHist3[2]={fMultNbins,5};\r
   Double_t minRecMCEventHist3[2]={-0.5,0.0}; \r
   Double_t maxRecMCEventHist3[2]={149.50,5.0}; \r
   fRecMCEventHist3 = new THnSparseF("fRecMCEventHist3","mult:EventType (ND, DD, SD)",2,binsRecMCEventHist3,minRecMCEventHist3,maxRecMCEventHist3);\r
+  fRecMCEventHist3->SetBinEdges(0,fBinsMult);    \r
   fRecMCEventHist3->GetAxis(0)->SetTitle("multiplicity");\r
   fRecMCEventHist3->GetAxis(1)->SetTitle("EventType");\r
   fRecMCEventHist3->Sumw2();\r
@@ -869,29 +871,29 @@ void AlidNdPtAnalysis::Init(){
   {\r
   // THnSparse track histograms\r
  \r
-  Int_t binsMCTrackHist1[3]=  {ptNbins, etaNbins, 90};\r
+  Int_t binsMCTrackHist1[3]=  {fPtCorrNbins, fEtaNbins, 90};\r
   Double_t minMCTrackHist1[3]={0.,-1.,0.}; \r
   Double_t maxMCTrackHist1[3]={10.,1.,2.*TMath::Pi()}; \r
   sprintf(name,"fMCTrackHist1_%d",i);\r
   sprintf(title,"mcPt:mcEta:mcPhi");\r
   \r
   fMCTrackHist1[i] = new THnSparseF(name,title,3,binsMCTrackHist1,minMCTrackHist1,maxMCTrackHist1);\r
-  fMCTrackHist1[i]->SetBinEdges(0,binsPt);\r
-  fMCTrackHist1[i]->SetBinEdges(1,binsEta);\r
+  fMCTrackHist1[i]->SetBinEdges(0,fBinsPtCorr);\r
+  fMCTrackHist1[i]->SetBinEdges(1,fBinsEta);\r
   fMCTrackHist1[i]->GetAxis(0)->SetTitle("mcPt (GeV/c)");\r
   fMCTrackHist1[i]->GetAxis(1)->SetTitle("mcEta");\r
   fMCTrackHist1[i]->GetAxis(2)->SetTitle("mcPhi (rad)");\r
   fMCTrackHist1[i]->Sumw2();\r
 \r
-  Int_t binsMCPrimTrackHist1[5]=  {ptNbins,etaNbins,6,20,4000};\r
+  Int_t binsMCPrimTrackHist1[5]=  {fPtCorrNbins,fEtaNbins,6,20,4000};\r
   Double_t minMCPrimTrackHist1[5]={0.,-1.,0.,0.,0.}; \r
   Double_t maxMCPrimTrackHist1[5]={10.,1.,6.,20.,4000.}; \r
   sprintf(name,"fMCPrimTrackHist1_%d",i);\r
   sprintf(title,"mcPt:mcEta:pid:mech:mother");\r
   \r
   fMCPrimTrackHist1[i] = new THnSparseF(name,title,5,binsMCPrimTrackHist1,minMCPrimTrackHist1,maxMCPrimTrackHist1);\r
-  fMCPrimTrackHist1[i]->SetBinEdges(0,binsPt);\r
-  fMCPrimTrackHist1[i]->SetBinEdges(1,binsEta);\r
+  fMCPrimTrackHist1[i]->SetBinEdges(0,fBinsPtCorr);\r
+  fMCPrimTrackHist1[i]->SetBinEdges(1,fBinsEta);\r
   fMCPrimTrackHist1[i]->GetAxis(0)->SetTitle("mcPt (GeV/c)");\r
   fMCPrimTrackHist1[i]->GetAxis(1)->SetTitle("mcEta");\r
   fMCPrimTrackHist1[i]->GetAxis(2)->SetTitle("pid");\r
@@ -911,15 +913,15 @@ void AlidNdPtAnalysis::Init(){
   fMCPrimTrackHist2[i]->GetAxis(2)->SetTitle("mother");\r
   fMCPrimTrackHist2[i]->Sumw2();\r
 \r
-  Int_t binsMCSecTrackHist1[5]=  {ptNbins,etaNbins,6,20,4000};\r
+  Int_t binsMCSecTrackHist1[5]=  {fPtCorrNbins,fEtaNbins,6,20,4000};\r
   Double_t minMCSecTrackHist1[5]={0.,-1.,0.,0.,0.}; \r
-  Double_t maxMCSecTrackHist1[5]={10.,1.,6.,20.,4000.}; \r
+  Double_t maxMCSecTrackHist1[5]={10.,1.,6.,20.,4000.};   \r
   sprintf(name,"fMCSecTrackHist1_%d",i);\r
   sprintf(title,"mcPt:mcEta:pid:mech:mother");\r
   \r
   fMCSecTrackHist1[i] = new THnSparseF(name,title,5,binsMCSecTrackHist1,minMCSecTrackHist1,maxMCSecTrackHist1);\r
-  fMCSecTrackHist1[i]->SetBinEdges(0,binsPt);\r
-  fMCSecTrackHist1[i]->SetBinEdges(1,binsEta);\r
+  fMCSecTrackHist1[i]->SetBinEdges(0,fBinsPtCorr);\r
+  fMCSecTrackHist1[i]->SetBinEdges(1,fBinsEta);\r
   fMCSecTrackHist1[i]->GetAxis(0)->SetTitle("mcPt (GeV/c)");\r
   fMCSecTrackHist1[i]->GetAxis(1)->SetTitle("mcEta");\r
   fMCSecTrackHist1[i]->GetAxis(2)->SetTitle("pid");\r
@@ -931,65 +933,66 @@ void AlidNdPtAnalysis::Init(){
 \r
   // \r
   \r
-  Int_t binsRecTrackHist1[3]={ptNbins,etaNbins,90};\r
+  Int_t binsRecTrackHist1[3]={fPtNbins,fEtaNbins,90};\r
   Double_t minRecTrackHist1[3]={0.,-1.,0.}; \r
   Double_t maxRecTrackHist1[3]={10.,1.,2.*TMath::Pi()};\r
   sprintf(name,"fRecTrackHist1_%d",i);\r
   sprintf(title,"Pt:Eta:Phi");\r
   fRecTrackHist1[i] = new THnSparseF(name,title,3,binsRecTrackHist1,minRecTrackHist1,maxRecTrackHist1);\r
-  fRecTrackHist1[i]->SetBinEdges(0,binsPt);\r
-  fRecTrackHist1[i]->SetBinEdges(1,binsEta);\r
+  fRecTrackHist1[i]->SetBinEdges(0,fBinsPt);\r
+  fRecTrackHist1[i]->SetBinEdges(1,fBinsEta);\r
   fRecTrackHist1[i]->GetAxis(0)->SetTitle("p_{T} (GeV/c)");\r
   fRecTrackHist1[i]->GetAxis(1)->SetTitle("#eta");\r
   fRecTrackHist1[i]->GetAxis(2)->SetTitle("#phi (rad)");\r
   fRecTrackHist1[i]->Sumw2();\r
 \r
   // \r
-  Int_t binsRecTrackMultHist1[2]={ptNbins,150};\r
-  Double_t minRecTrackMultHist1[2]={0.,-0.5}; \r
-  Double_t maxRecTrackMultHist1[2]={10.,149.5};\r
+  Int_t binsRecTrackMultHist1[2]={fPtNbins,fMultNbins};\r
+//   Double_t minRecTrackMultHist1[2]={0.,-0.5}; \r
+//   Double_t maxRecTrackMultHist1[2]={10.,149.5};\r
   sprintf(name,"fRecTrackMultHist_%d",i);\r
   sprintf(title,"Pt:Mult");\r
-  fRecTrackMultHist1[i] = new THnSparseF(name,title,2,binsRecTrackMultHist1,minRecTrackMultHist1,maxRecTrackMultHist1);\r
-  fRecTrackMultHist1[i]->SetBinEdges(0,binsPt);\r
+  fRecTrackMultHist1[i] = new THnSparseF(name,title,2,binsRecTrackMultHist1); //,minRecTrackMultHist1,maxRecTrackMultHist1);\r
+  fRecTrackMultHist1[i]->SetBinEdges(0,fBinsPt);\r
+  fRecTrackMultHist1[i]->SetBinEdges(1,fBinsMult);\r
   fRecTrackMultHist1[i]->GetAxis(0)->SetTitle("Pt (GeV/c)");\r
   fRecTrackMultHist1[i]->GetAxis(1)->SetTitle("multiplicity");\r
   fRecTrackMultHist1[i]->Sumw2();\r
   }\r
 \r
-  Int_t binsRecMCTrackHist1[4] = {ptNbins,etaNbins,100,100};\r
+  Int_t binsRecMCTrackHist1[4] = {fPtCorrNbins,fEtaNbins,100,100};\r
   Double_t minRecMCTrackHist1[4]={0.,-1.,-0.5,-0.5}; \r
   Double_t maxRecMCTrackHist1[4]={20.,1.,0.5,0.5}; \r
   sprintf(name,"fRecMCTrackHist1");\r
   sprintf(title,"mcPt:mcEta:(Pt-mcPt)/mcPt:(Eta-mcEta)");\r
   fRecMCTrackHist1 = new THnSparseF(name,title,4,binsRecMCTrackHist1,minRecMCTrackHist1,maxRecMCTrackHist1);\r
-  fRecMCTrackHist1->SetBinEdges(0,binsPt);\r
-  fRecMCTrackHist1->SetBinEdges(1,binsEta);\r
+  fRecMCTrackHist1->SetBinEdges(0,fBinsPtCorr);\r
+  fRecMCTrackHist1->SetBinEdges(1,fBinsEta);\r
   fRecMCTrackHist1->GetAxis(0)->SetTitle("mcPt (GeV/c)");\r
   fRecMCTrackHist1->GetAxis(1)->SetTitle("mcEta");\r
   fRecMCTrackHist1->GetAxis(2)->SetTitle("(Pt-mcPt)/mcPt");\r
   fRecMCTrackHist1->GetAxis(3)->SetTitle("Eta-mcEta");\r
 \r
-  Int_t binsMCMultRecTrackHist1[3] = {ptNbins,etaNbins,6};\r
+  Int_t binsMCMultRecTrackHist1[3] = {fPtCorrNbins,fEtaNbins,6};\r
   Double_t minMCMultRecTrackHist1[3]={0.,-1.,0.}; \r
   Double_t maxMCMultRecTrackHist1[3]={20.,1.,6.}; \r
   sprintf(name,"fMCMultRecTrackHist1");\r
   sprintf(title,"mcPt:mcEta:pid");\r
   fMCMultRecTrackHist1 = new THnSparseF(name,title,3,binsMCMultRecTrackHist1,minMCMultRecTrackHist1,maxMCMultRecTrackHist1);\r
-  fMCMultRecTrackHist1->SetBinEdges(0,binsPt);\r
-  fMCMultRecTrackHist1->SetBinEdges(1,binsEta);\r
+  fMCMultRecTrackHist1->SetBinEdges(0,fBinsPtCorr);\r
+  fMCMultRecTrackHist1->SetBinEdges(1,fBinsEta);\r
   fMCMultRecTrackHist1->GetAxis(0)->SetTitle("mcPt (GeV/c)");\r
   fMCMultRecTrackHist1->GetAxis(1)->SetTitle("mcEta");\r
   fMCMultRecTrackHist1->GetAxis(2)->SetTitle("pid");\r
 \r
   //nClust:chi2PerClust:pt:eta:phi\r
-  Int_t binsRecTrackHist2[5]={160,100,ptNbins,etaNbins,90};\r
+  Int_t binsRecTrackHist2[5]={160,100,fPtNbins,fEtaNbins,90};\r
   Double_t minRecTrackHist2[5]={0., 0., 0, -1.5, 0.};\r
   Double_t maxRecRecTrackHist2[5]={160.,10., 16, 1.5, 2.*TMath::Pi()};\r
 \r
   fRecTrackHist2 = new THnSparseF("fRecTrackHist2","nClust:chi2PerClust:pt:eta:phi",5,binsRecTrackHist2,minRecTrackHist2,maxRecRecTrackHist2);\r
-  fRecTrackHist2->SetBinEdges(2,binsPt);\r
-  fRecTrackHist2->SetBinEdges(3,binsEta);\r
+  fRecTrackHist2->SetBinEdges(2,fBinsPt);\r
+  fRecTrackHist2->SetBinEdges(3,fBinsEta);\r
   fRecTrackHist2->GetAxis(0)->SetTitle("nClust");\r
   fRecTrackHist2->GetAxis(1)->SetTitle("chi2PerClust");\r
   fRecTrackHist2->GetAxis(2)->SetTitle("p_{T} (GeV/c)");\r
@@ -1072,16 +1075,18 @@ void AlidNdPtAnalysis::Process(AliESDEvent *const esdEvent, AliMCEvent *const mc
       //\r
       // 0-multiplicity bin for LHC background correction\r
       //\r
+      /* bin0 done in the train\r
       if( GetAnalysisMode() == AlidNdPtHelper::kTPCITS || \r
           GetAnalysisMode() == AlidNdPtHelper::kTPCTrackSPDvtx || \r
          GetAnalysisMode() == AlidNdPtHelper::kTPCTrackSPDvtxUpdate || \r
           GetAnalysisMode() == AlidNdPtHelper::kTPCITSHybridTrackSPDvtx || \r
          GetAnalysisMode() == AlidNdPtHelper::kTPCITSHybridTrackSPDvtxDCArPt ) \r
       {\r
-        physicsSelection->SetBin0CallbackViaPointer(&AlidNdPtAnalysis::IsBinZeroTrackSPDvtx);\r
+         physicsSelection->SetBin0CallbackViaPointer(&AlidNdPtAnalysis::IsBinZeroTrackSPDvtx);\r
       } else {\r
-        physicsSelection->SetBin0CallbackViaPointer(&AlidNdPtAnalysis::IsBinZeroSPDvtx);\r
+         physicsSelection->SetBin0CallbackViaPointer(&AlidNdPtAnalysis::IsBinZeroSPDvtx);\r
       }\r
+      */\r
     }\r
   }\r
 \r
@@ -1749,11 +1754,7 @@ void AlidNdPtAnalysis::FillHistograms(AliESDtrack *const esdTrack, AliStack *con
   if(!stack) return;\r
 \r
   Int_t label = TMath::Abs(esdTrack->GetLabel()); \r
-  if(label > stack->GetNtrack()) \r
-  {\r
-    printf("esd track label: %d, stack->GetNtrack(): %d\n", label, stack->GetNtrack());\r
-    return;\r
-  }\r
+  //if(label == 0) return;\r
 \r
   TParticle* particle = stack->Particle(label);\r
   if(!particle) return;\r

diff --git a/PWG0/dNdPt/AlidNdPtAnalysis.h b/PWG0/dNdPt/AlidNdPtAnalysis.h
index 108d5a3bdad5503d67d20520e67f087f02151e30..36c34695062446210920a61c0b2b81da87ab38b8 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtAnalysis.h
+++ b/PWG0/dNdPt/AlidNdPtAnalysis.h
@@ -64,11 +64,11 @@ public :
   TFolder *CreateFolder(TString folder = "folderdNdPtAnalysis",TString title = "Analysed dNdPt histograms");
 
   // Set binning for Histograms (if not set default binning is used)
-  void SetBinsMult(Int_t nbins, Double_t* edges) { fMultNbins = nbins; fBinsMult = edges; }
-  void SetBinsPt(Int_t nbins, Double_t* edges) { fPtNbins = nbins; fBinsPt = edges; }
-  void SetBinsPtCorr(Int_t nbins, Double_t* edges) { fPtCorrNbins = nbins; fBinsPtCorr = edges; }
-  void SetBinsEta(Int_t nbins, Double_t* edges) { fEtaNbins = nbins; fBinsEta = edges; }
-  void SetBinsZv(Int_t nbins, Double_t* edges) { fZvNbins = nbins; fBinsZv = edges; }  
+  void SetBinsMult(Int_t nbins, Double_t* edges) { fMultNbins = nbins; fBinsMult = CloneArray(nbins+1,edges); }
+  void SetBinsPt(Int_t nbins, Double_t* edges) { fPtNbins = nbins; fBinsPt = CloneArray(nbins+1,edges); }
+  void SetBinsPtCorr(Int_t nbins, Double_t* edges) { fPtCorrNbins = nbins; fBinsPtCorr = CloneArray(nbins+1,edges); }
+  void SetBinsEta(Int_t nbins, Double_t* edges) { fEtaNbins = nbins; fBinsEta = CloneArray(nbins+1,edges); }
+  void SetBinsZv(Int_t nbins, Double_t* edges) { fZvNbins = nbins; fBinsZv = CloneArray(nbins+1,edges); }
 
 
   // Fill histograms

diff --git a/PWG0/dNdPt/AlidNdPtAnalysisPbPb.cxx b/PWG0/dNdPt/AlidNdPtAnalysisPbPb.cxx
index 2dcad4254e0ef0415ba694368f26e18a5e843f2d..a31c24ec90e919a1ae5f49334f20d5f443fbe6c3 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtAnalysisPbPb.cxx
+++ b/PWG0/dNdPt/AlidNdPtAnalysisPbPb.cxx
@@ -285,6 +285,13 @@ AlidNdPtAnalysisPbPb::~AlidNdPtAnalysisPbPb() {
   if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
   
   if (fTriggerAnalysis) delete fTriggerAnalysis;  fTriggerAnalysis = 0;
+  
+  if (fBinsMult) delete fBinsMult; fBinsMult=0;
+  if (fBinsPt) delete fBinsPt; fBinsPt=0;
+  if (fBinsPtCorr) delete fBinsPtCorr; fBinsPtCorr=0;
+  if (fBinsEta) delete fBinsEta; fBinsEta=0;
+  if (fBinsZv) delete fBinsZv; fBinsZv=0;
+  if (fBinsCentrality) delete fBinsCentrality; fBinsCentrality=0;  
 }
 
 //_____________________________________________________________________________

diff --git a/PWG0/dNdPt/AlidNdPtAnalysisPbPb.h b/PWG0/dNdPt/AlidNdPtAnalysisPbPb.h
index e1c277f53bbab26f901638fb88334db186b6c5fc..f478295abdffdfb2f703ec2636bbd1f487938a90 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtAnalysisPbPb.h
+++ b/PWG0/dNdPt/AlidNdPtAnalysisPbPb.h
@@ -62,12 +62,12 @@ public :
   TFolder *CreateFolder(TString folder = "folderdNdPtAnalysis",TString title = "Analysed dNdPt histograms");
   
   // Set binning for Histograms (if not set default binning is used)
-  void SetBinsMult(Int_t nbins, Double_t* edges) { fMultNbins = nbins; fBinsMult = edges; }
-  void SetBinsPt(Int_t nbins, Double_t* edges) { fPtNbins = nbins; fBinsPt = edges; }
-  void SetBinsPtCorr(Int_t nbins, Double_t* edges) { fPtCorrNbins = nbins; fBinsPtCorr = edges; }
-  void SetBinsEta(Int_t nbins, Double_t* edges) { fEtaNbins = nbins; fBinsEta = edges; }
-  void SetBinsZv(Int_t nbins, Double_t* edges) { fZvNbins = nbins; fBinsZv = edges; }
-  void SetBinsCentrality(Int_t nbins, Double_t* edges) { fCentralityNbins = nbins; fBinsCentrality = edges; }
+  void SetBinsMult(Int_t nbins, Double_t* edges) { fMultNbins = nbins; fBinsMult = CloneArray(nbins+1,edges); }
+  void SetBinsPt(Int_t nbins, Double_t* edges) { fPtNbins = nbins; fBinsPt = CloneArray(nbins+1,edges); }
+  void SetBinsPtCorr(Int_t nbins, Double_t* edges) { fPtCorrNbins = nbins; fBinsPtCorr = CloneArray(nbins+1,edges); }
+  void SetBinsEta(Int_t nbins, Double_t* edges) { fEtaNbins = nbins; fBinsEta = CloneArray(nbins+1,edges); }
+  void SetBinsZv(Int_t nbins, Double_t* edges) { fZvNbins = nbins; fBinsZv= CloneArray(nbins+1,edges); }
+  void SetBinsCentrality(Int_t nbins, Double_t* edges) { fCentralityNbins = nbins; fBinsCentrality = CloneArray(nbins+1,edges); }
 
   // Fill histograms
   void FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack, AlidNdPtHelper::TrackObject trackObj, Float_t centralityF);

diff --git a/PWG0/dNdPt/AlidNdPtHelper.cxx b/PWG0/dNdPt/AlidNdPtHelper.cxx
index 71cc3f58b5b00f8f1d88944ae9453115deff7317..39b64584a454459ee5d852321e0791c51e3138be 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtHelper.cxx
+++ b/PWG0/dNdPt/AlidNdPtHelper.cxx
@@ -1480,5 +1480,70 @@ Int_t  AlidNdPtHelper::GetSPDMBPrimTrackMult(const AliESDEvent* const esdEvent,
 
 return inputCount;
 }
+//_____________________________________________________________________________
+
+THnSparse* AlidNdPtHelper::RebinTHnSparse(const THnSparse* hist1, THnSparse* hist2, const Char_t* newname, Option_t* option)
+{
+    THnSparse* htemp = 0;
+    const THnSparse* hist = 0;
+    TString opt = option;
+    opt.ToLower();
+    Bool_t calcErrors = kFALSE;
+    Bool_t useRange = kFALSE;
+    Bool_t overwrite = kFALSE;
+    if (opt.Contains("e")) { calcErrors = kTRUE; } // calcluate correct errors (not implemented)
+    if (opt.Contains("r")) { useRange = kTRUE; }   // use the axis range given in hist1
+    if (opt.Contains("o")) { overwrite = kTRUE; }  // overwrite hist2 instead of creating a new one
+    Int_t ndim  = hist1->GetNdimensions();
+    if (ndim != hist2->GetNdimensions()) {
+        printf("AlidNdPtHelper::RebinTHnSparse: ERROR: Histograms have different dimensions \n");
+        return 0;
+    }    
+    Int_t* dims = new Int_t[ndim];
+    for (Int_t i = 0; i < ndim; i++) { dims[i] = i; }
+    if (useRange) {         
+        htemp = hist1->Projection(ndim,dims,"e");
+       hist = htemp; 
+    } else { hist = hist1; }
+    //THnSparse* hnew = hist2->Projection(ndim,dims,"o");
+    //hnew->SetName(newname);
+    THnSparse* hnew = 0;
+    if (overwrite) { 
+        hnew = hist2;
+    } else {
+        hnew = (THnSparse*) hist2->Clone(newname);
+    }
+    for (Int_t i = 0; i < ndim; i++) { hnew->GetAxis(i)->SetRange(); }
+    hnew->SetTitle(hist1->GetTitle());
+    hnew->Reset();
+    hnew->Sumw2();
+    Double_t content;
+    Double_t error;
+    Int_t* c = new Int_t[ndim];
+    Double_t* x = new Double_t[ndim];
+    Long64_t n = hist->GetNbins();
+    for (Long64_t j = 0; j < n; j++) {
+        content = hist->GetBinContent(j,c);
+        error = hist->GetBinError(j);
+        for (Int_t i = 0; i < ndim; i++) {
+            x[i] = hist->GetAxis(i)->GetBinCenter(c[i]);
+        }
+        /* function IsInRange is protected, shit!
+        if (useRange) {
+            if (! hist1->IsInRange(c)) continue;
+        }
+        */
+        if (calcErrors) {
+           // implementation to be done
+        } else {
+           hnew->Fill(x,content);
+        }
+    }
+    delete[] c; c=0;
+    delete[] x; x=0;
+    delete[] dims; dims=0;
+    if (htemp) { delete htemp; htemp = 0;}
+    return hnew;
+}
 
 

diff --git a/PWG0/dNdPt/AlidNdPtHelper.h b/PWG0/dNdPt/AlidNdPtHelper.h
index bf3f91aff3e8e05905143a8d2eb0d22574e5fbc2..9cd7f581f8e1e9f85ef83a6a79f03e7090fe09e6 100644 (file)
--- a/PWG0/dNdPt/AlidNdPtHelper.h
+++ b/PWG0/dNdPt/AlidNdPtHelper.h
@@ -110,6 +110,9 @@ class AlidNdPtHelper : public TObject
     static Double_t GetStrangenessCorrFactorPbPb(const Double_t pt);    
     static Double_t GetLinearInterpolationValue(const Double_t x1, const Double_t y1, const Double_t x2, const Double_t y2, const Double_t pt);
 
+    // function to rebin THnSparse, the content of hist1 will be rebinned, hist2 serves as a protoype for the binning
+    static THnSparse* RebinTHnSparse(const THnSparse* hist1, THnSparse* hist2, const Char_t* newname = "",  Option_t* option = "");
+
     ClassDef(AlidNdPtHelper, 1);
 
   private: