[u/mrichter/AliRoot.git] / PWGLF / 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 "AliPWG0Helper.h"
#include "AliTriggerAnalysis.h"
#include "AliAnalysisManager.h"
#include "AliPIDResponse.h"
#include "AliTPCPIDResponse.h" 
#include "AliInputEventHandler.h"

#include <iostream>
#include "AliLog.h"

using namespace std;

ClassImp(AliAnalysisTaskHadEt)


//________________________________________________________________________
  AliAnalysisTaskHadEt::AliAnalysisTaskHadEt(const char *name, Bool_t isMc, TString recoConfigFile, TString mcConfigFile) :
        AliAnalysisTaskTransverseEnergy(name, isMc)
	,fPIDResponse(0)
	,fRecAnalysis(0)
	,fMCAnalysis(0)
	,fIsSim(isMc)
	,kIsOfflineV0AND(0)
	,kIsOfflineMB(0)
{
    // Constructor
  //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");
  else{cout<<"PIDResponse was created!"<<endl;}


  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;
  delete fPIDResponse;
}


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

    // Called once


  //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");
  else{cout<<"PIDResponse was created!"<<endl;}


  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){
    // AliAnalysisTaskSE::	SelectCollisionCandidates(AliVEvent::kINT7 ) ;
    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::GetStandardITSSATrackCuts2010(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!");
  }


 PostData(1, fOutputList);
}

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

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

//AliCentrality *cent = GetCentralityObject();

//if(res == 0 && cent){
//if(cent){
 AliTriggerAnalysis *fTriggerAnalysis = new AliTriggerAnalysis();

  kIsOfflineV0AND = fTriggerAnalysis->IsOfflineTriggerFired(fESDEvent, AliTriggerAnalysis::kV0AND);  
  kIsOfflineMB = fTriggerAnalysis->IsOfflineTriggerFired(fESDEvent, AliTriggerAnalysis::kMB1);  
  fRecAnalysis->SetIsOfflineV0AND(kIsOfflineV0AND);
  fMCAnalysis->SetIsOfflineV0AND(kIsOfflineV0AND);
  fMCAnalysis->SetIsOfflineMB(kIsOfflineMB);

  Int_t eventtype = 	AliPWG0Helper::kInvalidProcess;
  if(fIsSim && fRecAnalysis->DataSet()!=20100) eventtype = (Int_t) AliPWG0Helper::GetEventProcessType(MCEvent()->Header());
  fRecAnalysis->AnalyseEvent(fESDEvent,eventtype);
  if(fIsSim){
    AliMCEvent* mcEvent = MCEvent();
    if(!mcEvent){  
      AliFatal("ERROR: MC Event does not exist");
      return;
    }
    if (fESDEvent){
      ((AliAnalysisHadEtMonteCarlo*)fMCAnalysis)->AnalyseEvent((AliVEvent*)mcEvent,(AliVEvent*)fESDEvent);

    if( fRecAnalysis->DataSet()==20100 || AliPWG0Helper::GetEventProcessType(mcEvent->Header()) == AliPWG0Helper::kND){//either non-diffractive or Pb+Pb
      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() );

	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );

	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPC() );
	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceITS( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITS() );
	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPCNoPID() );
	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITSNoPID() );//Had
      }
      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());
      }
    }
  }
  }
  delete fTriggerAnalysis;
  //}
//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"
2c0680a5	26	#include "AliPWG0Helper.h"
d35312c9	27	#include "AliTriggerAnalysis.h"
9a365626	28	#include "AliAnalysisManager.h"
	29	#include "AliPIDResponse.h"
	30	#include "AliTPCPIDResponse.h"
	31	#include "AliInputEventHandler.h"
641e1e0c	32
641e1e0c	33	#include <iostream>
6b246af1	34	#include "AliLog.h"
641e1e0c	35
	36	using namespace std;
	37
	38	ClassImp(AliAnalysisTaskHadEt)
	39
	40
	41
	42	//________________________________________________________________________
bccadd89	43	AliAnalysisTaskHadEt::AliAnalysisTaskHadEt(const char *name, Bool_t isMc, TString recoConfigFile, TString mcConfigFile) :
d3d7bfe9	44	AliAnalysisTaskTransverseEnergy(name, isMc)
9a365626	45	,fPIDResponse(0)
d3d7bfe9	46	,fRecAnalysis(0)
d3d7bfe9	47	,fMCAnalysis(0)
21ce38dd	48	,fIsSim(isMc)
d35312c9	49	,kIsOfflineV0AND(0)
ba222433	50	,kIsOfflineMB(0)
641e1e0c	51	{
641e1e0c	52	// Constructor
9a365626	53	//input hander
9a365626	54	AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
beb92504	55	if (!man) {
	56	AliFatal("Analysis manager needed");
	57	return;
	58	}
	59
9a365626	60	AliInputEventHandler inputHandler=dynamic_cast<AliInputEventHandler>(man->GetInputEventHandler());
beb92504	61	if (!inputHandler) {
	62	AliFatal("Input handler needed");
	63	return;
	64	}
9a365626	65
	66	//pid response object
	67	fPIDResponse=inputHandler->GetPIDResponse();
	68	if (!fPIDResponse) AliError("PIDResponse object was not created");
	69	else{cout<<"PIDResponse was created!"<<endl;}
	70
	71
bccadd89	72	fMCConfigFile = mcConfigFile;
bccadd89	73	fRecoConfigFile = recoConfigFile;
bccadd89	74
ea331c5d	75	if(fMCAnalysis) delete fMCAnalysis;
	76	if(fRecAnalysis) delete fRecAnalysis;
	77
49b25059	78	if (fRecoConfigFile.Length()) {
bccadd89	79	cout<<"Rereading AliAnalysisHadEtReconstructed configuration file "<<fRecoConfigFile<<endl;
49b25059	80	gROOT->LoadMacro(fRecoConfigFile);
	81	fRecAnalysis = (AliAnalysisHadEtReconstructed *) gInterpreter->ProcessLine("ConfigHadEtReconstructed()");
	82	}
	83
d3d7bfe9	84	if (fMCConfigFile.Length()) {
bccadd89	85	cout<<"Rereading AliAnalysisHadEtMonteCarlo configuration file "<<fMCConfigFile<<endl;
d3d7bfe9	86	gROOT->LoadMacro(fMCConfigFile);
7d2d1773	87	fMCAnalysis = (AliAnalysisHadEtMonteCarlo *) gInterpreter->ProcessLine("ConfigHadEtMonteCarlo()");
49b25059	88	fMCAnalysis->SetHadEtReconstructed(fRecAnalysis);
7d2d1773	89	}
641e1e0c	90
	91	// Define input and output slots here
	92	// Input slot #0 works with a TChain
	93	DefineInput(0, TChain::Class());
	94	// Output slot #1 writes into a TH1 container
	95
	96	DefineOutput(1, TList::Class());
641e1e0c	97	}
464aa50c	98	AliAnalysisTaskHadEt::~AliAnalysisTaskHadEt(){//Destructor
951efd81	99	delete fRecAnalysis;
951efd81	100	delete fMCAnalysis;
9a365626	101	delete fPIDResponse;
951efd81	102	}
641e1e0c	103
	104
	105	//________________________________________________________________________
	106	void AliAnalysisTaskHadEt::UserCreateOutputObjects()
	107	{
	108	// Create histograms
bccadd89	109
641e1e0c	110	// Called once
bccadd89	111
bccadd89	112
9a365626	113	//input hander
9a365626	114	AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
beb92504	115	if (!man) {
	116	AliFatal("Analysis manager needed");
	117	return;
	118	}
	119
9a365626	120	AliInputEventHandler inputHandler=dynamic_cast<AliInputEventHandler>(man->GetInputEventHandler());
beb92504	121	if (!inputHandler) {
	122	AliFatal("Input handler needed");
	123	return;
	124	}
9a365626	125
	126	//pid response object
	127	fPIDResponse=inputHandler->GetPIDResponse();
	128	if (!fPIDResponse) AliError("PIDResponse object was not created");
	129	else{cout<<"PIDResponse was created!"<<endl;}
	130
bccadd89	131
641e1e0c	132	fOutputList = new TList;
951efd81	133	fOutputList->SetOwner();
641e1e0c	134	fMCAnalysis->SetHistoList(fOutputList);
641e1e0c	135	fRecAnalysis->SetHistoList(fOutputList);
21ce38dd	136	if(fIsSim) fMCAnalysis->CreateHistograms();
641e1e0c	137	fRecAnalysis->CreateHistograms();
641e1e0c	138
9845dc2c	139
964c8159	140	if(fRecAnalysis->DataSet() != fMCAnalysis->DataSet()){
	141	cout<<"Warning: Reconstruction data set and Monte Carlo data set are not the same! Setting data set to "<<fRecAnalysis->DataSet()<<endl;
	142	}
641e1e0c	143
964c8159	144	Bool_t selectPrimaries=kTRUE;
ea331c5d	145	if(fEsdtrackCutsITSTPC) delete fEsdtrackCutsITSTPC;
	146	if(fEsdtrackCutsITS) delete fEsdtrackCutsITS;
	147	if(fEsdtrackCutsTPC) delete fEsdtrackCutsTPC;
5c66cc7a	148	//We do not use these because we are using the 2010 900 GeV data
	149	// if(fRecAnalysis->DataSet()==2009){
	150	// cout<<"Setting track cuts for the 2009 p+p collisions at 900 GeV"<<endl;
	151	// fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selectPrimaries);
	152	// fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	153	// fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	154	// fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	155	// //ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	156	// fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
	157	// fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
	158	// }
	159	if(fRecAnalysis->DataSet()==2010 \|\| fRecAnalysis->DataSet()==20111\|\|fRecAnalysis->DataSet()==2009){
43809680	160	// AliAnalysisTaskSE:: SelectCollisionCandidates(AliVEvent::kINT7 ) ;
bccadd89	161	if(fRecAnalysis->DataSet()==2010)cout<<"Setting track cuts for the 2010 p+p collisions at 7 TeV"<<endl;
fbcb7701	162	else{
	163	if(fRecAnalysis->DataSet()==2009){cout<<"Setting track cuts for the 2010 p+p collisions at 900 GeV"<<endl;}
	164	else{cout<<"Setting track cuts for the 2011 p+p collisions at 2.76 TeV"<<endl;}
	165	}
4bb44829	166	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
964c8159	167	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	168	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	169	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	170	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	171	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
a719cc37	172	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
964c8159	173	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
964c8159	174	}
49b25059	175	if(fRecAnalysis->DataSet()==20100){
	176	cout<<"Setting track cuts for the 2010 Pb+Pb collisions at 2.76 TeV"<<endl;
	177	//cout<<"Warning: Have not set 2010 track cuts yet!!"<<endl;
	178	fEsdtrackCutsITSTPC = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
	179	fEsdtrackCutsITSTPC->SetName("fEsdTrackCuts");
	180	fEsdtrackCutsTPC = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	181	fEsdtrackCutsTPC->SetName("fEsdTrackCutsTPCOnly");
	182	//ITS stand alone cuts - similar to 2009 cuts but with only ITS hits required
	183	fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
5c66cc7a	184	// fEsdtrackCutsITS = AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(kTRUE,kFALSE);//we do want primaries but we do not want to require PID info
5c66cc7a	185	fEsdtrackCutsITS->SetName("fEsdTrackCutsITS");
49b25059	186	}
cf6522d1	187
964c8159	188	fOutputList->Add(fEsdtrackCutsITSTPC);
	189	fOutputList->Add(fEsdtrackCutsTPC);
	190	fOutputList->Add(fEsdtrackCutsITS);
	191	if(fEsdtrackCutsITSTPC && fEsdtrackCutsTPC){
	192	fRecAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	193	fMCAnalysis->SetITSTrackCuts( GetITSTrackCuts());
	194	fRecAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	195	fMCAnalysis->SetTPCITSTrackCuts( GetTPCITSTrackCuts());
	196	fRecAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	197	fMCAnalysis->SetTPCOnlyTrackCuts( GetTPCOnlyTrackCuts());
	198	//add ITS stuff!
	199	}
	200	else{
	201	Printf("Error: no track cuts!");
	202	}
19ec7ce2	203
9a365626	204
9a365626	205
19ec7ce2	206	PostData(1, fOutputList);
641e1e0c	207	}
	208
	209	//________________________________________________________________________
	210	void AliAnalysisTaskHadEt::UserExec(Option_t *)
cf6522d1	211	{ // execute method
d3d7bfe9	212	fESDEvent = dynamic_cast<AliESDEvent*>(InputEvent());
d3d7bfe9	213	if (!fESDEvent) {
641e1e0c	214	Printf("ERROR: Could not retrieve event");
	215	return;
	216	}
2c0680a5	217	//cout<<"AliAnalysisTaskHadEt 165"<<endl;
7d2d1773	218
e50ad0d0	219	//Int_t res = CheckPhysicsSelection(fESDEvent->GetRunNumber()); // Check if the physics selection is valid for this run
d3d7bfe9	220
b1a5cb85	221	//AliCentrality *cent = GetCentralityObject();
641e1e0c	222
1794f02f	223	//if(res == 0 && cent){
1794f02f	224	//if(cent){
d35312c9	225	AliTriggerAnalysis *fTriggerAnalysis = new AliTriggerAnalysis();
	226
	227	kIsOfflineV0AND = fTriggerAnalysis->IsOfflineTriggerFired(fESDEvent, AliTriggerAnalysis::kV0AND);
ba222433	228	kIsOfflineMB = fTriggerAnalysis->IsOfflineTriggerFired(fESDEvent, AliTriggerAnalysis::kMB1);
d35312c9	229	fRecAnalysis->SetIsOfflineV0AND(kIsOfflineV0AND);
d35312c9	230	fMCAnalysis->SetIsOfflineV0AND(kIsOfflineV0AND);
ba222433	231	fMCAnalysis->SetIsOfflineMB(kIsOfflineMB);
a719cc37	232
1794f02f	233	Int_t eventtype = AliPWG0Helper::kInvalidProcess;
5c3c2341	234	if(fIsSim && fRecAnalysis->DataSet()!=20100) eventtype = (Int_t) AliPWG0Helper::GetEventProcessType(MCEvent()->Header());
a719cc37	235	fRecAnalysis->AnalyseEvent(fESDEvent,eventtype);
a719cc37	236	if(fIsSim){
1794f02f	237	AliMCEvent* mcEvent = MCEvent();
	238	if(!mcEvent){
	239	AliFatal("ERROR: MC Event does not exist");
	240	return;
	241	}
1794f02f	242	if (fESDEvent){
1794f02f	243	((AliAnalysisHadEtMonteCarlo)fMCAnalysis)->AnalyseEvent((AliVEvent)mcEvent,(AliVEvent*)fESDEvent);
6b246af1	244
a719cc37	245	if( fRecAnalysis->DataSet()==20100 \|\| AliPWG0Helper::GetEventProcessType(mcEvent->Header()) == AliPWG0Helper::kND){//either non-diffractive or Pb+Pb
d3d7bfe9	246	if(fMCAnalysis->Full()){
	247	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
	248	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
	249	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
	250	fMCAnalysis->FillSimTotEtMinusRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
	251	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
	252	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
	253	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
	254	fMCAnalysis->FillSimHadEtMinusRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );
6b246af1	255
	256	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPC() );
	257	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceITS( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITS() );
	258	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceTPCNoPID() );
	259	fMCAnalysis->FillSimTotEtVsRecoTotEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtFullAcceptanceITSNoPID() );
	260	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPC() );
	261	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceITS( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITS() );
	262	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceTPCNoPID() );
	263	fMCAnalysis->FillSimHadEtVsRecoHadEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtFullAcceptanceITSNoPID() );
62346fc2	264
	265	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceTPC( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPC() );
	266	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceITS( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITS() );
	267	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPCNoPID() );
	268	fMCAnalysis->FillSimPiKPEtVsRecoPiKPEtFullAcceptanceITSNoPID( fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITSNoPID() );//Had
d3d7bfe9	269	}
	270	if(fMCAnalysis->EMCAL()){
	271	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPC() );
	272	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITS() );
	273	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceTPCNoPID() );
	274	fMCAnalysis->FillSimTotEtMinusRecoTotEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtEMCALAcceptanceITSNoPID() );
	275	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPC() );
	276	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITS( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITS() );
	277	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceTPCNoPID() );
	278	fMCAnalysis->FillSimHadEtMinusRecoHadEtEMCALAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtEMCALAcceptanceITSNoPID() );
	279	}
	280	if(fMCAnalysis->PHOS()){
	281	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPC() );
	282	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITS() );
	283	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceTPCNoPID() );
	284	fMCAnalysis->FillSimTotEtMinusRecoTotEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedTotEtPHOSAcceptanceITSNoPID() );
	285	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPC( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPC() );
	286	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITS( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITS() );
	287	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceTPCNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceTPCNoPID() );
	288	fMCAnalysis->FillSimHadEtMinusRecoHadEtPHOSAcceptanceITSNoPID( fRecAnalysis->GetCorrectedHadEtPHOSAcceptanceITSNoPID() );
	289	}
	290	if(fMCAnalysis->PiKP() && fMCAnalysis->Full()){
	291	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPC(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPC());
	292	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITS(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITS());
	293	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceTPCNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceTPCNoPID());
	294	fMCAnalysis->FillSimPiKPMinusRecoPiKPFullAcceptanceITSNoPID(fRecAnalysis->GetCorrectedPiKPEtFullAcceptanceITSNoPID());
	295	}
7d2d1773	296	}
641e1e0c	297	}
1794f02f	298	}
d35312c9	299	delete fTriggerAnalysis;
1794f02f	300	//}
49b25059	301	//cout<<"End Event"<<endl<<endl;
641e1e0c	302	// Post output data.
6b246af1	303	PostData(1, fOutputList);
641e1e0c	304	}
	305
	306	//________________________________________________________________________
	307	void AliAnalysisTaskHadEt::Terminate(Option_t *)
	308	{
	309	// Draw result to the screen
	310	// Called once at the end of the query
	311
	312	fOutputList = dynamic_cast<TList*> (GetOutputData(1));
	313	if (!fOutputList) {
	314	printf("ERROR: Output list not available\n");
	315	return;
	316	}
	317	}
	318
	319