[u/mrichter/AliRoot.git] / PWGJE / macros / AddTaskFragmentationFunction.C


/*************************************************************************************************
***  Add Fragmentation Function Task ***
**************************************************************************************************
The fragmentation function task expects an ESD filter and jet finder running before this task. 
Or it runs on delta-AODs filled with filtered tracks and jets before.

** Parameters **
(char) recJetsBranch: branch in AOD for (reconstructed) jets
(char) genJetsBranch: branch in AOD for (generated) jets
(char) jetType: "AOD"   jets from recJetsBranch
                "AODMC" jets from genJetsBranch
                "KINE"  jets from PYCELL
                 +"b" (e.g. "AODb") jets with acceptance cuts
(char) trackType: "AOD"     reconstructed tracks from AOD filled by ESD filter (choose filter mask!)
                  "AODMC"   MC tracks from AOD filled by kine filter
                  "KINE"    kine particles from MC event 
                  +"2" (e.g. "AOD2")  charged tracks only
                  +"b" (e.g. "AOD2b") with acceptance cuts
(UInt_t) filterMask: select filter bit of ESD filter task

***************************************************************************************************/

AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(UInt_t iFlag=1, UInt_t filterMask=32, Int_t eventClass=0){
        
        AliAnalysisTaskFragmentationFunction *ff=0;

        // UA1 Jets
        // only reconstructed (default)
	if(iFlag&(1<<0)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "", "", "", filterMask, 0.4,0,1000., eventClass);
        // charged MC tracks and jets
	if(iFlag&(1<<1)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMC", "AODMC2", filterMask, 0.4,0,1000., eventClass);
        // charged MC tracks and jets with acceptance cuts
	if(iFlag&(1<<2)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMCb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
        // kine tracks in acceptance, pythia jets in acceptance
	if(iFlag&(1<<3)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "", "KINEb", "KINEb", filterMask, 0.4,0,1000., eventClass);
        // reconstructed charged tracks after cuts, MC jets in acceptance 
	if(iFlag&(1<<4)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsMC2b", "AODMCb", "AOD2b", filterMask, 0.4,0,1000., eventClass);
	// reconstruction efficiency: pointing with rec jet axis into gen tracks 
	if(iFlag&(1<<5)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);


     	// Jet background subtracted
	// anti-kt, pt cut 1 GeV
	if(iFlag&(1<<20)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,1000.,eventClass, "_Skip00");
	// anti-kt, pt cut 2 GeV
	if(iFlag&(1<<21)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,2000.,eventClass, "_Skip00");
	// anti-kt, pt cut 150 MeV
	if(iFlag&(1<<22)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.2,2,150.,eventClass, "_Skip00");

	
	// Jet background subtracted
	if(iFlag&(1<<23)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,150.,eventClass, "_Skip00");
        // charged MC tracks and jets
	if(iFlag&(1<<24)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMC", "AODMC2", filterMask, 0.4,2,150.,eventClass, "_Skip00");
        // charged MC tracks and jets with acceptance cuts
	if(iFlag&(1<<25)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMCb", "AODMC2b", filterMask, 0.4,2,150., eventClass, "_Skip00");

       if(iFlag&(1<<26)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,1,150.,eventClass, "_Skip00");

       if(iFlag&(1<<27)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,3,150.,eventClass, "_Skip00");	

      // SISCONE 
      if(iFlag&(1<<28)) ff = AddTaskFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,1,150.,eventClass);
      if(iFlag&(1<<29)) ff = AddTaskFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,2,150.,eventClass);
      if(iFlag&(1<<30)) ff = AddTaskFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,3,150.,eventClass);

	return ff;
}

// _______________________________________________________________________________________

AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunctionAllCent(
        const char* recJetsBranch,
	const char* recJetsBackBranch,
	const char* genJetsBranch,
	const char* jetType,
	const char* trackType,
	UInt_t filterMask,
        Float_t radius,
        int kBackgroundMode,
        Int_t PtTrackMin,
        TString BrOpt="",
        TString BrOpt2="",
        TString BrOpt3="",
        Float_t radiusBckg=0.4,
	Int_t   FFMaxTrackPt = -1,
	Float_t FFMinNTracks = 0)
{

  // adds task with  given configuration for all centralities
  
  AliAnalysisTaskFragmentationFunction *ff=0;

  for(Int_t eventClass=1; eventClass<=4; eventClass++){
    
    ff = AddTaskFragmentationFunction(recJetsBranch,
				      recJetsBackBranch,
				      genJetsBranch,
				      jetType,
				      trackType,
				      filterMask,
				      radius,
				      kBackgroundMode,
				      PtTrackMin,
				      eventClass,
				      BrOpt,
				      BrOpt2,
				      BrOpt3,
				      radiusBckg
	                              FFMaxTrackPt,
				      FFMinNTracks);
  }
  
  return ff;
}

// _______________________________________________________________________________________

AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(
        const char* recJetsBranch,
	const char* recJetsBackBranch,
	const char* genJetsBranch,
	const char* jetType,
	const char* trackType,
	UInt_t filterMask,
        Float_t radius,
        int kBackgroundMode,
        Int_t PtTrackMin,
        Int_t eventClass=0,
        TString BrOpt="",
        TString BrOpt2="",
        TString BrOpt3="",
        Float_t radiusBckg=0.4,
	Int_t FFMaxTrackPt = -1,
	Int_t FFMinNTracks = 0)
{
   // Creates a fragmentation function task,
   // configures it and adds it to the analysis manager.

   //******************************************************************************
   //*** Configuration Parameter **************************************************
   //******************************************************************************

   // space for configuration parameter: histo bin, cuts, ...
   // so far only default parameter used

   Int_t debug = -1; // debug level, -1: not set here

   //******************************************************************************


   // Get the pointer to the existing analysis manager via the static access method.
   //==============================================================================
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
   if (!mgr) {
	  ::Error("AddTaskFragmentationFunction", "No analysis manager to connect to.");
	  return NULL;
   }
   
   // Check the analysis type using the event handlers connected to the analysis manager.
   //==============================================================================
   if (!mgr->GetInputEventHandler()) {
	 ::Error("AddTaskFragmentationFunction", "This task requires an input event handler");
	  return NULL;
   }

   TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
   Printf("Data Type: %s", type.Data());

   TString branchRecBackJets(recJetsBackBranch);
   TString branchRecJets(recJetsBranch);
   TString branchGenJets(genJetsBranch);
   TString typeJets(jetType);
   TString typeTracks(trackType);

   if(branchRecBackJets.Length()==0) branchRecBackJets = "noRecBackJets";
   if(branchRecJets.Length()==0) branchRecJets = "noRecJets";
   if(branchGenJets.Length()==0) branchGenJets = "noGenJets";
   if(typeTracks.Length()==0) typeTracks = "trackTypeUndef";
   if(typeJets.Length()==0)   typeJets   = "jetTypeUndef";
   
   // Create the task and configure it.
   //===========================================================================

   AliAnalysisTaskFragmentationFunction *task = new AliAnalysisTaskFragmentationFunction(
        Form("Fragmentation Function %s %s %s %s", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(), typeTracks.Data()));
   
   if(debug>=0) task->SetDebugLevel(debug);
   
   Printf("Rec Jets %s", branchRecJets.Data());
   Printf("Back Rec Jets %s", branchRecBackJets.Data());
   Printf("Gen Jets %s", branchGenJets.Data());
   Printf("Jet Type %s", typeJets.Data());
   Printf("Track Type %s", typeTracks.Data());
   
   // attach the filter mask and options
   TString cAdd = "";
   cAdd += Form("%02d",(int)((radius+0.01)*10.));
   cAdd += Form("_B%d",(int)((kBackgroundMode)));
   cAdd += Form("_Filter%05d",filterMask);
   cAdd += Form("_Cut%05d",PtTrackMin);
   cAdd += Form("%s",BrOpt.Data());
   cAdd += Form("%s",BrOpt2.Data());

   Printf("%s",cAdd.Data());

   TString cAddb = "";
   cAddb += Form("%02d",(int)((radiusBckg+0.01)*10.));
   cAddb += Form("_B%d",(int)((kBackgroundMode)));
   cAddb += Form("_Filter%05d",filterMask);
   cAddb += Form("_Cut%05d",PtTrackMin);
   cAddb += Form("%s",BrOpt.Data());
   cAddb += Form("%s",BrOpt2.Data());

   Printf("%s",cAddb.Data());

   TString cAddmc = "";
   cAddmc += Form("%02d",(int)((radius+0.01)*10.));
   cAddmc += Form("_B%d",(int)((kBackgroundMode)));
   cAddmc += Form("_Filter%05d",filterMask);
   cAddmc += Form("_Cut%05d",PtTrackMin);
   cAddmc += Form("%s",BrOpt3.Data());

   Printf("%s",cAddmc.Data());


   if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("jets")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
   if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("cluster")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;

   if(branchRecBackJets.Contains("back")&&branchRecBackJets.Contains("cluster")&&!branchRecBackJets.Contains("MC"))branchRecBackJets = branchRecBackJets + cAddb; 

   if(branchGenJets.Contains("AOD")&&branchGenJets.Contains("MC"))branchGenJets = branchGenJets + cAddmc;

   Printf("Gen jets branch %s: ", branchGenJets.Data());
   Printf("Rec jets branch %s: ", branchRecJets.Data());
   Printf("Jet backg branch %s: ", branchRecBackJets.Data());

   if(!branchRecJets.Contains("noRecJets")) task->SetBranchRecJets(branchRecJets);
   if(!branchRecBackJets.Contains("noRecBackJets")) task->SetBranchRecBackJets(branchRecBackJets);
   if(!branchGenJets.Contains("noGenJets")) task->SetBranchGenJets(branchGenJets);


   if(typeTracks.Contains("AODMC2b"))      task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODMCChargedAcceptance);
   else if(typeTracks.Contains("AODMC2"))  task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODMCCharged);
   else if(typeTracks.Contains("AODMC"))   task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODMCAll);
   else if(typeTracks.Contains("KINE2b"))  task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackKineChargedAcceptance);
   else if(typeTracks.Contains("KINE2"))   task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackKineCharged);
   else if(typeTracks.Contains("KINE"))    task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackKineAll);
   else if(typeTracks.Contains("AODb"))    task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODCuts);
   else if(typeTracks.Contains("AOD"))     task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAOD);
   else if(typeTracks.Contains("trackTypeUndef")) task->SetTrackTypeGen(0); // undefined
   else Printf("trackType %s not found", typeTracks.Data());

   if(typeJets.Contains("AODMCb"))         task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsGenAcceptance);
   else if(typeJets.Contains("AODMC"))     task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsGen);
   else if(typeJets.Contains("KINEb"))     task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsKineAcceptance);
   else if(typeJets.Contains("KINE"))      task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsKine);
   else if(typeJets.Contains("AODb"))      task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsRecAcceptance);
   else if(typeJets.Contains("AOD"))       task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsRec);
   else if(typeJets.Contains("jetTypeUndef")) task->SetJetTypeGen(0); // undefined
   else Printf("jetType %s not found", typeJets.Data());
   
   if(typeJets.Contains("AODMCb")) task->SetJetTypeRecEff(AliAnalysisTaskFragmentationFunction::kJetsGenAcceptance); // kJetsRecAcceptance
   else if(typeJets.Contains("AODb")) task->SetJetTypeRecEff(AliAnalysisTaskFragmentationFunction::kJetsRecAcceptance); 
   else task->SetJetTypeRecEff(0);

   task->SetFilterMask(filterMask);
   task->SetEventClass(eventClass);
  
   // Set default parameters 
   // Cut selection 

   if(PtTrackMin == 150)       task->SetTrackCuts();  // default : pt > 0.150 GeV, |eta|<0.9, full phi acc
   else if(PtTrackMin == 1000) task->SetTrackCuts(1.0, -0.9, 0.9, 0., 2*TMath::Pi());
   else if(PtTrackMin == 2000) task->SetTrackCuts(2.0, -0.9, 0.9, 0., 2*TMath::Pi());
   else                        task->SetTrackCuts(0.001*PtTrackMin,-0.9, 0.9, 0., 2*TMath::Pi());


   task->SetJetCuts();          // default: jet pt > 5 GeV, |eta|<0.5, full phi acc
   task->SetDiJetCuts();        // default: type of cut = 1 (cut in deltaPhi), deltaPhi = 0., cdf = 0.5, fraction of pt = 0.6
   task->SetKindSlices();       // default: kindSlice = 1 (inv mass)
   task->SetFFRadius(radius); 
   task->SetFFBckgRadius();     // default: R = 0.7
   task->SetBckgSubMethod();    // default: subMethod = O, 1 = leading jet removed for rho extraction, 2 = 2 leading jets removed
   task->SetIJMode(0);          // default: ijMode = 1
   task->SetQAMode();           // default: qaMode = 3
   task->SetFFMode();           // default: ffMode = 1
   task->SetDJMode(0);          // default: djMode = 1
   task->SetEffMode(0);         // default: effMode = 1
   task->SetPhiCorrMode(1);     // default: phiCorrMode = 1
   task->SetHighPtThreshold();  // default: pt > 5 Gev
   task->UseRecEffRecJetPtBins(); // efficiency in bins of rec/gen jet pt - default: kTRUE  

   task->SetBckgMode(1);        // default: bgMode = 1 
   task->SetBckgType();
   task->SetBranchRecBackClusters(Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00",filterMask));

   // Define histo bins
   task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70,  0., 7.,22,  0.,  1.1);

   task->SetQAJetHistoBins();
   task->SetQATrackHistoBins();
   task->SetIJHistoBins();
   task->SetDiJetHistoBins();
   task->SetQADiJetHistoBins();

   if(FFMaxTrackPt>0) task->SetFFMaxTrackPt(FFMaxTrackPt);
   if(FFMinNTracks>0) task->SetFFMinNTracks(FFMinNTracks);

   mgr->AddTask(task);

   // Create ONLY the output containers for the data produced by the task.
   // Get and connect other common input/output containers via the manager as below
   //==============================================================================

   TString strList(Form("fracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
   
   TString strDir(Form("%s:PWGJE_FragmentationFunction_%s_%s_%s_%s_cl%d", 
		       AliAnalysisManager::GetCommonFileName(), branchRecJets.Data(), branchGenJets. Data(), 
		       typeTracks.Data(), typeJets.Data(), eventClass));


   if(FFMaxTrackPt>0){
     strList += Form("_FFMaxPt%d", FFMaxTrackPt);
     strDir  += Form("_FFMaxPt%d", FFMaxTrackPt);
   }
   if(FFMinNTracks>0){
     strList += Form("_minNTr%d",FFMinNTracks);
     strDir  += Form("_minNTr%d",FFMinNTracks);
   }

   AliAnalysisDataContainer *coutput_FragFunc = mgr->CreateContainer(strList,TList::Class(),
								     AliAnalysisManager::kOutputContainer,
								     strDir);

   mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
   mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
   mgr->ConnectOutput (task, 1, coutput_FragFunc);
   
   return task;
}
Commit	Line	Data
1db1733e	1
	2	/*************************************************************************************************
	3	* Add Fragmentation Function Task *
	4	**************************************************************************************************
44b235ce	5	The fragmentation function task expects an ESD filter and jet finder running before this task.
1db1733e	6	Or it runs on delta-AODs filled with filtered tracks and jets before.
	7
	8	Parameters
	9	(char) recJetsBranch: branch in AOD for (reconstructed) jets
	10	(char) genJetsBranch: branch in AOD for (generated) jets
	11	(char) jetType: "AOD" jets from recJetsBranch
	12	"AODMC" jets from genJetsBranch
	13	"KINE" jets from PYCELL
	14	+"b" (e.g. "AODb") jets with acceptance cuts
	15	(char) trackType: "AOD" reconstructed tracks from AOD filled by ESD filter (choose filter mask!)
	16	"AODMC" MC tracks from AOD filled by kine filter
	17	"KINE" kine particles from MC event
	18	+"2" (e.g. "AOD2") charged tracks only
	19	+"b" (e.g. "AOD2b") with acceptance cuts
	20	(UInt_t) filterMask: select filter bit of ESD filter task
	21
	22	***************************************************************************************************/
	23
44b235ce	24	AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(UInt_t iFlag=1, UInt_t filterMask=32, Int_t eventClass=0){
1db1733e	25
	26	AliAnalysisTaskFragmentationFunction *ff=0;
	27
c2658535	28	// UA1 Jets
1db1733e	29	// only reconstructed (default)
44b235ce	30	if(iFlag&(1<<0)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "", "", "", filterMask, 0.4,0,1000., eventClass);
ac017ff3	31	// charged MC tracks and jets
44b235ce	32	if(iFlag&(1<<1)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMC", "AODMC2", filterMask, 0.4,0,1000., eventClass);
ac017ff3	33	// charged MC tracks and jets with acceptance cuts
44b235ce	34	if(iFlag&(1<<2)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMCb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
1db1733e	35	// kine tracks in acceptance, pythia jets in acceptance
44b235ce	36	if(iFlag&(1<<3)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "", "KINEb", "KINEb", filterMask, 0.4,0,1000., eventClass);
1db1733e	37	// reconstructed charged tracks after cuts, MC jets in acceptance
44b235ce	38	if(iFlag&(1<<4)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsMC2b", "AODMCb", "AOD2b", filterMask, 0.4,0,1000., eventClass);
cfd02305	39	// reconstruction efficiency: pointing with rec jet axis into gen tracks
44b235ce	40	if(iFlag&(1<<5)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
c2658535	41
c2658535	42
c2658535	43
a5f1b959	44	// Jet background subtracted
	45	// anti-kt, pt cut 1 GeV
	46	if(iFlag&(1<<20)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,1000.,eventClass, "_Skip00");
	47	// anti-kt, pt cut 2 GeV
	48	if(iFlag&(1<<21)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,2000.,eventClass, "_Skip00");
	49	// anti-kt, pt cut 150 MeV
	50	if(iFlag&(1<<22)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.2,2,150.,eventClass, "_Skip00");
	51
	52
44b235ce	53	// Jet background subtracted
a5f1b959	54	if(iFlag&(1<<23)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,150.,eventClass, "_Skip00");
44b235ce	55	// charged MC tracks and jets
a5f1b959	56	if(iFlag&(1<<24)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMC", "AODMC2", filterMask, 0.4,2,150.,eventClass, "_Skip00");
44b235ce	57	// charged MC tracks and jets with acceptance cuts
a5f1b959	58	if(iFlag&(1<<25)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMCb", "AODMC2b", filterMask, 0.4,2,150., eventClass, "_Skip00");
c2658535	59
a5f1b959	60	if(iFlag&(1<<26)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,1,150.,eventClass, "_Skip00");
b101fa2e	61
34af6526	62	if(iFlag&(1<<27)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,3,150.,eventClass, "_Skip00");
b101fa2e	63
	64	// SISCONE
	65	if(iFlag&(1<<28)) ff = AddTaskFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,1,150.,eventClass);
	66	if(iFlag&(1<<29)) ff = AddTaskFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,2,150.,eventClass);
	67	if(iFlag&(1<<30)) ff = AddTaskFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,3,150.,eventClass);
	68
1db1733e	69	return ff;
	70	}
	71
	72	// _______________________________________________________________________________________
	73
1aa4f09f	74	AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunctionAllCent(
	75	const char* recJetsBranch,
	76	const char* recJetsBackBranch,
	77	const char* genJetsBranch,
	78	const char* jetType,
	79	const char* trackType,
	80	UInt_t filterMask,
	81	Float_t radius,
	82	int kBackgroundMode,
6daac008	83	Int_t PtTrackMin,
1aa4f09f	84	TString BrOpt="",
1aa4f09f	85	TString BrOpt2="",
6daac008	86	TString BrOpt3="",
	87	Float_t radiusBckg=0.4,
	88	Int_t FFMaxTrackPt = -1,
	89	Float_t FFMinNTracks = 0)
1aa4f09f	90	{
	91
	92	// adds task with given configuration for all centralities
	93
	94	AliAnalysisTaskFragmentationFunction *ff=0;
	95
	96	for(Int_t eventClass=1; eventClass<=4; eventClass++){
	97
	98	ff = AddTaskFragmentationFunction(recJetsBranch,
	99	recJetsBackBranch,
	100	genJetsBranch,
	101	jetType,
	102	trackType,
	103	filterMask,
	104	radius,
	105	kBackgroundMode,
	106	PtTrackMin,
	107	eventClass,
	108	BrOpt,
	109	BrOpt2,
6daac008	110	BrOpt3,
	111	radiusBckg
	112	FFMaxTrackPt,
	113	FFMinNTracks);
1aa4f09f	114	}
	115
	116	return ff;
	117	}
	118
	119	// _______________________________________________________________________________________
	120
1db1733e	121	AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(
1db1733e	122	const char* recJetsBranch,
44b235ce	123	const char* recJetsBackBranch,
1db1733e	124	const char* genJetsBranch,
	125	const char* jetType,
	126	const char* trackType,
44b235ce	127	UInt_t filterMask,
	128	Float_t radius,
	129	int kBackgroundMode,
6daac008	130	Int_t PtTrackMin,
44b235ce	131	Int_t eventClass=0,
	132	TString BrOpt="",
	133	TString BrOpt2="",
6daac008	134	TString BrOpt3="",
	135	Float_t radiusBckg=0.4,
	136	Int_t FFMaxTrackPt = -1,
	137	Int_t FFMinNTracks = 0)
6bec8236	138	{
1db1733e	139	// Creates a fragmentation function task,
	140	// configures it and adds it to the analysis manager.
	141
	142	//******************************************************************************
	143	//* Configuration Parameter ************************************************
	144	//******************************************************************************
	145
	146	// space for configuration parameter: histo bin, cuts, ...
	147	// so far only default parameter used
	148
	149	Int_t debug = -1; // debug level, -1: not set here
6bec8236	150
1db1733e	151	//******************************************************************************
	152
	153
	154
6bec8236	155	// Get the pointer to the existing analysis manager via the static access method.
	156	//==============================================================================
	157	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	158	if (!mgr) {
1db1733e	159	::Error("AddTaskFragmentationFunction", "No analysis manager to connect to.");
	160	return NULL;
	161	}
6bec8236	162
	163	// Check the analysis type using the event handlers connected to the analysis manager.
	164	//==============================================================================
	165	if (!mgr->GetInputEventHandler()) {
1db1733e	166	::Error("AddTaskFragmentationFunction", "This task requires an input event handler");
1db1733e	167	return NULL;
6bec8236	168	}
6bec8236	169
1db1733e	170	TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
	171	Printf("Data Type: %s", type.Data());
	172
44b235ce	173	TString branchRecBackJets(recJetsBackBranch);
1db1733e	174	TString branchRecJets(recJetsBranch);
	175	TString branchGenJets(genJetsBranch);
	176	TString typeJets(jetType);
	177	TString typeTracks(trackType);
	178
44b235ce	179	if(branchRecBackJets.Length()==0) branchRecBackJets = "noRecBackJets";
1db1733e	180	if(branchRecJets.Length()==0) branchRecJets = "noRecJets";
	181	if(branchGenJets.Length()==0) branchGenJets = "noGenJets";
	182	if(typeTracks.Length()==0) typeTracks = "trackTypeUndef";
	183	if(typeJets.Length()==0) typeJets = "jetTypeUndef";
	184
6bec8236	185	// Create the task and configure it.
6bec8236	186	//===========================================================================
1db1733e	187
1db1733e	188	AliAnalysisTaskFragmentationFunction *task = new AliAnalysisTaskFragmentationFunction(
44b235ce	189	Form("Fragmentation Function %s %s %s %s", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(), typeTracks.Data()));
1db1733e	190
1db1733e	191	if(debug>=0) task->SetDebugLevel(debug);
6bec8236	192
1db1733e	193	Printf("Rec Jets %s", branchRecJets.Data());
44b235ce	194	Printf("Back Rec Jets %s", branchRecBackJets.Data());
1db1733e	195	Printf("Gen Jets %s", branchGenJets.Data());
	196	Printf("Jet Type %s", typeJets.Data());
	197	Printf("Track Type %s", typeTracks.Data());
6bec8236	198
44b235ce	199	// attach the filter mask and options
	200	TString cAdd = "";
	201	cAdd += Form("%02d",(int)((radius+0.01)*10.));
	202	cAdd += Form("_B%d",(int)((kBackgroundMode)));
	203	cAdd += Form("_Filter%05d",filterMask);
6daac008	204	cAdd += Form("_Cut%05d",PtTrackMin);
44b235ce	205	cAdd += Form("%s",BrOpt.Data());
44b235ce	206	cAdd += Form("%s",BrOpt2.Data());
6daac008	207
44b235ce	208	Printf("%s",cAdd.Data());
	209
	210	TString cAddb = "";
	211	cAddb += Form("%02d",(int)((radiusBckg+0.01)*10.));
	212	cAddb += Form("_B%d",(int)((kBackgroundMode)));
	213	cAddb += Form("_Filter%05d",filterMask);
6daac008	214	cAddb += Form("_Cut%05d",PtTrackMin);
44b235ce	215	cAddb += Form("%s",BrOpt.Data());
44b235ce	216	cAddb += Form("%s",BrOpt2.Data());
6daac008	217
44b235ce	218	Printf("%s",cAddb.Data());
	219
	220	TString cAddmc = "";
	221	cAddmc += Form("%02d",(int)((radius+0.01)*10.));
	222	cAddmc += Form("_B%d",(int)((kBackgroundMode)));
	223	cAddmc += Form("_Filter%05d",filterMask);
6daac008	224	cAddmc += Form("_Cut%05d",PtTrackMin);
	225	cAddmc += Form("%s",BrOpt3.Data());
	226
44b235ce	227	Printf("%s",cAddmc.Data());
	228
	229
	230	if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("jets")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
	231	if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("cluster")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
	232
	233	if(branchRecBackJets.Contains("back")&&branchRecBackJets.Contains("cluster")&&!branchRecBackJets.Contains("MC"))branchRecBackJets = branchRecBackJets + cAddb;
	234
	235	if(branchGenJets.Contains("AOD")&&branchGenJets.Contains("MC"))branchGenJets = branchGenJets + cAddmc;
	236
	237	Printf("Gen jets branch %s: ", branchGenJets.Data());
	238	Printf("Rec jets branch %s: ", branchRecJets.Data());
	239	Printf("Jet backg branch %s: ", branchRecBackJets.Data());
f4132e7d	240
1db1733e	241	if(!branchRecJets.Contains("noRecJets")) task->SetBranchRecJets(branchRecJets);
44b235ce	242	if(!branchRecBackJets.Contains("noRecBackJets")) task->SetBranchRecBackJets(branchRecBackJets);
1db1733e	243	if(!branchGenJets.Contains("noGenJets")) task->SetBranchGenJets(branchGenJets);
6bec8236	244
6bec8236	245
1db1733e	246	if(typeTracks.Contains("AODMC2b")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODMCChargedAcceptance);
	247	else if(typeTracks.Contains("AODMC2")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODMCCharged);
	248	else if(typeTracks.Contains("AODMC")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODMCAll);
	249	else if(typeTracks.Contains("KINE2b")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackKineChargedAcceptance);
	250	else if(typeTracks.Contains("KINE2")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackKineCharged);
	251	else if(typeTracks.Contains("KINE")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackKineAll);
	252	else if(typeTracks.Contains("AODb")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAODCuts);
	253	else if(typeTracks.Contains("AOD")) task->SetTrackTypeGen(AliAnalysisTaskFragmentationFunction::kTrackAOD);
	254	else if(typeTracks.Contains("trackTypeUndef")) task->SetTrackTypeGen(0); // undefined
	255	else Printf("trackType %s not found", typeTracks.Data());
	256
	257	if(typeJets.Contains("AODMCb")) task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsGenAcceptance);
	258	else if(typeJets.Contains("AODMC")) task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsGen);
	259	else if(typeJets.Contains("KINEb")) task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsKineAcceptance);
	260	else if(typeJets.Contains("KINE")) task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsKine);
	261	else if(typeJets.Contains("AODb")) task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsRecAcceptance);
	262	else if(typeJets.Contains("AOD")) task->SetJetTypeGen(AliAnalysisTaskFragmentationFunction::kJetsRec);
	263	else if(typeJets.Contains("jetTypeUndef")) task->SetJetTypeGen(0); // undefined
	264	else Printf("jetType %s not found", typeJets.Data());
	265
7d9e8b32	266	if(typeJets.Contains("AODMCb")) task->SetJetTypeRecEff(AliAnalysisTaskFragmentationFunction::kJetsGenAcceptance); // kJetsRecAcceptance
	267	else if(typeJets.Contains("AODb")) task->SetJetTypeRecEff(AliAnalysisTaskFragmentationFunction::kJetsRecAcceptance);
	268	else task->SetJetTypeRecEff(0);
	269
1db1733e	270	task->SetFilterMask(filterMask);
44b235ce	271	task->SetEventClass(eventClass);
1db1733e	272
f3564520	273	// Set default parameters
f3564520	274	// Cut selection
6daac008	275
	276	if(PtTrackMin == 150) task->SetTrackCuts(); // default : pt > 0.150 GeV, \|eta\|<0.9, full phi acc
	277	else if(PtTrackMin == 1000) task->SetTrackCuts(1.0, -0.9, 0.9, 0., 2*TMath::Pi());
	278	else if(PtTrackMin == 2000) task->SetTrackCuts(2.0, -0.9, 0.9, 0., 2*TMath::Pi());
	279	else task->SetTrackCuts(0.001PtTrackMin,-0.9, 0.9, 0., 2TMath::Pi());
a5f1b959	280
a5f1b959	281
6daac008	282	task->SetJetCuts(); // default: jet pt > 5 GeV, \|eta\|<0.5, full phi acc
	283	task->SetDiJetCuts(); // default: type of cut = 1 (cut in deltaPhi), deltaPhi = 0., cdf = 0.5, fraction of pt = 0.6
	284	task->SetKindSlices(); // default: kindSlice = 1 (inv mass)
633ed180	285	task->SetFFRadius(radius);
6daac008	286	task->SetFFBckgRadius(); // default: R = 0.7
	287	task->SetBckgSubMethod(); // default: subMethod = O, 1 = leading jet removed for rho extraction, 2 = 2 leading jets removed
	288	task->SetIJMode(0); // default: ijMode = 1
	289	task->SetQAMode(); // default: qaMode = 3
	290	task->SetFFMode(); // default: ffMode = 1
b101fa2e	291	task->SetDJMode(0); // default: djMode = 1
b101fa2e	292	task->SetEffMode(0); // default: effMode = 1
9cefe9be	293	task->SetPhiCorrMode(1); // default: phiCorrMode = 1
a5f1b959	294	task->SetHighPtThreshold(); // default: pt > 5 Gev
cb76764e	295	task->UseRecEffRecJetPtBins(); // efficiency in bins of rec/gen jet pt - default: kTRUE
cb76764e	296
c08c3ad2	297	task->SetBckgMode(1); // default: bgMode = 1
3170a3f8	298	task->SetBckgType();
d5e8640d	299	task->SetBranchRecBackClusters(Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00",filterMask));
c08c3ad2	300
f3564520	301	// Define histo bins
a5f1b959	302	task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70, 0., 7.,22, 0., 1.1);
a5f1b959	303
1db1733e	304	task->SetQAJetHistoBins();
1db1733e	305	task->SetQATrackHistoBins();
f3564520	306	task->SetIJHistoBins();
	307	task->SetDiJetHistoBins();
	308	task->SetQADiJetHistoBins();
1db1733e	309
6daac008	310	if(FFMaxTrackPt>0) task->SetFFMaxTrackPt(FFMaxTrackPt);
	311	if(FFMinNTracks>0) task->SetFFMinNTracks(FFMinNTracks);
	312
1db1733e	313	mgr->AddTask(task);
6bec8236	314
6bec8236	315	// Create ONLY the output containers for the data produced by the task.
	316	// Get and connect other common input/output containers via the manager as below
	317	//==============================================================================
6bec8236	318
6daac008	319	TString strList(Form("fracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
	320
	321	TString strDir(Form("%s:PWGJE_FragmentationFunction_%s_%s_%s_%s_cl%d",
	322	AliAnalysisManager::GetCommonFileName(), branchRecJets.Data(), branchGenJets. Data(),
	323	typeTracks.Data(), typeJets.Data(), eventClass));
	324
	325
	326	if(FFMaxTrackPt>0){
	327	strList += Form("_FFMaxPt%d", FFMaxTrackPt);
	328	strDir += Form("_FFMaxPt%d", FFMaxTrackPt);
	329	}
	330	if(FFMinNTracks>0){
	331	strList += Form("_minNTr%d",FFMinNTracks);
	332	strDir += Form("_minNTr%d",FFMinNTracks);
	333	}
	334
	335	AliAnalysisDataContainer *coutput_FragFunc = mgr->CreateContainer(strList,TList::Class(),
	336	AliAnalysisManager::kOutputContainer,
	337	strDir);
1db1733e	338
	339	mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer());
	340	mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
	341	mgr->ConnectOutput (task, 1, coutput_FragFunc);
6bec8236	342
1db1733e	343	return task;
6bec8236	344	}