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

enum AlgoType {kKT, kANTIKT};
enum JetType  {kFULLJETS, kCHARGEDJETS, kNEUTRALJETS};

AliAnalysisTaskEmcalJetMass* AddTaskEmcalJetMass(const char * njetsBase, 
						 const char * njetsTag, 
						 const Double_t R,
						 const char * nrhoBase, 
						 const char * nrhoTag, 
						 const char * ntracks, 
						 const char * nclusters,
						 const char *type,					     
						 const char *CentEst,
						 Int_t       pSel,
						 TString     trigClass      = "",
						 TString     kEmcalTriggers = "");

AliAnalysisTaskEmcalJetMass* AddTaskEmcalJetMass(TString     kTracksName         = "PicoTracks", 
						 TString     kClusName           = "caloClustersCorr",
						 Double_t    R                   = 0.4, 
						 Double_t    ptminTrack          = 0.15, 
						 Double_t    etminClus           = 0.3, 
						 Double_t    ptminTag            = 4.,
						 Int_t       rhoType             = 1,
						 const char *type                = "EMCAL",
						 const char *CentEst             = "V0M",
						 Int_t       pSel                = AliVEvent::kCentral | AliVEvent::kSemiCentral | AliVEvent::kMB,
						 TString     trigClass           = "",
						 TString     kEmcalTriggers      = "",
						 TString     kPeriod             = "LHC11h"
						 ) {
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
    {
      Error("AddTaskEmcalJetMass","No analysis manager found.");
      return 0;
    }
  Bool_t ismc=kFALSE;
  ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;

  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler())
    {
      ::Error("AddTaskEmcalJetMass", "This task requires an input event handler");
      return NULL;
    }

  // #### Add necessary jet finder tasks
  gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");

  AliEmcalJetTask* jetFinderTaskBase = 0x0;
  if (strcmp(type,"TPC")==0)
    jetFinderTaskBase = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,0);
  else if (strcmp(type,"EMCAL")==0)
    jetFinderTaskBase = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kFULLJETS, ptminTrack, etminClus,0.005,0);

  TString strJetsBase = jetFinderTaskBase->GetName();

  AliAnalysisTaskRhoBase *rhoTaskBase;
  TString rhoNameBase = "";
  if(rhoType==1) {
    rhoTaskBase = AttachRhoTask(kPeriod,kTracksName,kClusName,R,ptminTrack,etminClus);
    rhoTaskBase->SetCentralityEstimator(CentEst);  
    rhoTaskBase->SelectCollisionCandidates(AliVEvent::kAny);

    if (strcmp(type,"TPC")==0)
      rhoNameBase = rhoTaskBase->GetOutRhoName();
    if (strcmp(type,"EMCAL")==0)
      rhoNameBase = rhoTaskBase->GetOutRhoScaledName();
  }

  //Configure jet tagger task
  AliAnalysisTaskEmcalJetMass *task = AddTaskEmcalJetMass(jetFinderTaskBase->GetName(),
							  R,
							  rhoNameBase,
							  kTracksName.Data(),
							  kClusName.Data(),
							  type,
							  CentEst,
							  pSel,
							  trigClass,
							  kEmcalTriggers
							  );
  
  return task;  

}

AliAnalysisTaskEmcalJetMass* AddTaskEmcalJetMass(const char * njetsBase, 
						 const Double_t R,
						 const char * nrhoBase, 
						 const char * ntracks, 
						 const char * nclusters,
						 const char * type,
						 const char * CentEst,
						 Int_t        pSel,
						 TString      trigClass,
						 TString      kEmcalTriggers
						 ) {

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
    {
      Error("AddTaskEmcalJetMass","No analysis manager found.");
      return 0;
    }
  Bool_t ismc=kFALSE;
  ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;

  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler())
    {
      ::Error("AddTaskEmcalJetMass", "This task requires an input event handler");
      return NULL;
    }

  TString wagonName = Form("JetMass_%s_TC%s",njetsBase,trigClass.Data());

  //Configure jet tagger task
  AliAnalysisTaskEmcalJetMass *task = new AliAnalysisTaskEmcalJetMass(wagonName.Data());

  task->SetNCentBins(4);
  //task->SetVzRange(-10.,10.);

  AliParticleContainer *trackCont  = task->AddParticleContainer(ntracks);
  AliClusterContainer *clusterCont = task->AddClusterContainer(nclusters);

  task->SetJetContainerBase(0);

  TString strType(type);
  AliJetContainer *jetContBase = task->AddJetContainer(njetsBase,strType,R);
  if(jetContBase) {
    jetContBase->SetRhoName(nrhoBase);
    jetContBase->ConnectParticleContainer(trackCont);
    jetContBase->ConnectClusterContainer(clusterCont);
    jetContBase->SetZLeadingCut(0.98,0.98);
    task->SetPercAreaCut(0.6, 0);
  }

  task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());

  task->SetCentralityEstimator(CentEst);

  task->SelectCollisionCandidates(pSel);

  task->SetUseAliAnaUtils(kFALSE);

  mgr->AddTask(task);

  //Connnect input
  mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );

  //Connect output
  TString contName(wagonName);
  TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
  mgr->ConnectOutput(task,1,coutput1);

  return task;  

}


AliAnalysisTaskRhoBase *AttachRhoTask(TString     kPeriod             ,// = "LHC13b",
				      TString     kTracksName         ,// = "PicoTracks", 
				      TString     kClusName           ,// = "caloClustersCorr",
				      Double_t    R                   ,// = 0.4, 
				      Double_t    ptminTrack          ,// = 0.15, 
				      Double_t    etminClus            // = 0.3 
				      ) {
  
  AliAnalysisTaskRhoBase *rhoTaskBase;

  kPeriod.ToLower();

  // Add kt jet finder and rho task in case we want background subtraction
  AliEmcalJetTask *jetFinderKt;
  AliEmcalJetTask *jetFinderAKt;
  jetFinderKt   = AddTaskEmcalJet(kTracksName, "", kKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,0);
  jetFinderAKt  = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,0);

  if(kPeriod.EqualTo("lhc13b") || kPeriod.EqualTo("lhc13c") || kPeriod.EqualTo("lhc13d") || kPeriod.EqualTo("lhc13e") || kPeriod.EqualTo("lhc13f")) {

    jetFinderKt->SetMinJetPt(0.);

    gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRhoSparse.C");  
    TF1 *fScale = new TF1("fScale","1.42",0.,100.); //scale factor for pPb
    AliAnalysisTaskRhoSparse *rhoTaskSparse = AddTaskRhoSparse(
			       jetFinderKt->GetName(),
			       jetFinderAKt->GetName(),
			       kTracksName,
			       kClusName,
			       Form("RhoSparseR%03d",(int)(100*R)),
			       R,
			       "TPC",
			       0.01,
			       0.15,
			       0,
			       fScale,
			       0,
			       kTRUE,
			       Form("RhoSparseR%03d",(int)(100*R)),
			       kTRUE
			       );
    rhoTaskSparse->SetUseAliAnaUtils(kTRUE);

    rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTaskSparse;
  }
  else if(kPeriod.EqualTo("lhc10h") || kPeriod.EqualTo("lhc11h") ) {

    gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRho.C");

    TF1* sfunc = new TF1("sfunc","[0]*x*x+[1]*x+[2]",-1,100);
    sfunc->SetParameter(2,1.76458);
    sfunc->SetParameter(1,-0.0111656);
    sfunc->SetParameter(0,0.000107296);
    AliAnalysisTaskRho *rhoTask = AddTaskRho(
					     jetFinderKt->GetName(), 
					     kTracksName, 
					     kClusName, 
					     Form("RhoR%03dptmin%3.0f",(int)(100*R),ptminTrack*1000.0), 
					     R, 
					     "TPC", 
					     0.01, 
					     0, 
					     sfunc, 
					     2, 
					     kTRUE);
    rhoTask->SetHistoBins(100,0,250);

    rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTask;

  }

  return rhoTaskBase;

}
Commit	Line	Data
8612dfc8	1	enum AlgoType {kKT, kANTIKT};
	2	enum JetType {kFULLJETS, kCHARGEDJETS, kNEUTRALJETS};
	3
	4	AliAnalysisTaskEmcalJetMass* AddTaskEmcalJetMass(const char * njetsBase,
	5	const char * njetsTag,
	6	const Double_t R,
	7	const char * nrhoBase,
	8	const char * nrhoTag,
	9	const char * ntracks,
	10	const char * nclusters,
	11	const char *type,
	12	const char *CentEst,
	13	Int_t pSel,
	14	TString trigClass = "",
	15	TString kEmcalTriggers = "");
	16
	17	AliAnalysisTaskEmcalJetMass* AddTaskEmcalJetMass(TString kTracksName = "PicoTracks",
	18	TString kClusName = "caloClustersCorr",
	19	Double_t R = 0.4,
	20	Double_t ptminTrack = 0.15,
	21	Double_t etminClus = 0.3,
	22	Double_t ptminTag = 4.,
	23	Int_t rhoType = 1,
	24	const char *type = "EMCAL",
	25	const char *CentEst = "V0M",
	26	Int_t pSel = AliVEvent::kCentral \| AliVEvent::kSemiCentral \| AliVEvent::kMB,
	27	TString trigClass = "",
	28	TString kEmcalTriggers = "",
	29	TString kPeriod = "LHC11h"
	30	) {
	31
	32	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	33	if (!mgr)
	34	{
	35	Error("AddTaskEmcalJetMass","No analysis manager found.");
	36	return 0;
	37	}
	38	Bool_t ismc=kFALSE;
	39	ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
	40
	41	// Check the analysis type using the event handlers connected to the analysis manager.
	42	//==============================================================================
	43	if (!mgr->GetInputEventHandler())
	44	{
	45	::Error("AddTaskEmcalJetMass", "This task requires an input event handler");
	46	return NULL;
	47	}
	48
	49	// #### Add necessary jet finder tasks
	50	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
	51
	52	AliEmcalJetTask* jetFinderTaskBase = 0x0;
	53	if (strcmp(type,"TPC")==0)
	54	jetFinderTaskBase = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,0);
	55	else if (strcmp(type,"EMCAL")==0)
	56	jetFinderTaskBase = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kFULLJETS, ptminTrack, etminClus,0.005,0);
	57
	58	TString strJetsBase = jetFinderTaskBase->GetName();
	59
	60	AliAnalysisTaskRhoBase *rhoTaskBase;
	61	TString rhoNameBase = "";
	62	if(rhoType==1) {
	63	rhoTaskBase = AttachRhoTask(kPeriod,kTracksName,kClusName,R,ptminTrack,etminClus);
	64	rhoTaskBase->SetCentralityEstimator(CentEst);
65	rhoTaskBase->SelectCollisionCandidates(AliVEvent::kAny);
66
67	if (strcmp(type,"TPC")==0)
68	rhoNameBase = rhoTaskBase->GetOutRhoName();
69	if (strcmp(type,"EMCAL")==0)
70	rhoNameBase = rhoTaskBase->GetOutRhoScaledName();
71	}
72
73	//Configure jet tagger task
74	AliAnalysisTaskEmcalJetMass *task = AddTaskEmcalJetMass(jetFinderTaskBase->GetName(),
75	R,
76	rhoNameBase,
77	kTracksName.Data(),
78	kClusName.Data(),
79	type,
80	CentEst,
81	pSel,
82	trigClass,
83	kEmcalTriggers
84	);
85
86	return task;
87
88	}
89
90	AliAnalysisTaskEmcalJetMass* AddTaskEmcalJetMass(const char * njetsBase,
91	const Double_t R,
92	const char * nrhoBase,
93	const char * ntracks,
94	const char * nclusters,
95	const char * type,
96	const char * CentEst,
97	Int_t pSel,
98	TString trigClass,
99	TString kEmcalTriggers
100	) {
101
102	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
103	if (!mgr)
104	{
105	Error("AddTaskEmcalJetMass","No analysis manager found.");
106	return 0;
107	}
108	Bool_t ismc=kFALSE;
109	ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
110
111	// Check the analysis type using the event handlers connected to the analysis manager.
112	//==============================================================================
113	if (!mgr->GetInputEventHandler())
114	{
115	::Error("AddTaskEmcalJetMass", "This task requires an input event handler");
116	return NULL;
117	}
118
119	TString wagonName = Form("JetMass_%s_TC%s",njetsBase,trigClass.Data());
120
121	//Configure jet tagger task
122	AliAnalysisTaskEmcalJetMass *task = new AliAnalysisTaskEmcalJetMass(wagonName.Data());
123
124	task->SetNCentBins(4);
125	//task->SetVzRange(-10.,10.);
126
127	AliParticleContainer *trackCont = task->AddParticleContainer(ntracks);
128	AliClusterContainer *clusterCont = task->AddClusterContainer(nclusters);
129
130	task->SetJetContainerBase(0);
131
132	TString strType(type);
133	AliJetContainer *jetContBase = task->AddJetContainer(njetsBase,strType,R);
134	if(jetContBase) {
135	jetContBase->SetRhoName(nrhoBase);
136	jetContBase->ConnectParticleContainer(trackCont);
137	jetContBase->ConnectClusterContainer(clusterCont);
138	jetContBase->SetZLeadingCut(0.98,0.98);
139	task->SetPercAreaCut(0.6, 0);
140	}
141
142	task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());
143
144	task->SetCentralityEstimator(CentEst);
145
146	task->SelectCollisionCandidates(pSel);
147
148	task->SetUseAliAnaUtils(kFALSE);
149
150	mgr->AddTask(task);
151
152	//Connnect input
153	mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );
154
155	//Connect output
156	TString contName(wagonName);
157	TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
158	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
159	mgr->ConnectOutput(task,1,coutput1);
160
161	return task;
162
163	}
164
165
166	AliAnalysisTaskRhoBase *AttachRhoTask(TString kPeriod ,// = "LHC13b",
167	TString kTracksName ,// = "PicoTracks",
168	TString kClusName ,// = "caloClustersCorr",
169	Double_t R ,// = 0.4,
170	Double_t ptminTrack ,// = 0.15,
171	Double_t etminClus // = 0.3
172	) {
173
174	AliAnalysisTaskRhoBase *rhoTaskBase;
175
176	kPeriod.ToLower();
177
178	// Add kt jet finder and rho task in case we want background subtraction
179	AliEmcalJetTask *jetFinderKt;
180	AliEmcalJetTask *jetFinderAKt;
181	jetFinderKt = AddTaskEmcalJet(kTracksName, "", kKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,0);
182	jetFinderAKt = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,0);
183
184	if(kPeriod.EqualTo("lhc13b") \|\| kPeriod.EqualTo("lhc13c") \|\| kPeriod.EqualTo("lhc13d") \|\| kPeriod.EqualTo("lhc13e") \|\| kPeriod.EqualTo("lhc13f")) {
185
186	jetFinderKt->SetMinJetPt(0.);
187
188	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRhoSparse.C");
189	TF1 *fScale = new TF1("fScale","1.42",0.,100.); //scale factor for pPb
190	AliAnalysisTaskRhoSparse *rhoTaskSparse = AddTaskRhoSparse(
191	jetFinderKt->GetName(),
192	jetFinderAKt->GetName(),
193	kTracksName,
194	kClusName,
195	Form("RhoSparseR%03d",(int)(100*R)),
196	R,
197	"TPC",
198	0.01,
199	0.15,
200	0,
201	fScale,
202	0,
203	kTRUE,
204	Form("RhoSparseR%03d",(int)(100*R)),
205	kTRUE
206	);
207	rhoTaskSparse->SetUseAliAnaUtils(kTRUE);
208
209	rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTaskSparse;
210	}
211	else if(kPeriod.EqualTo("lhc10h") \|\| kPeriod.EqualTo("lhc11h") ) {
212
213	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRho.C");
214
215	TF1* sfunc = new TF1("sfunc","[0]xx+[1]*x+[2]",-1,100);
216	sfunc->SetParameter(2,1.76458);
217	sfunc->SetParameter(1,-0.0111656);
218	sfunc->SetParameter(0,0.000107296);
219	AliAnalysisTaskRho *rhoTask = AddTaskRho(
220	jetFinderKt->GetName(),
221	kTracksName,
222	kClusName,
223	Form("RhoR%03dptmin%3.0f",(int)(100R),ptminTrack1000.0),
224	R,
225	"TPC",
226	0.01,
227	0,
228	sfunc,
229	2,
230	kTRUE);
231	rhoTask->SetHistoBins(100,0,250);
232
233	rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTask;
234
235	}
236
237	return rhoTaskBase;
238
239	}