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

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

AliAnalysisTaskEmcalJetMassBkg* AddTaskEmcalJetMassBkg(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 = "");

AliAnalysisTaskEmcalJetMassBkg* AddTaskEmcalJetMassBkg(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("AddTaskEmcalJetMassBkg","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("AddTaskEmcalJetMassBkg", "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);
    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();
    }
  }

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

}

AliAnalysisTaskEmcalJetMassBkg* AddTaskEmcalJetMassBkg(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("AddTaskEmcalJetMassBkg","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("AddTaskEmcalJetMassBkg", "This task requires an input event handler");
      return NULL;
    }

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

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

  task->SetNCentBins(4);
  task->SetConeRadius(R);

  if (strcmp(type,"TPC")==0)
    task->SetConeEtaPhiTPC();
  else if (strcmp(type,"EMCAL")==0)
    task->SetConeEtaPhiEMCAL();

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