[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;
  }
  inputHandler->SetNeedField(); 

  //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 || fRecAnalysis->DataSet()==2012 || fRecAnalysis->DataSet()==2013){
    // 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()==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::GetStandardITSSATrackCuts2010(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");
  }

  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 || fRecAnalysis->DataSet()!=2011) ) eventtype = (Int_t) AliPWG0Helper::GetEventProcessType(MCEvent()->Header());
  //only do the analysis if it meets the offline trigger cut
  if(kIsOfflineV0AND) fRecAnalysis->AnalyseEvent(fESDEvent,eventtype);
  //else{cout<<"Not analyzing this event!  Does not meet trigger condition!"<<endl;}
  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 || fRecAnalysis->DataSet()==2013|| fRecAnalysis->DataSet()==2011){//either non-diffractive or Pb+Pb or p+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

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