[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) :
        AliAnalysisTaskTransverseEnergy(name, isMc)
	,fRecAnalysis(0)
	,fMCAnalysis(0)
{
    // Constructor
  fMCConfigFile = "ConfigHadEtMonteCarlo.C";
  fRecoConfigFile = "ConfigHadEtReconstructed.C";
  
  if(fMCAnalysis) delete fMCAnalysis;
  if(fRecAnalysis) delete fRecAnalysis;

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

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

    // 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);
  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;
  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()==20100){
    //cout<<"Setting track cuts for the 2010 p+p collisions at 7 GeV"<<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::GetStandardITSPureSATrackCuts2009(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

AliESDCentrality *cent = GetCentralityObject();

if(res == 0 && cent){
  
  
  fRecAnalysis->AnalyseEvent(fESDEvent);

  AliMCEvent* mcEvent = MCEvent();
// if (!mcEvent) {
//   Printf("ERROR: Could not retrieve MC event");
//  }
  if (mcEvent && fESDEvent){
      ((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());
      }
    }
  }
// 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	//________________________________________________________________________
d3d7bfe9	36	AliAnalysisTaskHadEt::AliAnalysisTaskHadEt(const char *name, Bool_t isMc) :
	37	AliAnalysisTaskTransverseEnergy(name, isMc)
	38	,fRecAnalysis(0)
	39	,fMCAnalysis(0)
641e1e0c	40	{
641e1e0c	41	// Constructor
d3d7bfe9	42	fMCConfigFile = "ConfigHadEtMonteCarlo.C";
	43	fRecoConfigFile = "ConfigHadEtReconstructed.C";
	44
ea331c5d	45	if(fMCAnalysis) delete fMCAnalysis;
	46	if(fRecAnalysis) delete fRecAnalysis;
	47
d3d7bfe9	48	if (fMCConfigFile.Length()) {
7d2d1773	49	cout<<"Rereading AliAnalysisHadEtMonteCarlo configuration file..."<<endl;
d3d7bfe9	50	gROOT->LoadMacro(fMCConfigFile);
7d2d1773	51	fMCAnalysis = (AliAnalysisHadEtMonteCarlo *) gInterpreter->ProcessLine("ConfigHadEtMonteCarlo()");
7d2d1773	52	}
641e1e0c	53
d3d7bfe9	54	if (fRecoConfigFile.Length()) {
7d2d1773	55	cout<<"Rereading AliAnalysisHadEtReconstructed configuration file..."<<endl;
d3d7bfe9	56	gROOT->LoadMacro(fRecoConfigFile);
7d2d1773	57	fRecAnalysis = (AliAnalysisHadEtReconstructed *) gInterpreter->ProcessLine("ConfigHadEtReconstructed()");
7d2d1773	58	}
4b40b2b1	59
641e1e0c	60	// Define input and output slots here
	61	// Input slot #0 works with a TChain
	62	DefineInput(0, TChain::Class());
	63	// Output slot #1 writes into a TH1 container
	64
	65	DefineOutput(1, TList::Class());
641e1e0c	66	}
464aa50c	67	AliAnalysisTaskHadEt::~AliAnalysisTaskHadEt(){//Destructor
951efd81	68	delete fRecAnalysis;
951efd81	69	delete fMCAnalysis;
951efd81	70	}
641e1e0c	71
	72
	73	//________________________________________________________________________
	74	void AliAnalysisTaskHadEt::UserCreateOutputObjects()
	75	{
	76	// Create histograms
	77	// Called once
	78	fOutputList = new TList;
951efd81	79	fOutputList->SetOwner();
641e1e0c	80	fMCAnalysis->SetHistoList(fOutputList);
	81	fRecAnalysis->SetHistoList(fOutputList);
	82	fMCAnalysis->CreateHistograms();
	83	fRecAnalysis->CreateHistograms();
641e1e0c	84
964c8159	85	if(fRecAnalysis->DataSet() != fMCAnalysis->DataSet()){
	86	cout<<"Warning: Reconstruction data set and Monte Carlo data set are not the same! Setting data set to "<<fRecAnalysis->DataSet()<<endl;
	87	}
641e1e0c	88
964c8159	89	Bool_t selectPrimaries=kTRUE;
ea331c5d	90	if(fEsdtrackCutsITSTPC) delete fEsdtrackCutsITSTPC;
	91	if(fEsdtrackCutsITS) delete fEsdtrackCutsITS;
	92	if(fEsdtrackCutsTPC) delete fEsdtrackCutsTPC;
964c8159	93	if(fRecAnalysis->DataSet()==2009){
964c8159	94	cout<<"Setting track cuts for the 2009 p+p collisions at 900 GeV"<<endl;
cf6522d1	95	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selectPrimaries);
	96	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	97	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	98	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
641e1e0c	99	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
b64de20c	100	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
cf6522d1	101	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
964c8159	102	}
f43fc416	103	if(fRecAnalysis->DataSet()==2010 \|\| fRecAnalysis->DataSet()==20100){
964c8159	104	//cout<<"Setting track cuts for the 2010 p+p collisions at 7 GeV"<<endl;
	105	cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	106	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	107	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	108	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	109	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	110	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	111	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	112	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	113	}
cf6522d1	114
964c8159	115	fOutputList->Add(fEsdtrackCutsITSTPC);
	116	fOutputList->Add(fEsdtrackCutsTPC);
	117	fOutputList->Add(fEsdtrackCutsITS);
	118	if(fEsdtrackCutsITSTPC && fEsdtrackCutsTPC){
	119	fRecAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	120	fMCAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	121	fRecAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	122	fMCAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	123	fRecAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	124	fMCAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	125	//add ITS stuff!
	126	}
	127	else{
	128	Printf("Error: no track cuts!");
	129	}
641e1e0c	130	}
	131
	132	//________________________________________________________________________
	133	void AliAnalysisTaskHadEt::UserExec(Option_t *)
cf6522d1	134	{ // execute method
d3d7bfe9	135	fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
d3d7bfe9	136	if (!fESDEvent) {
641e1e0c	137	Printf("ERROR: Could not retrieve event");
	138	return;
	139	}
7d2d1773	140	//cout<<"AliAnalysisHadEtReconstructed 90"<<endl;
7d2d1773	141
d3d7bfe9	142	Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber()); // Check if the physics selection is valid for this run
	143
	144	AliESDCentrality *cent = GetCentralityObject();
641e1e0c	145
d3d7bfe9	146	if(res == 0 && cent){
	147
	148
	149	fRecAnalysis->AnalyseEvent(fESDEvent);
	150
	151	AliMCEvent* mcEvent = MCEvent();
7d2d1773	152	// if (!mcEvent) {
	153	// Printf("ERROR: Could not retrieve MC event");
	154	// }
d3d7bfe9	155	if (mcEvent && fESDEvent){
	156	((AliAnalysisHadEtMonteCarlo)fMCAnalysis)->AnalyseEvent((AliVEvent)mcEvent,(AliVEvent*)fESDEvent);
	157	if(fMCAnalysis->Full()){
	158	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
	159	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
	160	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
	161	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
	162	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
	163	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
	164	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
	165	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );
	166	}
	167	if(fMCAnalysis->EMCAL()){
	168	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPC() );
	169	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITS() );
	170	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPCNoPID() );
	171	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITSNoPID() );
	172	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPC() );
	173	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITS() );
	174	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPCNoPID() );
	175	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITSNoPID() );
	176	}
	177	if(fMCAnalysis->PHOS()){
	178	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPC() );
	179	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITS() );
	180	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPCNoPID() );
	181	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITSNoPID() );
	182	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPC() );
	183	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITS() );
	184	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPCNoPID() );
	185	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITSNoPID() );
	186	}
	187	if(fMCAnalysis->PiKP() && fMCAnalysis->Full()){
	188	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPC(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPC());
	189	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITS(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITS());
	190	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPCNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPCNoPID());
	191	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITSNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITSNoPID());
	192	}
7d2d1773	193	}
641e1e0c	194	}
641e1e0c	195	// Post output data.
641e1e0c	196	PostData(1, fOutputList);
641e1e0c	197	}
	198
	199	//________________________________________________________________________
	200	void AliAnalysisTaskHadEt::Terminate(Option_t *)
	201	{
	202	// Draw result to the screen
	203	// Called once at the end of the query
	204
	205	fOutputList = dynamic_cast<TList*> (GetOutputData(1));
	206	if (!fOutputList) {
	207	printf("ERROR: Output list not available\n");
	208	return;
	209	}
	210	}
	211
	212