[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     tag                 = "Jet"
						     ) {
  
  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");

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

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

  if(tag.EqualTo("JetPythia")) {
    jetFinderTaskBase->SelectConstituents(TObject::kBitMask, 0);
    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,tag);
    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,tag);
      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);
    jetContBase->SetZLeadingCut(0.98,0.98);
  }

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

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