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

  AliEmcalJetTask* jetFinderTaskTag  = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTag, etminClus,0.005,recombScheme,tag.Data());

  if(tag.IsEqual("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);
    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.);
      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;
    }
  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("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());

  if(tag.IsEqual("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("RhoR%03dptmin%3.0f%s",(int)(100*R),ptminTrack*1000.0,kTracksName.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	}
	40	Bool_t ismc=kFALSE;
	41	ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
	42
	43	// Check the analysis type using the event handlers connected to the analysis manager.
	44	//==============================================================================
	45	if (!mgr->GetInputEventHandler())
	46	{
	47	::Error("AddTaskEmcalJetTagger", "This task requires an input event handler");
	48	return NULL;
	49	}
	50
	51	// #### Add necessary jet finder tasks
	52	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
	53
	54	AliEmcalJetTask* jetFinderTaskBase = 0x0;
	55	if (strcmp(type,"TPC")==0)
13972cbd	56	jetFinderTaskBase = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
8612dfc8	57	else if (strcmp(type,"EMCAL")==0)
13972cbd	58	jetFinderTaskBase = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kFULLJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
8612dfc8	59
13972cbd	60	AliEmcalJetTask* jetFinderTaskTag = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTag, etminClus,0.005,recombScheme,tag.Data());
	61
	62	if(tag.IsEqual("JetPythia")) {
	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) {
396ffc82 MV	75	rhoTaskBase = AttachRhoTaskTagger(kPeriod,kTracksName,kClusName,R,ptminTrack,etminClus,recombScheme);
	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) {
	85	rhoTaskTag = AttachRhoTaskTagger(kPeriod,kTracksName,kClusName,R,ptminTag,0.);
	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	}
	131	Bool_t ismc=kFALSE;
	132	ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
	133
	134	// Check the analysis type using the event handlers connected to the analysis manager.
	135	//==============================================================================
	136	if (!mgr->GetInputEventHandler())
	137	{
	138	::Error("AddTaskEmcalJetTagger", "This task requires an input event handler");
	139	return NULL;
	140	}
	141
	142	TString wagonName = Form("JetTagger_%s_%s_TC%s",njetsBase,njetsTag,trigClass.Data());
	143
	144	//Configure jet tagger task
	145	AliAnalysisTaskEmcalJetTagger *task = new AliAnalysisTaskEmcalJetTagger(wagonName.Data());
	146
	147	task->SetNCentBins(4);
	148	//task->SetVzRange(-10.,10.);
	149
	150	AliParticleContainer *trackCont = task->AddParticleContainer(ntracks);
	151	AliClusterContainer *clusterCont = task->AddClusterContainer(nclusters);
	152
	153	task->SetJetContainerBase(0);
154	task->SetJetContainerTag(1);
155
156	TString strType(type);
157	AliJetContainer *jetContBase = task->AddJetContainer(njetsBase,strType,R);
158	if(jetContBase) {
159	jetContBase->SetRhoName(nrhoBase);
160	jetContBase->ConnectParticleContainer(trackCont);
161	jetContBase->ConnectClusterContainer(clusterCont);
162	jetContBase->SetZLeadingCut(0.98,0.98);
163	}
164
165	AliJetContainer *jetContTag = task->AddJetContainer(njetsTag,"TPC",R);
166	if(jetContTag) {
167	jetContTag->SetRhoName(nrhoTag);
168	jetContTag->ConnectParticleContainer(trackCont);
169	jetContTag->ConnectClusterContainer(clusterCont);
170	}
171
172	for(Int_t i=0; i<2; i++) {
173	task->SetPercAreaCut(0.6, i);
174	}
175
176	task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());
177
178	task->SetCentralityEstimator(CentEst);
179
180	task->SelectCollisionCandidates(pSel);
181
182	task->SetUseAliAnaUtils(kFALSE);
183
184	mgr->AddTask(task);
185
186	//Connnect input
187	mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );
188
189	//Connect output
190	TString contName(wagonName);
191	TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
192	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
193	mgr->ConnectOutput(task,1,coutput1);
194
195	return task;
196
197	}
198
199
200	AliAnalysisTaskRhoBase *AttachRhoTaskTagger(TString kPeriod = "LHC13b",
201	TString kTracksName = "PicoTracks",
202	TString kClusName = "caloClustersCorr",
203	Double_t R = 0.4,
204	Double_t ptminTrack = 0.15,
396ffc82	205	Double_t etminClus = 0.3,
13972cbd	206	Int_t recombScheme = 0,
13972cbd	207	TString tag = "Jet"
8612dfc8	208	) {
	209
	210	AliAnalysisTaskRhoBase *rhoTaskBase;
	211
	212	kPeriod.ToLower();
	213
	214	// Add kt jet finder and rho task in case we want background subtraction
	215	AliEmcalJetTask *jetFinderKt;
	216	AliEmcalJetTask *jetFinderAKt;
13972cbd	217	jetFinderKt = AddTaskEmcalJet(kTracksName, "", kKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
	218	jetFinderAKt = AddTaskEmcalJet(kTracksName, "", kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,recombScheme,tag.Data());
	219
	220	if(tag.IsEqual("JetPythia")) {
	221	jetFinderKt->SelectConstituents(TObject::kBitMask, 0);
	222	jetFinderAKt->SelectConstituents(TObject::kBitMask, 0);
	223	}
8612dfc8	224
	225	if(kPeriod.EqualTo("lhc13b") \|\| kPeriod.EqualTo("lhc13c") \|\| kPeriod.EqualTo("lhc13d") \|\| kPeriod.EqualTo("lhc13e") \|\| kPeriod.EqualTo("lhc13f")) {
	226
	227
	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);
	250
	251	rhoTaskBase = dynamic_cast<AliAnalysisTaskRhoBase*>rhoTaskSparse;
	252	}
	253	else if(kPeriod.EqualTo("lhc10h") \|\| kPeriod.EqualTo("lhc11h") ) {
	254
	255	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRho.C");
	256
	257	TF1* sfunc = new TF1("sfunc","[0]xx+[1]*x+[2]",-1,100);
	258	sfunc->SetParameter(2,1.76458);
	259	sfunc->SetParameter(1,-0.0111656);
	260	sfunc->SetParameter(0,0.000107296);
396ffc82	261	TString rhoname = Form("RhoR%03dptmin%3.0f%s",(int)(100R),ptminTrack1000.0,kTracksName.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;
	277
	278	}
	279
	280	return rhoTaskBase;
	281
	282	}