X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=PWG4%2FtotEt%2FAliAnalysisHadEtReconstructed.cxx;h=492c6f7919eaf7639c3d91f9e26e285d18de059f;hb=f43fc416d40e00681aff395a9a23627875665108;hp=c79313f13d606daaac6b9f13ee57c6c4b193d2a2;hpb=cf6522d1f92f0aaf826d9118caf8a13d2a506386;p=u%2Fmrichter%2FAliRoot.git diff --git a/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx b/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx index c79313f13d6..492c6f7919e 100644 --- a/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx +++ b/PWG4/totEt/AliAnalysisHadEtReconstructed.cxx @@ -7,88 +7,562 @@ //Created by Christine Nattrass, Rebecca Scott, Irakli Martashvili //University of Tennessee at Knoxville //_________________________________________________________________________ + +#include +#include +#include #include "AliAnalysisHadEtReconstructed.h" #include "AliAnalysisEtCuts.h" #include "AliESDtrack.h" #include "AliESDCaloCluster.h" #include "AliVEvent.h" #include "AliESDEvent.h" +#include "AliESDtrackCuts.h" +#include "AliESDpid.h" #include "AliVParticle.h" #include +#include "AliAnalysisHadEtCorrections.h" +#include "TFile.h" +#include "TString.h" +#include "AliAnalysisEtCommon.h" +#include "AliAnalysisHadEt.h" + +using namespace std; + +ClassImp(AliAnalysisHadEtReconstructed); + AliAnalysisHadEtReconstructed::AliAnalysisHadEtReconstructed() : AliAnalysisHadEt() + ,fCorrections(0) + ,fConfigFile("ConfigHadEtAnalysis.C") + ,fCorrTotEtFullAcceptanceTPC(0) + ,fCorrTotEtFullAcceptanceITS(0) + ,fCorrHadEtFullAcceptanceTPC(0) + ,fCorrHadEtFullAcceptanceITS(0) + ,fCorrTotEtEMCALAcceptanceTPC(0) + ,fCorrTotEtEMCALAcceptanceITS(0) + ,fCorrHadEtEMCALAcceptanceTPC(0) + ,fCorrHadEtEMCALAcceptanceITS(0) + ,fCorrTotEtPHOSAcceptanceTPC(0) + ,fCorrTotEtPHOSAcceptanceITS(0) + ,fCorrHadEtPHOSAcceptanceTPC(0) + ,fCorrHadEtPHOSAcceptanceITS(0) + ,fCorrectedHadEtFullAcceptanceTPCNoPID(0) + ,fCorrectedHadEtFullAcceptanceITSNoPID(0) + ,fCorrectedHadEtEMCALAcceptanceTPCNoPID(0) + ,fCorrectedHadEtEMCALAcceptanceITSNoPID(0) + ,fCorrectedHadEtPHOSAcceptanceTPCNoPID(0) + ,fCorrectedHadEtPHOSAcceptanceITSNoPID(0) + ,fCorrectedHadEtFullAcceptanceTPC(0) + ,fCorrectedHadEtFullAcceptanceITS(0) + ,fCorrectedHadEtEMCALAcceptanceTPC(0) + ,fCorrectedHadEtEMCALAcceptanceITS(0) + ,fCorrectedHadEtPHOSAcceptanceTPC(0) + ,fCorrectedHadEtPHOSAcceptanceITS(0) + ,fRawEtFullAcceptanceTPC(0) + ,fRawEtFullAcceptanceITS(0) + ,fRawEtEMCALAcceptanceTPC(0) + ,fRawEtEMCALAcceptanceITS(0) + ,fRawEtPHOSAcceptanceTPC(0) + ,fRawEtPHOSAcceptanceITS(0) + ,fRawEtFullAcceptanceTPCNoPID(0) + ,fRawEtFullAcceptanceITSNoPID(0) + ,fRawEtEMCALAcceptanceTPCNoPID(0) + ,fRawEtEMCALAcceptanceITSNoPID(0) + ,fRawEtPHOSAcceptanceTPCNoPID(0) + ,fRawEtPHOSAcceptanceITSNoPID(0) { - } AliAnalysisHadEtReconstructed::~AliAnalysisHadEtReconstructed() { + delete fCorrections; } Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev) { // analyse ESD event ResetEventValues(); - AliESDEvent *event = dynamic_cast(ev); - - for (Int_t iTrack = 0; iTrack < event->GetNumberOfTracks(); iTrack++) - { - AliVParticle *track = event->GetTrack(iTrack); - if (!track) - { - Printf("ERROR: Could not get track %d", iTrack); - continue; - } - - fMultiplicity++; - - const Double_t *pidWeights = track->PID(); - if (pidWeights) - { - Int_t maxpid = -1; - Float_t maxpidweight = 0; - for (Int_t p =0; p < AliPID::kSPECIES; p++) - { - if (pidWeights[p] > maxpidweight) - { - maxpidweight = pidWeights[p]; - maxpid = p; - } - } - if (maxpid == AliPID::kProton) - { - // massPart = -0.938*track->Charge(); - } - - } - } + AliESDEvent *realEvent = dynamic_cast(ev); + //for PID + AliESDpid *pID = new AliESDpid(); + pID->MakePID(realEvent); + TString *strTPC = new TString("TPC"); + TString *strITS = new TString("ITS"); + TString *strTPCITS = new TString("TPCITS"); + for(Int_t cutset=0;cutset<2;cutset++){ + bool isTPC = false; + TString *cutName; + TObjArray* list; + switch(cutset){ + case 0: + cutName = strTPCITS; + list = fEsdtrackCutsITSTPC->GetAcceptedTracks(realEvent); + isTPC = true; + break; + case 1: + cutName = strITS; + list = fEsdtrackCutsITS->GetAcceptedTracks(realEvent); + break; + case 2: + cutName = strTPC; + list = fEsdtrackCutsTPC->GetAcceptedTracks(realEvent); + break; + default: + cerr<<"Error: cannot fill histograms!"<GetEntries(); + for (Int_t iTrack = 0; iTrack < nGoodTracks; iTrack++) + { + - fTotNeutralEtAcc = fTotNeutralEt; - fTotEt = fTotChargedEt + fTotNeutralEt; - fTotEtAcc = fTotChargedEtAcc + fTotNeutralEtAcc; + AliESDtrack *track = dynamic_cast (list->At(iTrack)); + if (!track) + { + Printf("ERROR: Could not get track %d", iTrack); + continue; + } + else{ + if(TMath::Abs(track->Eta())>fCorrections->GetEtaCut()) continue; + Float_t nSigmaPion,nSigmaProton,nSigmaKaon,nSigmaElectron; + if(cutset!=1){ + nSigmaPion = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kPion)); + nSigmaProton = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kProton)); + nSigmaKaon = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kKaon)); + nSigmaElectron = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kElectron)); + } + else{ + nSigmaPion = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kPion)); + nSigmaProton = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kProton)); + nSigmaKaon = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kKaon)); + nSigmaElectron = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kElectron)); + } + bool isPion = (nSigmaPion<3.0 && nSigmaProton>2.0 && nSigmaKaon>2.0); + bool isElectron = (nSigmaElectron<2.0 && nSigmaPion>4.0 && nSigmaProton>3.0 && nSigmaKaon>3.0); + bool isKaon = (nSigmaPion>3.0 && nSigmaProton>2.0 && nSigmaKaon<2.0); + bool isProton = (nSigmaPion>3.0 && nSigmaProton<2.0 && nSigmaKaon>2.0); - std::cout << fTotChargedEtAcc << std::endl; - // Fill the histograms... - FillHistograms(); + bool unidentified = (!isProton && !isKaon && !isElectron && !isPion); + Float_t dEdx = track->GetTPCsignal(); + if(cutset==1) dEdx = track->GetITSsignal(); + FillHisto2D(Form("dEdxDataAll%s",cutName->Data()),track->P(),dEdx,1.0); + bool inPHOS = IsInPHOS(track); + bool inEMCAL = IsInEMCAL(track); + + Float_t corrBkgd=0.0; + Float_t corrNotID=0.0; + Float_t corrNoID=0.0;// = fCorrections->GetNotIDCorrectionNoPID(track->Pt()); + Float_t corrEff = 0.0; + Float_t corrEffNoID = 0.0; + if(cutset==0){//TPC + corrBkgd = fCorrections->GetBackgroundCorrectionTPC(track->Pt()); + corrEffNoID = fCorrections->GetTPCEfficiencyCorrectionHadron(track->Pt()); + corrNotID = fCorrections->GetNotIDConstCorrectionTPC(); + corrNoID = fCorrections->GetNotIDConstCorrectionTPCNoID(); + } + if(cutset==1){//ITS + corrBkgd = fCorrections->GetBackgroundCorrectionITS(track->Pt()); + corrEffNoID = fCorrections->GetITSEfficiencyCorrectionHadron(track->Pt()); + corrNotID = fCorrections->GetNotIDConstCorrectionITS(); + corrNoID = fCorrections->GetNotIDConstCorrectionITSNoID(); + } + Float_t et = 0.0; + Float_t etNoID = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge()); + Float_t etpartialcorrected = 0.0; + Float_t etpartialcorrectedNoID = corrNoID*corrBkgd*corrEffNoID*etNoID; + FillHisto2D(Form("EtDataRaw%sNoID",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrectedNoID); + + if(isPion){ + FillHisto2D(Form("dEdxDataPion%s",cutName->Data()),track->P(),dEdx,1.0); + et = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge()); + if(cutset==0){corrEff = fCorrections->GetTPCEfficiencyCorrectionPion(track->Pt());} + //else{corrEff = fCorrections->GetITSEfficiencyCorrectionPion(track->Pt());} + etpartialcorrected = et*corrBkgd*corrEff*corrNotID; + + if(track->Charge()>0.0){ + FillHisto2D(Form("EtDataRaw%sPiPlus",cutName->Data()),track->Pt(),track->Eta(),et); + FillHisto2D(Form("EtDataCorrected%sPiPlus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + else{ + FillHisto2D(Form("EtDataRaw%sPiMinus",cutName->Data()),track->Pt(),track->Eta(),et); + FillHisto2D(Form("EtDataCorrected%sPiMinus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + } + if(isKaon){ + FillHisto2D(Form("dEdxDataKaon%s",cutName->Data()),track->P(),dEdx,1.0); + et = Et(track->P(),track->Theta(),fgKPlusCode,track->Charge()); + if(cutset==0){corrEff = fCorrections->GetTPCEfficiencyCorrectionKaon(track->Pt());} + //else{corrEff = fCorrections->GetITSEfficiencyCorrectionKaon(track->Pt());} + etpartialcorrected = et*corrBkgd*corrEff*corrNotID; + + if(track->Charge()>0.0){ + FillHisto2D(Form("EtDataRaw%sKPlus",cutName->Data()),track->Pt(),track->Eta(),et); + FillHisto2D(Form("EtDataCorrected%sKPlus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + else{ + FillHisto2D(Form("EtDataRaw%sKMinus",cutName->Data()),track->Pt(),track->Eta(),et); + FillHisto2D(Form("EtDataCorrected%sKMinus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + } + if(isProton){ + FillHisto2D(Form("dEdxDataProton%s",cutName->Data()),track->P(),dEdx,1.0); + et = Et(track->P(),track->Theta(),fgProtonCode,track->Charge()); + if(cutset==0){corrEff = fCorrections->GetTPCEfficiencyCorrectionProton(track->Pt());} + //else{corrEff = fCorrections->GetITSEfficiencyCorrectionProton(track->Pt());} + etpartialcorrected = et*corrBkgd*corrEff*corrNotID; + + if(track->Charge()>0.0){ + FillHisto2D(Form("EtDataRaw%sProton",cutName->Data()),track->Pt(),track->Eta(),et); + FillHisto2D(Form("EtDataCorrected%sProton",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + else{ + FillHisto2D(Form("EtDataRaw%sAntiProton",cutName->Data()),track->Pt(),track->Eta(),et); + FillHisto2D(Form("EtDataCorrected%sAntiProton",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + } + if(isElectron){ + FillHisto2D(Form("dEdxDataProton%s",cutName->Data()),track->P(),dEdx,1.0); + //et = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge()); + } + if(unidentified){ + //if(!isPion) + FillHisto2D(Form("dEdxDataUnidentified%s",cutName->Data()),track->P(),dEdx,1.0); + et = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge()); + etpartialcorrected = et*corrBkgd*corrEffNoID*corrNotID; + //if(!isPion) + FillHisto2D(Form("EtDataCorrected%sUnidentified",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected); + } + if(!isTPC){ + etpartialcorrected = etpartialcorrectedNoID;//Not using PID for ITS + } + AddEt(et,etNoID,etpartialcorrected,etpartialcorrectedNoID,track->Pt(),isTPC,inPHOS,inEMCAL); + } + } + } + if(GetCorrectedHadEtFullAcceptanceTPC()>0.0)FillHisto1D("RecoHadEtFullAcceptanceTPC",GetCorrectedHadEtFullAcceptanceTPC(),1.0); + if(GetCorrectedTotEtFullAcceptanceTPC()>0.0)FillHisto1D("RecoTotEtFullAcceptanceTPC",GetCorrectedTotEtFullAcceptanceTPC(),1.0); + if(GetCorrectedHadEtEMCALAcceptanceTPC()>0.0)FillHisto1D("RecoHadEtEMCALAcceptanceTPC",GetCorrectedHadEtEMCALAcceptanceTPC(),1.0); + if(GetCorrectedTotEtEMCALAcceptanceTPC()>0.0)FillHisto1D("RecoTotEtEMCALAcceptanceTPC",GetCorrectedTotEtEMCALAcceptanceTPC(),1.0); + if(GetCorrectedHadEtPHOSAcceptanceTPC()>0.0)FillHisto1D("RecoHadEtPHOSAcceptanceTPC",GetCorrectedHadEtPHOSAcceptanceTPC(),1.0); + if(GetCorrectedTotEtPHOSAcceptanceTPC()>0.0)FillHisto1D("RecoTotEtPHOSAcceptanceTPC",GetCorrectedTotEtPHOSAcceptanceTPC(),1.0); + if(GetCorrectedHadEtFullAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoHadEtFullAcceptanceTPCNoPID",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0); + if(GetCorrectedTotEtFullAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoTotEtFullAcceptanceTPCNoPID",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0); + if(GetCorrectedHadEtEMCALAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoHadEtEMCALAcceptanceTPCNoPID",GetCorrectedHadEtEMCALAcceptanceTPCNoPID(),1.0); + if(GetCorrectedTotEtEMCALAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoTotEtEMCALAcceptanceTPCNoPID",GetCorrectedTotEtEMCALAcceptanceTPCNoPID(),1.0); + if(GetCorrectedHadEtPHOSAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoHadEtPHOSAcceptanceTPCNoPID",GetCorrectedHadEtPHOSAcceptanceTPCNoPID(),1.0); + if(GetCorrectedTotEtPHOSAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoTotEtPHOSAcceptanceTPCNoPID",GetCorrectedTotEtPHOSAcceptanceTPCNoPID(),1.0); + if(GetCorrectedHadEtFullAcceptanceITS()>0.0)FillHisto1D("RecoHadEtFullAcceptanceITS",GetCorrectedHadEtFullAcceptanceITS(),1.0); + if(GetCorrectedTotEtFullAcceptanceITS()>0.0)FillHisto1D("RecoTotEtFullAcceptanceITS",GetCorrectedTotEtFullAcceptanceITS(),1.0); + if(GetCorrectedHadEtEMCALAcceptanceITS()>0.0)FillHisto1D("RecoHadEtEMCALAcceptanceITS",GetCorrectedHadEtEMCALAcceptanceITS(),1.0); + if(GetCorrectedTotEtEMCALAcceptanceITS()>0.0)FillHisto1D("RecoTotEtEMCALAcceptanceITS",GetCorrectedTotEtEMCALAcceptanceITS(),1.0); + if(GetCorrectedHadEtPHOSAcceptanceITS()>0.0)FillHisto1D("RecoHadEtPHOSAcceptanceITS",GetCorrectedHadEtPHOSAcceptanceITS(),1.0); + if(GetCorrectedTotEtPHOSAcceptanceITS()>0.0)FillHisto1D("RecoTotEtPHOSAcceptanceITS",GetCorrectedTotEtPHOSAcceptanceITS(),1.0); + if(GetCorrectedHadEtFullAcceptanceITSNoPID()>0.0)FillHisto1D("RecoHadEtFullAcceptanceITSNoPID",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0); + if(GetCorrectedTotEtFullAcceptanceITSNoPID()>0.0)FillHisto1D("RecoTotEtFullAcceptanceITSNoPID",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0); + if(GetCorrectedHadEtEMCALAcceptanceITSNoPID()>0.0)FillHisto1D("RecoHadEtEMCALAcceptanceITSNoPID",GetCorrectedHadEtEMCALAcceptanceITSNoPID(),1.0); + if(GetCorrectedTotEtEMCALAcceptanceITSNoPID()>0.0)FillHisto1D("RecoTotEtEMCALAcceptanceITSNoPID",GetCorrectedTotEtEMCALAcceptanceITSNoPID(),1.0); + if(GetCorrectedHadEtPHOSAcceptanceITSNoPID()>0.0)FillHisto1D("RecoHadEtPHOSAcceptanceITSNoPID",GetCorrectedHadEtPHOSAcceptanceITSNoPID(),1.0); + if(GetCorrectedTotEtPHOSAcceptanceITSNoPID()>0.0)FillHisto1D("RecoTotEtPHOSAcceptanceITSNoPID",GetCorrectedTotEtPHOSAcceptanceITSNoPID(),1.0); + + if(GetRawEtFullAcceptanceTPC()>0.0)FillHisto1D("RecoRawEtFullAcceptanceTPC",GetRawEtFullAcceptanceTPC(),1.0); + if(GetRawEtEMCALAcceptanceTPC()>0.0)FillHisto1D("RecoRawEtEMCALAcceptanceTPC",GetRawEtEMCALAcceptanceTPC(),1.0); + if(GetRawEtPHOSAcceptanceTPC()>0.0)FillHisto1D("RecoRawEtPHOSAcceptanceTPC",GetRawEtPHOSAcceptanceTPC(),1.0); + if(GetRawEtFullAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoRawEtFullAcceptanceTPCNoPID",GetRawEtFullAcceptanceTPCNoPID(),1.0); + if(GetRawEtEMCALAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoRawEtEMCALAcceptanceTPCNoPID",GetRawEtEMCALAcceptanceTPCNoPID(),1.0); + if(GetRawEtPHOSAcceptanceTPCNoPID()>0.0)FillHisto1D("RecoRawEtPHOSAcceptanceTPCNoPID",GetRawEtPHOSAcceptanceTPCNoPID(),1.0); + if(GetRawEtFullAcceptanceITS()>0.0)FillHisto1D("RecoRawEtFullAcceptanceITS",GetRawEtFullAcceptanceITS(),1.0); + if(GetRawEtEMCALAcceptanceITS()>0.0)FillHisto1D("RecoRawEtEMCALAcceptanceITS",GetRawEtEMCALAcceptanceITS(),1.0); + if(GetRawEtPHOSAcceptanceITS()>0.0)FillHisto1D("RecoRawEtPHOSAcceptanceITS",GetRawEtPHOSAcceptanceITS(),1.0); + if(GetRawEtFullAcceptanceITSNoPID()>0.0)FillHisto1D("RecoRawEtFullAcceptanceITSNoPID",GetRawEtFullAcceptanceITSNoPID(),1.0); + if(GetRawEtEMCALAcceptanceITSNoPID()>0.0)FillHisto1D("RecoRawEtEMCALAcceptanceITSNoPID",GetRawEtEMCALAcceptanceITSNoPID(),1.0); + if(GetRawEtPHOSAcceptanceITSNoPID()>0.0)FillHisto1D("RecoRawEtPHOSAcceptanceITSNoPID",GetRawEtPHOSAcceptanceITSNoPID(),1.0); + delete pID; + delete strTPC; + delete strITS; + delete strTPCITS; return 1; } +void AliAnalysisHadEtReconstructed::AddEt(Float_t rawEt, Float_t rawEtNoPID, Float_t corrEt, Float_t corrEtNoPID, Float_t pt, Bool_t IsTPC, Bool_t InPHOS, Bool_t InEMCAL) {//Adding Et to each of the variables that tracks et event by event + if(pt>=AliAnalysisHadEt::fgPtTPCCutOff && IsTPC){//TPC tracks + //adding to the raw Et + fRawEtFullAcceptanceTPC += rawEt; + if(InPHOS)fRawEtPHOSAcceptanceTPC += rawEt; + if(InEMCAL)fRawEtEMCALAcceptanceTPC += rawEt; + fRawEtFullAcceptanceTPCNoPID += rawEtNoPID; + if(InPHOS)fRawEtPHOSAcceptanceTPCNoPID += rawEtNoPID; + if(InEMCAL)fRawEtEMCALAcceptanceTPCNoPID += rawEtNoPID; + //adding to the corrected Et + fCorrectedHadEtFullAcceptanceTPC += corrEt; + if(InPHOS)fCorrectedHadEtPHOSAcceptanceTPC += corrEt; + if(InEMCAL)fCorrectedHadEtEMCALAcceptanceTPC += corrEt; + fCorrectedHadEtFullAcceptanceTPCNoPID += corrEtNoPID; + if(InPHOS)fCorrectedHadEtPHOSAcceptanceTPCNoPID += corrEtNoPID; + if(InEMCAL)fCorrectedHadEtEMCALAcceptanceTPCNoPID += corrEtNoPID; + } + if(pt=AliAnalysisHadEt::fgPtITSCutOff && !IsTPC){//ITS tracks + //adding to the raw Et + fRawEtFullAcceptanceITS += rawEt; + if(InPHOS)fRawEtPHOSAcceptanceITS += rawEt; + if(InEMCAL)fRawEtEMCALAcceptanceITS += rawEt; + fRawEtFullAcceptanceITSNoPID += rawEtNoPID; + if(InPHOS)fRawEtPHOSAcceptanceITSNoPID += rawEtNoPID; + if(InEMCAL)fRawEtEMCALAcceptanceITSNoPID += rawEtNoPID; + //adding to the corrected Et + fCorrectedHadEtFullAcceptanceITS += corrEt; + if(InPHOS)fCorrectedHadEtPHOSAcceptanceITS += corrEt; + if(InEMCAL)fCorrectedHadEtEMCALAcceptanceITS += corrEt; + fCorrectedHadEtFullAcceptanceITSNoPID += corrEtNoPID; + if(InPHOS)fCorrectedHadEtPHOSAcceptanceITSNoPID += corrEtNoPID; + if(InEMCAL)fCorrectedHadEtEMCALAcceptanceITSNoPID += corrEtNoPID; + } +} -bool AliAnalysisHadEtReconstructed::CheckGoodVertex(AliVParticle* track) +Bool_t AliAnalysisHadEtReconstructed::IsInPHOS(AliESDtrack *track){//This function will need to be elaborated on later to include PHOS dead channels + return TMath::Abs(track->Eta()) < fCuts->GetGeometryPhosEtaAccCut()//in eta acceptance + && track->Phi()*180.0/TMath::Pi() > fCuts->GetGeometryPhosPhiAccMinCut()//greater than the minimum phi + && track->Phi()*180.0/TMath::Pi() < fCuts->GetGeometryPhosPhiAccMaxCut();//less than the maximum phi +} +Bool_t AliAnalysisHadEtReconstructed::IsInEMCAL(AliESDtrack *track){//This function will need to be elaborated on later to include EMCAL dead channels + return TMath::Abs(track->Eta()) < fCuts->GetGeometryEmcalEtaAccCut()//in eta acceptance + && track->Phi()*180.0/TMath::Pi() > fCuts->GetGeometryEmcalPhiAccMinCut()//greater than the minimum phi + && track->Phi()*180.0/TMath::Pi() < fCuts->GetGeometryEmcalPhiAccMaxCut();//less than the maximum phi +} +Bool_t AliAnalysisHadEtReconstructed::CheckGoodVertex(AliVParticle* track) { // check vertex Float_t bxy = 999.; Float_t bz = 999.; dynamic_cast(track)->GetImpactParametersTPC(bxy,bz); - return TMath::Abs(track->Xv()) < fVertexXCut && TMath::Abs(track->Yv()) < fVertexYCut && TMath::Abs(track->Zv()) < fVertexZCut && TMath::Abs(bxy) < fIPxyCut && TMath::Abs(bz) < fIPzCut;; + bool status = (TMath::Abs(track->Xv()) < fCuts->GetReconstructedVertexXCut()) && + (TMath::Abs(track->Yv()) < fCuts->GetReconstructedVertexYCut()) && + (TMath::Abs(track->Zv()) < fCuts->GetReconstructedVertexZCut()) && + (TMath::Abs(bxy) < fCuts->GetReconstructedIPxyCut()) && + (TMath::Abs(bz) < fCuts->GetReconstructedIPzCut()); + return status; } void AliAnalysisHadEtReconstructed::Init() { // Init - AliAnalysisHadEt::Init(); + AliAnalysisHadEt::Init(); + if(fCorrections){ + fCorrTotEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"Full"); + fCorrTotEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"Full"); + fCorrHadEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"Full"); + fCorrHadEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"Full"); + fCorrTotEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"EMCAL"); + fCorrTotEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"EMCAL"); + fCorrHadEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"EMCAL"); + fCorrHadEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"EMCAL"); + fCorrTotEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"PHOS"); + fCorrTotEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"PHOS"); + fCorrHadEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PHOS"); + fCorrHadEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PHOS"); + } + else{ + cout<<"Warning! You have not set corrections. Your code will crash. You have to set the corrections."<LoadMacro(fConfigFile); + fCorrections = (AliAnalysisHadEtCorrections *) gInterpreter->ProcessLine("ConfigHadEtAnalysis()"); + fCorrTotEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"Full"); + fCorrTotEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"Full"); + fCorrHadEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"Full"); + fCorrHadEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"Full"); + fCorrTotEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"EMCAL"); + fCorrTotEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"EMCAL"); + fCorrHadEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"EMCAL"); + fCorrHadEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"EMCAL"); + fCorrTotEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"PHOS"); + fCorrTotEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"PHOS"); + fCorrHadEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PHOS"); + fCorrHadEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PHOS"); + } + else{cerr<<"Uh-oh! Unable to open configuration file!"<Data()),"Raw reconstructed E_{T} from identified #pi^{+}"); + CreateEtaPtHisto2D(Form("EtDataRaw%sPiMinus",cutName->Data()),"Raw reconstructed E_{T} from identified #pi^{-}"); + CreateEtaPtHisto2D(Form("EtDataRaw%sKPlus",cutName->Data()),"Raw reconstructed E_{T} from identified K^{+}"); +// CreateEtaPtHisto2D(Form("EtDataRaw%sEMinus",cutName->Data()),"Raw reconstructed E_{T} from identified e^{-}"); +// CreateEtaPtHisto2D(Form("EtDataRaw%sEPlus",cutName->Data()),"Raw reconstructed E_{T} from identified e^{+}"); + CreateEtaPtHisto2D(Form("EtDataRaw%sKMinus",cutName->Data()),"Raw reconstructed E_{T} from identified K^{-}"); + CreateEtaPtHisto2D(Form("EtDataRaw%sProton",cutName->Data()),"Raw reconstructed E_{T} from identified p"); + CreateEtaPtHisto2D(Form("EtDataRaw%sAntiProton",cutName->Data()),"Raw reconstructed E_{T} from identified #bar{p}"); + CreateEtaPtHisto2D(Form("EtDataRaw%sUnidentified",cutName->Data()),"Raw reconstructed E_{T} from unidentified particles using real mass"); + CreateEtaPtHisto2D(Form("EtDataRaw%sNoID",cutName->Data()),"Raw reconstructed E_{T} from unidentified particles using real mass"); + + CreateEtaPtHisto2D(Form("EtDataCorrected%sPiPlus",cutName->Data()),"Corrected reconstructed E_{T} from identified #pi^{+}"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sPiMinus",cutName->Data()),"Corrected reconstructed E_{T} from identified #pi^{-}"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sKPlus",cutName->Data()),"Corrected reconstructed E_{T} from identified K^{+}"); +// CreateEtaPtHisto2D(Form("EtDataCorrected%sEMinus",cutName->Data()),"Corrected reconstructed E_{T} from identified e^{-}"); +// CreateEtaPtHisto2D(Form("EtDataCorrected%sEPlus",cutName->Data()),"Corrected reconstructed E_{T} from identified e^{+}"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sKMinus",cutName->Data()),"Corrected reconstructed E_{T} from identified K^{-}"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sProton",cutName->Data()),"Corrected reconstructed E_{T} from identified p"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sAntiProton",cutName->Data()),"Corrected reconstructed E_{T} from identified #bar{p}"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sUnidentified",cutName->Data()),"Corrected reconstructed E_{T} from unidentified particles using real mass"); + CreateEtaPtHisto2D(Form("EtDataCorrected%sNoID",cutName->Data()),"Corrected reconstructed E_{T} from unidentified particles using real mass"); + + + CreateEtaPtHisto2D(Form("EtNData%sPiPlus",cutName->Data()),"Number of reconstructed #pi^{+}"); + CreateEtaPtHisto2D(Form("EtNData%sPiMinus",cutName->Data()),"Number of reconstructed #pi^{-}"); + CreateEtaPtHisto2D(Form("EtNData%sKPlus",cutName->Data()),"Number of reconstructed K^{+}"); + CreateEtaPtHisto2D(Form("EtNData%sKMinus",cutName->Data()),"Number of reconstructed K^{-}"); + CreateEtaPtHisto2D(Form("EtNData%sProton",cutName->Data()),"Number of reconstructed p"); + CreateEtaPtHisto2D(Form("EtNData%sAntiProton",cutName->Data()),"Number of reconstructed #bar{p}"); + CreateEtaPtHisto2D(Form("EtNData%sUnidentified",cutName->Data()),"Number of Reconstructed unidentified particles"); + + CreateHisto2D(Form("dEdxDataAll%s",cutName->Data()),"dE/dx for all particles","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx); + CreateHisto2D(Form("dEdxDataPion%s",cutName->Data()),"dE/dx for #pi^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx); + CreateHisto2D(Form("dEdxDataKaon%s",cutName->Data()),"dE/dx for K^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx); + CreateHisto2D(Form("dEdxDataProton%s",cutName->Data()),"dE/dx for p(#bar{p})","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx); + CreateHisto2D(Form("dEdxDataElectron%s",cutName->Data()),"dE/dx for e^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx); + CreateHisto2D(Form("dEdxDataUnidentified%s",cutName->Data()),"dE/dx for unidentified particles","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx); + } + + Float_t minEt = 0.0; + Float_t maxEt = 100.0; + Int_t nbinsEt = 200; + char histoname[200]; + char histotitle[200]; + char xtitle[50]; + TString *ytitle = new TString("Number of events"); + TString *sTPC = new TString("TPC"); + TString *sITS = new TString("ITS"); + TString *sTPCpt = new TString("0.15"); + TString *sITSpt = new TString("0.10"); + TString *sPID = new TString(""); + TString *sNoPID = new TString("NoPID"); + TString *sNoPIDString = new TString(", No PID"); + TString *sHadEt = new TString("HadEt"); + TString *sRawEt = new TString("RawEt"); + TString *sTotEt = new TString("TotEt"); + TString *sTotEtString = new TString("total E_{T}"); + TString *sHadEtString = new TString("hadronic E_{T}"); + TString *sRawEtString = new TString("raw E_{T}"); + TString *sFull = new TString("Full"); + TString *sEMCAL = new TString("EMCAL"); + TString *sPHOS = new TString("PHOS"); + + for(int tpc = 0;tpc<2;tpc++){ + for(int hadet = 0;hadet<3;hadet++){ + for(int type = 0;type<3;type++){ + for(int pid = 0;pid<2;pid++){ + TString *detector; + TString *partid; + TString *et = sHadEt; + TString *acceptance; + TString *ptstring; + TString *partidstring; + TString *etstring = sHadEtString; + if(tpc==1) {detector = sTPC; ptstring = sTPCpt;} + else{detector = sITS; ptstring = sITSpt;} + if(pid==1){partid = sPID; partidstring = sPID;} + else{partid = sNoPID; partidstring = sNoPIDString;} + if(hadet==1) {et = sHadEt; etstring = sHadEtString;} + if(hadet==0){et = sTotEt; etstring = sTotEtString;} + if(hadet==2){et = sRawEt; etstring = sRawEtString;} + switch(type){ + case 0: + acceptance = sFull; + break; + case 1: + acceptance = sEMCAL; + break; + case 2: + acceptance = sPHOS; + break; + default: + acceptance = sFull; + } + sprintf(histoname,"Reco%s%sAcceptance%s%s",et->Data(),acceptance->Data(),detector->Data(),partid->Data()); + sprintf(histotitle,"Reconstructed %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data()); + sprintf(xtitle,"Reconstructed %s",etstring->Data()); + CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt); + } + } + } + } + + //CreateHisto2D("Efficiency","Efficiency","pT","efficiency", + + delete sTPC; + delete sITS; + delete sTPCpt; + delete sITSpt; + delete sPID; + delete sNoPID; + delete sNoPIDString; + delete sHadEt; + delete sTotEt; + delete sTotEtString; + delete sHadEtString; + delete sFull; + delete sEMCAL; + delete sPHOS; + +}