[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 <iostream>
#include <AliCentrality.h>

  using namespace std;

ClassImp(AliAnalysisTaskTotEt)

//________________________________________________________________________
  AliAnalysisTaskTotEt::AliAnalysisTaskTotEt(const char *name, Bool_t isMc) :
    AliAnalysisTaskTransverseEnergy(name, isMc)
    ,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);
  //t.ToUpper();
  if (t.Contains("EMC")) {
    if (t.Contains("Detail")) {

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

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

//________________________________________________________________________
void AliAnalysisTaskTotEt::UserCreateOutputObjects()
{
  // 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){
    if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 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){
    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());
    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!");
  }

}

//________________________________________________________________________
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)
  //{
  if (IsPhysicsSelected())
    {
      fRecAnalysis->SetCentralityObject(cent);
      fRecAnalysis->AnalyseEvent(fESDEvent);
		
      AliMCEvent* mcEvent = MCEvent();
      if (mcEvent)
	{
	  fMCAnalysis->SetCentralityObject(cent);
	  fMCAnalysis->AnalyseEvent(mcEvent, fESDEvent);
	  //fMCAnalysis->AnalyseEvent(mcEvent);
	}
      if(fMCAnalysis)
	{
	  fHistEtRecvsEtMC->Fill(fRecAnalysis->GetTotNeutralEtAcc(), fMCAnalysis->GetTotNeutralEtAcc());
	  if(fMCAnalysis->GetTotNeutralEtAcc()) fHistEtRecOverEtMC->Fill(fRecAnalysis->GetTotNeutralEt()/fMCAnalysis->GetTotNeutralEtAcc(), cent->GetCentralityClass10("V0M"));
	  if(fMCAnalysis->GetTotNeutralEtAcc()) 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"
2fbf38ac	31
2fbf38ac	32	#include <iostream>
a403aff5	33	#include <AliCentrality.h>
2fbf38ac	34
ee1083d5	35	using namespace std;
2fbf38ac	36
	37	ClassImp(AliAnalysisTaskTotEt)
	38
	39	//________________________________________________________________________
ee1083d5	40	AliAnalysisTaskTotEt::AliAnalysisTaskTotEt(const char *name, Bool_t isMc) :
	41	AliAnalysisTaskTransverseEnergy(name, isMc)
	42	,fRecAnalysis(0)
	43	,fMCAnalysis(0)
01b73fb0	44	// ,fSparseHistRecVsMc(0)
01b73fb0	45	//,fSparseRecVsMc(0)
2fbf38ac	46	{
ee1083d5	47	// Constructor
ee1083d5	48	// select if we should use EMCal or PHOS class
	49	// PHOS by default, EMCal if name string contains EMC
	50	TString t(name);
	51	//t.ToUpper();
	52	if (t.Contains("EMC")) {
	53	if (t.Contains("Detail")) {
	54
	55	cout<<"Rereading AliAnalysisEtMonteCarlo configuration file..."<<endl;
	56	gROOT->LoadMacro(fMCConfigFile);
	57	fMCAnalysis = (AliAnalysisEmEtMonteCarlo *) gInterpreter->ProcessLine("ConfigEtMonteCarlo(true,true)");
1815c8d7	58
ee1083d5	59	cout << "Instantiating AliAnalysisEmEtMonteCarlo class..."<< endl;
	60	}
	61	else if (fMCConfigFile.Length()) {
	62	cout<<"Rereading AliAnalysisEtMonteCarloEmcal configuration file..."<<endl;
	63	gROOT->LoadMacro(fMCConfigFile);
	64	fMCAnalysis = (AliAnalysisEtMonteCarloEmcal *) gInterpreter->ProcessLine("ConfigEtMonteCarlo()");
	65	}
1815c8d7	66
ee1083d5	67	if (t.Contains("Detail")) {
	68	cout<<"Rereading AliAnalysisEmEtReconstructed configuration file..."<<endl;
	69	gROOT->LoadMacro(fRecoConfigFile);
	70	fRecAnalysis = (AliAnalysisEmEtReconstructed *) gInterpreter->ProcessLine("ConfigEtReconstructed(true,true)");
	71
	72	}
	73	else if (fRecoConfigFile.Length()) {
	74	cout<<"Rereading AliAnalysisEtReconstructedEmcal configuration file..."<<endl;
	75	gROOT->LoadMacro(fRecoConfigFile);
	76	fRecAnalysis = (AliAnalysisEtReconstructedEmcal *) gInterpreter->ProcessLine("ConfigEtReconstructed()");
2fbf38ac	77	}
ee1083d5	78	}
	79	else {
	80	if (fMCConfigFile.Length()) {
	81	cout<<"Rereading AliAnalysisEtMonteCarloPhos configuration file..."<<endl;
	82	gROOT->LoadMacro(fMCConfigFile);
1815c8d7	83
ee1083d5	84	fMCAnalysis = (AliAnalysisEtMonteCarloPhos *) gInterpreter->ProcessLine("ConfigEtMonteCarlo(false)");
	85	cout << fMCAnalysis << endl;
	86	}
1815c8d7	87
ee1083d5	88	if (fRecoConfigFile.Length()) {
	89	cout<<"Rereading AliAnalysisEtReconstructedPhos configuration file..."<<endl;
	90	gROOT->LoadMacro(fRecoConfigFile);
	91	fRecAnalysis = (AliAnalysisEtReconstructedPhos *) gInterpreter->ProcessLine("ConfigEtReconstructed(false)");
2fbf38ac	92	}
ee1083d5	93	}
	94	// Define input and output slots here
	95	// Input slot #0 works with a TChain
	96	DefineInput(0, TChain::Class());
	97	// Output slot #1 writes into a TH1 container
1815c8d7	98
ee1083d5	99	DefineOutput(1, TList::Class());
1815c8d7	100
2fbf38ac	101	}
d3d7bfe9	102	AliAnalysisTaskTotEt::~AliAnalysisTaskTotEt() {//Destructor
ee1083d5	103	// fOutputList->Clear();
	104	delete fRecAnalysis;
	105	delete fMCAnalysis;
01b73fb0	106	//delete fSparseHistRecVsMc;
01b73fb0	107	//delete fSparseRecVsMc;
951efd81	108	}
2fbf38ac	109
	110	//________________________________________________________________________
	111	void AliAnalysisTaskTotEt::UserCreateOutputObjects()
	112	{
ee1083d5	113	// Create histograms
	114	// Called once
	115	if (fMCAnalysis)
	116	fMCAnalysis->CreateHistograms();
	117	fRecAnalysis->CreateHistograms();
	118	fOutputList = new TList;
	119	fOutputList->SetOwner();
	120	fRecAnalysis->FillOutputList(fOutputList);
	121	if (fMCAnalysis)
	122	fMCAnalysis->FillOutputList(fOutputList);
	123	fHistEtRecvsEtMC = new TH2F("fHistEtRecvsEtMC", "Reconstructed E_{T} vs MC E_{T}", 1000, 0.000, 100, 1000, 0.0001, 100);
	124	fHistEtRecOverEtMC = new TH2F("fHistEtRecOverEtMC", "Reconstructed E_{T} over MC E_{T} vs centrality", 1000, 0.00, 2.0, 11, -0.5, 10.5);
	125	fHistDiffEtRecEtMCOverEtMC = new TH2F("fHistDiffEtRecEtMCOverEtMC", "fHistDiffEtRecEtMCOverEtMC", 10000, 0.0, 1000, 1000, -5, 5);
	126	fOutputList->Add(fHistEtRecvsEtMC);
	127	fOutputList->Add(fHistEtRecOverEtMC);
	128	fOutputList->Add(fHistDiffEtRecEtMCOverEtMC);
	129
	130	Bool_t selectPrimaries=kTRUE;
	131	if(fRecAnalysis->DataSet()==2010 \|\| fRecAnalysis->DataSet()==20111\|\|fRecAnalysis->DataSet()==2009){
	132	if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
	133	else{
	134	if(fRecAnalysis->DataSet()==2009){cout<<"Setting track cuts for the 2010 p+p collisions at 900 GeV"<<endl;}
	135	else{cout<<"Setting track cuts for the 2011 p+p collisions at 2.76 TeV"<<endl;}
d3d7bfe9	136	}
ee1083d5	137	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	138	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	139	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	140	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	141	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	142	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	143	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	144	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	145	}
	146	if(fRecAnalysis->DataSet()==20100){
	147	cout<<"Setting track cuts for the 2010 Pb+Pb collisions at 2.76 TeV"<<endl;
	148	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	149	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	150	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	151	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	152	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	153	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	154	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	155	// fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	156	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	157	}
1815c8d7	158
ee1083d5	159
	160	fOutputList->Add(fEsdtrackCutsITSTPC);
	161	fOutputList->Add(fEsdtrackCutsTPC);
	162	fOutputList->Add(fEsdtrackCutsITS);
	163	if (fEsdtrackCutsITSTPC && fEsdtrackCutsTPC) {
	164	fRecAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	165	if (fMCAnalysis)
	166	fMCAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	167	fRecAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	168	if (fMCAnalysis)
	169	fMCAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	170	fRecAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	171	if (fMCAnalysis)
	172	fMCAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	173	//add ITS stuff!
	174	}
	175	else {
	176	Printf("Error: no track cuts!");
	177	}
01b73fb0	178
2fbf38ac	179	}
	180
	181	//________________________________________________________________________
	182	void AliAnalysisTaskTotEt::UserExec(Option_t *)
cf6522d1	183	{ // execute method
1815c8d7	184
ee1083d5	185	fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
ee1083d5	186	if (!fESDEvent)
d3d7bfe9	187	{
ee1083d5	188	Printf("ERROR: Could not retrieve event");
ee1083d5	189	return;
2fbf38ac	190	}
1815c8d7	191
ee1083d5	192	//Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber());
1815c8d7	193
ee1083d5	194	AliCentrality *cent = GetCentralityObject();
1815c8d7	195
ee1083d5	196	//if (res == 0 && cent)
	197	//{
	198	if (IsPhysicsSelected())
	199	{
	200	fRecAnalysis->SetCentralityObject(cent);
	201	fRecAnalysis->AnalyseEvent(fESDEvent);
1815c8d7	202
ee1083d5	203	AliMCEvent* mcEvent = MCEvent();
	204	if (mcEvent)
	205	{
	206	fMCAnalysis->SetCentralityObject(cent);
	207	fMCAnalysis->AnalyseEvent(mcEvent, fESDEvent);
	208	//fMCAnalysis->AnalyseEvent(mcEvent);
	209	}
	210	if(fMCAnalysis)
	211	{
	212	fHistEtRecvsEtMC->Fill(fRecAnalysis->GetTotNeutralEtAcc(), fMCAnalysis->GetTotNeutralEtAcc());
	213	if(fMCAnalysis->GetTotNeutralEtAcc()) fHistEtRecOverEtMC->Fill(fRecAnalysis->GetTotNeutralEt()/fMCAnalysis->GetTotNeutralEtAcc(), cent->GetCentralityClass10("V0M"));
	214	if(fMCAnalysis->GetTotNeutralEtAcc()) fHistDiffEtRecEtMCOverEtMC->Fill(fMCAnalysis->GetTotNeutralEt(), (fRecAnalysis->GetTotNeutralEt()-fMCAnalysis->GetTotNeutralEt())/fMCAnalysis->GetTotNeutralEt());
1815c8d7	215	}
ee1083d5	216	}
	217	//}
	218	// Post output data.
	219	PostData(1, fOutputList);
2fbf38ac	220	}
	221
	222	//________________________________________________________________________
	223	void AliAnalysisTaskTotEt::Terminate(Option_t *)
	224	{
ee1083d5	225	// Draw result to the screen
ee1083d5	226	// Called once at the end of the query
1815c8d7	227
ee1083d5	228	fOutputList = dynamic_cast<TList*> (GetOutputData(1));
	229	if (!fOutputList) {
	230	printf("ERROR: Output list not available\n");
	231	return;
	232	}
2fbf38ac	233	}
	234
	235
	236