[u/mrichter/AliRoot.git] / PWG4 / totEt / AliAnalysisTaskHadEt.cxx

//_________________________________________________________________________
//  Utility Class for transverse energy studies; charged hadrons
//  Task for analysis
//  - reconstruction and MC output
// implementation file
//
//Created by Christine Nattrass, Rebecca Scott, Irakli Martashvili
//University of Tennessee at Knoxville
//_________________________________________________________________________
//Necessary to read config macros
#include <TROOT.h>
#include <TSystem.h>
#include <TInterpreter.h>

#include "TChain.h"
#include "TList.h"
#include "TH2F.h"

#include "AliESDEvent.h"
#include "AliMCEvent.h"
#include "AliESDtrackCuts.h"

#include "AliAnalysisTaskHadEt.h"
#include "AliAnalysisHadEtReconstructed.h"
#include "AliAnalysisHadEtMonteCarlo.h"

#include <iostream>

using namespace std;

ClassImp(AliAnalysisTaskHadEt)


//________________________________________________________________________
  AliAnalysisTaskHadEt::AliAnalysisTaskHadEt(const char *name, Bool_t isMc, TString recoConfigFile, TString mcConfigFile) :
        AliAnalysisTaskTransverseEnergy(name, isMc)
	,fRecAnalysis(0)
	,fMCAnalysis(0)
	,fIsSim(isMc)
{
    // Constructor
  fMCConfigFile = mcConfigFile;
  fRecoConfigFile = recoConfigFile;

  if(fMCAnalysis) delete fMCAnalysis;
  if(fRecAnalysis) delete fRecAnalysis;

  if (fRecoConfigFile.Length()) {
    cout<<"Rereading AliAnalysisHadEtReconstructed configuration file "<<fRecoConfigFile<<endl;
    gROOT->LoadMacro(fRecoConfigFile);
    fRecAnalysis = (AliAnalysisHadEtReconstructed *) gInterpreter->ProcessLine("ConfigHadEtReconstructed()");
  }

  if (fMCConfigFile.Length()) {
    cout<<"Rereading AliAnalysisHadEtMonteCarlo configuration file "<<fMCConfigFile<<endl;
    gROOT->LoadMacro(fMCConfigFile);
    fMCAnalysis = (AliAnalysisHadEtMonteCarlo *) gInterpreter->ProcessLine("ConfigHadEtMonteCarlo()");
    fMCAnalysis->SetHadEtReconstructed(fRecAnalysis);
  }

    // Define input and output slots here
    // Input slot #0 works with a TChain
    DefineInput(0, TChain::Class());
    // Output slot #1 writes into a TH1 container

    DefineOutput(1, TList::Class());
}
AliAnalysisTaskHadEt::~AliAnalysisTaskHadEt(){//Destructor
  delete fRecAnalysis;
  delete fMCAnalysis;
}


//________________________________________________________________________
void AliAnalysisTaskHadEt::UserCreateOutputObjects()
{
    // Create histograms

    // Called once


  fOutputList = new TList;
  fOutputList->SetOwner();
  fMCAnalysis->SetHistoList(fOutputList);
  fRecAnalysis->SetHistoList(fOutputList);
  if(fIsSim) fMCAnalysis->CreateHistograms();
  fRecAnalysis->CreateHistograms();


  if(fRecAnalysis->DataSet() != fMCAnalysis->DataSet()){
    cout<<"Warning: Reconstruction data set and Monte Carlo data set are not the same!  Setting data set to "<<fRecAnalysis->DataSet()<<endl;
  }

  Bool_t selectPrimaries=kTRUE;
  if(fEsdtrackCutsITSTPC) delete fEsdtrackCutsITSTPC;
  if(fEsdtrackCutsITS) delete fEsdtrackCutsITS;
  if(fEsdtrackCutsTPC) delete fEsdtrackCutsTPC;
  //We do not use these because we are using the 2010 900 GeV data
//   if(fRecAnalysis->DataSet()==2009){
//     cout<<"Setting track cuts for the 2009 p+p collisions at 900 GeV"<<endl;
//     fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selectPrimaries);
//     fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
//     fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
//     fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
//     //ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
//     fEsdtrackCutsITS =  AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
//     fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
//   }
  if(fRecAnalysis->DataSet()==2010 || fRecAnalysis->DataSet()==20111||fRecAnalysis->DataSet()==2009){
    if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
    else{cout<<"Setting track cuts for the 2011 p+p collisions at 2.76 TeV"<<endl;}
    //cout<<"Warning:  Have not set 2010 track cuts yet!!"<<endl;
    fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
    fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
    fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
    fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
    //ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
    fEsdtrackCutsITS =  AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
    fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
  }
  if(fRecAnalysis->DataSet()==20100){
    cout<<"Setting track cuts for the 2010 Pb+Pb collisions at 2.76 TeV"<<endl;
    //cout<<"Warning:  Have not set 2010 track cuts yet!!"<<endl;
    fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
    fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
    fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
    fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
    //ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
    fEsdtrackCutsITS =  AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
    // fEsdtrackCutsITS =  AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
   fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
  }

  fOutputList->Add(fEsdtrackCutsITSTPC);
  fOutputList->Add(fEsdtrackCutsTPC);
  fOutputList->Add(fEsdtrackCutsITS);
  if(fEsdtrackCutsITSTPC && fEsdtrackCutsTPC){
    fRecAnalysis->SetITSTrackCuts( GetITSTrackCuts());
    fMCAnalysis->SetITSTrackCuts( GetITSTrackCuts());
    fRecAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
    fMCAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
    fRecAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
    fMCAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
    //add ITS stuff!
  }
  else{
    Printf("Error: no track cuts!");
  }
}

//________________________________________________________________________
void AliAnalysisTaskHadEt::UserExec(Option_t *)
{ // execute method
  fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
if (!fESDEvent) {
  Printf("ERROR: Could not retrieve event");
  return;
 }
//cout<<"AliAnalysisHadEtReconstructed 90"<<endl;

Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber()); // Check if the physics selection is valid for this run

AliCentrality *cent = GetCentralityObject();

if(res == 0 && cent){
  
  //cout<<"New Event"<<endl;  

  fRecAnalysis->AnalyseEvent(fESDEvent);

  AliMCEvent* mcEvent = MCEvent();
// if (!mcEvent) {
//   Printf("ERROR: Could not retrieve MC event");
//  }
  if (mcEvent && fESDEvent && fIsSim){
      ((AliAnalysisHadEtMonteCarlo*)fMCAnalysis)->AnalyseEvent((AliVEvent*)mcEvent,(AliVEvent*)fESDEvent);
      if(fMCAnalysis->Full()){
	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );
      }
      if(fMCAnalysis->EMCAL()){
	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPC() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITS() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITSNoPID() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPC() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITS() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITSNoPID() );
      }
      if(fMCAnalysis->PHOS()){
	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPC() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITS() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITSNoPID() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPC() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITS() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITSNoPID() );
      }
      if(fMCAnalysis->PiKP() && fMCAnalysis->Full()){
	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPC(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPC());
	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITS(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITS());
	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPCNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPCNoPID());
	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITSNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITSNoPID());
      }
    }
  }
//cout<<"End Event"<<endl<<endl;
// Post output data.
PostData(1, fOutputList);
}

//________________________________________________________________________
void AliAnalysisTaskHadEt::Terminate(Option_t *)
{
    // Draw result to the screen
    // Called once at the end of the query

    fOutputList = dynamic_cast<TList*> (GetOutputData(1));
    if (!fOutputList) {
        printf("ERROR: Output list not available\n");
        return;
    }
}
Commit	Line	Data
cf6522d1	1	//_________________________________________________________________________
	2	// Utility Class for transverse energy studies; charged hadrons
	3	// Task for analysis
	4	// - reconstruction and MC output
	5	// implementation file
	6	//
	7	//Created by Christine Nattrass, Rebecca Scott, Irakli Martashvili
641e1e0c	8	//University of Tennessee at Knoxville
cf6522d1	9	//_________________________________________________________________________
7d2d1773	10	//Necessary to read config macros
	11	#include <TROOT.h>
	12	#include <TSystem.h>
	13	#include <TInterpreter.h>
cf6522d1	14
641e1e0c	15	#include "TChain.h"
cf6522d1	16	#include "TList.h"
641e1e0c	17	#include "TH2F.h"
641e1e0c	18
641e1e0c	19	#include "AliESDEvent.h"
641e1e0c	20	#include "AliMCEvent.h"
cf6522d1	21	#include "AliESDtrackCuts.h"
cf6522d1	22
641e1e0c	23	#include "AliAnalysisTaskHadEt.h"
cf6522d1	24	#include "AliAnalysisHadEtReconstructed.h"
cf6522d1	25	#include "AliAnalysisHadEtMonteCarlo.h"
641e1e0c	26
641e1e0c	27	#include <iostream>
641e1e0c	28
	29	using namespace std;
	30
	31	ClassImp(AliAnalysisTaskHadEt)
	32
	33
	34
	35	//________________________________________________________________________
bccadd89	36	AliAnalysisTaskHadEt::AliAnalysisTaskHadEt(const char *name, Bool_t isMc, TString recoConfigFile, TString mcConfigFile) :
d3d7bfe9	37	AliAnalysisTaskTransverseEnergy(name, isMc)
	38	,fRecAnalysis(0)
	39	,fMCAnalysis(0)
21ce38dd	40	,fIsSim(isMc)
641e1e0c	41	{
641e1e0c	42	// Constructor
bccadd89	43	fMCConfigFile = mcConfigFile;
bccadd89	44	fRecoConfigFile = recoConfigFile;
bccadd89	45
ea331c5d	46	if(fMCAnalysis) delete fMCAnalysis;
	47	if(fRecAnalysis) delete fRecAnalysis;
	48
49b25059	49	if (fRecoConfigFile.Length()) {
bccadd89	50	cout<<"Rereading AliAnalysisHadEtReconstructed configuration file "<<fRecoConfigFile<<endl;
49b25059	51	gROOT->LoadMacro(fRecoConfigFile);
	52	fRecAnalysis = (AliAnalysisHadEtReconstructed *) gInterpreter->ProcessLine("ConfigHadEtReconstructed()");
	53	}
	54
d3d7bfe9	55	if (fMCConfigFile.Length()) {
bccadd89	56	cout<<"Rereading AliAnalysisHadEtMonteCarlo configuration file "<<fMCConfigFile<<endl;
d3d7bfe9	57	gROOT->LoadMacro(fMCConfigFile);
7d2d1773	58	fMCAnalysis = (AliAnalysisHadEtMonteCarlo *) gInterpreter->ProcessLine("ConfigHadEtMonteCarlo()");
49b25059	59	fMCAnalysis->SetHadEtReconstructed(fRecAnalysis);
7d2d1773	60	}
641e1e0c	61
	62	// Define input and output slots here
	63	// Input slot #0 works with a TChain
	64	DefineInput(0, TChain::Class());
	65	// Output slot #1 writes into a TH1 container
	66
	67	DefineOutput(1, TList::Class());
641e1e0c	68	}
464aa50c	69	AliAnalysisTaskHadEt::~AliAnalysisTaskHadEt(){//Destructor
951efd81	70	delete fRecAnalysis;
951efd81	71	delete fMCAnalysis;
951efd81	72	}
641e1e0c	73
	74
	75	//________________________________________________________________________
	76	void AliAnalysisTaskHadEt::UserCreateOutputObjects()
	77	{
	78	// Create histograms
bccadd89	79
641e1e0c	80	// Called once
bccadd89	81
	82
	83
641e1e0c	84	fOutputList = new TList;
951efd81	85	fOutputList->SetOwner();
641e1e0c	86	fMCAnalysis->SetHistoList(fOutputList);
641e1e0c	87	fRecAnalysis->SetHistoList(fOutputList);
21ce38dd	88	if(fIsSim) fMCAnalysis->CreateHistograms();
641e1e0c	89	fRecAnalysis->CreateHistograms();
641e1e0c	90
9845dc2c	91
964c8159	92	if(fRecAnalysis->DataSet() != fMCAnalysis->DataSet()){
	93	cout<<"Warning: Reconstruction data set and Monte Carlo data set are not the same! Setting data set to "<<fRecAnalysis->DataSet()<<endl;
	94	}
641e1e0c	95
964c8159	96	Bool_t selectPrimaries=kTRUE;
ea331c5d	97	if(fEsdtrackCutsITSTPC) delete fEsdtrackCutsITSTPC;
	98	if(fEsdtrackCutsITS) delete fEsdtrackCutsITS;
	99	if(fEsdtrackCutsTPC) delete fEsdtrackCutsTPC;
5c66cc7a	100	//We do not use these because we are using the 2010 900 GeV data
	101	// if(fRecAnalysis->DataSet()==2009){
	102	// cout<<"Setting track cuts for the 2009 p+p collisions at 900 GeV"<<endl;
	103	// fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selectPrimaries);
	104	// fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	105	// fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	106	// fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	107	// //ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	108	// fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	109	// fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	110	// }
	111	if(fRecAnalysis->DataSet()==2010 \|\| fRecAnalysis->DataSet()==20111\|\|fRecAnalysis->DataSet()==2009){
bccadd89	112	if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
bccadd89	113	else{cout<<"Setting track cuts for the 2011 p+p collisions at 2.76 TeV"<<endl;}
4bb44829	114	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
964c8159	115	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	116	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	117	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	118	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	119	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
4bb44829	120	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
964c8159	121	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
964c8159	122	}
49b25059	123	if(fRecAnalysis->DataSet()==20100){
	124	cout<<"Setting track cuts for the 2010 Pb+Pb collisions at 2.76 TeV"<<endl;
	125	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	126	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	127	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	128	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	129	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	130	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	131	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
5c66cc7a	132	// fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
5c66cc7a	133	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
49b25059	134	}
cf6522d1	135
964c8159	136	fOutputList->Add(fEsdtrackCutsITSTPC);
	137	fOutputList->Add(fEsdtrackCutsTPC);
	138	fOutputList->Add(fEsdtrackCutsITS);
	139	if(fEsdtrackCutsITSTPC && fEsdtrackCutsTPC){
	140	fRecAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	141	fMCAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	142	fRecAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	143	fMCAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	144	fRecAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	145	fMCAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	146	//add ITS stuff!
	147	}
	148	else{
	149	Printf("Error: no track cuts!");
	150	}
641e1e0c	151	}
	152
	153	//________________________________________________________________________
	154	void AliAnalysisTaskHadEt::UserExec(Option_t *)
cf6522d1	155	{ // execute method
d3d7bfe9	156	fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
d3d7bfe9	157	if (!fESDEvent) {
641e1e0c	158	Printf("ERROR: Could not retrieve event");
	159	return;
	160	}
7d2d1773	161	//cout<<"AliAnalysisHadEtReconstructed 90"<<endl;
7d2d1773	162
d3d7bfe9	163	Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber()); // Check if the physics selection is valid for this run
d3d7bfe9	164
b6dd6ad2	165	AliCentrality *cent = GetCentralityObject();
641e1e0c	166
d3d7bfe9	167	if(res == 0 && cent){
d3d7bfe9	168
49b25059	169	//cout<<"New Event"<<endl;
49b25059	170
d3d7bfe9	171	fRecAnalysis->AnalyseEvent(fESDEvent);
	172
	173	AliMCEvent* mcEvent = MCEvent();
7d2d1773	174	// if (!mcEvent) {
	175	// Printf("ERROR: Could not retrieve MC event");
	176	// }
21ce38dd	177	if (mcEvent && fESDEvent && fIsSim){
d3d7bfe9	178	((AliAnalysisHadEtMonteCarlo)fMCAnalysis)->AnalyseEvent((AliVEvent)mcEvent,(AliVEvent*)fESDEvent);
	179	if(fMCAnalysis->Full()){
	180	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
	181	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
	182	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
	183	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
	184	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
	185	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
	186	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
	187	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );
	188	}
	189	if(fMCAnalysis->EMCAL()){
	190	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPC() );
	191	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITS() );
	192	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPCNoPID() );
	193	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITSNoPID() );
	194	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPC() );
	195	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITS() );
	196	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPCNoPID() );
	197	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITSNoPID() );
	198	}
	199	if(fMCAnalysis->PHOS()){
	200	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPC() );
	201	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITS() );
	202	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPCNoPID() );
	203	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITSNoPID() );
	204	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPC() );
	205	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITS() );
	206	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPCNoPID() );
	207	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITSNoPID() );
	208	}
	209	if(fMCAnalysis->PiKP() && fMCAnalysis->Full()){
	210	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPC(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPC());
	211	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITS(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITS());
	212	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPCNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPCNoPID());
	213	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITSNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITSNoPID());
	214	}
7d2d1773	215	}
641e1e0c	216	}
49b25059	217	//cout<<"End Event"<<endl<<endl;
641e1e0c	218	// Post output data.
641e1e0c	219	PostData(1, fOutputList);
641e1e0c	220	}
	221
	222	//________________________________________________________________________
	223	void AliAnalysisTaskHadEt::Terminate(Option_t *)
	224	{
	225	// Draw result to the screen
	226	// Called once at the end of the query
	227
	228	fOutputList = dynamic_cast<TList*> (GetOutputData(1));
	229	if (!fOutputList) {
	230	printf("ERROR: Output list not available\n");
	231	return;
	232	}
	233	}
	234
	235