* about the suitability of this software for any purpose. It is *\r
* provided "as is" without express or implied warranty. *\r
**************************************************************************/\r
+//------------------------------------------------------------------------------\r
+// AlidNdPtAnalysis class. \r
+// \r
+// a. functionality:\r
+// - fills analysis control histograms\r
+// - fills generic correction matrices \r
+// - generates correction matrices \r
+//\r
+// b. data members:\r
+// - generic correction matrices\r
+// - control histograms\r
+//\r
+// Author: J.Otwinowski 04/11/2008 \r
+//------------------------------------------------------------------------------\r
\r
-#include <iostream>\r
-\r
-#include "TFile.h"\r
-#include "TCint.h"\r
#include "TH1.h"\r
#include "TH2.h"\r
#include "TCanvas.h"\r
// rec. track control histograms\r
fRecTrackHist2(0)\r
{\r
+ //\r
// constructor\r
+ //\r
for(Int_t i=0; i<AlidNdPtHelper::kCutSteps; i++) { \r
fMCTrackHist1[i]=0; \r
fMCPrimTrackHist1[i]=0; \r
\r
//_____________________________________________________________________________\r
AlidNdPtAnalysis::~AlidNdPtAnalysis() {\r
+ //\r
+ // destructor\r
//\r
if(fEventMultCorrelationMatrix) delete fEventMultCorrelationMatrix; fEventMultCorrelationMatrix=0;\r
//\r
fRecEventHist2->Sumw2();\r
\r
//\r
- Double_t kFact = 1.0;\r
- if(GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtx || \r
- GetAnalysisMode() == AlidNdPtHelper::kTPCSPDvtxUpdate) kFact = 0.03; \r
-\r
+ Double_t kFact = 0.1;\r
Int_t binsRecMCEventHist1[3]={100,100,100};\r
Double_t minRecMCEventHist1[3]={-10.0*kFact,-10.0*kFact,-10.0*kFact}; \r
Double_t maxRecMCEventHist1[3]={10.0*kFact,10.0*kFact,10.0*kFact}; \r
\r
// only charged particles\r
Double_t charge = particle->GetPDG()->Charge()/3.;\r
- if (charge == 0.0)\r
+ if ( TMath::Abs(charge) < 0.001 )\r
continue;\r
\r
// only postive charged \r
FillHistograms(stack,iMc,AlidNdPtHelper::kAccTracks); \r
\r
// check multiple found tracks\r
- Int_t mult_count = 0;\r
+ Int_t multCount = 0;\r
for(Int_t iRec=0; iRec<multRec; ++iRec)\r
{\r
if(iMc == labelsRec[iRec]) \r
{\r
- mult_count++;\r
- if(mult_count>1)\r
+ multCount++;\r
+ if(multCount>1)\r
{ \r
fRecMultTrackMatrix->Fill(vTrackMatrix);\r
\r
if(!esdTrack) return;\r
\r
Float_t q = esdTrack->Charge();\r
- if(q==0) return;\r
+ if(TMath::Abs(q) < 0.001) return;\r
\r
Float_t pt = esdTrack->Pt();\r
//Float_t qpt = esdTrack->Pt() * q;\r
//Bool_t prim = stack->IsPhysicalPrimary(label);\r
//Int_t pid = AlidNdPtHelper::ConvertPdgToPid(particle);\r
\r
- Int_t mother_pdg = -1;\r
+ Int_t motherPdg = -1;\r
TParticle* mother = 0;\r
\r
//TParticle* prim_mother = AlidNdPtHelper::FindPrimaryMother(stack,label);\r
Int_t motherLabel = particle->GetMother(0); \r
if(motherLabel>0) mother = stack->Particle(motherLabel);\r
- if(mother) mother_pdg = TMath::Abs(mother->GetPdgCode()); // take abs for visualisation only\r
+ if(mother) motherPdg = TMath::Abs(mother->GetPdgCode()); // take abs for visualisation only\r
//Int_t mech = particle->GetUniqueID(); // production mechanism\r
\r
Double_t gq = particle->GetPDG()->Charge()/3.0; // Charge units |e|/3 \r
- if(gq==0) return;\r
+ if(TMath::Abs(gq)<0.001) return;\r
Float_t gpt = particle->Pt();\r
Float_t geta = particle->Eta();\r
//Float_t qgpt = particle->Pt() * gq;\r
TParticle* particle = stack->Particle(label);\r
if(!particle) return;\r
\r
- Int_t mother_pdg = -1;\r
+ Int_t motherPdg = -1;\r
TParticle* mother = 0;\r
\r
//TParticle* prim_mother = AlidNdPtHelper::FindPrimaryMother(stack,label);\r
Int_t motherLabel = particle->GetMother(0); \r
if(motherLabel>0) mother = stack->Particle(motherLabel);\r
- if(mother) mother_pdg = TMath::Abs(mother->GetPdgCode()); // take abs for visualisation only\r
+ if(mother) motherPdg = TMath::Abs(mother->GetPdgCode()); // take abs for visualisation only\r
Int_t mech = particle->GetUniqueID(); // production mechanism\r
\r
Double_t gq = particle->GetPDG()->Charge()/3.0; // Charge units |e|/3 \r
- if(gq == 0) return;\r
+ if(TMath::Abs(gq) < 0.001) return;\r
Float_t gpt = particle->Pt();\r
//Float_t qgpt = particle->Pt() * gq;\r
Float_t geta = particle->Eta();\r
Int_t pid = AlidNdPtHelper::ConvertPdgToPid(particle);\r
\r
//if(prim&&pid==5) printf("pdgcode %d, production mech %d \n",particle->GetPdgCode(),mech);\r
- //if(!prim) printf("mother_pdg %d, particle %d, production mech %d\n",mother_pdg, particle->GetPdgCode(),mech);\r
+ //if(!prim) printf("motherPdg %d, particle %d, production mech %d\n",motherPdg, particle->GetPdgCode(),mech);\r
\r
//\r
// fill histogram\r
Double_t vMCTrackHist1[3] = {gpt,geta,gphi};\r
fMCTrackHist1[trackObj]->Fill(vMCTrackHist1);\r
\r
- Double_t vMCPrimTrackHist1[5] = {gpt,geta,pid,mech,mother_pdg};\r
+ Double_t vMCPrimTrackHist1[5] = {gpt,geta,pid,mech,motherPdg};\r
if(prim) fMCPrimTrackHist1[trackObj]->Fill(vMCPrimTrackHist1);\r
else { \r
fMCSecTrackHist1[trackObj]->Fill(vMCPrimTrackHist1);\r
}\r
\r
//_____________________________________________________________________________\r
-Long64_t AlidNdPtAnalysis::Merge(TCollection* list) \r
+Long64_t AlidNdPtAnalysis::Merge(TCollection* const list) \r
{\r
// Merge list of objects (needed by PROOF)\r
\r
// - secondaries (mother)\r
//\r
\r
- TH1D *mc_pt_acc_all = fMCTrackHist1[1]->Projection(0);\r
- mc_pt_acc_all->SetName("mc_pt_acc_all");\r
- aFolderObj->Add(mc_pt_acc_all);\r
+ TH1D *mcPtAccall = fMCTrackHist1[1]->Projection(0);\r
+ mcPtAccall->SetName("mc_pt_acc_all");\r
+ aFolderObj->Add(mcPtAccall);\r
\r
- TH1D *mc_pt_acc_prim = fMCPrimTrackHist1[1]->Projection(0);\r
- mc_pt_acc_prim->SetName("mc_pt_acc_prim");\r
- aFolderObj->Add(mc_pt_acc_prim);\r
+ TH1D *mcPtAccprim = fMCPrimTrackHist1[1]->Projection(0);\r
+ mcPtAccprim->SetName("mc_pt_acc_prim");\r
+ aFolderObj->Add(mcPtAccprim);\r
\r
- TH1D *mc_pt_rec_all = fMCTrackHist1[2]->Projection(0);\r
- mc_pt_rec_all->SetName("mc_pt_rec_all");\r
- aFolderObj->Add(mc_pt_rec_all);\r
+ TH1D *mcPtRecall = fMCTrackHist1[2]->Projection(0);\r
+ mcPtRecall->SetName("mc_pt_rec_all");\r
+ aFolderObj->Add(mcPtRecall);\r
\r
- TH1D *mc_pt_rec_prim = fMCPrimTrackHist1[2]->Projection(0);\r
- mc_pt_rec_prim->SetName("mc_pt_rec_prim");\r
- aFolderObj->Add(mc_pt_rec_prim);\r
+ TH1D *mcPtRecprim = fMCPrimTrackHist1[2]->Projection(0);\r
+ mcPtRecprim->SetName("mc_pt_rec_prim");\r
+ aFolderObj->Add(mcPtRecprim);\r
\r
- TH1D *mc_pt_rec_sec = fMCSecTrackHist1[2]->Projection(0);\r
- mc_pt_rec_sec->SetName("mc_pt_rec_sec");\r
- aFolderObj->Add(mc_pt_rec_sec);\r
+ TH1D *mcPtRecsec = fMCSecTrackHist1[2]->Projection(0);\r
+ mcPtRecsec->SetName("mc_pt_rec_sec");\r
+ aFolderObj->Add(mcPtRecsec);\r
\r
for(Int_t i = 0; i<6; i++) \r
{ \r
-#ifndef ALIDEDPTANALYSIS_H
-#define ALIDEDPTANALYSIS_H
+#ifndef ALIDNDPTANALYSIS_H
+#define ALIDNDPTANALYSIS_H
//------------------------------------------------------------------------------
-// AlidNdPtAnalysis class.
+// AlidNdPtAnalysis class used for dNdPt analysis.
//
-// a. functionality:
-// - fills analysis control histograms
-// - fills generic correction matrices
-// - generates correction matrices
-//
-// b. data members:
-// - generic correction matrices
-// - control histograms
-//
// Author: J.Otwinowski 04/11/2008
//------------------------------------------------------------------------------
+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 "THnSparse.h"
#include "AlidNdPt.h"
class AlidNdPtAnalysis : public AlidNdPt {
virtual void Process(AliESDEvent *const esdEvent=0, AliMCEvent *const mcEvent=0);
// Merge output objects (needed by PROOF)
- virtual Long64_t Merge(TCollection* list);
+ virtual Long64_t Merge(TCollection* const list);
// Analyse output histograms
virtual void Analyse();
virtual TFolder *ExportToFolder(TObjArray * array=0);
// Get analysis folder
- TFolder* GetAnalysisFolder() {return fAnalysisFolder;}
+ TFolder* GetAnalysisFolder() const {return fAnalysisFolder;}
// Fill control histograms
- void SetHistogramsOn(Bool_t histOn=kTRUE) {fHistogramsOn = histOn;}
- Bool_t IsHistogramsOn() {return fHistogramsOn;}
+ void SetHistogramsOn(const Bool_t histOn=kTRUE) {fHistogramsOn = histOn;}
+ Bool_t IsHistogramsOn() const {return fHistogramsOn;}
// Create folder for analysed histograms
TFolder *CreateFolder(TString folder = "folderdNdPtAnalysis",TString title = "Analysed dNdPt histograms");
void FillHistograms(TObjArray *const allChargedTracks,Int_t *const labelsAll,Int_t multAll,Int_t *const labelsAcc,Int_t multAcc,Int_t *const labelsRec,Int_t multRec);
// Getters
- THnSparseF *GetEventMultCorrelationMatrix() {return fEventMultCorrelationMatrix;}
- THnSparseF *GetTrackPtCorrelationMatrix() {return fTrackPtCorrelationMatrix;}
+ THnSparseF *GetEventMultCorrelationMatrix() const {return fEventMultCorrelationMatrix;}
+ THnSparseF *GetTrackPtCorrelationMatrix() const {return fTrackPtCorrelationMatrix;}
//
- THnSparseF *GetGenEventMatrix() {return fGenEventMatrix;}
- THnSparseF *GetGenSDEventMatrix() {return fGenSDEventMatrix;}
- THnSparseF *GetGenDDEventMatrix() {return fGenDDEventMatrix;}
- THnSparseF *GetGenNDEventMatrix() {return fGenNDEventMatrix;}
- THnSparseF *GetGenNSDEventMatrix() {return fGenNSDEventMatrix;}
-
- THnSparseF *GetTriggerEventMatrix() {return fTriggerEventMatrix;}
- THnSparseF *GetTriggerSDEventMatrix() {return fTriggerSDEventMatrix;}
- THnSparseF *GetTriggerDDEventMatrix() {return fTriggerDDEventMatrix;}
- THnSparseF *GetTriggerNDEventMatrix() {return fTriggerNDEventMatrix;}
- THnSparseF *GetTriggerNSDEventMatrix() {return fTriggerNSDEventMatrix;}
-
- THnSparseF *GetRecEventMatrix() {return fRecEventMatrix;}
- THnSparseF *GetRecSDEventMatrix() {return fRecSDEventMatrix;}
- THnSparseF *GetRecDDEventMatrix() {return fRecDDEventMatrix;}
- THnSparseF *GetRecNDEventMatrix() {return fRecNDEventMatrix;}
- THnSparseF *GetRecNSDEventMatrix() {return fRecNSDEventMatrix;}
+ THnSparseF *GetGenEventMatrix() const {return fGenEventMatrix;}
+ THnSparseF *GetGenSDEventMatrix() const {return fGenSDEventMatrix;}
+ THnSparseF *GetGenDDEventMatrix() const {return fGenDDEventMatrix;}
+ THnSparseF *GetGenNDEventMatrix() const {return fGenNDEventMatrix;}
+ THnSparseF *GetGenNSDEventMatrix() const {return fGenNSDEventMatrix;}
+
+ THnSparseF *GetTriggerEventMatrix() const {return fTriggerEventMatrix;}
+ THnSparseF *GetTriggerSDEventMatrix() const {return fTriggerSDEventMatrix;}
+ THnSparseF *GetTriggerDDEventMatrix() const {return fTriggerDDEventMatrix;}
+ THnSparseF *GetTriggerNDEventMatrix() const {return fTriggerNDEventMatrix;}
+ THnSparseF *GetTriggerNSDEventMatrix() const {return fTriggerNSDEventMatrix;}
+
+ THnSparseF *GetRecEventMatrix() const {return fRecEventMatrix;}
+ THnSparseF *GetRecSDEventMatrix() const {return fRecSDEventMatrix;}
+ THnSparseF *GetRecDDEventMatrix() const {return fRecDDEventMatrix;}
+ THnSparseF *GetRecNDEventMatrix() const {return fRecNDEventMatrix;}
+ THnSparseF *GetRecNSDEventMatrix() const {return fRecNSDEventMatrix;}
//
- THnSparseF *GetGenTrackEventMatrix() {return fGenTrackEventMatrix;}
- THnSparseF *GetGenTrackSDEventMatrix() {return fGenTrackSDEventMatrix;}
- THnSparseF *GetGenTrackDDEventMatrix() {return fGenTrackDDEventMatrix;}
- THnSparseF *GetGenTrackNDEventMatrix() {return fGenTrackNDEventMatrix;}
- THnSparseF *GetGenTrackNSDEventMatrix() {return fGenTrackNSDEventMatrix;}
-
- THnSparseF *GetTriggerTrackEventMatrix() {return fTriggerTrackEventMatrix;}
- THnSparseF *GetTriggerTrackSDEventMatrix() {return fTriggerTrackSDEventMatrix;}
- THnSparseF *GetTriggerTrackDDEventMatrix() {return fTriggerTrackDDEventMatrix;}
- THnSparseF *GetTriggerTrackNDEventMatrix() {return fTriggerTrackNDEventMatrix;}
- THnSparseF *GetTriggerTrackNSDEventMatrix() {return fTriggerTrackNSDEventMatrix;}
-
- THnSparseF *GetRecTrackEventMatrix() {return fRecTrackEventMatrix;}
- THnSparseF *GetRecTrackSDEventMatrix() {return fRecTrackSDEventMatrix;}
- THnSparseF *GetRecTrackDDEventMatrix() {return fRecTrackDDEventMatrix;}
- THnSparseF *GetRecTrackNDEventMatrix() {return fRecTrackNDEventMatrix;}
- THnSparseF *GetRecTrackNSDEventMatrix() {return fRecTrackNSDEventMatrix;}
+ THnSparseF *GetGenTrackEventMatrix() const {return fGenTrackEventMatrix;}
+ THnSparseF *GetGenTrackSDEventMatrix() const {return fGenTrackSDEventMatrix;}
+ THnSparseF *GetGenTrackDDEventMatrix() const {return fGenTrackDDEventMatrix;}
+ THnSparseF *GetGenTrackNDEventMatrix() const {return fGenTrackNDEventMatrix;}
+ THnSparseF *GetGenTrackNSDEventMatrix() const {return fGenTrackNSDEventMatrix;}
+
+ THnSparseF *GetTriggerTrackEventMatrix() const {return fTriggerTrackEventMatrix;}
+ THnSparseF *GetTriggerTrackSDEventMatrix() const {return fTriggerTrackSDEventMatrix;}
+ THnSparseF *GetTriggerTrackDDEventMatrix() const {return fTriggerTrackDDEventMatrix;}
+ THnSparseF *GetTriggerTrackNDEventMatrix() const {return fTriggerTrackNDEventMatrix;}
+ THnSparseF *GetTriggerTrackNSDEventMatrix() const {return fTriggerTrackNSDEventMatrix;}
+
+ THnSparseF *GetRecTrackEventMatrix() const {return fRecTrackEventMatrix;}
+ THnSparseF *GetRecTrackSDEventMatrix() const {return fRecTrackSDEventMatrix;}
+ THnSparseF *GetRecTrackDDEventMatrix() const {return fRecTrackDDEventMatrix;}
+ THnSparseF *GetRecTrackNDEventMatrix() const {return fRecTrackNDEventMatrix;}
+ THnSparseF *GetRecTrackNSDEventMatrix() const {return fRecTrackNSDEventMatrix;}
//
- THnSparseF *GetGenTrackMatrix() {return fGenTrackMatrix;}
- THnSparseF *GetGenPrimTrackMatrix() {return fGenPrimTrackMatrix;}
- THnSparseF *GetRecPrimTrackMatrix() {return fRecPrimTrackMatrix;}
+ THnSparseF *GetGenTrackMatrix() const {return fGenTrackMatrix;}
+ THnSparseF *GetGenPrimTrackMatrix() const {return fGenPrimTrackMatrix;}
+ THnSparseF *GetRecPrimTrackMatrix() const {return fRecPrimTrackMatrix;}
- THnSparseF *GetRecTrackMatrix() {return fRecTrackMatrix;}
- THnSparseF *GetRecSecTrackMatrix() {return fRecSecTrackMatrix;}
- THnSparseF *GetRecMultTrackMatrix() {return fRecMultTrackMatrix;}
+ THnSparseF *GetRecTrackMatrix() const {return fRecTrackMatrix;}
+ THnSparseF *GetRecSecTrackMatrix() const {return fRecSecTrackMatrix;}
+ THnSparseF *GetRecMultTrackMatrix() const {return fRecMultTrackMatrix;}
//
// control histograms
//
- THnSparseF *GetMCEventHist1() {return fMCEventHist1;}
- THnSparseF *GetRecEventHist1() {return fRecEventHist1;}
- THnSparseF *GetRecEventHist2() {return fRecEventHist2;}
- THnSparseF *GetRecMCEventHist1() {return fRecMCEventHist1;}
- THnSparseF *GetRecMCEventHist2() {return fRecMCEventHist2;}
- THnSparseF *GetRecMCEventHist3() {return fRecMCEventHist3;}
+ THnSparseF *GetMCEventHist1() const {return fMCEventHist1;}
+ THnSparseF *GetRecEventHist1() const {return fRecEventHist1;}
+ THnSparseF *GetRecEventHist2() const {return fRecEventHist2;}
+ THnSparseF *GetRecMCEventHist1() const {return fRecMCEventHist1;}
+ THnSparseF *GetRecMCEventHist2() const {return fRecMCEventHist2;}
+ THnSparseF *GetRecMCEventHist3() const {return fRecMCEventHist3;}
- THnSparseF *GetMCTrackHist1(Int_t i) {return fMCTrackHist1[i];}
- THnSparseF *GetMCPrimTrackHist1(Int_t i) {return fMCPrimTrackHist1[i];}
- THnSparseF *GetMCSecTrackHist1(Int_t i) {return fMCSecTrackHist1[i];}
+ THnSparseF *GetMCTrackHist1(Int_t i) const {return fMCTrackHist1[i];}
+ THnSparseF *GetMCPrimTrackHist1(Int_t i) const {return fMCPrimTrackHist1[i];}
+ THnSparseF *GetMCSecTrackHist1(Int_t i) const {return fMCSecTrackHist1[i];}
- THnSparseF *GetRecTrackHist1(Int_t i) {return fRecTrackHist1[i];}
- THnSparseF *GetRecTrackMultHist1(Int_t i) {return fRecTrackMultHist1[i];}
+ THnSparseF *GetRecTrackHist1(Int_t i) const {return fRecTrackHist1[i];}
+ THnSparseF *GetRecTrackMultHist1(Int_t i) const {return fRecTrackMultHist1[i];}
- THnSparseF *GetRecMCTrackHist1() {return fRecMCTrackHist1;}
- THnSparseF *GetMCMultRecTrackHist1() {return fMCMultRecTrackHist1;}
+ THnSparseF *GetRecMCTrackHist1() const {return fRecMCTrackHist1;}
+ THnSparseF *GetMCMultRecTrackHist1() const {return fMCMultRecTrackHist1;}
- THnSparseF *GetRecTrackHist2() {return fRecTrackHist2;}
+ THnSparseF *GetRecTrackHist2() const {return fRecTrackHist2;}
private:
// analysis folder
TFolder *fAnalysisFolder; // folder for analysed histograms
-
- // switch on/off filling of control histograms
- Bool_t fHistogramsOn;
+ Bool_t fHistogramsOn; // switch on/off filling of control histograms
//
// correlation matrices (histograms)
* about the suitability of this software for any purpose. It is *\r
* provided "as is" without express or implied warranty. *\r
**************************************************************************/\r
-\r
-#include <iostream>\r
+//------------------------------------------------------------------------------\r
+// AlidNdPtCorrection class:\r
+//\r
+// a. functionality:\r
+// - applies corrections on dNdPt spectra\r
+// - fills corrected dNdPt histograms\r
+// - fills correction control histograms \r
+//\r
+// b. data members:\r
+// - dNdPt spectra before and after correction procedure\r
+// - control histograms\r
+// - correction matrices (must be loaded)\r
+// \r
+// Author: J.Otwinowski 04/11/2008 \r
+//------------------------------------------------------------------------------\r
\r
#include "TFile.h"\r
-#include "TCint.h"\r
#include "TH1.h"\r
#include "TH2.h"\r
\r
\r
// only charged particles\r
Double_t charge = particle->GetPDG()->Charge()/3.;\r
- if (charge == 0.0)\r
+ if (TMath::Abs(charge) < 0.001)\r
continue;\r
\r
// only postive charged \r
}\r
\r
//_____________________________________________________________________________\r
-void AlidNdPtCorrection::FillHistograms(AlidNdPtHelper::EventObject eventObj, Double_t zv, Int_t multMBTracks)\r
+void AlidNdPtCorrection::FillHistograms(AlidNdPtHelper::EventObject eventObj, Double_t zv, Int_t multMBTracks) const\r
{\r
//\r
// Fill corrected histograms\r
if(eventObj==AlidNdPtHelper::kTriggeredEvents && multMBTracks==0) // empty triggered events\r
{\r
Int_t bin = fZvEmptyEventsNorm->FindBin(zv);\r
- Double_t Fz = fZvEmptyEventsNorm->GetBinContent(bin);\r
+ Double_t factZ = fZvEmptyEventsNorm->GetBinContent(bin);\r
Double_t corrToInelF0 = GetCorrFactZvMult(fCorrTriggerMBtoInelEventMatrix,zv,multMBTracks);\r
Double_t corrToNDF0 = GetCorrFactZvMult(fCorrTriggerMBtoNDEventMatrix,zv,multMBTracks);\r
Double_t corrToNSDF0 = GetCorrFactZvMult(fCorrTriggerMBtoNSDEventMatrix,zv,multMBTracks);\r
- //printf("Fz %f, corrToInelF0 %f, corrToNDF0 %f, corrToNSDF0 %f \n",Fz,corrToInelF0,corrToNDF0,corrToNSDF0);\r
+ //printf("factZ %f, corrToInelF0 %f, corrToNDF0 %f, corrToNSDF0 %f \n",factZ,corrToInelF0,corrToNDF0,corrToNSDF0);\r
\r
fCorrRecEventHist2[0]->Fill(vEventMatrix);\r
- fCorrRecEventHist2[1]->Fill(vEventMatrix,Fz);\r
- fCorrRecEventHist2[2]->Fill(vEventMatrix,Fz*corrToInelF0);\r
- fCorrRecEventHist2[3]->Fill(vEventMatrix,Fz*corrToNDF0);\r
- fCorrRecEventHist2[4]->Fill(vEventMatrix,Fz*corrToNSDF0);\r
+ fCorrRecEventHist2[1]->Fill(vEventMatrix,factZ);\r
+ fCorrRecEventHist2[2]->Fill(vEventMatrix,factZ*corrToInelF0);\r
+ fCorrRecEventHist2[3]->Fill(vEventMatrix,factZ*corrToNDF0);\r
+ fCorrRecEventHist2[4]->Fill(vEventMatrix,factZ*corrToNSDF0);\r
}\r
}\r
\r
//_____________________________________________________________________________\r
-void AlidNdPtCorrection::FillHistograms(AliESDtrack *esdTrack, AliStack *stack, AlidNdPtHelper::TrackObject trackObj, Double_t zv, Int_t mult)\r
+void AlidNdPtCorrection::FillHistograms(AliESDtrack * const esdTrack, AliStack * const stack, AlidNdPtHelper::TrackObject trackObj, Double_t zv, Int_t mult) const\r
{\r
//\r
// Fill ESD track and MC histograms \r
if(!particle) return;\r
\r
Double_t gq = particle->GetPDG()->Charge()/3.0; // Charge units |e|/3\r
- if(gq==0) return;\r
+ if(TMath::Abs(gq)<0.001) return;\r
Float_t gpt = particle->Pt();\r
Float_t geta = particle->Eta();\r
Float_t gphi = particle->Phi();\r
}\r
\r
//_____________________________________________________________________________\r
-void AlidNdPtCorrection::FillHistograms(AliStack *stack, Int_t /*label*/, AlidNdPtHelper::TrackObject /*trackObj*/, Int_t /*mult*/)\r
+void AlidNdPtCorrection::FillHistograms(AliStack * const stack, Int_t /*label*/, AlidNdPtHelper::TrackObject /*trackObj*/, Int_t /*mult*/) const\r
{\r
// Fill MC histograms\r
if(!stack) return;\r
}\r
\r
//_____________________________________________________________________________\r
-Double_t AlidNdPtCorrection::GetCorrFactZvPtEta(THnSparse *hist, Double_t zv, Double_t pt, Double_t eta) const {\r
+Double_t AlidNdPtCorrection::GetCorrFactZvPtEta(THnSparse * const hist, Double_t zv, Double_t pt, Double_t eta) const {\r
// return correction factor F(zv,pt,eta)\r
\r
if(!hist) return 1.;\r
}\r
\r
//_____________________________________________________________________________\r
-Double_t AlidNdPtCorrection::GetContFactZvPtEta(THnSparse *hist, Double_t zv, Double_t pt, Double_t eta) const {\r
+Double_t AlidNdPtCorrection::GetContFactZvPtEta(THnSparse * const hist, Double_t zv, Double_t pt, Double_t eta) const {\r
// return contamination correction factor F(zv,pt,eta)\r
\r
if(!hist) return 1.0;\r
}\r
\r
//_____________________________________________________________________________\r
-Double_t AlidNdPtCorrection::GetCorrFactZvMult(THnSparse *hist, Double_t zv, Int_t mult) const {\r
+Double_t AlidNdPtCorrection::GetCorrFactZvMult(THnSparse * const hist, Double_t zv, Int_t mult) const {\r
// return correction factor F(zv,mult)\r
\r
if(!hist) return 1.;\r
}\r
\r
//_____________________________________________________________________________\r
-Double_t AlidNdPtCorrection::GetContFactZvMult(THnSparse *hist, Double_t zv, Int_t mult) const {\r
+Double_t AlidNdPtCorrection::GetContFactZvMult(THnSparse * const hist, Double_t zv, Int_t mult) const {\r
// return contamination correction factor F(zv,mult)\r
\r
if(!hist) return 1.;\r
}\r
\r
//_____________________________________________________________________________\r
-Long64_t AlidNdPtCorrection::Merge(TCollection* list) \r
+Long64_t AlidNdPtCorrection::Merge(TCollection* const list) \r
{\r
// Merge list of objects (needed by PROOF)\r
\r
return count;\r
}\r
\r
-Int_t AlidNdPtCorrection::GetTrueMult(THnSparse *hist, Int_t mult)\r
+//____________________________________________________________________________\r
+Int_t AlidNdPtCorrection::GetTrueMult(THnSparse * const hist, Int_t mult) const\r
{\r
+//\r
+// get multiplicity of primary particles\r
+//\r
if(!hist) return 0;\r
- Int_t true_mult = 0;\r
+ Int_t trueMult = 0;\r
\r
// 0 bins exluded\r
TAxis *ax = hist->GetAxis(0);\r
\r
// get true multiplicity\r
TH1D *h1 = (TH1D *)hist->Projection(1);\r
- true_mult = (Int_t)h1->GetMean();\r
+ trueMult = (Int_t)h1->GetMean();\r
\r
- return true_mult;\r
+ return trueMult;\r
}\r
\r
//_____________________________________________________________________________\r
//\r
//Double_t minPt = accCuts->GetMinPt();\r
//Double_t maxPt = accCuts->GetMaxPt();\r
- //Double_t minEta = accCuts->GetMinEta();\r
- //Double_t maxEta = accCuts->GetMaxEta()-0.00001;\r
+ Double_t minEta = accCuts->GetMinEta();\r
+ Double_t maxEta = accCuts->GetMaxEta()-0.00001;\r
\r
+ printf("minEta %f, maxEta %f \n",minEta, maxEta);\r
\r
//\r
// cosmics background histo\r
hsc->Scale(1./(fCorrRecEventHist1[2]->Projection(1)->Integral() + fCorrRecEventHist2[2]->Projection(1)->Integral()));\r
aFolderObj->Add(hsc);\r
\r
+ // positive eta\r
+ fCorrRecTrackMultHist1[5]->GetAxis(1)->SetRangeUser(0., maxEta);\r
+\r
+ h = fCorrRecTrackMultHist1[5]->Projection(0);\r
+ h->SetName("pt_rec_trig_event_track_mult_eff_cont_corrected_posEta");\r
+ hs = AlidNdPtHelper::ScaleByBinWidth(h);\r
+ hs->SetName("pt_rec_trig_event_track_mult_eff_cont_corrected_s_posEta");\r
+ aFolderObj->Add(hs);\r
+\r
+ hsc = (TH1D*)hs->Clone();\r
+ hsc->SetName("pt_rec_trig_event_track_mult_eff_cont_corrected_s_norm_posEta");\r
+ hsc->Scale(1./(fCorrRecEventHist1[2]->Projection(1)->Integral()+fCorrRecEventHist2[2]->Projection(1)->Integral()));\r
+ aFolderObj->Add(hsc);\r
+\r
+ // negative eta\r
+ fCorrRecTrackMultHist1[5]->GetAxis(1)->SetRangeUser(minEta, -0.00001);\r
+\r
+ h = fCorrRecTrackMultHist1[5]->Projection(0);\r
+ h->SetName("pt_rec_trig_event_track_mult_eff_cont_corrected_negEta");\r
+ hs = AlidNdPtHelper::ScaleByBinWidth(h);\r
+ hs->SetName("pt_rec_trig_event_track_mult_eff_cont_corrected_s_negEta");\r
+ aFolderObj->Add(hs);\r
+\r
+ hsc = (TH1D*)hs->Clone();\r
+ hsc->SetName("pt_rec_trig_event_track_mult_eff_cont_corrected_s_norm_negEta");\r
+ hsc->Scale(1./(fCorrRecEventHist1[2]->Projection(1)->Integral()+fCorrRecEventHist2[2]->Projection(1)->Integral()));\r
+ aFolderObj->Add(hsc);\r
+\r
+ fCorrRecTrackMultHist1[5]->GetAxis(1)->SetRange(1, fCorrRecTrackMultHist1[5]->GetAxis(1)->GetNbins());\r
+\r
//\r
h = fCorrRecTrackMultHist1[6]->Projection(0);\r
h->SetName("pt_rec_ND_trig_event_track_mult_eff_cont_corrected");\r
hsc->Scale(1./(fCorrRecEventHist1[4]->Projection(1)->Integral()+fCorrRecEventHist2[4]->Projection(1)->Integral()));\r
aFolderObj->Add(hsc);\r
\r
+ //\r
+ // positive eta\r
+ //\r
+ fCorrRecTrackMultHist1[7]->GetAxis(1)->SetRangeUser(0., maxEta);\r
+\r
+ h = fCorrRecTrackMultHist1[7]->Projection(0);\r
+ h->SetName("pt_rec_NSD_trig_event_track_mult_eff_cont_corrected_posEta");\r
+ hs = AlidNdPtHelper::ScaleByBinWidth(h);\r
+ hs->SetName("pt_rec_NSD_trig_event_track_mult_eff_cont_corrected_s_posEta");\r
+ aFolderObj->Add(hs);\r
+\r
+ hsc = (TH1D*)hs->Clone();\r
+ hsc->SetName("pt_rec_NSD_trig_event_track_mult_eff_cont_corrected_s_norm_posEta");\r
+ hsc->Scale(1./(fCorrRecEventHist1[4]->Projection(1)->Integral()+fCorrRecEventHist2[4]->Projection(1)->Integral()));\r
+ aFolderObj->Add(hsc);\r
+\r
+ //\r
+ // negative eta\r
+ //\r
+ fCorrRecTrackMultHist1[7]->GetAxis(1)->SetRangeUser(minEta, -0.00001);\r
+\r
+ h = fCorrRecTrackMultHist1[7]->Projection(0);\r
+ h->SetName("pt_rec_NSD_trig_event_track_mult_eff_cont_corrected_negEta");\r
+ hs = AlidNdPtHelper::ScaleByBinWidth(h);\r
+ hs->SetName("pt_rec_NSD_trig_event_track_mult_eff_cont_corrected_s_negEta");\r
+ aFolderObj->Add(hs);\r
+\r
+ hsc = (TH1D*)hs->Clone();\r
+ hsc->SetName("pt_rec_NSD_trig_event_track_mult_eff_cont_corrected_s_norm_negEta");\r
+ hsc->Scale(1./(fCorrRecEventHist1[4]->Projection(1)->Integral()+fCorrRecEventHist2[4]->Projection(1)->Integral()));\r
+ aFolderObj->Add(hsc);\r
+\r
+ fCorrRecTrackMultHist1[7]->GetAxis(1)->SetRange(1, fCorrRecTrackMultHist1[7]->GetAxis(1)->GetNbins());\r
+\r
// eta axis\r
h = fCorrRecTrackMultHist1[0]->Projection(1);\r
h->SetName("eta_rec_track_not_corrected");\r
-#ifndef ALIDEDPTCORRECTION_H
-#define ALIDEDPTCORRECTION_H
+#ifndef ALIDNDPTCORRECTION_H
+#define ALIDNDPTCORRECTION_H
//------------------------------------------------------------------------------
-// AlidNdPtCorrection class:
+// AlidNdPtCorrection class to correct and
+// normalised dNdPt spectra.
//
-// a. functionality:
-// - applies corrections on dNdPt spectra
-// - fills corrected dNdPt histograms
-// - fills correction control histograms
-//
-// b. data members:
-// - dNdPt spectra before and after correction procedure
-// - control histograms
-// - correction matrices (must be loaded)
-//
// Author: J.Otwinowski 04/11/2008
//------------------------------------------------------------------------------
-
+class iostream;
+class TFile;
+class TCint;
class TFolder;
class TObjArray;
class TString;
+class THnSparse;
class AliESDtrackCuts;
class AliVertexerTracks;
class AlidNdPt;
class AlidNdPtHelper;
-#include "THnSparse.h"
#include "AlidNdPt.h"
class AlidNdPtCorrection : public AlidNdPt {
virtual void Process(AliESDEvent *const esdEvent=0, AliMCEvent *const mcEvent=0);
// Merge output objects (needed by PROOF)
- virtual Long64_t Merge(TCollection* list);
+ virtual Long64_t Merge(TCollection* const list);
// Analyse output histograms
virtual void Analyse();
virtual TFolder *ExportToFolder(TObjArray * array=0);
// Get analysis folder
- TFolder* GetCorrectionFolder() {return fCorrectionFolder;}
+ TFolder* GetCorrectionFolder() const {return fCorrectionFolder;}
// Create folder for analysed histograms
TFolder *CreateFolder(TString folder = "folderdNdPtCorrection",TString title = "Analysed dNdPt histograms");
// Fill histograms
- void FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack, AlidNdPtHelper::TrackObject trackObj, Double_t zv, Int_t multRec);
- void FillHistograms(AliStack *const stack, Int_t label, AlidNdPtHelper::TrackObject trackObj, Int_t multRec);
- void FillHistograms(AlidNdPtHelper::EventObject eventObj, Double_t zv, Int_t multMBRec);
+ void FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack, AlidNdPtHelper::TrackObject trackObj, Double_t zv, Int_t multRec) const;
+ void FillHistograms(AliStack *const stack, Int_t label, AlidNdPtHelper::TrackObject trackObj, Int_t multRec) const;
+ void FillHistograms(AlidNdPtHelper::EventObject eventObj, Double_t zv, Int_t multMBRec) const;
// Get correction factors
Double_t GetCorrFactZvPtEta(THnSparse *const hist=0, Double_t zv =0, Double_t pt=0, Double_t eta=0) const;
Double_t GetContFactZvMult(THnSparse *const hist=0, Double_t zv =0, Int_t mult=0) const;
// Getters
- THnSparseF *GetMCAllEventMultHist1() {return fMCAllEventMultHist1;};
- THnSparseF *GetMCAllNDEventMultHist1() {return fMCAllNDEventMultHist1;};
- THnSparseF *GetMCAllNSDEventMultHist1() {return fMCAllNSDEventMultHist1;};
- THnSparseF *GetMCTriggerMultHist1() {return fMCTriggerMultHist1;};
- THnSparseF *GetMCEventMultHist1() {return fMCEventMultHist1;};
+ THnSparseF *GetMCAllEventMultHist1() const {return fMCAllEventMultHist1;};
+ THnSparseF *GetMCAllNDEventMultHist1() const {return fMCAllNDEventMultHist1;};
+ THnSparseF *GetMCAllNSDEventMultHist1() const {return fMCAllNSDEventMultHist1;};
+ THnSparseF *GetMCTriggerMultHist1() const {return fMCTriggerMultHist1;};
+ THnSparseF *GetMCEventMultHist1() const {return fMCEventMultHist1;};
- THnSparseF *GetMCAllPrimTrackMultHist1() {return fMCAllPrimTrackMultHist1;};
- THnSparseF *GetMCNDEventAllPrimTrackMultHist1() {return fMCNDEventAllPrimTrackMultHist1;};
- THnSparseF *GetMCNSDEventAllPrimTrackMultHist1() {return fMCNSDEventAllPrimTrackMultHist1;};
- THnSparseF *GetMCTriggerPrimTrackMultHist1() {return fMCTriggerPrimTrackMultHist1;};
- THnSparseF *GetMCEventPrimTrackMultHist1() {return fMCEventPrimTrackMultHist1;};
+ THnSparseF *GetMCAllPrimTrackMultHist1() const {return fMCAllPrimTrackMultHist1;};
+ THnSparseF *GetMCNDEventAllPrimTrackMultHist1() const {return fMCNDEventAllPrimTrackMultHist1;};
+ THnSparseF *GetMCNSDEventAllPrimTrackMultHist1() const {return fMCNSDEventAllPrimTrackMultHist1;};
+ THnSparseF *GetMCTriggerPrimTrackMultHist1() const {return fMCTriggerPrimTrackMultHist1;};
+ THnSparseF *GetMCEventPrimTrackMultHist1() const {return fMCEventPrimTrackMultHist1;};
- THnSparseF *GetCorrRecTrackMultHist1(Int_t i) {return fCorrRecTrackMultHist1[i];}
- THnSparseF *GetCorrRecEventHist1(Int_t i) {return fCorrRecEventHist1[i];}
- THnSparseF *GetCorrRecEventHist2(Int_t i) {return fCorrRecEventHist2[i];}
+ THnSparseF *GetCorrRecTrackMultHist1(Int_t i) const {return fCorrRecTrackMultHist1[i];}
+ THnSparseF *GetCorrRecEventHist1(Int_t i) const {return fCorrRecEventHist1[i];}
+ THnSparseF *GetCorrRecEventHist2(Int_t i) const {return fCorrRecEventHist2[i];}
- THnSparseF *GetPtvsPt(Int_t i) {return fPtvsPt[i];}
+ THnSparseF *GetPtvsPt(Int_t i) const {return fPtvsPt[i];}
// correlation matrix
void SetEventMultCorrelationMatrix(THnSparseF *const matrix=0) {fEventMultCorrelationMatrix = matrix;}
- THnSparseF *GetEventMultCorrelationMatrix() {return fEventMultCorrelationMatrix;}
+ THnSparseF *GetEventMultCorrelationMatrix() const {return fEventMultCorrelationMatrix;}
//
void SetZvNorm(TH1D *const matrix=0) {fZvNorm = matrix;}
- TH1D *GetZvNorm() {return fZvNorm;}
+ TH1D *GetZvNorm() const {return fZvNorm;}
void SetZvEmptyEventsNorm(TH1D *const matrix=0) {fZvEmptyEventsNorm = matrix;}
- TH1D *GetZvEmptyEventsNorm() {return fZvEmptyEventsNorm;}
+ TH1D *GetZvEmptyEventsNorm() const {return fZvEmptyEventsNorm;}
//
void SetCorrEventMatrix(THnSparseF *const matrix=0) {fCorrEventMatrix = matrix;}
- THnSparseF *GetCorrEventMatrix() {return fCorrEventMatrix;}
+ THnSparseF *GetCorrEventMatrix() const {return fCorrEventMatrix;}
void SetCorrTriggerMBtoInelEventMatrix(THnSparseF *const matrix=0) {fCorrTriggerMBtoInelEventMatrix = matrix;}
- THnSparseF *GetCorrTriggerMBtoInelEventMatrix() {return fCorrTriggerMBtoInelEventMatrix;}
+ THnSparseF *GetCorrTriggerMBtoInelEventMatrix() const {return fCorrTriggerMBtoInelEventMatrix;}
void SetCorrTriggerMBtoNDEventMatrix(THnSparseF *const matrix=0) {fCorrTriggerMBtoNDEventMatrix = matrix;}
- THnSparseF *GetCorrTriggerMBtoNDEventMatrix() {return fCorrTriggerMBtoNDEventMatrix;}
+ THnSparseF *GetCorrTriggerMBtoNDEventMatrix() const {return fCorrTriggerMBtoNDEventMatrix;}
void SetCorrTriggerMBtoNSDEventMatrix(THnSparseF *const matrix=0) {fCorrTriggerMBtoNSDEventMatrix = matrix;}
- THnSparseF *GetCorrTriggerMBtoNSDEventMatrix() {return fCorrTriggerMBtoNSDEventMatrix;}
+ THnSparseF *GetCorrTriggerMBtoNSDEventMatrix() const {return fCorrTriggerMBtoNSDEventMatrix;}
//
void SetCorrTrackEventMatrix(THnSparseF *const matrix=0) {fCorrTrackEventMatrix = matrix;}
- THnSparseF *GetCorrTrackEventMatrix() {return fCorrTrackEventMatrix;}
+ THnSparseF *GetCorrTrackEventMatrix() const {return fCorrTrackEventMatrix;}
void SetCorrTriggerMBtoInelTrackEventMatrix(THnSparseF *const matrix=0) {fCorrTriggerMBtoInelTrackEventMatrix = matrix;}
- THnSparseF *GetCorrTriggerMBtoInelTrackEventMatrix() {return fCorrTriggerMBtoInelTrackEventMatrix;}
+ THnSparseF *GetCorrTriggerMBtoInelTrackEventMatrix() const {return fCorrTriggerMBtoInelTrackEventMatrix;}
void SetCorrTriggerMBtoNDTrackEventMatrix(THnSparseF *const matrix=0) {fCorrTriggerMBtoNDTrackEventMatrix = matrix;}
- THnSparseF *GetCorrTriggerMBtoNDTrackEventMatrix() {return fCorrTriggerMBtoNDTrackEventMatrix;}
+ THnSparseF *GetCorrTriggerMBtoNDTrackEventMatrix() const {return fCorrTriggerMBtoNDTrackEventMatrix;}
void SetCorrTriggerMBtoNSDTrackEventMatrix(THnSparseF *const matrix=0) {fCorrTriggerMBtoNSDTrackEventMatrix = matrix;}
- THnSparseF *GetCorrTriggerMBtoNSDTrackEventMatrix() {return fCorrTriggerMBtoNSDTrackEventMatrix;}
+ THnSparseF *GetCorrTriggerMBtoNSDTrackEventMatrix() const {return fCorrTriggerMBtoNSDTrackEventMatrix;}
void SetCorrTrackMatrix(THnSparseF *const matrix=0) {fCorrTrackMatrix = matrix;}
- THnSparseF *GetCorrTrackMatrix() {return fCorrTrackMatrix;}
+ THnSparseF *GetCorrTrackMatrix() const {return fCorrTrackMatrix;}
void SetContTrackMatrix(THnSparseF *const matrix=0) {fContTrackMatrix = matrix;}
- THnSparseF *GetContTrackMatrix() {return fContTrackMatrix;}
+ THnSparseF *GetContTrackMatrix() const {return fContTrackMatrix;}
void SetContMultTrackMatrix(THnSparseF *const matrix=0) {fContMultTrackMatrix = matrix;}
- THnSparseF *GetContMultTrackMatrix() {return fContMultTrackMatrix;}
+ THnSparseF *GetContMultTrackMatrix() const {return fContMultTrackMatrix;}
void SetCorrMatrixFileName(TString name="") { fCorrMatrixFileName = name; }
- Int_t GetTrueMult(THnSparse *const hist=0, Int_t mult=0);
+ Int_t GetTrueMult(THnSparse *const hist=0, Int_t mult=0) const;
private:
* about the suitability of this software for any purpose. It is *\r
* provided "as is" without express or implied warranty. *\r
**************************************************************************/\r
-\r
-#include <iostream>\r
-\r
-#include "TFile.h"\r
-#include "TCint.h"\r
+//------------------------------------------------------------------------------\r
+// AlidNdPtCutAnalysis class. \r
+//\r
+// a. functionality:\r
+// - fills generic cut histograms\r
+// - generates cuts (selection criteria)\r
+//\r
+// b. data members:\r
+// - generic cut histograms\r
+// - control histograms\r
+//\r
+// Author: J.Otwinowski 04/11/2008 \r
+//------------------------------------------------------------------------------\r
#include "TH1.h"\r
#include "TH2.h"\r
\r
fEventCount->Sumw2();\r
\r
//Xv:Yv:Zv:ResZv:Mult\r
+ Double_t kFact = 0.1;\r
+\r
Int_t binsRecEventHist[5]={80,80,100,80,150};\r
- Double_t minRecEventHist[5]={-3.,-3.,-35.,0.,0.}; \r
- Double_t maxRecEventHist[5]={3.,3.,35.,10.,150.}; \r
+ Double_t minRecEventHist[5]={-3.*kFact,-3.*kFact,-35.,0.,0.}; \r
+ Double_t maxRecEventHist[5]={3.*kFact,3.*kFact,35.,10.,150.}; \r
fRecEventHist = new THnSparseF("fRecEventHist","Xv:Yv:Zv:ResZv:Mult",5,binsRecEventHist,minRecEventHist,maxRecEventHist);\r
fRecEventHist->GetAxis(0)->SetTitle("Xv (cm)");\r
fRecEventHist->GetAxis(1)->SetTitle("Yv (cm)");\r
fMCEventHist->Sumw2();\r
\r
//Xv-mcXv:Yv-mcYv:Zv-mcZv:Mult\r
- Float_t fact = 0.1;\r
Int_t binsRecMCEventHist[4]={100,100,100,150};\r
- Double_t minRecMCEventHist[4]={-10.0*fact,-10.0*fact,-10.0*fact,0.}; \r
- Double_t maxRecMCEventHist[4]={10.0*fact,10.0*fact,10.0*fact,150.}; \r
+ Double_t minRecMCEventHist[4]={-10.0*kFact,-10.0*kFact,-10.0*kFact,0.}; \r
+ Double_t maxRecMCEventHist[4]={10.0*kFact,10.0*kFact,10.0*kFact,150.}; \r
fRecMCEventHist = new THnSparseF("fRecMCEventHist","mcXv-Xv:mcYv-Yv:mcZv-Zv:Mult",4,binsRecMCEventHist,minRecMCEventHist,maxRecMCEventHist);\r
fRecMCEventHist->GetAxis(0)->SetTitle("mcXv-Xv (cm)");\r
fRecMCEventHist->GetAxis(1)->SetTitle("mcYv-Yv (cm)");\r
Double_t minRecMCTrackHist[11]={0., 0., 0., -10.,-10.,-1.5, 0., ptMin, 0., 0., 0.};\r
Double_t maxRecMCTrackHist[11]={160.,10.,1.2, 10.,10.,1.5, 2.*TMath::Pi(), ptMax, 2.,2., 2.};\r
\r
- fRecMCTrackHist = new THnSparseF("fRecMCTrackHist","nClust:chi2PerClust:nClust/nFindableClust:DCAy:DCAz:eta:phi:pt:isKink:isPrim:polarity",10,binsRecMCTrackHist,minRecMCTrackHist,maxRecMCTrackHist);\r
+ fRecMCTrackHist = new THnSparseF("fRecMCTrackHist","nClust:chi2PerClust:nClust/nFindableClust:DCAy:DCAz:eta:phi:pt:isKink:isPrim:polarity",11,binsRecMCTrackHist,minRecMCTrackHist,maxRecMCTrackHist);\r
fRecMCTrackHist->SetBinEdges(7,binsPt);\r
\r
fRecMCTrackHist->GetAxis(0)->SetTitle("nClust");\r
}\r
\r
//_____________________________________________________________________________\r
-void AlidNdPtCutAnalysis::FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack)\r
+void AlidNdPtCutAnalysis::FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack) const\r
{\r
//\r
// Fill ESD track and MC histograms \r
}\r
\r
//_____________________________________________________________________________\r
-Long64_t AlidNdPtCutAnalysis::Merge(TCollection* list) \r
+Long64_t AlidNdPtCutAnalysis::Merge(TCollection* const list) \r
{\r
// Merge list of objects (needed by PROOF)\r
\r
#define ALIDEDPTCUTANALYSIS_H
//------------------------------------------------------------------------------
-// AlidNdPtCutAnalysis class.
-//
-// a. functionality:
-// - fills generic cut histograms
-// - generates cuts (selection criteria)
-//
-// b. data members:
-// - generic cut histograms
-// - control histograms
+// AlidNdPtCutAnalysis class to determine
+// cuts to be used for dNdPt analysis.
//
// Author: J.Otwinowski 04/11/2008
//------------------------------------------------------------------------------
+class iostream;
+class TFile;
+class TCint;
class TProfile;
class TFolder;
class TObjArray;
class TString;
+class THnSparse;
class AliESDtrackCuts;
class AliVertexerTracks;
class AliESDfriend;
class AliESDfriendTrack;
-#include "THnSparse.h"
#include "AlidNdPt.h"
class AlidNdPtCutAnalysis : public AlidNdPt {
virtual void Process(AliESDEvent *const esdEvent=0, AliMCEvent *const mcEvent=0);
// Merge output objects (needed by PROOF)
- virtual Long64_t Merge(TCollection* list);
+ virtual Long64_t Merge(TCollection* const list);
// Analyse output histograms
virtual void Analyse();
// Export objects to folder
- virtual TFolder *ExportToFolder(TObjArray * array=0);
+ virtual TFolder *ExportToFolder(TObjArray * const array=0);
// Get analysis folder
- TFolder* GetAnalysisFolder() {return fAnalysisFolder;}
+ TFolder* GetAnalysisFolder() const {return fAnalysisFolder;}
// Create folder for analysed histograms
TFolder *CreateFolder(TString folder = "folderdNdPtAnalysis",TString title = "Analysed dNdPt histograms");
// Fill histograms
- void FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack);
+ void FillHistograms(AliESDtrack *const esdTrack, AliStack *const stack) const;
// Getters
- THnSparseF *GetEventCount() {return fEventCount;}
- THnSparseF *GetRecEventHist() {return fRecEventHist;}
- THnSparseF *GetMCEventHist() {return fMCEventHist;}
- THnSparseF *GetRecMCEventHist() {return fRecMCEventHist;}
+ THnSparseF *GetEventCount() const {return fEventCount;}
+ THnSparseF *GetRecEventHist() const {return fRecEventHist;}
+ THnSparseF *GetMCEventHist() const {return fMCEventHist;}
+ THnSparseF *GetRecMCEventHist() const {return fRecMCEventHist;}
//
- THnSparseF *GetRecMCTrackHist() {return fRecMCTrackHist;}
+ THnSparseF *GetRecMCTrackHist() const {return fRecMCTrackHist;}
private:
*/
//____________________________________________________________________
-Bool_t AlidNdPtHelper::IsCosmicTrack(AliESDtrack *track1, AliESDtrack *track2, Int_t trackIdx, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts)
+Bool_t AlidNdPtHelper::IsCosmicTrack(AliESDtrack *track1, AliESDtrack *track2, Int_t /*trackIdx*/, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts)
{
//
// check cosmic tracks
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff