[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / macros / AddTaskPtEMCalTriggerV1.C

#if !defined (__CINT__) || defined (__MAKECINT__)
#include "AliAnalysisManager.h"
#include "AliAnalysisTaskPtEMCalTriggerV1.h"
#include "AliESDtrackCuts.h"
#include "AliJetContainer.h"
#include <TList.h>
#include <TString.h>
#include <cstring>
#endif

void AddClusterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, bool isMC);
void AddTrackComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, AliESDtrackCuts *trackcuts, bool isMC, bool isSwapEta);
void AddMCParticleComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group);
void AddEventCounterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, bool isMC);
void AddMCJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, double minJetPt);
void AddRecJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, AliESDtrackCuts *trackcuts, double minJetPt, bool isMC, bool isSwapEta);
AliESDtrackCuts *CreateDefaultTrackCuts();
AliESDtrackCuts *CreateHybridTrackCuts();

AliAnalysisTask* AddTaskPtEMCalTriggerV1(
    bool isMC,
    bool usePythiaHard,
    const char *period ="LHC13d",
    const char *ntrackContainer = "",
    const char *nclusterContainer = "",
    const char *njetcontainerData = "",
    const char *njetcontainerMC = "",
    double jetradius = 0.5
)
{
  //AliLog::SetClassDebugLevel("EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTrigger", 2);
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();

  if (!mgr) {
    ::Error("AddTaskPtEMCalTrigger", "No analysis manager to connect to.");
    return NULL;
  }

  if (!mgr->GetInputEventHandler()) {
    ::Error("AddTaskPtEMCalTrigger", "This task requires an input event handler");
    return NULL;
  }

  bool isSwapEta = TString(period).CompareTo("LHC13f") ? kFALSE : kTRUE;
  EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTriggerV1 *pttriggertask = new EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTriggerV1("ptemcaltriggertask");
  //pttriggertask->SelectCollisionCandidates(AliVEvent::kINT7 | AliVEvent::kEMC7);                          // Select both INT7 or EMC7 triggered events
  pttriggertask->SelectCollisionCandidates(AliVEvent::kAny);
  if(isMC) pttriggertask->SetSwapThresholds();

  mgr->AddTask(pttriggertask);
  if(usePythiaHard){
    pttriggertask->SetIsPythia(kTRUE);
  }

  // Add components
  EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *noselect = new EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup("noselect");
  noselect->AddAnalysisComponent(new EMCalTriggerPtAnalysis::AliEMCalTriggerPatchAnalysisComponent("patchanalysis"));

  double jetpt[4] = {40., 60., 80., 100.};
  EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *defaultselect = new EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup("defaultselect");
  defaultselect->SetEventSelection(new EMCalTriggerPtAnalysis::AliEMCalTriggerEventSelection());
  EMCalTriggerPtAnalysis::AliEMCalTriggerKineCuts *kineCuts = new EMCalTriggerPtAnalysis::AliEMCalTriggerKineCuts();
  kineCuts->SetPtRange(2., 100.);
  defaultselect->SetKineCuts(kineCuts);
  AddEventCounterComponent(defaultselect, isMC);
  if(isMC){
    AddMCParticleComponent(defaultselect);
    for(int ijpt = 0; ijpt < 4; ijpt++)
      AddMCJetComponent(defaultselect, jetpt[ijpt]);
  }
  AddClusterComponent(defaultselect, isMC);
  AddTrackComponent(defaultselect, CreateDefaultTrackCuts(), isMC, isSwapEta);
  for(int ijpt = 0; ijpt < 4; ijpt++)
    AddRecJetComponent(defaultselect, CreateDefaultTrackCuts(), jetpt[ijpt], isMC, isSwapEta);

  pttriggertask->AddAnalysisGroup(noselect);
  pttriggertask->AddAnalysisGroup(defaultselect);

  // Add containers
  Bool_t isAOD = mgr->GetInputEventHandler()->IsA() == AliAODInputHandler::Class();
  AliParticleContainer *trackContainer = pttriggertask->AddParticleContainer(ntrackContainer);
  //trackContainer->SetClassName("AliVTrack");
  AliClusterContainer *clusterContainer = pttriggertask->AddClusterContainer(nclusterContainer);
  AliParticleContainer *mcpartcont = isMC ? pttriggertask->AddParticleContainer("MCParticlesSelected") : NULL;


  // Handle Jet Containers
  if(strlen(njetcontainerData)){
    AliJetContainer *jetcontainerData = pttriggertask->AddJetContainer(njetcontainerData, "TPC", jetradius);
    pttriggertask->SetDataJetContainerName("PtTriggerTaskJetsData");
    jetcontainerData->ConnectParticleContainer(trackContainer);
    jetcontainerData->SetName("PtTriggerTaskJetsData");
    jetcontainerData->SetJetPtCut(20.);
    jetcontainerData->SetJetEtaPhiEMCAL();
    printf("jet container added for Data\n");
  }
  if(isMC && strlen(njetcontainerMC)){
    AliJetContainer *jetcontainerMC = pttriggertask->AddJetContainer(njetcontainerMC, "TPC", jetradius);
    pttriggertask->SetMCJetContainerName("PtTriggerTaskJetsMC");
    jetcontainerMC->ConnectParticleContainer(mcpartcont);
    jetcontainerMC->SetName("PtTriggerTaskJetsMC");
    jetcontainerMC->SetJetPtCut(20.);
    jetcontainerMC->SetJetEtaPhiEMCAL();
    printf("Jet container added for MC");
  }

  TString containerName = mgr->GetCommonFileName();
  containerName += ":PtEMCalTriggerTask";
  printf("container name: %s\n", containerName.Data());

  AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
  AliAnalysisDataContainer *coutput = mgr->CreateContainer("results", TList::Class(),    AliAnalysisManager::kOutputContainer, containerName.Data());

  //Connect input/output
  mgr->ConnectInput(pttriggertask, 0, cinput);
  mgr->ConnectOutput(pttriggertask, 1, coutput);

  return pttriggertask;
}

void AddClusterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, bool isMC){
  EMCalTriggerPtAnalysis::AliEMCalTriggerClusterAnalysisComponent *clusteranalysis = new EMCalTriggerPtAnalysis::AliEMCalTriggerClusterAnalysisComponent("clusterAnalysis");
  clusteranalysis->SetEnergyRange(2., 100.);
  if(isMC) clusteranalysis->SetUsePatches();
  group->AddAnalysisComponent(clusteranalysis);
}

void AddTrackComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, AliESDtrackCuts * trackcuts, bool isMC, bool isSwapEta){
  EMCalTriggerPtAnalysis::AliEMCalTriggerRecTrackAnalysisComponent *trackanalysis = new EMCalTriggerPtAnalysis::AliEMCalTriggerRecTrackAnalysisComponent("trackAnalysisStandard");
  group->AddAnalysisComponent(trackanalysis);
  // Create charged hadrons pPb standard track cuts
  trackanalysis->SetTrackSelection(new EMCalTriggerPtAnalysis::AliEMCalPtTaskTrackSelectionESD(trackcuts));

  if(isMC){
    trackanalysis->SetRequestMCtrueTracks();
    trackanalysis->SetUsePatches();
  }
  if(isSwapEta) trackanalysis->SetSwapEta();
}

void AddEventCounterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, Bool_t isMC){
  EMCalTriggerPtAnalysis::AliEMCalTriggerEventCounterAnalysisComponent * evcount = new EMCalTriggerPtAnalysis::AliEMCalTriggerEventCounterAnalysisComponent("eventCounter");
  evcount->SetUsePatches(isMC);
  group->AddAnalysisComponent(evcount);
}

void AddMCParticleComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group){
  group->AddAnalysisComponent(new EMCalTriggerPtAnalysis::AliEMCalTriggerMCParticleAnalysisComponent("partana"));
}

void AddMCJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, double minJetPt){
  EMCalTriggerPtAnalysis::AliEMCalTriggerMCJetAnalysisComponent *jetana = new EMCalTriggerPtAnalysis::AliEMCalTriggerMCJetAnalysisComponent(Form("MCJetAna%f", minJetPt));
  jetana->SetMinimumJetPt(minJetPt);
  jetana->SetUsePatches();
  group->AddAnalysisComponent(jetana);
}

void AddRecJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, AliESDtrackCuts *trackcuts, double minJetPt, bool isMC, bool isSwapEta){
  EMCalTriggerPtAnalysis::AliEMCalTriggerRecJetAnalysisComponent *jetana = new EMCalTriggerPtAnalysis::AliEMCalTriggerRecJetAnalysisComponent(Form("RecJetAna%f", minJetPt));
  jetana->SetMinimumJetPt(minJetPt);
  jetana->SetUsePatches();
  jetana->SetSingleTrackCuts(new EMCalTriggerPtAnalysis::AliEMCalPtTaskTrackSelectionESD(trackcuts));
  group->AddAnalysisComponent(jetana);
}

AliESDtrackCuts *CreateDefaultTrackCuts(){
  AliESDtrackCuts *standardTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(true, 1);
  standardTrackCuts->SetName("Standard Track cuts");
  standardTrackCuts->SetMinNCrossedRowsTPC(120);
  standardTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
  return standardTrackCuts;
}

AliESDtrackCuts *CreateHybridTrackCuts(){
  AliESDtrackCuts* hybridTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE);
  hybridTrackCuts->SetName("Global Hybrid tracks, loose DCA");
  hybridTrackCuts->SetMaxDCAToVertexXY(2.4);
  hybridTrackCuts->SetMaxDCAToVertexZ(3.2);
  hybridTrackCuts->SetDCAToVertex2D(kTRUE);
  hybridTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
  hybridTrackCuts->SetMaxFractionSharedTPCClusters(0.4);
  return hybridTrackCuts;
}
Commit	Line	Data
ff5093a9	1	#if !defined (__CINT__) \|\| defined (__MAKECINT__)
	2	#include "AliAnalysisManager.h"
	3	#include "AliAnalysisTaskPtEMCalTriggerV1.h"
	4	#include "AliESDtrackCuts.h"
	5	#include "AliJetContainer.h"
	6	#include <TList.h>
	7	#include <TString.h>
	8	#include <cstring>
	9	#endif
	10
	11	void AddClusterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, bool isMC);
	12	void AddTrackComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup group, AliESDtrackCuts trackcuts, bool isMC, bool isSwapEta);
	13	void AddMCParticleComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group);
	14	void AddEventCounterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, bool isMC);
	15	void AddMCJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, double minJetPt);
	16	void AddRecJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup group, AliESDtrackCuts trackcuts, double minJetPt, bool isMC, bool isSwapEta);
	17	AliESDtrackCuts *CreateDefaultTrackCuts();
	18	AliESDtrackCuts *CreateHybridTrackCuts();
	19
	20	AliAnalysisTask* AddTaskPtEMCalTriggerV1(
	21	bool isMC,
	22	bool usePythiaHard,
	23	const char *period ="LHC13d",
	24	const char *ntrackContainer = "",
	25	const char *nclusterContainer = "",
	26	const char *njetcontainerData = "",
	27	const char *njetcontainerMC = "",
	28	double jetradius = 0.5
	29	)
	30	{
	31	//AliLog::SetClassDebugLevel("EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTrigger", 2);
	32	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	33
	34	if (!mgr) {
	35	::Error("AddTaskPtEMCalTrigger", "No analysis manager to connect to.");
	36	return NULL;
	37	}
	38
	39	if (!mgr->GetInputEventHandler()) {
	40	::Error("AddTaskPtEMCalTrigger", "This task requires an input event handler");
	41	return NULL;
	42	}
	43
	44	bool isSwapEta = TString(period).CompareTo("LHC13f") ? kFALSE : kTRUE;
	45	EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTriggerV1 *pttriggertask = new EMCalTriggerPtAnalysis::AliAnalysisTaskPtEMCalTriggerV1("ptemcaltriggertask");
	46	//pttriggertask->SelectCollisionCandidates(AliVEvent::kINT7 \| AliVEvent::kEMC7); // Select both INT7 or EMC7 triggered events
	47	pttriggertask->SelectCollisionCandidates(AliVEvent::kAny);
2e09b873	48	if(isMC) pttriggertask->SetSwapThresholds();
ff5093a9	49
	50	mgr->AddTask(pttriggertask);
	51	if(usePythiaHard){
	52	pttriggertask->SetIsPythia(kTRUE);
	53	}
	54
	55	// Add components
	56	EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *noselect = new EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup("noselect");
	57	noselect->AddAnalysisComponent(new EMCalTriggerPtAnalysis::AliEMCalTriggerPatchAnalysisComponent("patchanalysis"));
	58
0b065993	59	double jetpt[4] = {40., 60., 80., 100.};
ff5093a9	60	EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *defaultselect = new EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup("defaultselect");
0b065993	61	defaultselect->SetEventSelection(new EMCalTriggerPtAnalysis::AliEMCalTriggerEventSelection());
0b065993	62	EMCalTriggerPtAnalysis::AliEMCalTriggerKineCuts *kineCuts = new EMCalTriggerPtAnalysis::AliEMCalTriggerKineCuts();
ff5093a9	63	kineCuts->SetPtRange(2., 100.);
	64	defaultselect->SetKineCuts(kineCuts);
	65	AddEventCounterComponent(defaultselect, isMC);
	66	if(isMC){
	67	AddMCParticleComponent(defaultselect);
	68	for(int ijpt = 0; ijpt < 4; ijpt++)
	69	AddMCJetComponent(defaultselect, jetpt[ijpt]);
	70	}
	71	AddClusterComponent(defaultselect, isMC);
	72	AddTrackComponent(defaultselect, CreateDefaultTrackCuts(), isMC, isSwapEta);
	73	for(int ijpt = 0; ijpt < 4; ijpt++)
	74	AddRecJetComponent(defaultselect, CreateDefaultTrackCuts(), jetpt[ijpt], isMC, isSwapEta);
	75
	76	pttriggertask->AddAnalysisGroup(noselect);
	77	pttriggertask->AddAnalysisGroup(defaultselect);
	78
	79	// Add containers
	80	Bool_t isAOD = mgr->GetInputEventHandler()->IsA() == AliAODInputHandler::Class();
	81	AliParticleContainer *trackContainer = pttriggertask->AddParticleContainer(ntrackContainer);
	82	//trackContainer->SetClassName("AliVTrack");
	83	AliClusterContainer *clusterContainer = pttriggertask->AddClusterContainer(nclusterContainer);
	84	AliParticleContainer *mcpartcont = isMC ? pttriggertask->AddParticleContainer("MCParticlesSelected") : NULL;
	85
	86
	87	// Handle Jet Containers
	88	if(strlen(njetcontainerData)){
	89	AliJetContainer *jetcontainerData = pttriggertask->AddJetContainer(njetcontainerData, "TPC", jetradius);
	90	pttriggertask->SetDataJetContainerName("PtTriggerTaskJetsData");
	91	jetcontainerData->ConnectParticleContainer(trackContainer);
	92	jetcontainerData->SetName("PtTriggerTaskJetsData");
	93	jetcontainerData->SetJetPtCut(20.);
	94	jetcontainerData->SetJetEtaPhiEMCAL();
5f95099b	95	printf("jet container added for Data\n");
ff5093a9	96	}
	97	if(isMC && strlen(njetcontainerMC)){
	98	AliJetContainer *jetcontainerMC = pttriggertask->AddJetContainer(njetcontainerMC, "TPC", jetradius);
5f95099b	99	pttriggertask->SetMCJetContainerName("PtTriggerTaskJetsMC");
ff5093a9	100	jetcontainerMC->ConnectParticleContainer(mcpartcont);
	101	jetcontainerMC->SetName("PtTriggerTaskJetsMC");
	102	jetcontainerMC->SetJetPtCut(20.);
	103	jetcontainerMC->SetJetEtaPhiEMCAL();
5f95099b	104	printf("Jet container added for MC");
ff5093a9	105	}
	106
	107	TString containerName = mgr->GetCommonFileName();
	108	containerName += ":PtEMCalTriggerTask";
	109	printf("container name: %s\n", containerName.Data());
	110
	111	AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
	112	AliAnalysisDataContainer *coutput = mgr->CreateContainer("results", TList::Class(), AliAnalysisManager::kOutputContainer, containerName.Data());
	113
	114	//Connect input/output
	115	mgr->ConnectInput(pttriggertask, 0, cinput);
	116	mgr->ConnectOutput(pttriggertask, 1, coutput);
	117
	118	return pttriggertask;
	119	}
	120
	121	void AddClusterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, bool isMC){
0b065993	122	EMCalTriggerPtAnalysis::AliEMCalTriggerClusterAnalysisComponent *clusteranalysis = new EMCalTriggerPtAnalysis::AliEMCalTriggerClusterAnalysisComponent("clusterAnalysis");
0b065993	123	clusteranalysis->SetEnergyRange(2., 100.);
ff5093a9	124	if(isMC) clusteranalysis->SetUsePatches();
	125	group->AddAnalysisComponent(clusteranalysis);
	126	}
	127
	128	void AddTrackComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup group, AliESDtrackCuts trackcuts, bool isMC, bool isSwapEta){
0b065993	129	EMCalTriggerPtAnalysis::AliEMCalTriggerRecTrackAnalysisComponent *trackanalysis = new EMCalTriggerPtAnalysis::AliEMCalTriggerRecTrackAnalysisComponent("trackAnalysisStandard");
ff5093a9	130	group->AddAnalysisComponent(trackanalysis);
	131	// Create charged hadrons pPb standard track cuts
	132	trackanalysis->SetTrackSelection(new EMCalTriggerPtAnalysis::AliEMCalPtTaskTrackSelectionESD(trackcuts));
	133
	134	if(isMC){
	135	trackanalysis->SetRequestMCtrueTracks();
	136	trackanalysis->SetUsePatches();
	137	}
	138	if(isSwapEta) trackanalysis->SetSwapEta();
	139	}
	140
	141	void AddEventCounterComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, Bool_t isMC){
0b065993	142	EMCalTriggerPtAnalysis::AliEMCalTriggerEventCounterAnalysisComponent * evcount = new EMCalTriggerPtAnalysis::AliEMCalTriggerEventCounterAnalysisComponent("eventCounter");
ff5093a9	143	evcount->SetUsePatches(isMC);
	144	group->AddAnalysisComponent(evcount);
	145	}
	146
	147	void AddMCParticleComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group){
	148	group->AddAnalysisComponent(new EMCalTriggerPtAnalysis::AliEMCalTriggerMCParticleAnalysisComponent("partana"));
	149	}
	150
	151	void AddMCJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup *group, double minJetPt){
	152	EMCalTriggerPtAnalysis::AliEMCalTriggerMCJetAnalysisComponent *jetana = new EMCalTriggerPtAnalysis::AliEMCalTriggerMCJetAnalysisComponent(Form("MCJetAna%f", minJetPt));
	153	jetana->SetMinimumJetPt(minJetPt);
	154	jetana->SetUsePatches();
	155	group->AddAnalysisComponent(jetana);
	156	}
	157
	158	void AddRecJetComponent(EMCalTriggerPtAnalysis::AliEMCalTriggerTaskGroup group, AliESDtrackCuts trackcuts, double minJetPt, bool isMC, bool isSwapEta){
	159	EMCalTriggerPtAnalysis::AliEMCalTriggerRecJetAnalysisComponent *jetana = new EMCalTriggerPtAnalysis::AliEMCalTriggerRecJetAnalysisComponent(Form("RecJetAna%f", minJetPt));
	160	jetana->SetMinimumJetPt(minJetPt);
	161	jetana->SetUsePatches();
	162	jetana->SetSingleTrackCuts(new EMCalTriggerPtAnalysis::AliEMCalPtTaskTrackSelectionESD(trackcuts));
	163	group->AddAnalysisComponent(jetana);
	164	}
	165
	166	AliESDtrackCuts *CreateDefaultTrackCuts(){
	167	AliESDtrackCuts *standardTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(true, 1);
	168	standardTrackCuts->SetName("Standard Track cuts");
	169	standardTrackCuts->SetMinNCrossedRowsTPC(120);
	170	standardTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
	171	return standardTrackCuts;
	172	}
	173
	174	AliESDtrackCuts *CreateHybridTrackCuts(){
	175	AliESDtrackCuts* hybridTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE);
	176	hybridTrackCuts->SetName("Global Hybrid tracks, loose DCA");
	177	hybridTrackCuts->SetMaxDCAToVertexXY(2.4);
	178	hybridTrackCuts->SetMaxDCAToVertexZ(3.2);
	179	hybridTrackCuts->SetDCAToVertex2D(kTRUE);
	180	hybridTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
	181	hybridTrackCuts->SetMaxFractionSharedTPCClusters(0.4);
	182	return hybridTrackCuts;
	183	}