[u/mrichter/AliRoot.git] / PWGLF / totEt / AliAnalysisTaskTotEt.cxx

//_________________________________________________________________________
//  Utility Class for transverse energy studies
//  Task for analysis
//  - reconstruction and MC output
// implementation file
//
//*-- Authors: Oystein Djuvsland (Bergen), David Silvermyr (ORNL)
	       //_________________________________________________________________________
	       //Necessary to read config macros
#include <TROOT.h>
#include <TSystem.h>
#include <TInterpreter.h>

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

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

#include "AliAnalysisTaskTotEt.h"
#include "AliAnalysisEtReconstructedPhos.h"
#include "AliAnalysisEtReconstructedEmcal.h"
#include "AliAnalysisEtMonteCarloPhos.h"
#include "AliAnalysisEtMonteCarloEmcal.h"
#include "AliAnalysisEmEtMonteCarlo.h"
#include "AliAnalysisEmEtReconstructed.h"
#include "AliAnalysisManager.h"
#include "AliPIDResponse.h"
#include "AliTPCPIDResponse.h"
#include "AliInputEventHandler.h"

#include <iostream>
#include <AliCentrality.h>

  using namespace std;

ClassImp(AliAnalysisTaskTotEt)

//________________________________________________________________________
  AliAnalysisTaskTotEt::AliAnalysisTaskTotEt(const char *name, Bool_t isMc) :
    AliAnalysisTaskTransverseEnergy(name, isMc)
    ,fPIDResponse(0)
    ,fRecAnalysis(0)
    ,fMCAnalysis(0)
					    // ,fSparseHistRecVsMc(0)
					    //,fSparseRecVsMc(0)
{
  // Constructor
  // select if we should use EMCal or PHOS class
  // PHOS by default, EMCal if name string contains EMC
  TString t(name);
  gROOT->LoadMacro(fMCConfigFile);
  gROOT->LoadMacro(fRecoConfigFile);
  //There is a weird problem where the name reverts to a default using the plugin
  //these lines solve it - there is a function written into ConfigEtMonteCarlo.C which solves this
  Bool_t isEMCal = t.Contains("EMC");
  if (!(t.Contains("EMC")) && !(t.Contains("PHOS"))) {//the name does not contain either EMCal or PHOS
    cout<<"Default arguments called.  Reading config file."<<endl;
      isEMCal = (Bool_t) gInterpreter->ProcessLine("GetIsEMCAL()");
      isMc =  (Bool_t) gInterpreter->ProcessLine("GetIsMC()");

  }
  //cout<<__FILE__<<" My name is "<<name<<endl;
  //t.ToUpper();
  if (isEMCal) {
    if (t.Contains("Detail")) {

      cout<<"Rereading AliAnalysisEtMonteCarlo configuration file..."<<endl;
      fMCAnalysis = (AliAnalysisEmEtMonteCarlo *) gInterpreter->ProcessLine("ConfigEtMonteCarlo(true,true)");
			
      cout << "Instantiating AliAnalysisEmEtMonteCarlo class..."<< endl;
    }
    else if (fMCConfigFile.Length()) {
      cout<<"Rereading AliAnalysisEtMonteCarloEmcal configuration file..."<<endl;
      fMCAnalysis = (AliAnalysisEtMonteCarloEmcal *) gInterpreter->ProcessLine("ConfigEtMonteCarlo()");
    }
		
    if (t.Contains("Detail")) {
      cout<<"Rereading AliAnalysisEmEtReconstructed configuration file..."<<endl;
      fRecAnalysis = (AliAnalysisEmEtReconstructed *) gInterpreter->ProcessLine("ConfigEtReconstructed(true,true)");

    }
    else if (fRecoConfigFile.Length()) {
      cout<<"Rereading AliAnalysisEtReconstructedEmcal configuration file..."<<endl;
      fRecAnalysis = (AliAnalysisEtReconstructedEmcal *) gInterpreter->ProcessLine("ConfigEtReconstructed()");
    }
  }
  else {
    if (fMCConfigFile.Length()) {
      cout<<"Rereading AliAnalysisEtMonteCarloPhos configuration file..."<<endl;
			
      fMCAnalysis = (AliAnalysisEtMonteCarloPhos *) gInterpreter->ProcessLine("ConfigEtMonteCarlo(false)");
      cout << fMCAnalysis << endl;
    }
		
    if (fRecoConfigFile.Length()) {
      cout<<"Rereading AliAnalysisEtReconstructedPhos configuration file..."<<endl;
      fRecAnalysis = (AliAnalysisEtReconstructedPhos *) gInterpreter->ProcessLine("ConfigEtReconstructed(false)");
    }
  }
  // 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());
	
}
AliAnalysisTaskTotEt::~AliAnalysisTaskTotEt() {//Destructor
  //    fOutputList->Clear();
  delete fRecAnalysis;
  delete fMCAnalysis;
  delete fPIDResponse;
  //delete fSparseHistRecVsMc;
  //delete fSparseRecVsMc;
}

//________________________________________________________________________
void AliAnalysisTaskTotEt::UserCreateOutputObjects()
{
  //input hander
  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
  if (!man) {
    AliFatal("Analysis manager needed");
    return;
  }

  AliInputEventHandler *inputHandler=dynamic_cast<AliInputEventHandler*>(man->GetInputEventHandler());
  if (!inputHandler) {
    AliFatal("Input handler needed");
    return;
  }

  //pid response object
  fPIDResponse=inputHandler->GetPIDResponse();
  if (!fPIDResponse) AliError("PIDResponse object was not created");

  // Create histograms
  // Called once
  if (fMCAnalysis)
    fMCAnalysis->CreateHistograms();
  fRecAnalysis->CreateHistograms();
  fOutputList = new TList;
  fOutputList->SetOwner();
  fRecAnalysis->FillOutputList(fOutputList);
  if (fMCAnalysis)
    fMCAnalysis->FillOutputList(fOutputList);
  fHistEtRecvsEtMC = new TH2F("fHistEtRecvsEtMC", "Reconstructed E_{T} vs MC E_{T}", 1000, 0.000, 100, 1000, 0.0001, 100);
  fHistEtRecOverEtMC = new TH2F("fHistEtRecOverEtMC", "Reconstructed E_{T} over MC E_{T} vs centrality", 1000, 0.00, 2.0, 11, -0.5, 10.5); 
  fHistDiffEtRecEtMCOverEtMC = new TH2F("fHistDiffEtRecEtMCOverEtMC", "fHistDiffEtRecEtMCOverEtMC", 10000, 0.0, 1000, 1000, -5, 5); 
  fOutputList->Add(fHistEtRecvsEtMC);
  fOutputList->Add(fHistEtRecOverEtMC);
  fOutputList->Add(fHistDiffEtRecEtMCOverEtMC);

  Bool_t selectPrimaries=kTRUE;
  if(fRecAnalysis->DataSet()==2010 || fRecAnalysis->DataSet()==20111||fRecAnalysis->DataSet()==2009 || fRecAnalysis->DataSet()==2012 || fRecAnalysis->DataSet()==2013){
    if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
    else{
      if(fRecAnalysis->DataSet()==2012)cout<<"Setting track cuts for the 2012 p+p collisions at 8 TeV"<<endl;
      else{
	if(fRecAnalysis->DataSet()==2013)cout<<"Setting track cuts for the 2013 p+Pb collisions at 5 TeV"<<endl;
	else{
	  if(fRecAnalysis->DataSet()==2009){cout<<"Setting track cuts for the 2010 p+p collisions at 900 GeV"<<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 || fRecAnalysis->DataSet()==2011){
    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");
  }
  if(fRecAnalysis->DataSet()==2011){
    cout<<"Using 2011 acceptance"<<endl;
    if(fMCAnalysis) fMCAnalysis->ResetEventValues();//actually remakes AliAnalysisEtCuts if AliAnalysisEtCuts doesn't exist
    fRecAnalysis->ResetEventValues();
    if(fMCAnalysis && fMCAnalysis->GetCuts()){
      fMCAnalysis->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
      fMCAnalysis->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
      fMCAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
      fMCAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
    }
    else{if(fMCAnalysis)cerr<<"Error!  MC fCuts does not exist!"<<endl;}
    if(fRecAnalysis->GetCuts()){
      fRecAnalysis->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
      fRecAnalysis->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
      fRecAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
      fRecAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
    }
    else{cerr<<"Error!  Reco fCuts does not exist!"<<endl;}
  }

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

}

//________________________________________________________________________
void AliAnalysisTaskTotEt::UserExec(Option_t *)
{ // execute method
	
  fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
  if (!fESDEvent)
    {
      Printf("ERROR: Could not retrieve event");
      return;
    }
	
  //Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber());
	
  AliCentrality *cent = GetCentralityObject();
	
  //if (res == 0 && cent)
  //{
  fRecAnalysis->SetCentralityObject(cent);
  fRecAnalysis->AnalyseEvent(fESDEvent);
		
  AliMCEvent* mcEvent = MCEvent();
  if (mcEvent)
    {
      fMCAnalysis->SetCentralityObject(cent);
      fMCAnalysis->AnalyseEvent(mcEvent, fESDEvent);
      //fMCAnalysis->AnalyseEvent(mcEvent);
    }
  if(fMCAnalysis)
    {
      //set the number of tracks matched and the total number of hadrons calculated from the number of tracks matched so we can use them for calculating corrections
      fMCAnalysis->SetNumberOfChargedHadronsMatched(fRecAnalysis->GetNumberOfChargedHadronsMatched());
      fMCAnalysis->SetTotalNumberOfChargedHadrons(fRecAnalysis->GetTotalNumberOfChargedHadrons());
      fHistEtRecvsEtMC->Fill(fRecAnalysis->GetTotNeutralEt(), fMCAnalysis->GetTotNeutralEt());
      if(fMCAnalysis->GetTotNeutralEt()) fHistEtRecOverEtMC->Fill(fRecAnalysis->GetTotNeutralEt()/fMCAnalysis->GetTotNeutralEt(), cent->GetCentralityClass10("V0M"));
      if(fMCAnalysis->GetTotNeutralEt()) fHistDiffEtRecEtMCOverEtMC->Fill(fMCAnalysis->GetTotNeutralEt(), (fRecAnalysis->GetTotNeutralEt()-fMCAnalysis->GetTotNeutralEt())/fMCAnalysis->GetTotNeutralEt());
    }
  //}
  // Post output data.
  PostData(1, fOutputList);
}

//________________________________________________________________________
void AliAnalysisTaskTotEt::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
	3	// Task for analysis
	4	// - reconstruction and MC output
	5	// implementation file
	6	//
	7	//*-- Authors: Oystein Djuvsland (Bergen), David Silvermyr (ORNL)
ee1083d5	8	//_________________________________________________________________________
ee1083d5	9	//Necessary to read config macros
964c8159	10	#include <TROOT.h>
	11	#include <TSystem.h>
	12	#include <TInterpreter.h>
cf6522d1	13
2fbf38ac	14	#include "TChain.h"
cf6522d1	15	#include "TList.h"
1815c8d7	16	#include "TFile.h"
2fbf38ac	17	#include "TH2F.h"
a403aff5	18	#include "THnSparse.h"
2fbf38ac	19
2fbf38ac	20	#include "AliESDEvent.h"
2fbf38ac	21	#include "AliMCEvent.h"
b5821c13	22	#include "AliESDtrackCuts.h"
cf6522d1	23
2fbf38ac	24	#include "AliAnalysisTaskTotEt.h"
	25	#include "AliAnalysisEtReconstructedPhos.h"
	26	#include "AliAnalysisEtReconstructedEmcal.h"
	27	#include "AliAnalysisEtMonteCarloPhos.h"
	28	#include "AliAnalysisEtMonteCarloEmcal.h"
1815c8d7	29	#include "AliAnalysisEmEtMonteCarlo.h"
1815c8d7	30	#include "AliAnalysisEmEtReconstructed.h"
9a365626	31	#include "AliAnalysisManager.h"
	32	#include "AliPIDResponse.h"
	33	#include "AliTPCPIDResponse.h"
	34	#include "AliInputEventHandler.h"
2fbf38ac	35
2fbf38ac	36	#include <iostream>
a403aff5	37	#include <AliCentrality.h>
2fbf38ac	38
ee1083d5	39	using namespace std;
2fbf38ac	40
	41	ClassImp(AliAnalysisTaskTotEt)
	42
	43	//________________________________________________________________________
ee1083d5	44	AliAnalysisTaskTotEt::AliAnalysisTaskTotEt(const char *name, Bool_t isMc) :
ee1083d5	45	AliAnalysisTaskTransverseEnergy(name, isMc)
9a365626	46	,fPIDResponse(0)
ee1083d5	47	,fRecAnalysis(0)
ee1083d5	48	,fMCAnalysis(0)
01b73fb0	49	// ,fSparseHistRecVsMc(0)
01b73fb0	50	//,fSparseRecVsMc(0)
2fbf38ac	51	{
ee1083d5	52	// Constructor
ee1083d5	53	// select if we should use EMCal or PHOS class
	54	// PHOS by default, EMCal if name string contains EMC
	55	TString t(name);
c31562f7	56	gROOT->LoadMacro(fMCConfigFile);
	57	gROOT->LoadMacro(fRecoConfigFile);
	58	//There is a weird problem where the name reverts to a default using the plugin
	59	//these lines solve it - there is a function written into ConfigEtMonteCarlo.C which solves this
	60	Bool_t isEMCal = t.Contains("EMC");
	61	if (!(t.Contains("EMC")) && !(t.Contains("PHOS"))) {//the name does not contain either EMCal or PHOS
	62	cout<<"Default arguments called. Reading config file."<<endl;
	63	isEMCal = (Bool_t) gInterpreter->ProcessLine("GetIsEMCAL()");
	64	isMc = (Bool_t) gInterpreter->ProcessLine("GetIsMC()");
	65
	66	}
	67	//cout<<__FILE__<<" My name is "<<name<<endl;
ee1083d5	68	//t.ToUpper();
c31562f7	69	if (isEMCal) {
ee1083d5	70	if (t.Contains("Detail")) {
	71
	72	cout<<"Rereading AliAnalysisEtMonteCarlo configuration file..."<<endl;
ee1083d5	73	fMCAnalysis = (AliAnalysisEmEtMonteCarlo *) gInterpreter->ProcessLine("ConfigEtMonteCarlo(true,true)");
1815c8d7	74
ee1083d5	75	cout << "Instantiating AliAnalysisEmEtMonteCarlo class..."<< endl;
	76	}
	77	else if (fMCConfigFile.Length()) {
	78	cout<<"Rereading AliAnalysisEtMonteCarloEmcal configuration file..."<<endl;
ee1083d5	79	fMCAnalysis = (AliAnalysisEtMonteCarloEmcal *) gInterpreter->ProcessLine("ConfigEtMonteCarlo()");
ee1083d5	80	}
1815c8d7	81
ee1083d5	82	if (t.Contains("Detail")) {
ee1083d5	83	cout<<"Rereading AliAnalysisEmEtReconstructed configuration file..."<<endl;
ee1083d5	84	fRecAnalysis = (AliAnalysisEmEtReconstructed *) gInterpreter->ProcessLine("ConfigEtReconstructed(true,true)");
	85
	86	}
	87	else if (fRecoConfigFile.Length()) {
	88	cout<<"Rereading AliAnalysisEtReconstructedEmcal configuration file..."<<endl;
ee1083d5	89	fRecAnalysis = (AliAnalysisEtReconstructedEmcal *) gInterpreter->ProcessLine("ConfigEtReconstructed()");
2fbf38ac	90	}
ee1083d5	91	}
	92	else {
	93	if (fMCConfigFile.Length()) {
	94	cout<<"Rereading AliAnalysisEtMonteCarloPhos configuration file..."<<endl;
1815c8d7	95
ee1083d5	96	fMCAnalysis = (AliAnalysisEtMonteCarloPhos *) gInterpreter->ProcessLine("ConfigEtMonteCarlo(false)");
	97	cout << fMCAnalysis << endl;
	98	}
1815c8d7	99
ee1083d5	100	if (fRecoConfigFile.Length()) {
ee1083d5	101	cout<<"Rereading AliAnalysisEtReconstructedPhos configuration file..."<<endl;
ee1083d5	102	fRecAnalysis = (AliAnalysisEtReconstructedPhos *) gInterpreter->ProcessLine("ConfigEtReconstructed(false)");
2fbf38ac	103	}
ee1083d5	104	}
	105	// Define input and output slots here
	106	// Input slot #0 works with a TChain
	107	DefineInput(0, TChain::Class());
	108	// Output slot #1 writes into a TH1 container
1815c8d7	109
ee1083d5	110	DefineOutput(1, TList::Class());
1815c8d7	111
2fbf38ac	112	}
d3d7bfe9	113	AliAnalysisTaskTotEt::~AliAnalysisTaskTotEt() {//Destructor
ee1083d5	114	// fOutputList->Clear();
	115	delete fRecAnalysis;
	116	delete fMCAnalysis;
9a365626	117	delete fPIDResponse;
01b73fb0	118	//delete fSparseHistRecVsMc;
01b73fb0	119	//delete fSparseRecVsMc;
951efd81	120	}
2fbf38ac	121
	122	//________________________________________________________________________
	123	void AliAnalysisTaskTotEt::UserCreateOutputObjects()
	124	{
9a365626	125	//input hander
9a365626	126	AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
beb92504	127	if (!man) {
	128	AliFatal("Analysis manager needed");
	129	return;
	130	}
	131
9a365626	132	AliInputEventHandler inputHandler=dynamic_cast<AliInputEventHandler>(man->GetInputEventHandler());
beb92504	133	if (!inputHandler) {
	134	AliFatal("Input handler needed");
	135	return;
	136	}
9a365626	137
	138	//pid response object
	139	fPIDResponse=inputHandler->GetPIDResponse();
	140	if (!fPIDResponse) AliError("PIDResponse object was not created");
	141
ee1083d5	142	// Create histograms
	143	// Called once
	144	if (fMCAnalysis)
	145	fMCAnalysis->CreateHistograms();
	146	fRecAnalysis->CreateHistograms();
	147	fOutputList = new TList;
	148	fOutputList->SetOwner();
	149	fRecAnalysis->FillOutputList(fOutputList);
	150	if (fMCAnalysis)
	151	fMCAnalysis->FillOutputList(fOutputList);
	152	fHistEtRecvsEtMC = new TH2F("fHistEtRecvsEtMC", "Reconstructed E_{T} vs MC E_{T}", 1000, 0.000, 100, 1000, 0.0001, 100);
	153	fHistEtRecOverEtMC = new TH2F("fHistEtRecOverEtMC", "Reconstructed E_{T} over MC E_{T} vs centrality", 1000, 0.00, 2.0, 11, -0.5, 10.5);
	154	fHistDiffEtRecEtMCOverEtMC = new TH2F("fHistDiffEtRecEtMCOverEtMC", "fHistDiffEtRecEtMCOverEtMC", 10000, 0.0, 1000, 1000, -5, 5);
	155	fOutputList->Add(fHistEtRecvsEtMC);
	156	fOutputList->Add(fHistEtRecOverEtMC);
	157	fOutputList->Add(fHistDiffEtRecEtMCOverEtMC);
	158
	159	Bool_t selectPrimaries=kTRUE;
ae2636ae	160	if(fRecAnalysis->DataSet()==2010 \|\| fRecAnalysis->DataSet()==20111\|\|fRecAnalysis->DataSet()==2009 \|\| fRecAnalysis->DataSet()==2012 \|\| fRecAnalysis->DataSet()==2013){
ee1083d5	161	if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
ee1083d5	162	else{
ae2636ae	163	if(fRecAnalysis->DataSet()==2012)cout<<"Setting track cuts for the 2012 p+p collisions at 8 TeV"<<endl;
	164	else{
	165	if(fRecAnalysis->DataSet()==2013)cout<<"Setting track cuts for the 2013 p+Pb collisions at 5 TeV"<<endl;
	166	else{
	167	if(fRecAnalysis->DataSet()==2009){cout<<"Setting track cuts for the 2010 p+p collisions at 900 GeV"<<endl;}
	168	else{cout<<"Setting track cuts for the 2011 p+p collisions at 2.76 TeV"<<endl;}
	169	}
	170	}
d3d7bfe9	171	}
ee1083d5	172	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	173	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	174	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	175	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	176	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	177	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	178	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	179	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	180	}
27d85daa	181	if(fRecAnalysis->DataSet()==20100 \|\| fRecAnalysis->DataSet()==2011){
ee1083d5	182	cout<<"Setting track cuts for the 2010 Pb+Pb collisions at 2.76 TeV"<<endl;
	183	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	184	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	185	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	186	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	187	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	188	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	189	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	190	// fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	191	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	192	}
27d85daa	193	if(fRecAnalysis->DataSet()==2011){
27d85daa	194	cout<<"Using 2011 acceptance"<<endl;
f5ba3eed	195	if(fMCAnalysis) fMCAnalysis->ResetEventValues();//actually remakes AliAnalysisEtCuts if AliAnalysisEtCuts doesn't exist
	196	fRecAnalysis->ResetEventValues();
	197	if(fMCAnalysis && fMCAnalysis->GetCuts()){
	198	fMCAnalysis->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
	199	fMCAnalysis->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
177b9454	200	fMCAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
177b9454	201	fMCAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
f5ba3eed	202	}
	203	else{if(fMCAnalysis)cerr<<"Error! MC fCuts does not exist!"<<endl;}
	204	if(fRecAnalysis->GetCuts()){
	205	fRecAnalysis->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
	206	fRecAnalysis->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
177b9454	207	fRecAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMinCut(80);
177b9454	208	fRecAnalysis->GetSelector()->GetCuts()->SetGeometryEmcalPhiAccMaxCut(80+100);
f5ba3eed	209	}
f5ba3eed	210	else{cerr<<"Error! Reco fCuts does not exist!"<<endl;}
27d85daa	211	}
27d85daa	212
1815c8d7	213
ee1083d5	214
	215	fOutputList->Add(fEsdtrackCutsITSTPC);
	216	fOutputList->Add(fEsdtrackCutsTPC);
	217	fOutputList->Add(fEsdtrackCutsITS);
	218	if (fEsdtrackCutsITSTPC && fEsdtrackCutsTPC) {
	219	fRecAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	220	if (fMCAnalysis)
	221	fMCAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	222	fRecAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	223	if (fMCAnalysis)
	224	fMCAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	225	fRecAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	226	if (fMCAnalysis)
	227	fMCAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	228	//add ITS stuff!
	229	}
	230	else {
	231	Printf("Error: no track cuts!");
	232	}
1cc04082	233	PostData(1, fOutputList);
01b73fb0	234
2fbf38ac	235	}
	236
	237	//________________________________________________________________________
	238	void AliAnalysisTaskTotEt::UserExec(Option_t *)
cf6522d1	239	{ // execute method
1815c8d7	240
ee1083d5	241	fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
ee1083d5	242	if (!fESDEvent)
d3d7bfe9	243	{
ee1083d5	244	Printf("ERROR: Could not retrieve event");
ee1083d5	245	return;
2fbf38ac	246	}
1815c8d7	247
ee1083d5	248	//Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber());
1815c8d7	249
ee1083d5	250	AliCentrality *cent = GetCentralityObject();
1815c8d7	251
ee1083d5	252	//if (res == 0 && cent)
ee1083d5	253	//{
e50ad0d0	254	fRecAnalysis->SetCentralityObject(cent);
e50ad0d0	255	fRecAnalysis->AnalyseEvent(fESDEvent);
1815c8d7	256
e50ad0d0	257	AliMCEvent* mcEvent = MCEvent();
	258	if (mcEvent)
	259	{
	260	fMCAnalysis->SetCentralityObject(cent);
	261	fMCAnalysis->AnalyseEvent(mcEvent, fESDEvent);
	262	//fMCAnalysis->AnalyseEvent(mcEvent);
	263	}
	264	if(fMCAnalysis)
	265	{
eb169498	266	//set the number of tracks matched and the total number of hadrons calculated from the number of tracks matched so we can use them for calculating corrections
	267	fMCAnalysis->SetNumberOfChargedHadronsMatched(fRecAnalysis->GetNumberOfChargedHadronsMatched());
	268	fMCAnalysis->SetTotalNumberOfChargedHadrons(fRecAnalysis->GetTotalNumberOfChargedHadrons());
f61cec2f	269	fHistEtRecvsEtMC->Fill(fRecAnalysis->GetTotNeutralEt(), fMCAnalysis->GetTotNeutralEt());
	270	if(fMCAnalysis->GetTotNeutralEt()) fHistEtRecOverEtMC->Fill(fRecAnalysis->GetTotNeutralEt()/fMCAnalysis->GetTotNeutralEt(), cent->GetCentralityClass10("V0M"));
	271	if(fMCAnalysis->GetTotNeutralEt()) fHistDiffEtRecEtMCOverEtMC->Fill(fMCAnalysis->GetTotNeutralEt(), (fRecAnalysis->GetTotNeutralEt()-fMCAnalysis->GetTotNeutralEt())/fMCAnalysis->GetTotNeutralEt());
ee1083d5	272	}
	273	//}
	274	// Post output data.
	275	PostData(1, fOutputList);
2fbf38ac	276	}
	277
	278	//________________________________________________________________________
	279	void AliAnalysisTaskTotEt::Terminate(Option_t *)
	280	{
ee1083d5	281	// Draw result to the screen
ee1083d5	282	// Called once at the end of the query
1815c8d7	283
ee1083d5	284	fOutputList = dynamic_cast<TList*> (GetOutputData(1));
	285	if (!fOutputList) {
	286	printf("ERROR: Output list not available\n");
	287	return;
	288	}
2fbf38ac	289	}
	290
	291
	292