Corrections implemented into AliAnalysisHadEtReconstructed, simulated hadronic and...
authorcnattras <cnattras@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 29 Sep 2010 04:04:23 +0000 (04:04 +0000)
committercnattras <cnattras@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 29 Sep 2010 04:04:23 +0000 (04:04 +0000)
PWG4/totEt/AliAnalysisHadEt.cxx
PWG4/totEt/AliAnalysisHadEt.h
PWG4/totEt/AliAnalysisHadEtMonteCarlo.cxx
PWG4/totEt/AliAnalysisHadEtMonteCarlo.h
PWG4/totEt/AliAnalysisHadEtReconstructed.cxx
PWG4/totEt/AliAnalysisHadEtReconstructed.h
PWG4/totEt/AliAnalysisTaskHadEt.cxx

index 5b79d7e..9cabf6d 100644 (file)
@@ -42,6 +42,9 @@ Float_t AliAnalysisHadEt::fgPtAxis[117]=
    5.0, 5.5, 6.0, 6.5, 7.0, 7.50, 8.00, 8.5, 9.0, 9.5, 10.0,12.0,14.0,16.0,18.0,
   20.0,25.0,30.0,35.0,40.0, 45.0, 50.0}; 
 
+Float_t AliAnalysisHadEt::fgPtTPCCutOff = 0.15;
+Float_t AliAnalysisHadEt::fgPtITSCutOff = 0.10;
+
 AliAnalysisHadEt::AliAnalysisHadEt() :
         fHistogramNameSuffix("")
        ,fCuts(0)
index 3bc4c53..210a6fd 100644 (file)
@@ -162,6 +162,8 @@ protected:
     static Int_t fgnumOfEtaBins;//number of eta bins
     static Float_t fgPtAxis[117];//bins for pt axis of histograms
     static Int_t fgNumOfPtBins;//number of pt bins
+    static Float_t fgPtTPCCutOff;//cut off for tracks in TPC
+    static Float_t fgPtITSCutOff;//cut off for tracks in ITS
     
 
 
index 4747a8b..9f74f28 100644 (file)
@@ -21,7 +21,16 @@ using namespace std;
 
 ClassImp(AliAnalysisHadEtMonteCarlo);
 
-
+AliAnalysisHadEtMonteCarlo::AliAnalysisHadEtMonteCarlo():AliAnalysisHadEt()
+                           ,fSimHadEt(0)
+                           ,fSimTotEt(0) 
+{
+}
+void AliAnalysisHadEtMonteCarlo::ResetEventValues(){
+  AliAnalysisHadEt::ResetEventValues();
+    fSimHadEt=0.0;
+    fSimTotEt=0.0;
+}
 Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev,AliVEvent* ev2)
 { // analyse MC and real event info
   FillHisto1D("NEvents",0.5,1);
@@ -402,6 +411,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            if(pdgCode == fPiPlusCode){
              //cout<<"I'm a simulated primary "<<part->GetName()<<"! "<<"my label is "<<part->GetFirstMother()<<" pt "<<part->Pt()<<endl;
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedPiPlus",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtNSimulatedPiPlus",part->Pt(),part->Eta(),1.0);
              FillHisto2D("EtSimulatedChargedHadron",part->Pt(),part->Eta(),myEt);
@@ -412,6 +423,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fPiMinusCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedPiMinus",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtNSimulatedPiMinus",part->Pt(),part->Eta(),1.0);
              FillHisto2D("EtSimulatedChargedHadron",part->Pt(),part->Eta(),myEt);
@@ -423,6 +436,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            if(pdgCode == fKPlusCode){
              float myEt = Et(part);
              float myEtPi = Et(part,fPionMass);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedKPlus",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtNSimulatedKPlus",part->Pt(),part->Eta(),1.0);
              FillHisto2D("EtSimulatedChargedHadron",part->Pt(),part->Eta(),myEt);
@@ -435,6 +450,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            if(pdgCode == fKMinusCode){
              float myEt = Et(part);
              float myEtPi = Et(part,fPionMass);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedKMinus",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtNSimulatedKMinus",part->Pt(),part->Eta(),1.0);
              FillHisto2D("EtSimulatedChargedHadron",part->Pt(),part->Eta(),myEt);
@@ -447,6 +464,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            if(pdgCode == fProtonCode){
              float myEt = Et(part);
              float myEtPi = Et(part,fPionMass);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedProton",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtNSimulatedProton",part->Pt(),part->Eta(),1.0);
              FillHisto2D("EtSimulatedChargedHadron",part->Pt(),part->Eta(),myEt);
@@ -459,6 +478,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            if(pdgCode == fAntiProtonCode){
              float myEt = Et(part);
              float myEtPi = Et(part,fPionMass);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedAntiProton",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtNSimulatedAntiProton",part->Pt(),part->Eta(),1.0);
              FillHisto2D("EtSimulatedChargedHadron",part->Pt(),part->Eta(),myEt);
@@ -472,18 +493,24 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
 
            if(pdgCode == fNeutronCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedNeutron",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fAntiNeutronCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedAntiNeutron",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fLambdaCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              //cout<<"I am a simulated lambda! pt "<<part->Pt()<<" eta "<<part->Eta()<<endl;
              FillHisto2D("EtSimulatedLambda",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
@@ -510,6 +537,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fAntiLambdaCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedAntiLambda",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              Int_t ndaughters = part->GetNDaughters();
@@ -535,6 +564,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fK0SCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedK0S",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              Int_t ndaughters = part->GetNDaughters();
@@ -561,12 +592,16 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fK0LCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedK0L",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fOmegaCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedOmega",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              Int_t ndaughters = part->GetNDaughters();
@@ -593,6 +628,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fAntiOmegaCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedOmega",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              Int_t ndaughters = part->GetNDaughters();
@@ -619,18 +656,24 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            //There are two codes for Sigmas
            if(pdgCode == fSigmaCode || pdgCode == -3222){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedSigma",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fAntiSigmaCode || pdgCode == 3222){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedAntiSigma",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fXiCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedXi",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              Int_t ndaughters = part->GetNDaughters();
@@ -658,6 +701,8 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fAntiXiCode){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedAntiXi",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              Int_t ndaughters = part->GetNDaughters();
@@ -683,12 +728,16 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
            }
            if(pdgCode == fXi0Code){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedXi0",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fAntiXi0Code){
              float myEt = Et(part);
+             fSimHadEt += myEt;
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedAntiXi0",part->Pt(),part->Eta(),myEt);
              FillHisto2D("EtSimulatedAllHadron",part->Pt(),part->Eta(),myEt);
              filled = true;
@@ -697,11 +746,13 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
 
            if(pdgCode == fEPlusCode){
              float myEt = Et(part);
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedEPlus",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fEMinusCode){
              float myEt = Et(part);
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedEMinus",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
@@ -712,37 +763,44 @@ Int_t AliAnalysisHadEtMonteCarlo::AnalyseEvent(AliVEvent* ev)
              //cout<<"I am a gamma and my mom is "<<mom->GetName()<<endl;
              if(pdgCodeMom == fEtaCode){
                float myEt = Et(mom);
+             fSimTotEt += myEt;
                FillHisto2D("EtSimulatedEta",mom->Pt(),mom->Eta(),myEt);
                filled = true;
              }
              if(pdgCodeMom == fPi0Code){
                float myEt = Et(mom);
+             fSimTotEt += myEt;
                FillHisto2D("EtSimulatedPi0",mom->Pt(),mom->Eta(),myEt);
                filled = true;
              }
              if(pdgCodeMom == fOmega0Code){
                float myEt = Et(mom);
+             fSimTotEt += myEt;
                FillHisto2D("EtSimulatedOmega0",mom->Pt(),mom->Eta(),myEt);
                filled = true;
              }
              if(!filled){
                float myEt = Et(part);
+             fSimTotEt += myEt;
                FillHisto2D("EtSimulatedGamma",part->Pt(),part->Eta(),myEt);
                filled = true;
              }
            }
            if(pdgCode == fEtaCode){
              float myEt = Et(part);
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedEta",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fPi0Code){
              float myEt = Et(part);
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedPi0",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
            if(pdgCode == fOmega0Code){
              float myEt = Et(part);
+             fSimTotEt += myEt;
              FillHisto2D("EtSimulatedOmega0",part->Pt(),part->Eta(),myEt);
              filled = true;
            }
@@ -911,7 +969,30 @@ void AliAnalysisHadEtMonteCarlo::CreateHistograms(){
     CreateHisto2D(Form("dEdxElectron%s",cutName->Data()),"dE/dx for e^{#pm}","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
     CreateHisto2D(Form("dEdxUnidentified%s",cutName->Data()),"dE/dx for unidentified particles","momentum (GeV/c)","dE/dx",400,0.0,maxPtdEdx,200,mindEdx,maxdEdx);
   }
-
+  CreateHisto2D("SimTotEtVsRecoTotEtFullAcceptanceTPC","Simulated total E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.15 GeV/c","Simulated total E_{T}","Reconstructed total E_{T} (Full acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceTPC","Simulated total E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.15 GeV/c","Simulated total E_{T}","Reconstructed total E_{T} (EMCAL acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceTPC","Simulated total E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.15 GeV/c","Simulated total E_{T}","Reconstructed total E_{T} (PHOS acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtFullAcceptanceTPC","Simulated hadronic E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.15 GeV/c","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (Full acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceTPC","Simulated hadronic E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.15 GeV/c","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (EMCAL acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceTPC","Simulated hadronic E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.15 GeV/c","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (PHOS acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtFullAcceptanceITS","Simulated total E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.10 GeV/c","Simulated total E_{T}","Reconstructed total E_{T} (Full acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceITS","Simulated total E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.10 GeV/c","Simulated total E_{T}","Reconstructed total E_{T} (EMCAL acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceITS","Simulated total E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.10 GeV/c","Simulated total E_{T}","Reconstructed total E_{T} (PHOS acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtFullAcceptanceITS","Simulated hadronic E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.10 GeV/c","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (Full acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceITS","Simulated hadronic E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.10 GeV/c","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (EMCAL acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceITS","Simulated hadronic E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.10 GeV/c","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (PHOS acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtFullAcceptanceTPCNoPID","Simulated total E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.15 GeV/c, no PID","Simulated total E_{T}","Reconstructed total E_{T} (Full acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceTPCNoPID","Simulated total E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.15 GeV/c, no PID","Simulated total E_{T}","Reconstructed total E_{T} (EMCAL acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceTPCNoPID","Simulated total E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.15 GeV/c, no PID","Simulated total E_{T}","Reconstructed total E_{T} (PHOS acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtFullAcceptanceTPCNoPID","Simulated hadronic E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.15 GeV/c, no PID","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (Full acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceTPCNoPID","Simulated hadronic E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.15 GeV/c, no PID","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (EMCAL acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceTPCNoPID","Simulated hadronic E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.15 GeV/c, no PID","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (PHOS acc., p_{T}>0.15 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtFullAcceptanceITSNoPID","Simulated total E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.10 GeV/c, no PID","Simulated total E_{T}","Reconstructed total E_{T} (Full acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceITSNoPID","Simulated total E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.10 GeV/c, no PID","Simulated total E_{T}","Reconstructed total E_{T} (EMCAL acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceITSNoPID","Simulated total E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.10 GeV/c, no PID","Simulated total E_{T}","Reconstructed total E_{T} (PHOS acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtFullAcceptanceITSNoPID","Simulated hadronic E_{T} vs reconstructed E_{T} with full acceptance for p_{T}>0.10 GeV/c, no PID","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (Full acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceITSNoPID","Simulated hadronic E_{T} vs reconstructed E_{T} with EMCAL acceptance for p_{T}>0.10 GeV/c, no PID","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (EMCAL acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
+  CreateHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceITSNoPID","Simulated hadronic E_{T} vs reconstructed E_{T} with PHOS acceptance for p_{T}>0.10 GeV/c, no PID","Simulated hadronic E_{T}","Reconstructed hadronic E_{T} (PHOS acc., p_{T}>0.10 GeV/c)",100,0.0,100.0,100,0.0,100.0);
   CreateIntHisto1D("NEvents","Number of events","number of events","Number of events",1,0,1);
 
   //CreateHisto1D("MisidentifiedPIDs","PIDs for particles misidentified that are not a #pi,K,p","PID","number of entries",3000,0.5,3000.5);
index 4bdf9fb..e82bcff 100644 (file)
@@ -17,8 +17,8 @@ class AliAnalysisHadEtMonteCarlo : public AliAnalysisHadEt
 
 public:
    
-    AliAnalysisHadEtMonteCarlo() {}
-    virtual ~AliAnalysisHadEtMonteCarlo() {}
+  AliAnalysisHadEtMonteCarlo();
+  virtual ~AliAnalysisHadEtMonteCarlo() {}
    
     virtual Int_t AnalyseEvent(AliVEvent* event);
     virtual Int_t AnalyseEvent(AliVEvent* event,AliVEvent* event2);
@@ -26,12 +26,43 @@ public:
     //void FillHistograms();
     void CreateHistograms();
     virtual void Init();
-    
+
+    Float_t GetSimulatedHadronicEt(){return fSimHadEt;}
+    Float_t GetSimulatedTotalEt(){return fSimTotEt;}
+
+    void FillSimTotEtVsRecoTotEtFullAcceptanceTPC(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtFullAcceptanceTPC",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtFullAcceptanceITS(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtFullAcceptanceITS",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtEMCALAcceptanceTPC(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceTPC",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtEMCALAcceptanceITS(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceITS",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtPHOSAcceptanceTPC(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceTPC",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtPHOSAcceptanceITS(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceITS",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtFullAcceptanceTPCNoPID(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtFullAcceptanceTPCNoPID",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtFullAcceptanceITSNoPID(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtFullAcceptanceITSNoPID",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtEMCALAcceptanceTPCNoPID(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceTPCNoPID",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtEMCALAcceptanceITSNoPID(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtEMCALAcceptanceITSNoPID",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtPHOSAcceptanceTPCNoPID(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceTPCNoPID",fSimTotEt,et,1.0);}
+    void FillSimTotEtVsRecoTotEtPHOSAcceptanceITSNoPID(Float_t et){FillHisto2D("SimTotEtVsRecoTotEtPHOSAcceptanceITSNoPID",fSimTotEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtFullAcceptanceTPC(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtFullAcceptanceTPC",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtFullAcceptanceITS(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtFullAcceptanceITS",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtEMCALAcceptanceTPC(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceTPC",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtEMCALAcceptanceITS(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceITS",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtPHOSAcceptanceTPC(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceTPC",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtPHOSAcceptanceITS(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceITS",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtFullAcceptanceTPCNoPID(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtFullAcceptanceTPCNoPID",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtFullAcceptanceITSNoPID(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtFullAcceptanceITSNoPID",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtEMCALAcceptanceTPCNoPID(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceTPCNoPID",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtEMCALAcceptanceITSNoPID(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtEMCALAcceptanceITSNoPID",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtPHOSAcceptanceTPCNoPID(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceTPCNoPID",fSimHadEt,et,1.0);}
+    void FillSimHadEtVsRecoHadEtPHOSAcceptanceITSNoPID(Float_t et){FillHisto2D("SimHadEtVsRecoHadEtPHOSAcceptanceITSNoPID",fSimHadEt,et,1.0);}
  private:
     //Declare it private to avoid compilation warning
     AliAnalysisHadEtMonteCarlo & operator = (const AliAnalysisHadEtMonteCarlo & g) ;//cpy assignment
     AliAnalysisHadEtMonteCarlo(const AliAnalysisHadEtMonteCarlo & g) ; // cpy ctor
 
+    Float_t fSimHadEt;
+    Float_t fSimTotEt;
+
+    void ResetEventValues();
     ClassDef(AliAnalysisHadEtMonteCarlo, 1);
 };
 
index 2151dbf..3dbcf26 100644 (file)
@@ -34,24 +34,42 @@ AliAnalysisHadEtReconstructed::AliAnalysisHadEtReconstructed() :
         AliAnalysisHadEt()
        ,corrections(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)
-       ,fRawEtFullAcceptanceTPC(0)
-       ,fRawEtFullAcceptanceITS(0)
-       ,fRawEtEMCALAcceptanceTPC(0)
-       ,fRawEtEMCALAcceptanceITS(0)
-       ,fRawEtPHOSAcceptanceTPC(0)
-       ,fRawEtPHOSAcceptanceITS(0)
+    ,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)
 {
 
 }
@@ -63,12 +81,6 @@ AliAnalysisHadEtReconstructed::~AliAnalysisHadEtReconstructed()
 Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
 { // analyse ESD event
     ResetEventValues();
-    fRawEtFullAcceptanceTPC=0.0;
-    fRawEtFullAcceptanceITS=0.0;
-    fRawEtEMCALAcceptanceTPC=0.0;
-    fRawEtEMCALAcceptanceITS=0.0;
-    fRawEtPHOSAcceptanceTPC=0.0;
-    fRawEtPHOSAcceptanceITS=0.0;
 
     AliESDEvent *realEvent = dynamic_cast<AliESDEvent*>(ev);
     //for PID
@@ -78,6 +90,7 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
     TString *strTPC = new TString("TPC");
     TString *strITS = new TString("ITS");
     TString *strTPCITS = new TString("TPCITS");
+    bool isTPC = false;
     for(Int_t cutset=0;cutset<2;cutset++){
       TString *cutName;
       TObjArray* list;
@@ -85,6 +98,7 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
       case 0:
        cutName = strTPC;
        list = fEsdtrackCutsTPC->GetAcceptedTracks(realEvent);
+       isTPC = true;
        break;
       case 1:
        cutName = strITS;
@@ -99,6 +113,7 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
        return -1;
       }
       Int_t nGoodTracks = list->GetEntries();
+      //cout<<nGoodTracks<<" "<<cutName->Data()<<" tracks"<<endl;
       for (Int_t iTrack = 0; iTrack < nGoodTracks; iTrack++)
        {
 
@@ -110,6 +125,7 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
              continue;
            }
          else{
+           if(TMath::Abs(track->Eta())>corrections->GetEtaCut()) continue;
            Float_t nSigmaPion,nSigmaProton,nSigmaKaon,nSigmaElectron;
            
            if(cutset!=1){
@@ -135,6 +151,8 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
            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);
            //if(!(corrections->GetEfficiencyPionTPC())) cerr<<"Uh-oh!  No histogram!"<<endl;
 
            Float_t corrBkgd=0.0;
@@ -153,8 +171,9 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
              corrNotID = corrections->GetNotIDCorrectionITS(track->Pt());
            }
            Float_t et = 0.0;
+           Float_t etNoID = Et(track->P(),track->Theta(),fPiPlusCode,track->Charge());
            Float_t etpartialcorrected = 0.0;
-           Float_t etpartialcorrectedNoID = corrNoID*corrBkgd*corrEffNoID*Et(track->P(),track->Theta(),fPiPlusCode,track->Charge());
+           Float_t etpartialcorrectedNoID = corrNoID*corrBkgd*corrEffNoID*etNoID;
            FillHisto2D(Form("EtDataRaw%sNoID",cutName->Data()),track->Pt(),track->Eta(),etpartialcorrectedNoID);
 
            if(isPion){
@@ -215,13 +234,95 @@ Int_t AliAnalysisHadEtReconstructed::AnalyseEvent(AliVEvent* ev)
              etpartialcorrected = et*corrBkgd*corrEffNoID*corrNotID;
              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(inEMCAL) cout<<"I should add a track"<<endl;
          }
        }
     }
+//   cout<<"Finishing with Raw/Corrected Et in full, PHOS, EMCAL acceptance of "
+//       << GetRawEtFullAcceptanceITS() <<"/"
+//       << GetCorrectedHadEtFullAcceptanceITS() <<", "
+//       << GetRawEtPHOSAcceptanceITS() <<"/"
+//       << GetCorrectedHadEtPHOSAcceptanceITS() <<", "
+//       << GetRawEtEMCALAcceptanceITS() <<"/"
+//       << GetCorrectedHadEtEMCALAcceptanceITS() <<endl;
+//   cout<<"Finishing with Raw/Corrected Et w/o PID in full, PHOS, EMCAL acceptance of "
+//       << GetRawEtFullAcceptanceITSNoPID() <<"/"
+//       << GetCorrectedHadEtFullAcceptanceITSNoPID() <<", "
+//       << GetRawEtPHOSAcceptanceITSNoPID() <<"/"
+//       << GetCorrectedHadEtPHOSAcceptanceITSNoPID() <<", "
+//       << GetRawEtEMCALAcceptanceITSNoPID() <<"/"
+//       << GetCorrectedHadEtEMCALAcceptanceITSNoPID() <<endl;
+//   cout<<"Finishing with Raw/Corrected Et in full, PHOS, EMCAL acceptance of "
+//       << GetRawEtFullAcceptanceTPC() <<"/"
+//       << GetCorrectedHadEtFullAcceptanceTPC() <<", "
+//       << GetRawEtPHOSAcceptanceTPC() <<"/"
+//       << GetCorrectedHadEtPHOSAcceptanceTPC() <<", "
+//       << GetRawEtEMCALAcceptanceTPC() <<"/"
+//       << GetCorrectedHadEtEMCALAcceptanceTPC() <<endl;
+//   cout<<"Finishing with Raw/Corrected Et w/o PID in full, PHOS, EMCAL acceptance of "
+//       << GetRawEtFullAcceptanceTPCNoPID() <<"/"
+//       << GetCorrectedHadEtFullAcceptanceTPCNoPID() <<", "
+//       << GetRawEtPHOSAcceptanceTPCNoPID() <<"/"
+//       << GetCorrectedHadEtPHOSAcceptanceTPCNoPID() <<", "
+//       << GetRawEtEMCALAcceptanceTPCNoPID() <<"/"
+//       << GetCorrectedHadEtEMCALAcceptanceTPCNoPID() <<endl;
+//   cout<<"Correction factors "
+//       <<fCorrTotEtFullAcceptanceTPC<<", "<<fCorrTotEtFullAcceptanceITS<<", "<<fCorrHadEtFullAcceptanceTPC<<", "<<fCorrHadEtFullAcceptanceITS<<","
+//       <<fCorrTotEtEMCALAcceptanceTPC<<", "<<fCorrTotEtEMCALAcceptanceITS<<", "<<fCorrHadEtEMCALAcceptanceTPC<<", "<<fCorrHadEtEMCALAcceptanceITS<<","
+//       <<fCorrTotEtPHOSAcceptanceTPC<<", "<<fCorrTotEtPHOSAcceptanceITS<<", "<<fCorrHadEtPHOSAcceptanceTPC<<", "<<fCorrHadEtPHOSAcceptanceITS<<endl;
     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) {
+  if(pt>=AliAnalysisHadEt::fgPtTPCCutOff && IsTPC){//TPC tracks
+    //adding to the raw Et
+    //if(InEMCAL) cout<<"Adding "<<rawEt<<" to the raw Et"<<endl;
+    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
+    //if(InPHOS) cout<<"Adding "<<corrEt<<" to the corrected Et"<<endl;
+    fCorrectedHadEtFullAcceptanceTPC += corrEt;
+    if(InPHOS)fCorrectedHadEtPHOSAcceptanceTPC += corrEt;
+    if(InEMCAL)fCorrectedHadEtEMCALAcceptanceTPC += corrEt;
+    fCorrectedHadEtFullAcceptanceTPCNoPID += corrEtNoPID;
+    if(InPHOS)fCorrectedHadEtPHOSAcceptanceTPCNoPID += corrEtNoPID;
+    if(InEMCAL)fCorrectedHadEtEMCALAcceptanceTPCNoPID += corrEtNoPID;
+  }
+  if(pt<AliAnalysisHadEt::fgPtTPCCutOff &&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
+  //cout<<"Eta: |"<<track->Eta()<<"|<"<< fCuts->GetGeometryEmcalEtaAccCut() <<"; phi: "<<fCuts->GetGeometryEmcalPhiAccMinCut()<<"<"<<track->Phi()*180.0/TMath::Pi()<<"<"<<fCuts->GetGeometryEmcalPhiAccMaxCut()<<endl;
+  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.;
@@ -244,23 +345,71 @@ void AliAnalysisHadEtReconstructed::Init()
   if (fConfigFile.Length()) {
     gROOT->LoadMacro(fConfigFile);
     corrections = (AliAnalysisHadEtCorrections *) gInterpreter->ProcessLine("ConfigHadEtAnalysis()");
-    fCorrTotEtFullAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,0.15,"Full");
-    fCorrTotEtFullAcceptanceITS = corrections->GetConstantCorrections(kTRUE,0.1,"Full");
-    fCorrHadEtFullAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,0.15,"Full");
-    fCorrHadEtFullAcceptanceITS = corrections->GetConstantCorrections(kFALSE,0.1,"Full");
-    fCorrTotEtEMCALAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,0.15,"EMCAL");
-    fCorrTotEtEMCALAcceptanceITS = corrections->GetConstantCorrections(kTRUE,0.1,"EMCAL");
-    fCorrHadEtEMCALAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,0.15,"EMCAL");
-    fCorrHadEtEMCALAcceptanceITS = corrections->GetConstantCorrections(kFALSE,0.1,"EMCAL");
-    fCorrTotEtPHOSAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,0.15,"PHOS");
-    fCorrTotEtPHOSAcceptanceITS = corrections->GetConstantCorrections(kTRUE,0.1,"PHOS");
-    fCorrHadEtPHOSAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,0.15,"PHOS");
-    fCorrHadEtPHOSAcceptanceITS = corrections->GetConstantCorrections(kFALSE,0.1,"PHOS");
+    fCorrTotEtFullAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"Full");
+    fCorrTotEtFullAcceptanceITS = corrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"Full");
+    fCorrHadEtFullAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"Full");
+    fCorrHadEtFullAcceptanceITS = corrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"Full");
+    fCorrTotEtEMCALAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"EMCAL");
+    fCorrTotEtEMCALAcceptanceITS = corrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"EMCAL");
+    fCorrHadEtEMCALAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"EMCAL");
+    fCorrHadEtEMCALAcceptanceITS = corrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"EMCAL");
+    fCorrTotEtPHOSAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"PHOS");
+    fCorrTotEtPHOSAcceptanceITS = corrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"PHOS");
+    fCorrHadEtPHOSAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PHOS");
+    fCorrHadEtPHOSAcceptanceITS = corrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PHOS");
 
   }
 }
 
+void AliAnalysisHadEtReconstructed::ResetEventValues(){
+  AliAnalysisHadEt::ResetEventValues();
+     fCorrectedHadEtFullAcceptanceTPCNoPID=0.0;
+     fCorrectedHadEtFullAcceptanceITSNoPID=0.0;
+     fCorrectedHadEtEMCALAcceptanceTPCNoPID=0.0;
+     fCorrectedHadEtEMCALAcceptanceITSNoPID=0.0;
+     fCorrectedHadEtPHOSAcceptanceTPCNoPID=0.0;
+     fCorrectedHadEtPHOSAcceptanceITSNoPID=0.0;
+     fCorrectedHadEtFullAcceptanceTPC=0.0;
+     fCorrectedHadEtFullAcceptanceITS=0.0;
+     fCorrectedHadEtEMCALAcceptanceTPC=0.0;
+     fCorrectedHadEtEMCALAcceptanceITS=0.0;
+     fCorrectedHadEtPHOSAcceptanceTPC=0.0;
+     fCorrectedHadEtPHOSAcceptanceITS=0.0;
+     fRawEtFullAcceptanceTPC=0.0;
+     fRawEtFullAcceptanceITS=0.0;
+     fRawEtEMCALAcceptanceTPC=0.0;
+     fRawEtEMCALAcceptanceITS=0.0;
+     fRawEtPHOSAcceptanceTPC=0.0;
+     fRawEtPHOSAcceptanceITS=0.0;
+     fRawEtFullAcceptanceTPCNoPID=0.0;
+     fRawEtFullAcceptanceITSNoPID=0.0;
+     fRawEtEMCALAcceptanceTPCNoPID=0.0;
+     fRawEtEMCALAcceptanceITSNoPID=0.0;
+     fRawEtPHOSAcceptanceTPCNoPID=0.0;
+     fRawEtPHOSAcceptanceITSNoPID=0.0;
+
+     if(TMath::Abs(fCorrTotEtFullAcceptanceTPC)<1e-3){
+       if (fConfigFile.Length()) {
+        cout<<"Rereading corrections file..."<<endl;
+        gROOT->LoadMacro(fConfigFile);
+        corrections = (AliAnalysisHadEtCorrections *) gInterpreter->ProcessLine("ConfigHadEtAnalysis()");
+        fCorrTotEtFullAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"Full");
+        fCorrTotEtFullAcceptanceITS = corrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"Full");
+        fCorrHadEtFullAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"Full");
+        fCorrHadEtFullAcceptanceITS = corrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"Full");
+        fCorrTotEtEMCALAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"EMCAL");
+        fCorrTotEtEMCALAcceptanceITS = corrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"EMCAL");
+        fCorrHadEtEMCALAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"EMCAL");
+        fCorrHadEtEMCALAcceptanceITS = corrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"EMCAL");
+        fCorrTotEtPHOSAcceptanceTPC = corrections->GetConstantCorrections(kTRUE,fgPtTPCCutOff,"PHOS");
+        fCorrTotEtPHOSAcceptanceITS = corrections->GetConstantCorrections(kTRUE,fgPtITSCutOff,"PHOS");
+        fCorrHadEtPHOSAcceptanceTPC = corrections->GetConstantCorrections(kFALSE,fgPtTPCCutOff,"PHOS");
+        fCorrHadEtPHOSAcceptanceITS = corrections->GetConstantCorrections(kFALSE,fgPtITSCutOff,"PHOS");
+       }
+       else{cerr<<"Uh-oh!  Unable to open configuration file!"<<endl;}
+     }
 
+}
 void AliAnalysisHadEtReconstructed::CreateHistograms(){
 
   TString *strTPC = new TString("TPC");
index a9dc380..b553b56 100644 (file)
@@ -14,6 +14,7 @@
 class AliVParticle;
 class AliAnalysisHadEtCorrections;
 class TString;
+class AliESDtrack;
 
 class AliAnalysisHadEtReconstructed : public AliAnalysisHadEt
 {
@@ -26,35 +27,93 @@ public:
     virtual void SetConfigFile(const char *c) {fConfigFile = c;}
     virtual Int_t AnalyseEvent(AliVEvent* event);
 
+    //the "Corrected" variables are only corrected for the track-by-track corrections
+    Float_t GetCorrectedHadEtFullAcceptanceTPC(){return fCorrHadEtFullAcceptanceTPC*fCorrectedHadEtFullAcceptanceTPC;}
+    Float_t GetCorrectedHadEtFullAcceptanceITS(){return fCorrHadEtFullAcceptanceITS*(fCorrectedHadEtFullAcceptanceTPC+fCorrectedHadEtFullAcceptanceITS);}
+    Float_t GetCorrectedHadEtEMCALAcceptanceTPC(){return fCorrHadEtEMCALAcceptanceTPC*fCorrectedHadEtEMCALAcceptanceTPC;}
+    Float_t GetCorrectedHadEtEMCALAcceptanceITS(){return fCorrHadEtEMCALAcceptanceITS*(fCorrectedHadEtEMCALAcceptanceTPC+fCorrectedHadEtEMCALAcceptanceITS);}
+    Float_t GetCorrectedHadEtPHOSAcceptanceTPC(){return fCorrHadEtPHOSAcceptanceTPC*fCorrectedHadEtPHOSAcceptanceTPC;}
+    Float_t GetCorrectedHadEtPHOSAcceptanceITS(){return fCorrHadEtPHOSAcceptanceITS*(fCorrectedHadEtPHOSAcceptanceTPC+fCorrectedHadEtPHOSAcceptanceITS);}
+    Float_t GetCorrectedTotEtFullAcceptanceTPC(){return fCorrTotEtFullAcceptanceTPC*fCorrectedHadEtFullAcceptanceTPC;}
+    Float_t GetCorrectedTotEtFullAcceptanceITS(){return fCorrTotEtFullAcceptanceITS*(fCorrectedHadEtFullAcceptanceTPC+fCorrectedHadEtFullAcceptanceITS);}
+    Float_t GetCorrectedTotEtEMCALAcceptanceTPC(){return fCorrTotEtEMCALAcceptanceTPC*fCorrectedHadEtEMCALAcceptanceTPC;}
+    Float_t GetCorrectedTotEtEMCALAcceptanceITS(){return fCorrTotEtEMCALAcceptanceITS*(fCorrectedHadEtEMCALAcceptanceTPC+fCorrectedHadEtEMCALAcceptanceITS);}
+    Float_t GetCorrectedTotEtPHOSAcceptanceTPC(){return fCorrTotEtPHOSAcceptanceTPC*fCorrectedHadEtPHOSAcceptanceTPC;}
+    Float_t GetCorrectedTotEtPHOSAcceptanceITS(){return fCorrTotEtPHOSAcceptanceTPC*(fCorrectedHadEtPHOSAcceptanceTPC+fCorrectedHadEtPHOSAcceptanceITS);}
+    Float_t GetRawEtFullAcceptanceTPC(){return fRawEtFullAcceptanceTPC;}
+    Float_t GetRawEtFullAcceptanceITS(){return fRawEtFullAcceptanceITS+fRawEtFullAcceptanceTPC;}
+    Float_t GetRawEtEMCALAcceptanceTPC(){return fRawEtEMCALAcceptanceTPC;}
+    Float_t GetRawEtEMCALAcceptanceITS(){return fRawEtEMCALAcceptanceITS+fRawEtEMCALAcceptanceTPC;}
+    Float_t GetRawEtPHOSAcceptanceTPC(){return fRawEtPHOSAcceptanceTPC;}
+    Float_t GetRawEtPHOSAcceptanceITS(){return fRawEtPHOSAcceptanceITS+fRawEtPHOSAcceptanceTPC;}
+    Float_t GetCorrectedHadEtFullAcceptanceTPCNoPID(){return fCorrHadEtFullAcceptanceTPC*fCorrectedHadEtFullAcceptanceTPCNoPID;}
+    Float_t GetCorrectedHadEtFullAcceptanceITSNoPID(){return fCorrHadEtFullAcceptanceITS*(fCorrectedHadEtFullAcceptanceTPCNoPID+fCorrectedHadEtFullAcceptanceITSNoPID);}
+    Float_t GetCorrectedHadEtEMCALAcceptanceTPCNoPID(){return fCorrHadEtEMCALAcceptanceTPC*fCorrectedHadEtEMCALAcceptanceTPCNoPID;}
+    Float_t GetCorrectedHadEtEMCALAcceptanceITSNoPID(){return fCorrHadEtEMCALAcceptanceITS*(fCorrectedHadEtEMCALAcceptanceTPCNoPID+fCorrectedHadEtEMCALAcceptanceITSNoPID);}
+    Float_t GetCorrectedHadEtPHOSAcceptanceTPCNoPID(){return fCorrHadEtPHOSAcceptanceTPC*fCorrectedHadEtPHOSAcceptanceTPCNoPID;}
+    Float_t GetCorrectedHadEtPHOSAcceptanceITSNoPID(){return fCorrHadEtPHOSAcceptanceITS*(fCorrectedHadEtPHOSAcceptanceTPCNoPID+fCorrectedHadEtPHOSAcceptanceITSNoPID);}
+    Float_t GetCorrectedTotEtFullAcceptanceTPCNoPID(){return fCorrTotEtFullAcceptanceTPC*fCorrectedHadEtFullAcceptanceTPCNoPID;}
+    Float_t GetCorrectedTotEtFullAcceptanceITSNoPID(){return fCorrTotEtFullAcceptanceITS*(fCorrectedHadEtFullAcceptanceTPCNoPID+fCorrectedHadEtFullAcceptanceITSNoPID);}
+    Float_t GetCorrectedTotEtEMCALAcceptanceTPCNoPID(){return fCorrTotEtEMCALAcceptanceTPC*fCorrectedHadEtEMCALAcceptanceTPCNoPID;}
+    Float_t GetCorrectedTotEtEMCALAcceptanceITSNoPID(){return fCorrTotEtEMCALAcceptanceITS*(fCorrectedHadEtEMCALAcceptanceTPCNoPID+fCorrectedHadEtEMCALAcceptanceITSNoPID);}
+    Float_t GetCorrectedTotEtPHOSAcceptanceTPCNoPID(){return fCorrTotEtPHOSAcceptanceTPC*fCorrectedHadEtPHOSAcceptanceTPCNoPID;}
+    Float_t GetCorrectedTotEtPHOSAcceptanceITSNoPID(){return fCorrTotEtPHOSAcceptanceITS*(fCorrectedHadEtPHOSAcceptanceTPCNoPID+fCorrectedHadEtPHOSAcceptanceITSNoPID);}
+    Float_t GetRawEtFullAcceptanceTPCNoPID(){return fRawEtFullAcceptanceTPCNoPID;}
+    Float_t GetRawEtFullAcceptanceITSNoPID(){return fRawEtFullAcceptanceITSNoPID+fRawEtFullAcceptanceTPCNoPID;}
+    Float_t GetRawEtEMCALAcceptanceTPCNoPID(){return fRawEtEMCALAcceptanceTPCNoPID;}
+    Float_t GetRawEtEMCALAcceptanceITSNoPID(){return fRawEtEMCALAcceptanceITSNoPID+fRawEtEMCALAcceptanceTPCNoPID;}
+    Float_t GetRawEtPHOSAcceptanceTPCNoPID(){return fRawEtPHOSAcceptanceTPCNoPID;}
+    Float_t GetRawEtPHOSAcceptanceITSNoPID(){return fRawEtPHOSAcceptanceITSNoPID+fRawEtPHOSAcceptanceTPCNoPID;}
+
     void CreateHistograms();
     virtual void Init();
     
 protected:
 
-    bool CheckGoodVertex(AliVParticle *track);
+    Bool_t CheckGoodVertex(AliVParticle *track);
     AliAnalysisHadEtCorrections *corrections;
 
     TString       fConfigFile;        // the name of the ConfigFile
     //virtual bool TrackHitsCalorimeter(AliVParticle *track, Double_t magField) = 0;
 
-    Float_t fCorrTotEtFullAcceptanceTPC;
-    Float_t fCorrTotEtFullAcceptanceITS;
-    Float_t fCorrHadEtFullAcceptanceTPC;
-    Float_t fCorrHadEtFullAcceptanceITS;
-    Float_t fCorrTotEtEMCALAcceptanceTPC;
-    Float_t fCorrTotEtEMCALAcceptanceITS;
-    Float_t fCorrHadEtEMCALAcceptanceTPC;
-    Float_t fCorrHadEtEMCALAcceptanceITS;
-    Float_t fCorrTotEtPHOSAcceptanceTPC;
-    Float_t fCorrTotEtPHOSAcceptanceITS;
-    Float_t fCorrHadEtPHOSAcceptanceTPC;
-    Float_t fCorrHadEtPHOSAcceptanceITS;
-    Float_t fRawEtFullAcceptanceTPC;
-    Float_t fRawEtFullAcceptanceITS;
-    Float_t fRawEtEMCALAcceptanceTPC;
-    Float_t fRawEtEMCALAcceptanceITS;
-    Float_t fRawEtPHOSAcceptanceTPC;
-    Float_t fRawEtPHOSAcceptanceITS;
+    //correction factors
+    Float_t fCorrTotEtFullAcceptanceTPC;//get the correction for total et for full acceptance, pt>0.15 GeV/c
+    Float_t fCorrTotEtFullAcceptanceITS;//get the correction for total et for full acceptance, pt>0.10 GeV/c
+    Float_t fCorrHadEtFullAcceptanceTPC;//get the correction for hadronic et for full acceptance, pt>0.15 GeV/c
+    Float_t fCorrHadEtFullAcceptanceITS;//get the correction for hadronic et for full acceptance, pt>0.10 GeV/c
+    Float_t fCorrTotEtEMCALAcceptanceTPC;//analogous to above for EMCal acceptance
+    Float_t fCorrTotEtEMCALAcceptanceITS;//analogous to above for EMCal acceptance
+    Float_t fCorrHadEtEMCALAcceptanceTPC;//analogous to above for EMCal acceptance
+    Float_t fCorrHadEtEMCALAcceptanceITS;//analogous to above for EMCal acceptance
+    Float_t fCorrTotEtPHOSAcceptanceTPC;//analogous to above for PHOS acceptance
+    Float_t fCorrTotEtPHOSAcceptanceITS;//analogous to above for PHOS acceptance
+    Float_t fCorrHadEtPHOSAcceptanceTPC;//analogous to above for PHOS acceptance
+    Float_t fCorrHadEtPHOSAcceptanceITS;//analogous to above for PHOS acceptance
+    //Et with various parameters...
+    Float_t fCorrectedHadEtFullAcceptanceTPCNoPID;//get the corrected hadronic et for full acceptance, pt>0.15 GeV/c
+    Float_t fCorrectedHadEtFullAcceptanceITSNoPID;//get the corrected hadronic et for full acceptance, pt>0.10 GeV/c
+    Float_t fCorrectedHadEtEMCALAcceptanceTPCNoPID;//analogous to above for EMCal acceptance
+    Float_t fCorrectedHadEtEMCALAcceptanceITSNoPID;//analogous to above for EMCal acceptance
+    Float_t fCorrectedHadEtPHOSAcceptanceTPCNoPID;//analogous to above for PHOS acceptance
+    Float_t fCorrectedHadEtPHOSAcceptanceITSNoPID;//analogous to above for PHOS acceptance
+    Float_t fCorrectedHadEtFullAcceptanceTPC;//get the corrected hadronic et for full acceptance, pt>0.15 GeV/c
+    Float_t fCorrectedHadEtFullAcceptanceITS;//get the corrected hadronic et for full acceptance, pt>0.10 GeV/c
+    Float_t fCorrectedHadEtEMCALAcceptanceTPC;//analogous to above for EMCal acceptance
+    Float_t fCorrectedHadEtEMCALAcceptanceITS;//analogous to above for EMCal acceptance
+    Float_t fCorrectedHadEtPHOSAcceptanceTPC;//analogous to above for PHOS acceptance
+    Float_t fCorrectedHadEtPHOSAcceptanceITS;//analogous to above for PHOS acceptance
+    Float_t fRawEtFullAcceptanceTPC;//uncorrected Et for full acceptance, pT > 0.15 GeV/c
+    Float_t fRawEtFullAcceptanceITS;//uncorrected Et for full acceptance, pT > 0.10 GeV/c
+    Float_t fRawEtEMCALAcceptanceTPC;//uncorrected Et for EMCal acceptance, pT > 0.15 GeV/c
+    Float_t fRawEtEMCALAcceptanceITS;//uncorrected Et for EMCal acceptance, pT > 0.10 GeV/c
+    Float_t fRawEtPHOSAcceptanceTPC;//uncorrected Et for PHOS acceptance, pT > 0.15 GeV/c
+    Float_t fRawEtPHOSAcceptanceITS;//uncorrected Et for PHOS acceptance, pT > 0.10 GeV/c
+    Float_t fRawEtFullAcceptanceTPCNoPID;//uncorrected Et for full acceptance, pT > 0.15 GeV/c
+    Float_t fRawEtFullAcceptanceITSNoPID;//uncorrected Et for full acceptance, pT > 0.10 GeV/c
+    Float_t fRawEtEMCALAcceptanceTPCNoPID;//uncorrected Et for EMCal acceptance, pT > 0.15 GeV/c
+    Float_t fRawEtEMCALAcceptanceITSNoPID;//uncorrected Et for EMCal acceptance, pT > 0.10 GeV/c
+    Float_t fRawEtPHOSAcceptanceTPCNoPID;//uncorrected Et for PHOS acceptance, pT > 0.15 GeV/c
+    Float_t fRawEtPHOSAcceptanceITSNoPID;//uncorrected Et for PHOS acceptance, pT > 0.10 GeV/c
 
 
  private:
@@ -62,7 +121,11 @@ protected:
     AliAnalysisHadEtReconstructed & operator = (const AliAnalysisHadEtReconstructed & g) ;//cpy assignment
     AliAnalysisHadEtReconstructed(const AliAnalysisHadEtReconstructed & g) ; // cpy ctor
 
+    void 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);
+    Bool_t IsInPHOS(AliESDtrack *track);
+    Bool_t IsInEMCAL(AliESDtrack *track);
 
+    void ResetEventValues();
     ClassDef(AliAnalysisHadEtReconstructed, 1);
 };
 
index 94a3377..d05701b 100644 (file)
@@ -112,6 +112,32 @@ AliMCEvent* mcEvent = MCEvent();
 if (mcEvent)
   {
     ((AliAnalysisHadEtMonteCarlo*)fMCAnalysis)->AnalyseEvent((AliVEvent*)mcEvent,(AliVEvent*)event);
+    //cout<<"Simulated Hadronic Et "<<fMCAnalysis->GetSimulatedHadronicEt()<<" Reconstructed Hadronic Et "<<fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS()<<endl;
+    //cout<<"Simulated Total Et "<<fMCAnalysis->GetSimulatedTotalEt()<<" Reconstructed Total Et "<<fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS()<<endl;
+    fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPC() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITS() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPC() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITS() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPCNoPID() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITSNoPID() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPCNoPID() );
+    fMCAnalysis->FillSimTotEtVsRecoTotEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITSNoPID() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPC() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITS() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPC() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITS() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPCNoPID() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITSNoPID() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPCNoPID() );
+    fMCAnalysis->FillSimHadEtVsRecoHadEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITSNoPID() );
   }
 
 // Post output data.