PWGLF/totEt/AliAnalysisHadEtReconstructed.cxx

   1 //_________________________________________________________________________
   2 //  Utility Class for transverse energy studies, charged hadrons
   3 //  Base class for ESD analysis
   4 //  - reconstruction output
   5 // implementation file
   6 //
   7 //Created by Christine Nattrass, Rebecca Scott, Irakli Martashvili
   8 //University of Tennessee at Knoxville
   9 //_________________________________________________________________________
  10
  11 #include <TROOT.h>
  12 #include <TSystem.h>
  13 #include <TInterpreter.h>
  14 #include "AliAnalysisHadEtReconstructed.h"
  15 #include "AliAnalysisEtCuts.h"
  16 #include "AliESDtrack.h"
  17 #include "AliESDCaloCluster.h"
  18 #include "AliVEvent.h"
  19 #include "AliESDEvent.h"
  20 #include "AliESDtrackCuts.h"
  21 #include "AliESDpid.h"
  22 #include "AliVParticle.h"
  23 #include <iostream>
  24 #include "AliAnalysisHadEtCorrections.h"
  25 #include "TFile.h"
  26 #include "TString.h"
  27 #include "AliAnalysisEtCommon.h"
  28 #include "AliAnalysisHadEt.h"
  29 #include "AliCentrality.h"
  30 #include "AliLog.h"
  31 #include "AliPIDResponse.h"
  32 #include "AliTPCPIDResponse.h"
  33 #include "AliInputEventHandler.h"
  34 #include "AliAnalysisManager.h"
  35 #include "AliPWG0Helper.h"
  36
  37 using namespace std;
  38
  39 ClassImp(AliAnalysisHadEtReconstructed);
  40
  41
  42 AliAnalysisHadEtReconstructed::AliAnalysisHadEtReconstructed() :
  43   AliAnalysisHadEt()
  44   ,fCorrections(0)
  45   ,fConfigFile("ConfigHadEtAnalysis.C")
  46   ,fCorrTotEtFullAcceptanceTPC(0)
  47   ,fCorrTotEtFullAcceptanceITS(0)
  48   ,fCorrHadEtFullAcceptanceTPC(0)
  49   ,fCorrHadEtFullAcceptanceITS(0)
  50   ,fCorrPiKPEtFullAcceptanceTPC(0)
  51   ,fCorrPiKPEtFullAcceptanceITS(0)
  52   ,fCorrTotEtEMCALAcceptanceTPC(0)
  53   ,fCorrTotEtEMCALAcceptanceITS(0)
  54   ,fCorrHadEtEMCALAcceptanceTPC(0)
  55   ,fCorrHadEtEMCALAcceptanceITS(0)
  56   ,fCorrTotEtPHOSAcceptanceTPC(0)
  57   ,fCorrTotEtPHOSAcceptanceITS(0)
  58   ,fCorrHadEtPHOSAcceptanceTPC(0)
  59   ,fCorrHadEtPHOSAcceptanceITS(0)
  60   ,fCorrectedHadEtFullAcceptanceTPCNoPID(0)
  61   ,fCorrectedHadEtFullAcceptanceITSNoPID(0)
  62   ,fCorrectedHadEtEMCALAcceptanceTPCNoPID(0)
  63   ,fCorrectedHadEtEMCALAcceptanceITSNoPID(0)
  64   ,fCorrectedHadEtPHOSAcceptanceTPCNoPID(0)
  65   ,fCorrectedHadEtPHOSAcceptanceITSNoPID(0)
  66   ,fCorrectedHadEtFullAcceptanceTPC(0)
  67   ,fCorrectedHadEtFullAcceptanceITS(0)
  68   ,fCorrectedHadEtFullAcceptanceTPCAssumingPion(0)
  69   ,fCorrectedHadEtFullAcceptanceITSAssumingPion(0)
  70   ,fCorrectedHadEtFullAcceptanceTPCAssumingProton(0)
  71   ,fCorrectedHadEtFullAcceptanceITSAssumingProton(0)
  72   ,fCorrectedHadEtFullAcceptanceTPCAssumingKaon(0)
  73   ,fCorrectedHadEtFullAcceptanceITSAssumingKaon(0)
  74   ,fCorrectedHadEtEMCALAcceptanceTPC(0)
  75   ,fCorrectedHadEtEMCALAcceptanceITS(0)
  76   ,fCorrectedHadEtPHOSAcceptanceTPC(0)
  77   ,fCorrectedHadEtPHOSAcceptanceITS(0)
  78   ,fRawEtFullAcceptanceTPC(0)
  79   ,fRawEtFullAcceptanceITS(0)
  80   ,fRawEtEMCALAcceptanceTPC(0)
  81   ,fRawEtEMCALAcceptanceITS(0)
  82   ,fRawEtPHOSAcceptanceTPC(0)
  83   ,fRawEtPHOSAcceptanceITS(0)
  84   ,fRawEtFullAcceptanceTPCNoPID(0)
  85   ,fRawEtFullAcceptanceITSNoPID(0)
  86   ,fRawEtEMCALAcceptanceTPCNoPID(0)
  87   ,fRawEtEMCALAcceptanceITSNoPID(0)
  88   ,fRawEtPHOSAcceptanceTPCNoPID(0)
  89   ,fRawEtPHOSAcceptanceITSNoPID(0)
  90   ,kIsOfflineV0AND(0)
  91   ,kDoTriggerChecks(0)
  92   ,kDoTriggerChecksOnly(0)
  93 {
  94 }
  95
  96 AliAnalysisHadEtReconstructed::~AliAnalysisHadEtReconstructed()
  97 {
  98   delete fCorrections;
  99 }
 100
 101 Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev, Int_t eventtype)
 102 { // analyse ESD event
 103   if(kDoTriggerChecksOnly){return 1;}//In this case we are just after trigger efficiencies and don't care about the ET reconstructed.
 104   if(kDoTriggerChecks && !kIsOfflineV0AND){return 1;}//In this case we are just after trigger efficiencies and don't care about the ET reconstructed.
 105   ResetEventValues();
 106   if(!ev){
 107     AliFatal("ERROR: Event does not exist");
 108     return 0;
 109   }
 110
 111   AliESDEvent *realEvent = dynamic_cast<AliESDEvent*>(ev);
 112   if(!realEvent){
 113     AliFatal("ERROR: ESD Event does not exist");
 114     return 0;
 115   }
 116   fCentBin= -1;
 117   fGoodEvent = kTRUE;//for p+p collisions if we made it this far we have a good event
 118   if(fDataSet==20100){//If this is Pb+Pb
 119     AliCentrality *centrality = realEvent->GetCentrality();
 120     if(fNCentBins<21) fCentBin= centrality->GetCentralityClass10(fCentralityMethod);
 121     else{ fCentBin= centrality->GetCentralityClass5(fCentralityMethod);}
 122     if(fCentBin ==-1) fGoodEvent = kFALSE;//but for Pb+Pb events we don't want to count events where we did not find a centrality
 123   }
 124   //for PID
 125   AliESDpid *pID = new AliESDpid();
 126   pID->MakePID(realEvent);
 127   TString *strTPC = new TString("TPC");
 128   TString *strITS = new TString("ITS");
 129   TString *strTPCITS = new TString("TPCITS");
 130   for(Int_t cutset=0;cutset<2;cutset++){
 131     bool isTPC = false;
 132     TString *cutName = NULL;
 133     TObjArray* list = NULL;
 134     switch(cutset){
 135     case 0:
 136       cutName = strTPCITS;
 137       list = fEsdtrackCutsITSTPC->GetAcceptedTracks(realEvent);
 138       isTPC = true;
 139       break;
 140     case 1:
 141       cutName = strITS;
 142       list = fEsdtrackCutsITS->GetAcceptedTracks(realEvent);
 143       break;
 144     case 2:
 145       cutName = strTPC;
 146       list = fEsdtrackCutsTPC->GetAcceptedTracks(realEvent);
 147       break;
 148     default:
 149       cerr<<"Error:  cannot fill histograms!"<<endl;
 150       return -1;
 151     }
 152     Int_t nGoodTracks = list->GetEntries();
 153     for (Int_t iTrack = 0; iTrack < nGoodTracks; iTrack++)
 154       {
 155
 156
 157         AliESDtrack *track = dynamic_cast<AliESDtrack*> (list->At(iTrack));
 158         if (!track)
 159           {
 160             Printf("ERROR: Could not get track %d", iTrack);
 161             continue;
 162           }
 163         else{
 164           if(TMath::Abs(track->Eta())>fCorrections->GetEtaCut()) continue;
 165           Float_t nSigmaPion,nSigmaProton,nSigmaKaon,nSigmaElectron;
 166 //        pID->MakeTPCPID(track);
 167 //        pID->MakeITSPID(track);
 168           //if(!fPIDResponse) cout<<"Uh-oh!  No PID Response!"<<endl;
 169           if(cutset!=1){
 170             nSigmaPion = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(track, AliPID::kPion));
 171             nSigmaProton = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(track, AliPID::kProton));
 172             nSigmaKaon =TMath::Abs( fPIDResponse->NumberOfSigmasTPC(track, AliPID::kKaon));
 173             nSigmaElectron =TMath::Abs( fPIDResponse->NumberOfSigmasTPC(track, AliPID::kElectron));
 174
 175 //          nSigmaPion = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kPion));
 176 //          nSigmaProton = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kProton));
 177 //          nSigmaKaon = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kKaon));
 178 //          nSigmaElectron = TMath::Abs(pID->NumberOfSigmasTPC(track,AliPID::kElectron));
 179           }
 180           else{
 181             nSigmaPion = TMath::Abs(fPIDResponse->NumberOfSigmasITS(track, AliPID::kPion));
 182             nSigmaProton = TMath::Abs(fPIDResponse->NumberOfSigmasITS(track, AliPID::kProton));
 183             nSigmaKaon = TMath::Abs(fPIDResponse->NumberOfSigmasITS(track, AliPID::kKaon));
 184             nSigmaElectron = TMath::Abs(fPIDResponse->NumberOfSigmasITS(track, AliPID::kElectron));
 185 //          nSigmaPion = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kPion));
 186 //          nSigmaProton = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kProton));
 187 //          nSigmaKaon = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kKaon));
 188 //          nSigmaElectron = TMath::Abs(pID->NumberOfSigmasITS(track,AliPID::kElectron));
 189           }
 190           //cout<<"Nsigma pion "<<nSigmaPion<<" proton "<<nSigmaProton<<" kaon "<<nSigmaKaon<<" electron "<<nSigmaElectron<<endl;
 191           //        bool isPion = (nSigmaPion<3.0 && nSigmaProton>2.0 && nSigmaKaon>2.0);
 192           //        bool isElectron = (nSigmaElectron<2.0 && nSigmaPion>4.0 && nSigmaProton>3.0 && nSigmaKaon>3.0);
 193           //        bool isKaon = (nSigmaPion>3.0 && nSigmaProton>2.0 && nSigmaKaon<2.0);
 194           //        bool isProton = (nSigmaPion>3.0 && nSigmaProton<2.0 && nSigmaKaon>2.0);
 195           bool isPion = (nSigmaPion<3.0 && nSigmaProton>2.0 && nSigmaKaon>2.0);
 196           bool isElectron = (nSigmaElectron<2.0 && nSigmaPion>4.0 && nSigmaProton>3.0 && nSigmaKaon>3.0);
 197           bool isKaon = (nSigmaPion>3.0 && nSigmaProton>3.0 && nSigmaKaon<3.0 && track->Pt()<0.45);
 198           bool isProton = (nSigmaPion>3.0 && nSigmaProton<3.0 && nSigmaKaon>3.0 && track->Pt()<0.9);
 199
 200           bool unidentified = (!isProton && !isKaon && !isElectron && !isPion);
 201           if(cutset==1){//ITS dE/dx identification requires tighter cuts on the tracks and we don't gain much from that so we won't do it
 202             unidentified = true;
 203             isPion=false;
 204             isElectron=false;
 205             isKaon=false;
 206             isProton=false;
 207           }
 208           Float_t dEdx = track->GetTPCsignal();
 209           if(cutset==1) dEdx = track->GetITSsignal();
 210           FillHisto2D(Form("dEdxDataAll%s",cutName->Data()),track->P(),dEdx,1.0);
 211
 212           bool inPHOS = IsInPHOS(track);
 213           bool inEMCAL = IsInEMCAL(track);
 214
 215           Float_t corrBkgd=0.0;
 216           Float_t corrNotID=0.0;
 217           Float_t corrNoID = fCorrections->GetNotIDCorrectionNoPID(track->Pt());
 218           Float_t corrEff = 0.0;
 219           Float_t corrEffNoID = 0.0;
 220           if(cutset!=1){//TPC
 221             corrBkgd = fCorrections->GetBackgroundCorrectionTPC(track->Pt());
 222             corrEffNoID = fCorrections->GetTPCEfficiencyCorrectionHadron(track->Pt(),fCentBin);
 223             corrNotID = fCorrections->GetNotIDConstCorrectionTPC();
 224             corrNoID = fCorrections->GetNotIDConstCorrectionTPCNoID();
 225           }
 226           if(cutset==1){//ITS
 227             corrBkgd = fCorrections->GetBackgroundCorrectionITS(track->Pt());
 228             corrEffNoID = fCorrections->GetITSEfficiencyCorrectionHadron(track->Pt(),fCentBin);
 229             corrNotID = fCorrections->GetNotIDConstCorrectionITS();
 230             corrNoID = fCorrections->GetNotIDConstCorrectionITSNoID();
 231           }
 232           if(fDataSet==20100){
 233             FillHisto2D("fbkgdVsCentralityBin",fCentBin,corrBkgd,1.0);
 234             FillHisto2D("fnotIDVsCentralityBin",fCentBin,corrNotID,1.0);
 235             FillHisto2D("fpTcutVsCentralityBin",fCentBin,fCorrections->GetpTCutCorrectionTPC(),1.0);
 236             if(fCorrHadEtFullAcceptanceTPC>0.0) FillHisto2D("fneutralVsCentralityBin",fCentBin,1.0/fCorrHadEtFullAcceptanceTPC,1.0);
 237             if(fCorrections->GetNeutralCorrection()>0.0) FillHisto2D("ConstantCorrectionsVsCentralityBin",fCentBin,1.0/fCorrections->GetNeutralCorrection(),1.0);
 238           }
 239           Float_t et = 0.0;
 240           Float_t etNoID = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge());
 241           Float_t etpartialcorrected = 0.0;
 242           Float_t etpartialcorrectedPion = 0.0;
 243           Float_t etpartialcorrectedKaon = 0.0;
 244           Float_t etpartialcorrectedProton = 0.0;
 245           Float_t etpartialcorrectedNoID = corrNoID*corrBkgd*corrEffNoID*etNoID;
 246           FillHisto2D(Form("EtDataRaw%sNoID",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrectedNoID);
 247
 248           if(isPion){
 249             FillHisto2D(Form("dEdxDataPion%s",cutName->Data()),track->P(),dEdx,1.0);
 250             et = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge());
 251             if(cutset==0){corrEff = fCorrections->GetTPCEfficiencyCorrectionPion(track->Pt(),fCentBin);}
 252             etpartialcorrected = et*corrBkgd*corrEff*corrNotID;
 253             if(corrEff>0.0&&fDataSet==20100)FillHisto2D("feffPionVsCentralityBin",fCentBin,1.0/corrEff,1.0);
 254             if(track->Charge()>0.0){
 255               FillHisto2D(Form("EtDataRaw%sPiPlus",cutName->Data()),track->Pt(),track->Eta(),et);
 256               FillHisto2D(Form("EtDataCorrected%sPiPlus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 257             }
 258             else{
 259               FillHisto2D(Form("EtDataRaw%sPiMinus",cutName->Data()),track->Pt(),track->Eta(),et);
 260               FillHisto2D(Form("EtDataCorrected%sPiMinus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 261             }
 262           }
 263           if(isKaon){
 264             FillHisto2D(Form("dEdxDataKaon%s",cutName->Data()),track->P(),dEdx,1.0);
 265             et = Et(track->P(),track->Theta(),fgKPlusCode,track->Charge());
 266             if(cutset==0){corrEff = fCorrections->GetTPCEfficiencyCorrectionKaon(track->Pt(),fCentBin);}
 267             etpartialcorrected = et*corrBkgd*corrEff*corrNotID;
 268             if(corrEff>0.0&&fDataSet==20100)FillHisto2D("feffKaonVsCentralityBin",fCentBin,1.0/corrEff,1.0);
 269
 270             if(track->Charge()>0.0){
 271               FillHisto2D(Form("EtDataRaw%sKPlus",cutName->Data()),track->Pt(),track->Eta(),et);
 272               FillHisto2D(Form("EtDataCorrected%sKPlus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 273             }
 274             else{
 275               FillHisto2D(Form("EtDataRaw%sKMinus",cutName->Data()),track->Pt(),track->Eta(),et);
 276               FillHisto2D(Form("EtDataCorrected%sKMinus",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 277             }
 278           }
 279           if(isProton){
 280             FillHisto2D(Form("dEdxDataProton%s",cutName->Data()),track->P(),dEdx,1.0);
 281             et = Et(track->P(),track->Theta(),fgProtonCode,track->Charge());
 282             if(cutset==0){corrEff = fCorrections->GetTPCEfficiencyCorrectionProton(track->Pt(),fCentBin);}
 283             etpartialcorrected = et*corrBkgd*corrEff*corrNotID;
 284             if(corrEff>0.0&&fDataSet==20100)FillHisto2D("feffProtonVsCentralityBin",fCentBin,1.0/corrEff,1.0);
 285
 286             if(track->Charge()>0.0){
 287               FillHisto2D(Form("EtDataRaw%sProton",cutName->Data()),track->Pt(),track->Eta(),et);
 288               FillHisto2D(Form("EtDataCorrected%sProton",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 289             }
 290             else{
 291               FillHisto2D(Form("EtDataRaw%sAntiProton",cutName->Data()),track->Pt(),track->Eta(),et);
 292               FillHisto2D(Form("EtDataCorrected%sAntiProton",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 293             }
 294           }
 295           if(isElectron){
 296             FillHisto2D(Form("dEdxDataElectron%s",cutName->Data()),track->P(),dEdx,1.0);
 297           }
 298           if(unidentified){
 299             if(isPion) cerr<<"I should not be here!!  AliAnalysisHadEtReconstructed 273"<<endl;
 300             FillHisto2D(Form("dEdxDataUnidentified%s",cutName->Data()),track->P(),dEdx,1.0);
 301             et = Et(track->P(),track->Theta(),fgPiPlusCode,track->Charge());
 302             Float_t etProton = Et(track->P(),track->Theta(),fgProtonCode,track->Charge());
 303             Float_t etKaon = Et(track->P(),track->Theta(),fgKPlusCode,track->Charge());
 304             if(corrEff>0.0&&fDataSet==20100)FillHisto2D("feffHadronVsCentralityBin",fCentBin,1.0/corrEff,1.0);
 305             etpartialcorrected = et*corrBkgd*corrEffNoID*corrNotID;
 306             etpartialcorrectedPion = et*corrBkgd*corrEffNoID;
 307             etpartialcorrectedProton = etProton*corrBkgd*corrEffNoID;
 308             etpartialcorrectedKaon = etKaon*corrBkgd*corrEffNoID;
 309             FillHisto2D(Form("EtDataCorrected%sUnidentified",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrected);
 310           }
 311           else{
 312             etpartialcorrectedPion = etpartialcorrected;
 313             etpartialcorrectedKaon = etpartialcorrected;
 314             etpartialcorrectedProton = etpartialcorrected;
 315           }
 316           if(!isTPC){
 317             etpartialcorrected = etpartialcorrectedNoID;//Not using PID for ITS
 318           }
 319           AddEt(et,etNoID,etpartialcorrected,etpartialcorrectedPion,etpartialcorrectedProton,etpartialcorrectedKaon,etpartialcorrectedNoID,track->Pt(),isTPC,inPHOS,inEMCAL);
 320         }
 321       }
 322     delete list;
 323   }
 324
 325   Int_t nondiff = 0;//(Int_t) AliPWG0Helper::kND;
 326   Int_t doublediff = 0;//(Int_t) AliPWG0Helper::kDD;
 327   Int_t singlediff = 0;//(Int_t) AliPWG0Helper::kSD;
 328   if(fDataSet!=20100){
 329     nondiff = (Int_t) AliPWG0Helper::kND;
 330     doublediff = (Int_t) AliPWG0Helper::kDD;
 331     singlediff = (Int_t) AliPWG0Helper::kSD;
 332   }
 333   if(eventtype == nondiff && fGoodEvent){
 334     FillHisto1D("RecoHadEtFullAcceptanceTPCND",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
 335     FillHisto1D("RecoPiKPEtFullAcceptanceTPCND",GetCorrectedPiKPEtFullAcceptanceTPC(),1.0);
 336     FillHisto1D("RecoTotEtFullAcceptanceTPCND",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
 337     FillHisto1D("RecoHadEtFullAcceptanceITSND",GetCorrectedHadEtFullAcceptanceITS(),1.0);
 338     FillHisto1D("RecoPiKPEtFullAcceptanceITSND",GetCorrectedPiKPEtFullAcceptanceITS(),1.0);
 339     FillHisto1D("RecoTotEtFullAcceptanceITSND",GetCorrectedTotEtFullAcceptanceITS(),1.0);
 340     FillHisto1D("RecoHadEtFullAcceptanceTPCNoPIDND",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
 341     FillHisto1D("RecoPiKPEtFullAcceptanceTPCNoPIDND",GetCorrectedPiKPEtFullAcceptanceTPCNoPID(),1.0);
 342     FillHisto1D("RecoTotEtFullAcceptanceTPCNoPIDND",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
 343     FillHisto1D("RecoHadEtFullAcceptanceITSNoPIDND",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
 344     FillHisto1D("RecoPiKPEtFullAcceptanceITSNoPIDND",GetCorrectedPiKPEtFullAcceptanceITSNoPID(),1.0);
 345     FillHisto1D("RecoTotEtFullAcceptanceITSNoPIDND",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
 346   }
 347   if(eventtype == doublediff){
 348     FillHisto1D("RecoHadEtFullAcceptanceTPCDD",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
 349     FillHisto1D("RecoPiKPEtFullAcceptanceTPCDD",GetCorrectedPiKPEtFullAcceptanceTPC(),1.0);
 350     FillHisto1D("RecoTotEtFullAcceptanceTPCDD",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
 351     FillHisto1D("RecoPiKPEtFullAcceptanceITSDD",GetCorrectedPiKPEtFullAcceptanceITS(),1.0);
 352     FillHisto1D("RecoHadEtFullAcceptanceITSDD",GetCorrectedHadEtFullAcceptanceITS(),1.0);
 353     FillHisto1D("RecoTotEtFullAcceptanceITSDD",GetCorrectedTotEtFullAcceptanceITS(),1.0);
 354     FillHisto1D("RecoHadEtFullAcceptanceTPCNoPIDDD",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
 355     FillHisto1D("RecoPiKPEtFullAcceptanceTPCNoPIDDD",GetCorrectedPiKPEtFullAcceptanceTPCNoPID(),1.0);
 356     FillHisto1D("RecoTotEtFullAcceptanceTPCNoPIDDD",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
 357     FillHisto1D("RecoHadEtFullAcceptanceITSNoPIDDD",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
 358     FillHisto1D("RecoPiKPEtFullAcceptanceITSNoPIDDD",GetCorrectedPiKPEtFullAcceptanceITSNoPID(),1.0);
 359     FillHisto1D("RecoTotEtFullAcceptanceITSNoPIDDD",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
 360   }
 361   if(eventtype == singlediff){
 362     FillHisto1D("RecoPiKPEtFullAcceptanceTPCSD",GetCorrectedPiKPEtFullAcceptanceTPC(),1.0);
 363     FillHisto1D("RecoHadEtFullAcceptanceTPCSD",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
 364     FillHisto1D("RecoTotEtFullAcceptanceTPCSD",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
 365     FillHisto1D("RecoHadEtFullAcceptanceITSSD",GetCorrectedHadEtFullAcceptanceITS(),1.0);
 366     FillHisto1D("RecoPiKPEtFullAcceptanceITSSD",GetCorrectedPiKPEtFullAcceptanceITS(),1.0);
 367     FillHisto1D("RecoTotEtFullAcceptanceITSSD",GetCorrectedTotEtFullAcceptanceITS(),1.0);
 368     FillHisto1D("RecoHadEtFullAcceptanceTPCNoPIDSD",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
 369     FillHisto1D("RecoPiKPEtFullAcceptanceTPCNoPIDSD",GetCorrectedPiKPEtFullAcceptanceTPCNoPID(),1.0);
 370     FillHisto1D("RecoTotEtFullAcceptanceTPCNoPIDSD",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
 371     FillHisto1D("RecoHadEtFullAcceptanceITSNoPIDSD",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
 372     FillHisto1D("RecoPiKPEtFullAcceptanceITSNoPIDSD",GetCorrectedPiKPEtFullAcceptanceITSNoPID(),1.0);
 373     FillHisto1D("RecoTotEtFullAcceptanceITSNoPIDSD",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
 374   }
 375   if(fGoodEvent){
 376     FillHisto1D("RecoPiKPEtFullAcceptanceTPC",GetCorrectedPiKPEtFullAcceptanceTPC(),1.0);
 377     FillHisto1D("RecoPiKPEtFullAcceptanceITS",GetCorrectedPiKPEtFullAcceptanceITS(),1.0);
 378     FillHisto1D("RecoPiKPEtFullAcceptanceTPCNoPID",GetCorrectedPiKPEtFullAcceptanceTPCNoPID(),1.0);
 379     FillHisto1D("RecoPiKPEtFullAcceptanceITSNoPID",GetCorrectedPiKPEtFullAcceptanceITSNoPID(),1.0);
 380     FillHisto1D("RecoHadEtFullAcceptanceTPC",GetCorrectedHadEtFullAcceptanceTPC(),1.0);
 381     FillHisto1D("RecoTotEtFullAcceptanceTPC",GetCorrectedTotEtFullAcceptanceTPC(),1.0);
 382     FillHisto1D("RecoHadEtFullAcceptanceTPCAssumingPion",GetCorrectedHadEtFullAcceptanceTPCAssumingPion(),1.0);
 383     FillHisto1D("RecoHadEtFullAcceptanceTPCAssumingProton",GetCorrectedHadEtFullAcceptanceTPCAssumingProton(),1.0);
 384     FillHisto1D("RecoHadEtFullAcceptanceTPCAssumingKaon",GetCorrectedHadEtFullAcceptanceTPCAssumingKaon(),1.0);
 385     FillHisto1D("RecoHadEtEMCALAcceptanceTPC",GetCorrectedHadEtEMCALAcceptanceTPC(),1.0);
 386     FillHisto1D("RecoTotEtEMCALAcceptanceTPC",GetCorrectedTotEtEMCALAcceptanceTPC(),1.0);
 387     FillHisto1D("RecoHadEtPHOSAcceptanceTPC",GetCorrectedHadEtPHOSAcceptanceTPC(),1.0);
 388     FillHisto1D("RecoTotEtPHOSAcceptanceTPC",GetCorrectedTotEtPHOSAcceptanceTPC(),1.0);
 389     FillHisto1D("RecoHadEtFullAcceptanceTPCNoPID",GetCorrectedHadEtFullAcceptanceTPCNoPID(),1.0);
 390     FillHisto1D("RecoTotEtFullAcceptanceTPCNoPID",GetCorrectedTotEtFullAcceptanceTPCNoPID(),1.0);
 391     FillHisto1D("RecoHadEtEMCALAcceptanceTPCNoPID",GetCorrectedHadEtEMCALAcceptanceTPCNoPID(),1.0);
 392     FillHisto1D("RecoTotEtEMCALAcceptanceTPCNoPID",GetCorrectedTotEtEMCALAcceptanceTPCNoPID(),1.0);
 393     FillHisto1D("RecoHadEtPHOSAcceptanceTPCNoPID",GetCorrectedHadEtPHOSAcceptanceTPCNoPID(),1.0);
 394     FillHisto1D("RecoTotEtPHOSAcceptanceTPCNoPID",GetCorrectedTotEtPHOSAcceptanceTPCNoPID(),1.0);
 395     FillHisto1D("RecoHadEtFullAcceptanceITS",GetCorrectedHadEtFullAcceptanceITS(),1.0);
 396     FillHisto1D("RecoHadEtFullAcceptanceITSAssumingPion",GetCorrectedHadEtFullAcceptanceITSAssumingPion(),1.0);
 397     FillHisto1D("RecoHadEtFullAcceptanceITSAssumingProton",GetCorrectedHadEtFullAcceptanceITSAssumingProton(),1.0);
 398     FillHisto1D("RecoHadEtFullAcceptanceITSAssumingKaon",GetCorrectedHadEtFullAcceptanceITSAssumingKaon(),1.0);
 399     FillHisto1D("RecoTotEtFullAcceptanceITS",GetCorrectedTotEtFullAcceptanceITS(),1.0);
 400     FillHisto1D("RecoHadEtEMCALAcceptanceITS",GetCorrectedHadEtEMCALAcceptanceITS(),1.0);
 401     FillHisto1D("RecoTotEtEMCALAcceptanceITS",GetCorrectedTotEtEMCALAcceptanceITS(),1.0);
 402     FillHisto1D("RecoHadEtPHOSAcceptanceITS",GetCorrectedHadEtPHOSAcceptanceITS(),1.0);
 403     FillHisto1D("RecoTotEtPHOSAcceptanceITS",GetCorrectedTotEtPHOSAcceptanceITS(),1.0);
 404     FillHisto1D("RecoHadEtFullAcceptanceITSNoPID",GetCorrectedHadEtFullAcceptanceITSNoPID(),1.0);
 405     FillHisto1D("RecoTotEtFullAcceptanceITSNoPID",GetCorrectedTotEtFullAcceptanceITSNoPID(),1.0);
 406     FillHisto1D("RecoHadEtEMCALAcceptanceITSNoPID",GetCorrectedHadEtEMCALAcceptanceITSNoPID(),1.0);
 407     FillHisto1D("RecoTotEtEMCALAcceptanceITSNoPID",GetCorrectedTotEtEMCALAcceptanceITSNoPID(),1.0);
 408     FillHisto1D("RecoHadEtPHOSAcceptanceITSNoPID",GetCorrectedHadEtPHOSAcceptanceITSNoPID(),1.0);
 409     FillHisto1D("RecoTotEtPHOSAcceptanceITSNoPID",GetCorrectedTotEtPHOSAcceptanceITSNoPID(),1.0);
 410
 411     FillHisto1D("RecoRawEtFullAcceptanceTPC",GetRawEtFullAcceptanceTPC(),1.0);
 412     FillHisto1D("RecoRawEtEMCALAcceptanceTPC",GetRawEtEMCALAcceptanceTPC(),1.0);
 413     FillHisto1D("RecoRawEtPHOSAcceptanceTPC",GetRawEtPHOSAcceptanceTPC(),1.0);
 414     FillHisto1D("RecoRawEtFullAcceptanceTPCNoPID",GetRawEtFullAcceptanceTPCNoPID(),1.0);
 415     FillHisto1D("RecoRawEtEMCALAcceptanceTPCNoPID",GetRawEtEMCALAcceptanceTPCNoPID(),1.0);
 416     FillHisto1D("RecoRawEtPHOSAcceptanceTPCNoPID",GetRawEtPHOSAcceptanceTPCNoPID(),1.0);
 417     FillHisto1D("RecoRawEtFullAcceptanceITS",GetRawEtFullAcceptanceITS(),1.0);
 418     FillHisto1D("RecoRawEtEMCALAcceptanceITS",GetRawEtEMCALAcceptanceITS(),1.0);
 419     FillHisto1D("RecoRawEtPHOSAcceptanceITS",GetRawEtPHOSAcceptanceITS(),1.0);
 420     FillHisto1D("RecoRawEtFullAcceptanceITSNoPID",GetRawEtFullAcceptanceITSNoPID(),1.0);
 421     FillHisto1D("RecoRawEtEMCALAcceptanceITSNoPID",GetRawEtEMCALAcceptanceITSNoPID(),1.0);
 422     FillHisto1D("RecoRawEtPHOSAcceptanceITSNoPID",GetRawEtPHOSAcceptanceITSNoPID(),1.0);
 423     if(fCentBin>-1){//if we have Pb+Pb and found a centrality bin
 424       FillHisto1D(Form("RecoHadEtFullAcceptanceTPCCB%i",fCentBin),GetCorrectedHadEtFullAcceptanceTPC(),1.0);
 425       FillHisto1D(Form("RecoTotEtFullAcceptanceTPCCB%i",fCentBin),GetCorrectedTotEtFullAcceptanceTPC(),1.0);
 426       FillHisto1D(Form("RecoHadEtFullAcceptanceITSCB%i",fCentBin),GetCorrectedHadEtFullAcceptanceITS(),1.0);
 427       FillHisto1D(Form("RecoTotEtFullAcceptanceITSCB%i",fCentBin),GetCorrectedTotEtFullAcceptanceITS(),1.0);
 428       FillHisto1D(Form("RecoRawEtFullAcceptanceTPCCB%i",fCentBin),GetRawEtFullAcceptanceTPC(),1.0);
 429       FillHisto1D(Form("RecoRawEtFullAcceptanceITSCB%i",fCentBin),GetRawEtFullAcceptanceITS(),1.0);
 430     }
 431   }
 432   delete pID;
 433   delete strTPC;
 434   delete strITS;
 435   delete strTPCITS;
 436   // cout<<"Reconstructed pi/k/p et "<<GetCorrectedPiKPEtFullAcceptanceTPC()<<endl;
 437   return 1;
 438 }
 439 void AliAnalysisHadEtReconstructed::AddEt(Float_t rawEt, Float_t rawEtNoPID, Float_t corrEt, Float_t corrEtPion, Float_t corrEtProton, Float_t corrEtKaon, 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
 440   if(pt>=AliAnalysisHadEt::fgPtTPCCutOff && IsTPC){//TPC tracks
 441     //adding to the raw Et
 442     fRawEtFullAcceptanceTPC += rawEt;
 443     if(InPHOS)fRawEtPHOSAcceptanceTPC += rawEt;
 444     if(InEMCAL)fRawEtEMCALAcceptanceTPC += rawEt;
 445     fRawEtFullAcceptanceTPCNoPID += rawEtNoPID;
 446     if(InPHOS)fRawEtPHOSAcceptanceTPCNoPID += rawEtNoPID;
 447     if(InEMCAL)fRawEtEMCALAcceptanceTPCNoPID += rawEtNoPID;
 448     //adding to the corrected Et
 449     fCorrectedHadEtFullAcceptanceTPC += corrEt;//the pi/k/p et
 450     fCorrectedHadEtFullAcceptanceTPCAssumingPion += corrEtPion;
 451     fCorrectedHadEtFullAcceptanceTPCAssumingProton += corrEtProton;
 452     fCorrectedHadEtFullAcceptanceTPCAssumingKaon += corrEtKaon;
 453     if(InPHOS)fCorrectedHadEtPHOSAcceptanceTPC += corrEt;
 454     if(InEMCAL)fCorrectedHadEtEMCALAcceptanceTPC += corrEt;
 455     fCorrectedHadEtFullAcceptanceTPCNoPID += corrEtNoPID;
 456     if(InPHOS)fCorrectedHadEtPHOSAcceptanceTPCNoPID += corrEtNoPID;
 457     if(InEMCAL)fCorrectedHadEtEMCALAcceptanceTPCNoPID += corrEtNoPID;
 458   }
 459   //if(pt<AliAnalysisHadEt::fgPtTPCCutOff &&pt>=AliAnalysisHadEt::fgPtITSCutOff && !IsTPC){//ITS tracks
 460   //If we use standalone tracks - not pure standalone tracks - the only tracks we get are ones that were missed by the TPC+ITS tracking.  Therefore we don't need to add a momentum cut-off
 461   if(pt<AliAnalysisHadEt::fgPtTPCCutOff && !IsTPC){//ITS tracks
 462     //adding to the raw Et
 463     fRawEtFullAcceptanceITS += rawEt;
 464     if(InPHOS)fRawEtPHOSAcceptanceITS += rawEt;
 465     if(InEMCAL)fRawEtEMCALAcceptanceITS += rawEt;
 466     fRawEtFullAcceptanceITSNoPID += rawEtNoPID;
 467     if(InPHOS)fRawEtPHOSAcceptanceITSNoPID += rawEtNoPID;
 468     if(InEMCAL)fRawEtEMCALAcceptanceITSNoPID += rawEtNoPID;
 469     //adding to the corrected Et
 470     fCorrectedHadEtFullAcceptanceITS += corrEt;
 471     fCorrectedHadEtFullAcceptanceITSAssumingPion += corrEtPion;
 472     fCorrectedHadEtFullAcceptanceITSAssumingProton += corrEtProton;
 473     fCorrectedHadEtFullAcceptanceITSAssumingKaon += corrEtKaon;
 474     if(InPHOS)fCorrectedHadEtPHOSAcceptanceITS += corrEt;
 475     if(InEMCAL)fCorrectedHadEtEMCALAcceptanceITS += corrEt;
 476     fCorrectedHadEtFullAcceptanceITSNoPID += corrEtNoPID;
 477     if(InPHOS)fCorrectedHadEtPHOSAcceptanceITSNoPID += corrEtNoPID;
 478     if(InEMCAL)fCorrectedHadEtEMCALAcceptanceITSNoPID += corrEtNoPID;
 479   }
 480 }
 481
 482 Bool_t AliAnalysisHadEtReconstructed::IsInPHOS(AliESDtrack *track){//This function will need to be elaborated on later to include PHOS dead channels
 483   if(!track){
 484     cout<<"Error: Track does not exist!!"<<endl;
 485     return kFALSE;
 486   }
 487   return   TMath::Abs(track->Eta()) < fCuts->GetGeometryPhosEtaAccCut()//in eta acceptance
 488     && track->Phi()*180.0/TMath::Pi() > fCuts->GetGeometryPhosPhiAccMinCut()//greater than the minimum phi
 489     && track->Phi()*180.0/TMath::Pi() < fCuts->GetGeometryPhosPhiAccMaxCut();//less than the maximum phi
 490 }
 491 Bool_t AliAnalysisHadEtReconstructed::IsInEMCAL(AliESDtrack *track){//This function will need to be elaborated on later to include EMCAL dead channels
 492   if(!track){
 493     cout<<"Error: Track does not exist!!"<<endl;
 494     return kFALSE;
 495   }
 496   return   TMath::Abs(track->Eta()) < fCuts->GetGeometryEmcalEtaAccCut()//in eta acceptance
 497     && track->Phi()*180.0/TMath::Pi() > fCuts->GetGeometryEmcalPhiAccMinCut()//greater than the minimum phi
 498     && track->Phi()*180.0/TMath::Pi() < fCuts->GetGeometryEmcalPhiAccMaxCut();//less than the maximum phi
 499 }
 500 Bool_t AliAnalysisHadEtReconstructed::CheckGoodVertex(AliVParticle* track)
 501 { // check vertex
 502
 503   Float_t bxy = 999.;
 504   Float_t bz = 999.;
 505   if(!track){
 506     AliError("ERROR: no track");
 507     return kFALSE;
 508   }
 509   AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(track);
 510   if(!esdTrack){
 511     AliError("ERROR: no track");
 512     return kFALSE;
 513   }
 514   esdTrack->GetImpactParametersTPC(bxy,bz);
 515
 516   bool status = (TMath::Abs(track->Xv()) < fCuts->GetReconstructedVertexXCut()) &&
 517     (TMath::Abs(track->Yv()) < fCuts->GetReconstructedVertexYCut()) &&
 518     (TMath::Abs(track->Zv()) < fCuts->GetReconstructedVertexZCut()) &&
 519     (TMath::Abs(bxy) < fCuts->GetReconstructedIPxyCut()) &&
 520     (TMath::Abs(bz) < fCuts->GetReconstructedIPzCut());
 521
 522   return status;
 523 }
 524
 525 void AliAnalysisHadEtReconstructed::Init()
 526 { // Init
 527   AliAnalysisHadEt::Init();
 528   if(fCorrections){
 529     fCorrTotEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"Full");
 530     fCorrTotEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"Full");
 531     fCorrHadEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"Full");
 532     fCorrHadEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"Full");
 533     fCorrPiKPEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PiKP");
 534     fCorrPiKPEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PiKP");
 535     fCorrTotEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"EMCAL");
 536     fCorrTotEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"EMCAL");
 537     fCorrHadEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"EMCAL");
 538     fCorrHadEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"EMCAL");
 539     fCorrTotEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"PHOS");
 540     fCorrTotEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"PHOS");
 541     fCorrHadEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PHOS");
 542     fCorrHadEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PHOS");
 543   }
 544   else{
 545     cout<<"Warning!  You have not set corrections.  Your code will crash.  You have to set the corrections."<<endl;
 546   }
 547 }
 548
 549 void AliAnalysisHadEtReconstructed::ResetEventValues(){//resetting event by event et's
 550   AliAnalysisHadEt::ResetEventValues();
 551   fCorrectedHadEtFullAcceptanceTPCNoPID=0.0;
 552   fCorrectedHadEtFullAcceptanceITSNoPID=0.0;
 553   fCorrectedHadEtEMCALAcceptanceTPCNoPID=0.0;
 554   fCorrectedHadEtEMCALAcceptanceITSNoPID=0.0;
 555   fCorrectedHadEtPHOSAcceptanceTPCNoPID=0.0;
 556   fCorrectedHadEtPHOSAcceptanceITSNoPID=0.0;
 557   fCorrectedHadEtFullAcceptanceTPC=0.0;
 558   fCorrectedHadEtFullAcceptanceITS=0.0;
 559   fCorrectedHadEtFullAcceptanceTPCAssumingPion=0.0;
 560   fCorrectedHadEtFullAcceptanceITSAssumingPion=0.0;
 561   fCorrectedHadEtFullAcceptanceTPCAssumingProton=0.0;
 562   fCorrectedHadEtFullAcceptanceITSAssumingProton=0.0;
 563   fCorrectedHadEtFullAcceptanceTPCAssumingKaon=0.0;
 564   fCorrectedHadEtFullAcceptanceITSAssumingKaon=0.0;
 565   fCorrectedHadEtEMCALAcceptanceTPC=0.0;
 566   fCorrectedHadEtEMCALAcceptanceITS=0.0;
 567   fCorrectedHadEtPHOSAcceptanceTPC=0.0;
 568   fCorrectedHadEtPHOSAcceptanceITS=0.0;
 569   fRawEtFullAcceptanceTPC=0.0;
 570   fRawEtFullAcceptanceITS=0.0;
 571   fRawEtEMCALAcceptanceTPC=0.0;
 572   fRawEtEMCALAcceptanceITS=0.0;
 573   fRawEtPHOSAcceptanceTPC=0.0;
 574   fRawEtPHOSAcceptanceITS=0.0;
 575   fRawEtFullAcceptanceTPCNoPID=0.0;
 576   fRawEtFullAcceptanceITSNoPID=0.0;
 577   fRawEtEMCALAcceptanceTPCNoPID=0.0;
 578   fRawEtEMCALAcceptanceITSNoPID=0.0;
 579   fRawEtPHOSAcceptanceTPCNoPID=0.0;
 580   fRawEtPHOSAcceptanceITSNoPID=0.0;
 581
 582   if(TMath::Abs(fCorrTotEtFullAcceptanceTPC)<1e-3){
 583     if (fConfigFile.Length()) {
 584       cout<<"Warning: Rereading fCorrections file..."<<endl;
 585       gROOT->LoadMacro(fConfigFile);
 586       fCorrections = (AliAnalysisHadEtCorrections *) gInterpreter->ProcessLine("ConfigHadEtAnalysis()");
 587       fCorrTotEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"Full");
 588       fCorrTotEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"Full");
 589       fCorrHadEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"Full");
 590       fCorrHadEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"Full");
 591       fCorrPiKPEtFullAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PiKP");
 592       fCorrPiKPEtFullAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PiKP");
 593       fCorrTotEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"EMCAL");
 594       fCorrTotEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"EMCAL");
 595       fCorrHadEtEMCALAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"EMCAL");
 596       fCorrHadEtEMCALAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"EMCAL");
 597       fCorrTotEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"PHOS");
 598       fCorrTotEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"PHOS");
 599       fCorrHadEtPHOSAcceptanceTPC = fCorrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PHOS");
 600       fCorrHadEtPHOSAcceptanceITS = fCorrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PHOS");
 601     }
 602     else{cerr<<"Uh-oh!  Unable to open configuration file!"<<endl;}
 603   }
 604 }
 605 void AliAnalysisHadEtReconstructed::CreateHistograms(){//Creating histograms and adding them to the output TList
 606
 607   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 608   if (!man) {
 609     AliFatal("Analysis manager needed");
 610     return;
 611   }
 612   AliInputEventHandler *inputHandler=dynamic_cast<AliInputEventHandler*>(man->GetInputEventHandler());
 613   if (!inputHandler) {
 614     AliFatal("Input handler needed");
 615     return;
 616   }
 617
 618   //pid response object
 619   fPIDResponse=inputHandler->GetPIDResponse();
 620   if (!fPIDResponse) AliError("PIDResponse object was not created");
 621
 622
 623   if(kDoTriggerChecksOnly){return;}//In this case we are just after trigger efficiencies and don't care about the ET reconstructed.
 624   //TString *strTPC = new TString("TPC");
 625   TString *strITS = new TString("ITS");
 626   TString *strTPCITS = new TString("TPCITS");
 627   for(Int_t i=0;i<2;i++){
 628     TString *cutName = NULL;
 629     Float_t maxPtdEdx = 10;
 630     Float_t mindEdx = 35;
 631     Float_t maxdEdx = 150.0;
 632     switch(i){
 633     case 0:
 634       cutName = strTPCITS;
 635       break;
 636     case 1:
 637       cutName = strITS;
 638       maxPtdEdx = 5;
 639       maxdEdx = 500.0;
 640       break;
 641       //not deleting this completely since we might want to add it back in later
 642       //     case 2:
 643       //       cutName = strTPC;
 644       //       maxPtdEdx = 5;
 645       //       maxdEdx = 500.0;
 646       //       break;
 647     default:
 648       cerr<<"Error:  cannot make histograms!"<<endl;
 649       return;
 650     }
 651
 652     CreateEtaPtHisto2D(Form("EtDataRaw%sPiPlus",cutName->Data()),"Raw reconstructed E_{T} from identified #pi^{+}");
 653     CreateEtaPtHisto2D(Form("EtDataRaw%sPiMinus",cutName->Data()),"Raw reconstructed E_{T} from identified #pi^{-}");
 654     CreateEtaPtHisto2D(Form("EtDataRaw%sKPlus",cutName->Data()),"Raw reconstructed E_{T} from identified K^{+}");
 655     //     CreateEtaPtHisto2D(Form("EtDataRaw%sEMinus",cutName->Data()),"Raw reconstructed E_{T} from identified e^{-}");
 656     //     CreateEtaPtHisto2D(Form("EtDataRaw%sEPlus",cutName->Data()),"Raw reconstructed E_{T} from identified e^{+}");
 657     CreateEtaPtHisto2D(Form("EtDataRaw%sKMinus",cutName->Data()),"Raw reconstructed E_{T} from identified K^{-}");
 658     CreateEtaPtHisto2D(Form("EtDataRaw%sProton",cutName->Data()),"Raw reconstructed E_{T} from identified p");
 659     CreateEtaPtHisto2D(Form("EtDataRaw%sAntiProton",cutName->Data()),"Raw reconstructed E_{T} from identified #bar{p}");
 660     CreateEtaPtHisto2D(Form("EtDataRaw%sUnidentified",cutName->Data()),"Raw reconstructed E_{T} from unidentified particles using real mass");
 661     CreateEtaPtHisto2D(Form("EtDataRaw%sNoID",cutName->Data()),"Raw reconstructed E_{T} from unidentified particles using real mass");
 662
 663     CreateEtaPtHisto2D(Form("EtDataCorrected%sPiPlus",cutName->Data()),"Corrected reconstructed E_{T} from identified #pi^{+}");
 664     CreateEtaPtHisto2D(Form("EtDataCorrected%sPiMinus",cutName->Data()),"Corrected reconstructed E_{T} from identified #pi^{-}");
 665     CreateEtaPtHisto2D(Form("EtDataCorrected%sKPlus",cutName->Data()),"Corrected reconstructed E_{T} from identified K^{+}");
 666     //     CreateEtaPtHisto2D(Form("EtDataCorrected%sEMinus",cutName->Data()),"Corrected reconstructed E_{T} from identified e^{-}");
 667     //     CreateEtaPtHisto2D(Form("EtDataCorrected%sEPlus",cutName->Data()),"Corrected reconstructed E_{T} from identified e^{+}");
 668     CreateEtaPtHisto2D(Form("EtDataCorrected%sKMinus",cutName->Data()),"Corrected reconstructed E_{T} from identified K^{-}");
 669     CreateEtaPtHisto2D(Form("EtDataCorrected%sProton",cutName->Data()),"Corrected reconstructed E_{T} from identified p");
 670     CreateEtaPtHisto2D(Form("EtDataCorrected%sAntiProton",cutName->Data()),"Corrected reconstructed E_{T} from identified #bar{p}");
 671     CreateEtaPtHisto2D(Form("EtDataCorrected%sUnidentified",cutName->Data()),"Corrected reconstructed E_{T} from unidentified particles using real mass");
 672     CreateEtaPtHisto2D(Form("EtDataCorrected%sNoID",cutName->Data()),"Corrected reconstructed E_{T} from unidentified particles using real mass");
 673
 674
 675     CreateEtaPtHisto2D(Form("EtNData%sPiPlus",cutName->Data()),"Number of reconstructed #pi^{+}");
 676     CreateEtaPtHisto2D(Form("EtNData%sPiMinus",cutName->Data()),"Number of reconstructed #pi^{-}");
 677     CreateEtaPtHisto2D(Form("EtNData%sKPlus",cutName->Data()),"Number of reconstructed K^{+}");
 678     CreateEtaPtHisto2D(Form("EtNData%sKMinus",cutName->Data()),"Number of reconstructed K^{-}");
 679     CreateEtaPtHisto2D(Form("EtNData%sProton",cutName->Data()),"Number of reconstructed p");
 680     CreateEtaPtHisto2D(Form("EtNData%sAntiProton",cutName->Data()),"Number of reconstructed #bar{p}");
 681     CreateEtaPtHisto2D(Form("EtNData%sUnidentified",cutName->Data()),"Number of Reconstructed unidentified particles");
 682
 683     CreateHisto2D(Form("dEdxDataAll%s",cutName->Data()),"dE/dx for all particles","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
 684     CreateHisto2D(Form("dEdxDataPion%s",cutName->Data()),"dE/dx for #pi^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
 685     CreateHisto2D(Form("dEdxDataKaon%s",cutName->Data()),"dE/dx for K^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
 686     CreateHisto2D(Form("dEdxDataProton%s",cutName->Data()),"dE/dx for p(#bar{p})","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
 687     CreateHisto2D(Form("dEdxDataElectron%s",cutName->Data()),"dE/dx for e^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
 688     CreateHisto2D(Form("dEdxDataUnidentified%s",cutName->Data()),"dE/dx for unidentified particles","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
 689   }
 690
 691   Float_t minEt = 0.0;
 692   Float_t maxEt = 100.0;
 693   Float_t minEtPiKP = 0.0;
 694   Float_t maxEtPiKP = 50.0;
 695   if(fDataSet==20100) maxEt=4000.0;
 696   Int_t nbinsEt = 200;
 697   char histoname[200];
 698   char histotitle[200];
 699   char xtitle[50];
 700   TString *ytitle = new TString("Number of events");
 701   TString *sTPC = new TString("TPC");
 702   TString *sITS = new TString("ITS");
 703   TString *sTPCpt = new TString("0.15");
 704   TString *sITSpt = new TString("0.10");
 705   TString *sPID = new TString("");
 706   TString *sNoPID = new TString("NoPID");
 707   TString *sNoPIDString = new TString(", No PID");
 708   TString *sHadEt = new TString("HadEt");
 709   TString *sPiKPEt = new TString("PiKPEt");
 710   TString *sRawEt = new TString("RawEt");
 711   TString *sTotEt = new TString("TotEt");
 712   TString *sTotEtString = new TString("total E_{T}");
 713   TString *sHadEtString = new TString("hadronic E_{T}");
 714   TString *sPiKPEtString = new TString("E_{T}^{#pi,K,p}");
 715   TString *sRawEtString = new TString("raw E_{T}");
 716   TString *sFull = new TString("Full");
 717   TString *sEMCAL = new TString("EMCAL");
 718   TString *sPHOS = new TString("PHOS");
 719
 720   for(int tpc = 0;tpc<2;tpc++){
 721     for(int hadet = 0;hadet<3;hadet++){
 722       for(int type = 0;type<3;type++){
 723         for(int pid = 0;pid<2;pid++){
 724           TString *detector = NULL;
 725           TString *partid = NULL;
 726           TString *et = sHadEt;
 727           TString *acceptance = NULL;
 728           TString *ptstring = NULL;
 729           TString *partidstring = NULL;
 730           TString *etstring = sHadEtString;
 731           if(tpc==1) {detector = sTPC; ptstring = sTPCpt;}
 732           else{detector = sITS; ptstring = sITSpt;}
 733           if(pid==1){partid = sPID; partidstring = sPID;}
 734           else{partid = sNoPID; partidstring = sNoPIDString;}
 735           if(hadet==1) {et = sHadEt; etstring = sHadEtString;}
 736           if(hadet==0){et = sTotEt; etstring = sTotEtString;}
 737           if(hadet==2){et = sRawEt; etstring = sRawEtString;}
 738           switch(type){
 739           case 0:
 740             acceptance = sFull;
 741             break;
 742           case 1:
 743             acceptance = sEMCAL;
 744             break;
 745           case 2:
 746             acceptance = sPHOS;
 747             break;
 748           default:
 749             acceptance = sFull;
 750           }
 751           snprintf(histoname,200,"Reco%s%sAcceptance%s%s",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
 752           snprintf(histotitle,200,"Reconstructed %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 753           snprintf(xtitle,50,"Reconstructed %s",etstring->Data());
 754           CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
 755           if(type==0){//full acceptance only
 756             snprintf(xtitle,50,"Reconstructed %s",etstring->Data());
 757
 758             snprintf(histoname,200,"Reco%s%sAcceptance%s%sND",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
 759             snprintf(histotitle,200,"Reconstructed non-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 760             CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
 761             snprintf(histoname,200,"Reco%s%sAcceptance%s%sDD",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
 762             snprintf(histotitle,200,"Reconstructed doubly-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 763             CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
 764             snprintf(histoname,200,"Reco%s%sAcceptance%s%sSD",et->Data(),acceptance->Data(),detector->Data(),partid->Data());
 765             snprintf(histotitle,200,"Reconstructed singly-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 766             CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
 767
 768
 769
 770           snprintf(histoname,200,"Reco%s%sAcceptance%s%s",sPiKPEt->Data(),acceptance->Data(),detector->Data(),partid->Data());
 771           snprintf(histotitle,200,"Reconstructed %s with %s acceptance for p_{T}>%s GeV/c%s",sPiKPEtString->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 772           snprintf(xtitle,50,"Reconstructed %s",sPiKPEtString->Data());
 773           CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEtPiKP,maxEtPiKP);
 774
 775             snprintf(xtitle,50,"Reconstructed %s",sPiKPEt->Data());
 776             snprintf(histoname,200,"Reco%s%sAcceptance%s%sND",sPiKPEt->Data(),acceptance->Data(),detector->Data(),partid->Data());
 777             snprintf(histotitle,200,"Reconstructed non-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",sPiKPEtString->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 778             CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEtPiKP,maxEtPiKP);
 779             snprintf(histoname,200,"Reco%s%sAcceptance%s%sDD",sPiKPEt->Data(),acceptance->Data(),detector->Data(),partid->Data());
 780             snprintf(histotitle,200,"Reconstructed doubly-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",sPiKPEtString->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 781             CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEtPiKP,maxEtPiKP);
 782             snprintf(histoname,200,"Reco%s%sAcceptance%s%sSD",sPiKPEt->Data(),acceptance->Data(),detector->Data(),partid->Data());
 783             snprintf(histotitle,200,"Reconstructed singly-diffractive events %s with %s acceptance for p_{T}>%s GeV/c%s",sPiKPEtString->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data());
 784             CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEtPiKP,maxEtPiKP);//et
 785
 786           }
 787           if(fDataSet==20100 && type ==0 &&pid==1){//If this is Pb+Pb and full acceptance with pid
 788             Int_t width = 5;
 789             if(fNCentBins<21) width = 10;
 790             for(Int_t i=0;i<fNCentBins;i++){
 791               snprintf(histoname,200,"Reco%s%sAcceptance%s%sCB%i",et->Data(),acceptance->Data(),detector->Data(),partid->Data(),i);
 792               snprintf(histotitle,200,"Reconstructed %s with %s acceptance for p_{T}>%s GeV/c%s for centrality %i-%i",etstring->Data(),acceptance->Data(),ptstring->Data(),partidstring->Data(),i*width,(i+1)*width);
 793               snprintf(xtitle,50,"Reconstructed %s",etstring->Data());
 794               CreateHisto1D(histoname,histotitle,xtitle,ytitle->Data(),nbinsEt*2,minEt,maxEt);
 795             }
 796           }
 797         }
 798       }
 799     }
 800   }
 801   CreateHisto1D("RecoHadEtFullAcceptanceTPCAssumingPion","Reconstructing E_{T}^{had} with full acceptance for p_{T}>0.15 GeV/c assuming pions","Reconstructed E_{T}^{had}","dN_{eve}/dE_{T}^{had}",nbinsEt*2,minEt,maxEt);
 802   CreateHisto1D("RecoHadEtFullAcceptanceTPCAssumingProton","Reconstructing E_{T}^{had} with full acceptance for p_{T}>0.15 GeV/c assuming protons","Reconstructed E_{T}^{had}","dN_{eve}/dE_{T}^{had}",nbinsEt*2,minEt,maxEt);
 803   CreateHisto1D("RecoHadEtFullAcceptanceTPCAssumingKaon","Reconstructing E_{T}^{had} with full acceptance for p_{T}>0.15 GeV/c assuming kaons","Reconstructed E_{T}^{had}","dN_{eve}/dE_{T}^{had}",nbinsEt*2,minEt,maxEt);
 804   CreateHisto1D("RecoHadEtFullAcceptanceITSAssumingPion","Reconstructing E_{T}^{had} with full acceptance for p_{T}>0.10 GeV/c assuming pions","Reconstructed E_{T}^{had}","dN_{eve}/dE_{T}^{had}",nbinsEt*2,minEt,maxEt);
 805   CreateHisto1D("RecoHadEtFullAcceptanceITSAssumingProton","Reconstructing E_{T}^{had} with full acceptance for p_{T}>0.10 GeV/c assuming protons","Reconstructed E_{T}^{had}","dN_{eve}/dE_{T}^{had}",nbinsEt*2,minEt,maxEt);
 806   CreateHisto1D("RecoHadEtFullAcceptanceITSAssumingKaon","Reconstructing E_{T}^{had} with full acceptance for p_{T}>0.10 GeV/c assuming kaons","Reconstructed E_{T}^{had}","dN_{eve}/dE_{T}^{had}",nbinsEt*2,minEt,maxEt);
 807
 808   //Cross checks that corrections are applied correctly
 809   if(fDataSet==20100){
 810     CreateHisto2D("fbkgdVsCentralityBin","f_{bkgd} vs centrality bin","centrality bin","f_{bkgd}",21,-1.5,19.5,200,0.7,1.05);//
 811     CreateHisto2D("feffPionVsCentralityBin","Pion efficiency vs centrality bin","centrality bin","pion efficiency",21,-1.5,19.5,200,0,1.2);//
 812     CreateHisto2D("feffHadronVsCentralityBin","Hadron efficiency vs centrality bin","centrality bin","hadron efficiency",21,-1.5,19.5,200,0,1.2);//
 813     CreateHisto2D("feffKaonVsCentralityBin","Kaon efficiency vs centrality bin","centrality bin","kaon efficiency",21,-1.5,19.5,200,0,1.2);//
 814     CreateHisto2D("feffProtonVsCentralityBin","Proton efficiency vs centrality bin","centrality bin","proton efficiency",21,-1.5,19.5,200,0,1.2);//
 815     CreateHisto2D("fnotIDVsCentralityBin","f_{notID} vs centrality bin","centrality bin","f_{notID}",21,-1.5,19.5,50,0.95,1.05);//
 816     CreateHisto2D("fpTcutVsCentralityBin","f_{pTcut} vs centrality bin","centrality bin","f_{pTcut}",21,-1.5,19.5,50,0.95,1.05);
 817     CreateHisto2D("fneutralVsCentralityBin","f_{neutral} vs centrality bin","centrality bin","f_{neutral}",21,-1.5,19.5,50,0.5,1.00);
 818     CreateHisto2D("ConstantCorrectionsVsCentralityBin","constant corrections vs centrality bin","centrality bin","constant corrections",21,-1.5,19.5,50,0.5,1.00);
 819   }
 820
 821   delete sTPC;
 822   delete sITS;
 823   delete sTPCpt;
 824   delete sITSpt;
 825   delete sPID;
 826   delete sNoPID;
 827   delete sNoPIDString;
 828   delete sPiKPEt;
 829   delete sHadEt;
 830   delete sTotEt;
 831   delete sTotEtString;
 832   delete sHadEtString;
 833   delete sPiKPEtString;
 834   delete sFull;
 835   delete sEMCAL;
 836   delete sPHOS;
 837
 838 }