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

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

AliAnalysisTaskEmcalJetTagger* AddTaskEmcalJetTagger(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 = "");

AliAnalysisTaskEmcalJetTagger* AddTaskEmcalJetTagger(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",
						     Int_t       recombScheme        = 0,
						     TString     tag1                = "Jet",
						     TString     tag2                = ""
						     ) {
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
    {
      Error("AddTaskEmcalJetTagger","No analysis manager found.");
      return 0;
    }

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

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

  if(tag2.IsNull()) tag2=tag1;

  AliEmcalJetTask* jetFinderTaskBase = 0x0;
  if (strcmp(type,"TPC")==0)
    jetFinderTaskBase = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag1.Data());
  else if (strcmp(type,"EMCAL")==0)
    jetFinderTaskBase = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kFULLJETS, ptminTrack, etminClus,0.005,recombScheme,tag1.Data());
  jetFinderTaskBase->SelectCollisionCandidates(AliVEvent::kAny);
  jetFinderTaskBase->SetMinJetPt(0.);

  AliEmcalJetTask* jetFinderTaskTag  = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTag, etminClus,0.005,recombScheme,tag2.Data());
  jetFinderTaskTag->SelectCollisionCandidates(AliVEvent::kAny);
  jetFinderTaskTag->SetMinJetPt(0.);

  if(tag1.EqualTo("JetPythia"))
    jetFinderTaskBase->SelectConstituents(TObject::kBitMask, 0);
  if(tag2.EqualTo("JetPythia"))
    jetFinderTaskTag->SelectConstituents(TObject::kBitMask, 0);
  
  TString strJetsBase = jetFinderTaskBase->GetName();
  TString strJetsTag  = jetFinderTaskTag->GetName();

  AliAnalysisTaskRhoBase *rhoTaskBase;
  AliAnalysisTaskRhoBase *rhoTaskTag;
  TString rhoNameBase = "";
  TString rhoNameTag  = "";
  if(rhoType==1) {
    rhoTaskBase = AttachRhoTaskTagger(kPeriod,kTracksName,kClusName,R,ptminTrack,etminClus,recombScheme,tag1);
    if(rhoTaskBase) {
      rhoTaskBase->SetCentralityEstimator(CentEst);  
      rhoTaskBase->SelectCollisionCandidates(AliVEvent::kAny);
      if (strcmp(type,"TPC")==0)
	rhoNameBase = rhoTaskBase->GetOutRhoName();    
      if (strcmp(type,"EMCAL")==0)
	rhoNameBase = rhoTaskBase->GetOutRhoScaledName();
    }
    if(rhoTaskTag) {
      rhoTaskTag = AttachRhoTaskTagger(kPeriod,kTracksName,kClusName,R,ptminTag,0.,recombScheme,tag2);
      rhoTaskTag->SetCentralityEstimator(CentEst); 
      rhoTaskTag->SelectCollisionCandidates(AliVEvent::kAny);
      rhoNameTag  = rhoTaskTag->GetOutRhoName();
    }
  }

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

}

AliAnalysisTaskEmcalJetTagger* AddTaskEmcalJetTagger(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
						     ) {

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
    {
      Error("AddTaskEmcalJetTagger","No analysis manager found.");
      return 0;
    }

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

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

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

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

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

  task->SetJetContainerBase(0);
  task->SetJetContainerTag(1);

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

  AliJetContainer *jetContTag = task->AddJetContainer(njetsTag,"TPC",R);
  if(jetContTag) {
    jetContTag->SetRhoName(nrhoTag);
    jetContTag->ConnectParticleContainer(trackCont);
    jetContTag->ConnectClusterContainer(clusterCont);
  }
  for(Int_t i=0; i<2; i++) {
    task->SetPercAreaCut(0.6, i);
  }
  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;  
}

//Attach rho task
AliAnalysisTaskRhoBase *AttachRhoTaskTagger(TString     kPeriod             = "LHC13b",
					    TString     kTracksName         = "PicoTracks", 
					    TString     kClusName           = "caloClustersCorr",
					    Double_t    R                   = 0.4, 
					    Double_t    ptminTrack          = 0.15, 
					    Double_t    etminClus           = 0.3,
					    Int_t       recombScheme        = 0,
					    TString     tag                 = "Jet"
					    ) {
  
  AliAnalysisTaskRhoBase *rhoTaskBase;

  kPeriod.ToLower();

  // Add kt jet finder and rho task in case we want background subtraction
  gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");  
  AliEmcalJetTask *jetFinderKt;
  AliEmcalJetTask *jetFinderAKt;
  jetFinderKt   = AddTaskEmcalJet(kTracksName, "", kKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
  jetFinderAKt  = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
  jetFinderKt->SelectCollisionCandidates(AliVEvent::kAny);
  jetFinderAKt->SelectCollisionCandidates(AliVEvent::kAny);
  jetFinderKt->SetMinJetPt(0.);
  jetFinderAKt->SetMinJetPt(0.);

  if(tag.EqualTo("JetPythia")) {
    jetFinderKt->SelectConstituents(TObject::kBitMask, 0);
    jetFinderAKt->SelectConstituents(TObject::kBitMask, 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);
    TString rhoname = Form("%sRhoR%03dptmin%3.0f%s",tag.Data(),(int)(100*R),ptminTrack*1000.0,kTracksName.Data());
    Printf("rhoname: %s",rhoname.Data());
    AliAnalysisTaskRho *rhoTask = AddTaskRho(
					     jetFinderKt->GetName(), 
					     kTracksName, 
					     kClusName, 
					     rhoname, 
					     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	AliAnalysisTaskEmcalJetTagger* AddTaskEmcalJetTagger(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	AliAnalysisTaskEmcalJetTagger* AddTaskEmcalJetTagger(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 = "",
396ffc82	29	TString kPeriod = "LHC11h",
13972cbd	30	Int_t recombScheme = 0,
ba7663ad	31	TString tag1 = "Jet",
ba7663ad	32	TString tag2 = ""
8612dfc8	33	) {
	34
	35	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	36	if (!mgr)
	37	{
	38	Error("AddTaskEmcalJetTagger","No analysis manager found.");
	39	return 0;
	40	}
8612dfc8	41
	42	// Check the analysis type using the event handlers connected to the analysis manager.
	43	//==============================================================================
	44	if (!mgr->GetInputEventHandler())
	45	{
	46	::Error("AddTaskEmcalJetTagger", "This task requires an input event handler");
	47	return NULL;
	48	}
	49
	50	// #### Add necessary jet finder tasks
	51	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
	52
ba7663ad	53	if(tag2.IsNull()) tag2=tag1;
ba7663ad	54
8612dfc8	55	AliEmcalJetTask* jetFinderTaskBase = 0x0;
8612dfc8	56	if (strcmp(type,"TPC")==0)
ba7663ad	57	jetFinderTaskBase = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag1.Data());
8612dfc8	58	else if (strcmp(type,"EMCAL")==0)
ba7663ad	59	jetFinderTaskBase = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kFULLJETS, ptminTrack, etminClus,0.005,recombScheme,tag1.Data());
785ed98a	60	jetFinderTaskBase->SelectCollisionCandidates(AliVEvent::kAny);
8a5cefd1	61	jetFinderTaskBase->SetMinJetPt(0.);
8612dfc8	62
ba7663ad	63	AliEmcalJetTask* jetFinderTaskTag = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTag, etminClus,0.005,recombScheme,tag2.Data());
785ed98a	64	jetFinderTaskTag->SelectCollisionCandidates(AliVEvent::kAny);
8a5cefd1	65	jetFinderTaskTag->SetMinJetPt(0.);
13972cbd	66
ba7663ad	67	if(tag1.EqualTo("JetPythia"))
13972cbd	68	jetFinderTaskBase->SelectConstituents(TObject::kBitMask, 0);
ba7663ad	69	if(tag2.EqualTo("JetPythia"))
13972cbd	70	jetFinderTaskTag->SelectConstituents(TObject::kBitMask, 0);
ba7663ad	71
8612dfc8	72	TString strJetsBase = jetFinderTaskBase->GetName();
	73	TString strJetsTag = jetFinderTaskTag->GetName();
	74
	75	AliAnalysisTaskRhoBase *rhoTaskBase;
	76	AliAnalysisTaskRhoBase *rhoTaskTag;
	77	TString rhoNameBase = "";
	78	TString rhoNameTag = "";
	79	if(rhoType==1) {
ba7663ad	80	rhoTaskBase = AttachRhoTaskTagger(kPeriod,kTracksName,kClusName,R,ptminTrack,etminClus,recombScheme,tag1);
396ffc82 MV	81	if(rhoTaskBase) {
	82	rhoTaskBase->SetCentralityEstimator(CentEst);
	83	rhoTaskBase->SelectCollisionCandidates(AliVEvent::kAny);
	84	if (strcmp(type,"TPC")==0)
	85	rhoNameBase = rhoTaskBase->GetOutRhoName();
	86	if (strcmp(type,"EMCAL")==0)
	87	rhoNameBase = rhoTaskBase->GetOutRhoScaledName();
	88	}
	89	if(rhoTaskTag) {
ba7663ad	90	rhoTaskTag = AttachRhoTaskTagger(kPeriod,kTracksName,kClusName,R,ptminTag,0.,recombScheme,tag2);
396ffc82 MV	91	rhoTaskTag->SetCentralityEstimator(CentEst);
	92	rhoTaskTag->SelectCollisionCandidates(AliVEvent::kAny);
	93	rhoNameTag = rhoTaskTag->GetOutRhoName();
	94	}
8612dfc8	95	}
	96
	97	//Configure jet tagger task
	98	AliAnalysisTaskEmcalJetTagger *task = AddTaskEmcalJetTagger(jetFinderTaskBase->GetName(),
	99	jetFinderTaskTag->GetName(),
	100	R,
	101	rhoNameBase,
	102	rhoNameTag,
	103	kTracksName.Data(),
	104	kClusName.Data(),
	105	type,
	106	CentEst,
	107	pSel,
	108	trigClass,
	109	kEmcalTriggers
	110	);
	111
	112	return task;
	113
	114	}
	115
	116	AliAnalysisTaskEmcalJetTagger* AddTaskEmcalJetTagger(const char * njetsBase,
	117	const char * njetsTag,
	118	const Double_t R,
	119	const char * nrhoBase,
	120	const char * nrhoTag,
	121	const char * ntracks,
	122	const char * nclusters,
	123	const char * type,
	124	const char * CentEst,
	125	Int_t pSel,
	126	TString trigClass,
	127	TString kEmcalTriggers
	128	) {
	129
	130	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	131	if (!mgr)
	132	{
	133	Error("AddTaskEmcalJetTagger","No analysis manager found.");
	134	return 0;
	135	}
8612dfc8	136
	137	// Check the analysis type using the event handlers connected to the analysis manager.
	138	//==============================================================================
	139	if (!mgr->GetInputEventHandler())
	140	{
	141	::Error("AddTaskEmcalJetTagger", "This task requires an input event handler");
	142	return NULL;
	143	}
	144
	145	TString wagonName = Form("JetTagger_%s_%s_TC%s",njetsBase,njetsTag,trigClass.Data());
	146
	147	//Configure jet tagger task
	148	AliAnalysisTaskEmcalJetTagger *task = new AliAnalysisTaskEmcalJetTagger(wagonName.Data());
	149
	150	task->SetNCentBins(4);
	151	//task->SetVzRange(-10.,10.);
	152
	153	AliParticleContainer *trackCont = task->AddParticleContainer(ntracks);
	154	AliClusterContainer *clusterCont = task->AddClusterContainer(nclusters);
	155
	156	task->SetJetContainerBase(0);
	157	task->SetJetContainerTag(1);
	158
	159	TString strType(type);
	160	AliJetContainer *jetContBase = task->AddJetContainer(njetsBase,strType,R);
	161	if(jetContBase) {
	162	jetContBase->SetRhoName(nrhoBase);
	163	jetContBase->ConnectParticleContainer(trackCont);
	164	jetContBase->ConnectClusterContainer(clusterCont);
8612dfc8	165	}
	166
	167	AliJetContainer *jetContTag = task->AddJetContainer(njetsTag,"TPC",R);
	168	if(jetContTag) {
	169	jetContTag->SetRhoName(nrhoTag);
	170	jetContTag->ConnectParticleContainer(trackCont);
	171	jetContTag->ConnectClusterContainer(clusterCont);
	172	}
8612dfc8	173	for(Int_t i=0; i<2; i++) {
	174	task->SetPercAreaCut(0.6, i);
	175	}
8612dfc8	176	task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());
8612dfc8	177	task->SetCentralityEstimator(CentEst);
8612dfc8	178	task->SelectCollisionCandidates(pSel);
8612dfc8	179	task->SetUseAliAnaUtils(kFALSE);
	180
	181	mgr->AddTask(task);
	182
	183	//Connnect input
	184	mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );
	185
	186	//Connect output
	187	TString contName(wagonName);
	188	TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
	189	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
	190	mgr->ConnectOutput(task,1,coutput1);
	191
	192	return task;
8612dfc8	193	}
8612dfc8	194
ba7663ad	195	//Attach rho task
8612dfc8	196	AliAnalysisTaskRhoBase *AttachRhoTaskTagger(TString kPeriod = "LHC13b",
	197	TString kTracksName = "PicoTracks",
	198	TString kClusName = "caloClustersCorr",
	199	Double_t R = 0.4,
	200	Double_t ptminTrack = 0.15,
396ffc82	201	Double_t etminClus = 0.3,
13972cbd	202	Int_t recombScheme = 0,
13972cbd	203	TString tag = "Jet"
8612dfc8	204	) {
	205
	206	AliAnalysisTaskRhoBase *rhoTaskBase;
	207
	208	kPeriod.ToLower();
	209
	210	// Add kt jet finder and rho task in case we want background subtraction
ea9931b6	211	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
8612dfc8	212	AliEmcalJetTask *jetFinderKt;
8612dfc8	213	AliEmcalJetTask *jetFinderAKt;
13972cbd	214	jetFinderKt = AddTaskEmcalJet(kTracksName, "", kKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
13972cbd	215	jetFinderAKt = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
785ed98a	216	jetFinderKt->SelectCollisionCandidates(AliVEvent::kAny);
785ed98a	217	jetFinderAKt->SelectCollisionCandidates(AliVEvent::kAny);
8a5cefd1	218	jetFinderKt->SetMinJetPt(0.);
	219	jetFinderAKt->SetMinJetPt(0.);
	220
c10cf894	221	if(tag.EqualTo("JetPythia")) {
13972cbd	222	jetFinderKt->SelectConstituents(TObject::kBitMask, 0);
	223	jetFinderAKt->SelectConstituents(TObject::kBitMask, 0);
	224	}
8612dfc8	225
	226	if(kPeriod.EqualTo("lhc13b") \|\| kPeriod.EqualTo("lhc13c") \|\| kPeriod.EqualTo("lhc13d") \|\| kPeriod.EqualTo("lhc13e") \|\| kPeriod.EqualTo("lhc13f")) {
	227
8612dfc8	228	jetFinderKt->SetMinJetPt(0.);
	229
	230	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRhoSparse.C");
	231	TF1 *fScale = new TF1("fScale","1.42",0.,100.); //scale factor for pPb
	232	AliAnalysisTaskRhoSparse *rhoTaskSparse = AddTaskRhoSparse(
	233	jetFinderKt->GetName(),
	234	jetFinderAKt->GetName(),
	235	kTracksName,
	236	kClusName,
	237	Form("RhoSparseR%03d",(int)(100*R)),
	238	R,
	239	"TPC",
	240	0.01,
	241	0.15,
	242	0,
	243	fScale,
	244	0,
	245	kTRUE,
	246	Form("RhoSparseR%03d",(int)(100*R)),
	247	kTRUE
	248	);
	249	rhoTaskSparse->SetUseAliAnaUtils(kTRUE);
8612dfc8	250	rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTaskSparse;
	251	}
	252	else if(kPeriod.EqualTo("lhc10h") \|\| kPeriod.EqualTo("lhc11h") ) {
	253
	254	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRho.C");
	255
	256	TF1* sfunc = new TF1("sfunc","[0]xx+[1]*x+[2]",-1,100);
	257	sfunc->SetParameter(2,1.76458);
	258	sfunc->SetParameter(1,-0.0111656);
	259	sfunc->SetParameter(0,0.000107296);
c10cf894	260	TString rhoname = Form("%sRhoR%03dptmin%3.0f%s",tag.Data(),(int)(100R),ptminTrack1000.0,kTracksName.Data());
c10cf894	261	Printf("rhoname: %s",rhoname.Data());
8612dfc8	262	AliAnalysisTaskRho *rhoTask = AddTaskRho(
	263	jetFinderKt->GetName(),
	264	kTracksName,
	265	kClusName,
396ffc82	266	rhoname,
8612dfc8	267	R,
	268	"TPC",
	269	0.01,
	270	0,
	271	sfunc,
	272	2,
	273	kTRUE);
	274	rhoTask->SetHistoBins(100,0,250);
	275
	276	rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTask;
8612dfc8	277	}
	278
	279	return rhoTaskBase;
8612dfc8	280	}