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

/*************************************************************************************************
***  Add Fragmentation Function Task ***
**************************************************************************************************
The ID 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

Typical parameters to run on 11a1* (MC_pp@7TeV):
"clustersAOD_ANTIKT", "", "clustersAODMC2_ANTIKT", "AODMCb", "AODMC2b", AliAnalysisManager::GetGlobalInt("kHighPtFilterMask", gDebug), 
-0.4, 0, 1000*AliAnalysisManager::GetGlobalDbl("kTrackPtCut", gDebug), 0, "_Skip00", "", "_Skip00", 0.4, -1, 0, 0, kFALSE,
"PWGJE_taskPID_Jets", "", "PWGJE_taskPID_Jets_Inclusive", "" 

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

void postConfig(AliAnalysisTaskIDFragmentationFunction* task, TString suffixPIDtaskJets1, TString suffixPIDtaskJets2,
                TString suffixPIDtaskInclusive1, TString suffixPIDtaskInclusive2) {

  task->SetBckgType(AliAnalysisTaskIDFragmentationFunction::kBckgPerp2,
        AliAnalysisTaskIDFragmentationFunction::kBckgPerp,
          AliAnalysisTaskIDFragmentationFunction::kBckgPerp2Area,
            AliAnalysisTaskIDFragmentationFunction::kBckgOutAJStat,
            AliAnalysisTaskIDFragmentationFunction::kBckgOut2J);

  task->SetBranchRecBackClusters("");

   // Define histo bins
   //task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70,  0., 7., 52, 0.,  1.3);
   task->SetQATrackHistoBins(2400,0,120); // 50 MeV binning for comp to track dN/dpt prel. plot
   
   // JS on
   task->SetJSMode();
   
   task->SetEffMode(0);
  
  // Set name of PID framework tasks
   
  // Invalid: Second suffix set, but first one not set -> No PID tasks set
  const Int_t numJetPIDtasks = (suffixPIDtaskJets1 != "") * ((suffixPIDtaskJets1 != "") + (suffixPIDtaskJets2 != ""));
  if (numJetPIDtasks > 0) {
    TString namesJetPIDtasks[numJetPIDtasks];
    namesJetPIDtasks[0] = suffixPIDtaskJets1;
    if (numJetPIDtasks > 1)
      namesJetPIDtasks[1] = suffixPIDtaskJets2;
    task->SetNamesOfJetPIDtasks(numJetPIDtasks, namesJetPIDtasks);
  }
  else
    task->SetNamesOfJetPIDtasks(numJetPIDtasks, 0x0);
  
  // Same for inclusive
  const Int_t numInclusivePIDtasks = (suffixPIDtaskInclusive1 != "") *
                                      ((suffixPIDtaskInclusive1 != "") + (suffixPIDtaskInclusive2 != ""));
  if (numInclusivePIDtasks > 0) {
    TString namesInclusivePIDtasks[numInclusivePIDtasks];
    namesInclusivePIDtasks[0] = suffixPIDtaskInclusive1;
    if (numInclusivePIDtasks > 1)
      namesInclusivePIDtasks[1] = suffixPIDtaskInclusive2;
    task->SetNamesOfInclusivePIDtasks(numInclusivePIDtasks, namesInclusivePIDtasks);
  }
  else
    task->SetNamesOfInclusivePIDtasks(numInclusivePIDtasks, 0x0);
  
  printf("PID framework:\n");
  printf("Jet PID tasks: ");
  for (Int_t i = 0; i < numJetPIDtasks; i++)
    printf("%s ", task->GetNamesOfJetPIDtasks()[i].Data());
  printf("\n");
  printf("Inclusive PID task: ");
  for (Int_t i = 0; i < numInclusivePIDtasks; i++)
    printf("%s ", task->GetNamesOfInclusivePIDtasks()[i].Data());
  printf("\n");
}


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

        // UA1 Jets
        // only reconstructed (default)
  if(iFlag&(1<<0)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "", "", "", filterMask, 0.4,0,1000., eventClass);
        // charged MC tracks and jets
  if(iFlag&(1<<1)) ff = AddTaskIDFragmentationFunction("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 = AddTaskIDFragmentationFunction("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 = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "", "KINEb", "KINEb", filterMask, 0.4,0,1000., eventClass);
        // reconstructed charged tracks after cuts, MC jets in acceptance 
  if(iFlag&(1<<4)) ff = AddTaskIDFragmentationFunction("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 = AddTaskIDFragmentationFunction("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 = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,1000.,eventClass, "_Skip00");
  // anti-kt, pt cut 2 GeV
  if(iFlag&(1<<21)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,2000.,eventClass, "_Skip00");
  // anti-kt, pt cut 150 MeV
  if(iFlag&(1<<22)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.2,2,150.,eventClass, "_Skip00");

  
  // Jet background subtracted
  if(iFlag&(1<<23)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,150.,eventClass, "_Skip00");
        // charged MC tracks and jets
  if(iFlag&(1<<24)) ff = AddTaskIDFragmentationFunction("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 = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMCb", "AODMC2b", filterMask, 0.4,2,150., eventClass, "_Skip00");

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

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

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

  return ff;
}

// _______________________________________________________________________________________

AliAnalysisTaskIDFragmentationFunction *AddTaskIDFragmentationFunctionAllCent(
        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,
  TString suffixPIDtaskJets1 = "",
  TString suffixPIDtaskJets2 = "",
  TString suffixPIDtaskInclusive1 = "",
  TString suffixPIDtaskInclusive2 = "")
{

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

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

// _______________________________________________________________________________________

AliAnalysisTaskIDFragmentationFunction *AddTaskIDFragmentationFunction(
        const char* recJetsBranch,
  const char* recJetsBackBranch,
  const char* genJetsBranch,
  const char* jetType,
  const char* trackType,
  UInt_t filterMask,
  Float_t radius,
  Int_t 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,
  UInt_t filterMaskTracks = 0,
  Bool_t onlyConsiderLeadingJets = kFALSE,
  TString suffixPIDtaskJets1 = "",
  TString suffixPIDtaskJets2 = "",
  TString suffixPIDtaskInclusive1 = "",
  TString suffixPIDtaskInclusive2 = "")
{
   // 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("AddTaskIDFragmentationFunction", "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("AddTaskIDFragmentationFunction", "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.
   //===========================================================================

   AliAnalysisTaskIDFragmentationFunction *task = new AliAnalysisTaskIDFragmentationFunction(
        Form("Fragmentation_Function_%s_%s_%s_%s_filterMaskTracks%d", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(),
             typeTracks.Data(), filterMaskTracks));
   
   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());
   
   Printf("Radius cut: %f", radius);
   Printf("FilterMaskTracks: %d", filterMaskTracks);
   
   // attach the filter mask and options
   TString cAdd = "";
   cAdd += Form("%02d",(int)((TMath::Abs(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)((TMath::Abs(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(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCChargedAcceptance);
   else if(typeTracks.Contains("AODMC2"))  task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCCharged);
   else if(typeTracks.Contains("AODMC"))   task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCAll);
   else if(typeTracks.Contains("KINE2b"))  task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineChargedAcceptance);
   else if(typeTracks.Contains("KINE2"))   task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineCharged);
   else if(typeTracks.Contains("KINE"))    task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineAll);
   else if(typeTracks.Contains("AODb"))    task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODCuts);
   else if(typeTracks.Contains("AOD"))     task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAOD);
   else if(typeTracks.Contains("trackTypeUndef")) task->SetTrackTypeGen(0); // undefined
   else Printf("trackType %s not found", typeTracks.Data());

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

   if(!filterMaskTracks) task->SetFilterMask(filterMask);
   else task->SetFilterMask(filterMaskTracks);

   task->SetEventSelectionMask(AliVEvent::kMB);
   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->SetFFRadius(radius); 
   task->SetFFBckgRadius();     // default: R = 0.7
   task->SetQAMode();           // default: qaMode = 3
   task->SetFFMode();           // default: ffMode = 1
   task->SetIDFFMode(0);        // default: IDffMode = 0
   task->SetEffMode(0);         // default: effMode = 1
   task->SetHighPtThreshold();  // default: pt > 5 Gev

   task->SetBckgMode(1);        // default: bgMode = 1 
   task->SetBckgType();
   task->SetBranchRecBackClusters(Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00",filterMask));
   
   task->SetOnlyLeadingJets(onlyConsiderLeadingJets); // default: kFALSE
   
   // Define histo bins
   task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70,  0., 7.,22,  0.,  1.1);
 
   task->SetQAJetHistoBins();
   task->SetQATrackHistoBins();

   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("idfracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
   
   TString strDir(Form("%s:PWGJE_IDFragmentationFunction_%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);
   }

   if(radius<0){
     strList += "_trackRefs";
     strDir  += "_trackRefs";
   }
   if(filterMaskTracks){
     strList += Form("_TrackFilter%05d",filterMaskTracks);
     strDir  += Form("_TrackFilter%05d",filterMaskTracks);
   }


   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);
   
   postConfig(task, suffixPIDtaskJets1, suffixPIDtaskJets2, suffixPIDtaskInclusive1, suffixPIDtaskInclusive2);
   
   return task;
}
Commit	Line	Data
e131b05f	1	/*************************************************************************************************
	2	* Add Fragmentation Function Task *
	3	**************************************************************************************************
	4	The ID fragmentation function task expects an ESD filter and jet finder running before this task.
	5	Or it runs on delta-AODs filled with filtered tracks and jets before.
	6
	7	Parameters
	8	(char) recJetsBranch: branch in AOD for (reconstructed) jets
	9	(char) genJetsBranch: branch in AOD for (generated) jets
	10	(char) jetType: "AOD" jets from recJetsBranch
	11	"AODMC" jets from genJetsBranch
	12	"KINE" jets from PYCELL
	13	+"b" (e.g. "AODb") jets with acceptance cuts
	14	(char) trackType: "AOD" reconstructed tracks from AOD filled by ESD filter (choose filter mask!)
	15	"AODMC" MC tracks from AOD filled by kine filter
	16	"KINE" kine particles from MC event
	17	+"2" (e.g. "AOD2") charged tracks only
	18	+"b" (e.g. "AOD2b") with acceptance cuts
	19	(UInt_t) filterMask: select filter bit of ESD filter task
	20
	21	Typical parameters to run on 11a1* (MC_pp@7TeV):
	22	"clustersAOD_ANTIKT", "", "clustersAODMC2_ANTIKT", "AODMCb", "AODMC2b", AliAnalysisManager::GetGlobalInt("kHighPtFilterMask", gDebug),
c4856fb1	23	-0.4, 0, 1000*AliAnalysisManager::GetGlobalDbl("kTrackPtCut", gDebug), 0, "_Skip00", "", "_Skip00", 0.4, -1, 0, 0, kFALSE,
e131b05f	24	"PWGJE_taskPID_Jets", "", "PWGJE_taskPID_Jets_Inclusive", ""
	25
	26	***************************************************************************************************/
	27
	28	void postConfig(AliAnalysisTaskIDFragmentationFunction* task, TString suffixPIDtaskJets1, TString suffixPIDtaskJets2,
	29	TString suffixPIDtaskInclusive1, TString suffixPIDtaskInclusive2) {
	30
	31	task->SetBckgType(AliAnalysisTaskIDFragmentationFunction::kBckgPerp2,
	32	AliAnalysisTaskIDFragmentationFunction::kBckgPerp,
	33	AliAnalysisTaskIDFragmentationFunction::kBckgPerp2Area,
	34	AliAnalysisTaskIDFragmentationFunction::kBckgOutAJStat,
	35	AliAnalysisTaskIDFragmentationFunction::kBckgOut2J);
	36
	37	task->SetBranchRecBackClusters("");
	38
	39	// Define histo bins
	40	//task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70, 0., 7., 52, 0., 1.3);
	41	task->SetQATrackHistoBins(2400,0,120); // 50 MeV binning for comp to track dN/dpt prel. plot
	42
	43	// JS on
	44	task->SetJSMode();
	45
	46	task->SetEffMode(0);
	47
	48	// Set name of PID framework tasks
	49
	50	// Invalid: Second suffix set, but first one not set -> No PID tasks set
	51	const Int_t numJetPIDtasks = (suffixPIDtaskJets1 != "") * ((suffixPIDtaskJets1 != "") + (suffixPIDtaskJets2 != ""));
	52	if (numJetPIDtasks > 0) {
	53	TString namesJetPIDtasks[numJetPIDtasks];
	54	namesJetPIDtasks[0] = suffixPIDtaskJets1;
	55	if (numJetPIDtasks > 1)
	56	namesJetPIDtasks[1] = suffixPIDtaskJets2;
	57	task->SetNamesOfJetPIDtasks(numJetPIDtasks, namesJetPIDtasks);
	58	}
	59	else
	60	task->SetNamesOfJetPIDtasks(numJetPIDtasks, 0x0);
	61
	62	// Same for inclusive
	63	const Int_t numInclusivePIDtasks = (suffixPIDtaskInclusive1 != "") *
	64	((suffixPIDtaskInclusive1 != "") + (suffixPIDtaskInclusive2 != ""));
	65	if (numInclusivePIDtasks > 0) {
	66	TString namesInclusivePIDtasks[numInclusivePIDtasks];
	67	namesInclusivePIDtasks[0] = suffixPIDtaskInclusive1;
	68	if (numInclusivePIDtasks > 1)
	69	namesInclusivePIDtasks[1] = suffixPIDtaskInclusive2;
	70	task->SetNamesOfInclusivePIDtasks(numInclusivePIDtasks, namesInclusivePIDtasks);
	71	}
	72	else
	73	task->SetNamesOfInclusivePIDtasks(numInclusivePIDtasks, 0x0);
	74
	75	printf("PID framework:\n");
	76	printf("Jet PID tasks: ");
	77	for (Int_t i = 0; i < numJetPIDtasks; i++)
	78	printf("%s ", task->GetNamesOfJetPIDtasks()[i].Data());
	79	printf("\n");
	80	printf("Inclusive PID task: ");
	81	for (Int_t i = 0; i < numInclusivePIDtasks; i++)
	82	printf("%s ", task->GetNamesOfInclusivePIDtasks()[i].Data());
	83	printf("\n");
	84	}
	85
	86
	87	AliAnalysisTaskIDFragmentationFunction *AddTaskIDFragmentationFunction(UInt_t iFlag=1, UInt_t filterMask=32, Int_t eventClass=0){
88
89	AliAnalysisTaskIDFragmentationFunction *ff=0;
90
91	// UA1 Jets
92	// only reconstructed (default)
93	if(iFlag&(1<<0)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "", "", "", filterMask, 0.4,0,1000., eventClass);
94	// charged MC tracks and jets
95	if(iFlag&(1<<1)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMC", "AODMC2", filterMask, 0.4,0,1000., eventClass);
96	// charged MC tracks and jets with acceptance cuts
97	if(iFlag&(1<<2)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMCb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
98	// kine tracks in acceptance, pythia jets in acceptance
99	if(iFlag&(1<<3)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "", "KINEb", "KINEb", filterMask, 0.4,0,1000., eventClass);
100	// reconstructed charged tracks after cuts, MC jets in acceptance
101	if(iFlag&(1<<4)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "jetsMC2b", "AODMCb", "AOD2b", filterMask, 0.4,0,1000., eventClass);
102	// reconstruction efficiency: pointing with rec jet axis into gen tracks
103	if(iFlag&(1<<5)) ff = AddTaskIDFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
104
105
106
107	// Jet background subtracted
108	// anti-kt, pt cut 1 GeV
109	if(iFlag&(1<<20)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,1000.,eventClass, "_Skip00");
110	// anti-kt, pt cut 2 GeV
111	if(iFlag&(1<<21)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,2000.,eventClass, "_Skip00");
112	// anti-kt, pt cut 150 MeV
113	if(iFlag&(1<<22)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.2,2,150.,eventClass, "_Skip00");
114
115
116	// Jet background subtracted
117	if(iFlag&(1<<23)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,150.,eventClass, "_Skip00");
118	// charged MC tracks and jets
119	if(iFlag&(1<<24)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMC", "AODMC2", filterMask, 0.4,2,150.,eventClass, "_Skip00");
120	// charged MC tracks and jets with acceptance cuts
121	if(iFlag&(1<<25)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMCb", "AODMC2b", filterMask, 0.4,2,150., eventClass, "_Skip00");
122
123	if(iFlag&(1<<26)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,1,150.,eventClass, "_Skip00");
124
125	if(iFlag&(1<<27)) ff = AddTaskIDFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,3,150.,eventClass, "_Skip00");
126
127	// SISCONE
128	if(iFlag&(1<<28)) ff = AddTaskIDFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,1,150.,eventClass);
129	if(iFlag&(1<<29)) ff = AddTaskIDFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,2,150.,eventClass);
130	if(iFlag&(1<<30)) ff = AddTaskIDFragmentationFunction("jetsAOD_SISCONE", "", "", "", "", filterMask, 0.4,3,150.,eventClass);
131
132	return ff;
133	}
134
135	// _______________________________________________________________________________________
136
137	AliAnalysisTaskIDFragmentationFunction *AddTaskIDFragmentationFunctionAllCent(
138	const char* recJetsBranch,
139	const char* recJetsBackBranch,
140	const char* genJetsBranch,
141	const char* jetType,
142	const char* trackType,
143	UInt_t filterMask,
144	Float_t radius,
145	int kBackgroundMode,
146	Int_t PtTrackMin,
147	TString BrOpt="",
148	TString BrOpt2="",
149	TString BrOpt3="",
150	Float_t radiusBckg=0.4,
151	Int_t FFMaxTrackPt = -1,
152	Float_t FFMinNTracks = 0,
153	TString suffixPIDtaskJets1 = "",
154	TString suffixPIDtaskJets2 = "",
155	TString suffixPIDtaskInclusive1 = "",
156	TString suffixPIDtaskInclusive2 = "")
157	{
158
159	// adds task with given configuration for all centralities
160
161	AliAnalysisTaskIDFragmentationFunction *ff=0;
162
163	for(Int_t eventClass=1; eventClass<=4; eventClass++){
164
165	ff = AddTaskIDFragmentationFunction(recJetsBranch,
166	recJetsBackBranch,
167	genJetsBranch,
168	jetType,
169	trackType,
170	filterMask,
171	radius,
172	kBackgroundMode,
173	PtTrackMin,
174	eventClass,
175	BrOpt,
176	BrOpt2,
177	BrOpt3,
178	radiusBckg
179	FFMaxTrackPt,
180	FFMinNTracks,
181	suffixPIDtaskJets1,
182	suffixPIDtaskJets2,
183	suffixPIDtaskInclusive1,
184	suffixPIDtaskInclusive2);
185	}
186
187	return ff;
188	}
189
190	// _______________________________________________________________________________________
191
192	AliAnalysisTaskIDFragmentationFunction *AddTaskIDFragmentationFunction(
193	const char* recJetsBranch,
194	const char* recJetsBackBranch,
195	const char* genJetsBranch,
196	const char* jetType,
197	const char* trackType,
198	UInt_t filterMask,
c4856fb1	199	Float_t radius,
	200	Int_t kBackgroundMode,
	201	Int_t PtTrackMin,
	202	Int_t eventClass=0,
	203	TString BrOpt="",
	204	TString BrOpt2="",
	205	TString BrOpt3="",
	206	Float_t radiusBckg=0.4,
e131b05f	207	Int_t FFMaxTrackPt = -1,
	208	Int_t FFMinNTracks = 0,
	209	UInt_t filterMaskTracks = 0,
c4856fb1	210	Bool_t onlyConsiderLeadingJets = kFALSE,
e131b05f	211	TString suffixPIDtaskJets1 = "",
	212	TString suffixPIDtaskJets2 = "",
	213	TString suffixPIDtaskInclusive1 = "",
	214	TString suffixPIDtaskInclusive2 = "")
	215	{
	216	// Creates a fragmentation function task,
	217	// configures it and adds it to the analysis manager.
	218
	219	//******************************************************************************
	220	//* Configuration Parameter ************************************************
	221	//******************************************************************************
	222
	223	// space for configuration parameter: histo bin, cuts, ...
	224	// so far only default parameter used
	225
	226	Int_t debug = -1; // debug level, -1: not set here
	227
	228	//******************************************************************************
	229
	230
	231
	232	// Get the pointer to the existing analysis manager via the static access method.
	233	//==============================================================================
	234	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	235	if (!mgr) {
	236	::Error("AddTaskIDFragmentationFunction", "No analysis manager to connect to.");
	237	return NULL;
	238	}
	239
	240	// Check the analysis type using the event handlers connected to the analysis manager.
	241	//==============================================================================
	242	if (!mgr->GetInputEventHandler()) {
	243	::Error("AddTaskIDFragmentationFunction", "This task requires an input event handler");
	244	return NULL;
	245	}
	246
	247	TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
	248	Printf("Data Type: %s", type.Data());
	249
	250	TString branchRecBackJets(recJetsBackBranch);
	251	TString branchRecJets(recJetsBranch);
	252	TString branchGenJets(genJetsBranch);
	253	TString typeJets(jetType);
	254	TString typeTracks(trackType);
	255
	256	if(branchRecBackJets.Length()==0) branchRecBackJets = "noRecBackJets";
	257	if(branchRecJets.Length()==0) branchRecJets = "noRecJets";
	258	if(branchGenJets.Length()==0) branchGenJets = "noGenJets";
	259	if(typeTracks.Length()==0) typeTracks = "trackTypeUndef";
	260	if(typeJets.Length()==0) typeJets = "jetTypeUndef";
	261
	262	// Create the task and configure it.
	263	//===========================================================================
	264
	265	AliAnalysisTaskIDFragmentationFunction *task = new AliAnalysisTaskIDFragmentationFunction(
07b146b5	266	Form("Fragmentation_Function_%s_%s_%s_%s_filterMaskTracks%d", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(),
07b146b5	267	typeTracks.Data(), filterMaskTracks));
e131b05f	268
	269	if(debug>=0) task->SetDebugLevel(debug);
	270
	271	Printf("Rec Jets %s", branchRecJets.Data());
	272	Printf("Back Rec Jets %s", branchRecBackJets.Data());
	273	Printf("Gen Jets %s", branchGenJets.Data());
	274	Printf("Jet Type %s", typeJets.Data());
	275	Printf("Track Type %s", typeTracks.Data());
	276
07b146b5	277	Printf("Radius cut: %f", radius);
	278	Printf("FilterMaskTracks: %d", filterMaskTracks);
	279
e131b05f	280	// attach the filter mask and options
	281	TString cAdd = "";
	282	cAdd += Form("%02d",(int)((TMath::Abs(radius)+0.01)*10.));
	283	cAdd += Form("_B%d",(int)((kBackgroundMode)));
	284	cAdd += Form("_Filter%05d",filterMask);
	285	cAdd += Form("_Cut%05d",PtTrackMin);
	286	cAdd += Form("%s",BrOpt.Data());
	287	cAdd += Form("%s",BrOpt2.Data());
	288
	289	Printf("%s",cAdd.Data());
	290
	291	TString cAddb = "";
	292	cAddb += Form("%02d",(int)((radiusBckg+0.01)*10.));
	293	cAddb += Form("_B%d",(int)((kBackgroundMode)));
	294	cAddb += Form("_Filter%05d",filterMask);
	295	cAddb += Form("_Cut%05d",PtTrackMin);
	296	cAddb += Form("%s",BrOpt.Data());
	297	cAddb += Form("%s",BrOpt2.Data());
	298
	299	Printf("%s",cAddb.Data());
	300
	301	TString cAddmc = "";
	302	cAddmc += Form("%02d",(int)((TMath::Abs(radius)+0.01)*10.));
	303	cAddmc += Form("_B%d",(int)((kBackgroundMode)));
	304	cAddmc += Form("_Filter%05d",filterMask);
	305	cAddmc += Form("_Cut%05d",PtTrackMin);
	306	cAddmc += Form("%s",BrOpt3.Data());
	307
	308	Printf("%s",cAddmc.Data());
	309
	310
	311	if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("jets")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
	312	if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("cluster")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
	313
	314	if(branchRecBackJets.Contains("back")&&branchRecBackJets.Contains("cluster")&&!branchRecBackJets.Contains("MC"))branchRecBackJets = branchRecBackJets + cAddb;
	315
	316	if(branchGenJets.Contains("AOD")&&branchGenJets.Contains("MC"))branchGenJets = branchGenJets + cAddmc;
	317
	318	Printf("Gen jets branch %s: ", branchGenJets.Data());
	319	Printf("Rec jets branch %s: ", branchRecJets.Data());
	320	Printf("Jet backg branch %s: ", branchRecBackJets.Data());
	321
	322	if(!branchRecJets.Contains("noRecJets")) task->SetBranchRecJets(branchRecJets);
	323	if(!branchRecBackJets.Contains("noRecBackJets")) task->SetBranchRecBackJets(branchRecBackJets);
	324	if(!branchGenJets.Contains("noGenJets")) task->SetBranchGenJets(branchGenJets);
	325
	326
	327	if(typeTracks.Contains("AODMC2b")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCChargedAcceptance);
	328	else if(typeTracks.Contains("AODMC2")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCCharged);
	329	else if(typeTracks.Contains("AODMC")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCAll);
	330	else if(typeTracks.Contains("KINE2b")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineChargedAcceptance);
	331	else if(typeTracks.Contains("KINE2")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineCharged);
	332	else if(typeTracks.Contains("KINE")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineAll);
	333	else if(typeTracks.Contains("AODb")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODCuts);
	334	else if(typeTracks.Contains("AOD")) task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAOD);
	335	else if(typeTracks.Contains("trackTypeUndef")) task->SetTrackTypeGen(0); // undefined
	336	else Printf("trackType %s not found", typeTracks.Data());
	337
	338	if(typeJets.Contains("AODMCb")) task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsGenAcceptance);
	339	else if(typeJets.Contains("AODMC")) task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsGen);
	340	else if(typeJets.Contains("KINEb")) task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsKineAcceptance);
	341	else if(typeJets.Contains("KINE")) task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsKine);
	342	else if(typeJets.Contains("AODb")) task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsRecAcceptance);
	343	else if(typeJets.Contains("AOD")) task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsRec);
344	else if(typeJets.Contains("jetTypeUndef")) task->SetJetTypeGen(0); // undefined
345	else Printf("jetType %s not found", typeJets.Data());
346
347	if(typeJets.Contains("AODMCb")) task->SetJetTypeRecEff(AliAnalysisTaskIDFragmentationFunction::kJetsGenAcceptance); // kJetsRecAcceptance
348	else if(typeJets.Contains("AODb")) task->SetJetTypeRecEff(AliAnalysisTaskIDFragmentationFunction::kJetsRecAcceptance);
349	else task->SetJetTypeRecEff(0);
350
351	if(!filterMaskTracks) task->SetFilterMask(filterMask);
352	else task->SetFilterMask(filterMaskTracks);
353
354	task->SetEventSelectionMask(AliVEvent::kMB);
355	task->SetEventClass(eventClass);
356
357	// Set default parameters
358	// Cut selection
359
360	if(PtTrackMin == 150) task->SetTrackCuts(); // default : pt > 0.150 GeV, \|eta\|<0.9, full phi acc
361	else if(PtTrackMin == 1000) task->SetTrackCuts(1.0, -0.9, 0.9, 0., 2*TMath::Pi());
362	else if(PtTrackMin == 2000) task->SetTrackCuts(2.0, -0.9, 0.9, 0., 2*TMath::Pi());
363	else task->SetTrackCuts(0.001PtTrackMin,-0.9, 0.9, 0., 2TMath::Pi());
364
365
366	task->SetJetCuts(); // default: jet pt > 5 GeV, \|eta\|<0.5, full phi acc
367	task->SetFFRadius(radius);
368	task->SetFFBckgRadius(); // default: R = 0.7
369	task->SetQAMode(); // default: qaMode = 3
370	task->SetFFMode(); // default: ffMode = 1
371	task->SetIDFFMode(0); // default: IDffMode = 0
372	task->SetEffMode(0); // default: effMode = 1
373	task->SetHighPtThreshold(); // default: pt > 5 Gev
374
375	task->SetBckgMode(1); // default: bgMode = 1
376	task->SetBckgType();
377	task->SetBranchRecBackClusters(Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00",filterMask));
378
c4856fb1	379	task->SetOnlyLeadingJets(onlyConsiderLeadingJets); // default: kFALSE
c4856fb1	380
e131b05f	381	// Define histo bins
	382	task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70, 0., 7.,22, 0., 1.1);
	383
	384	task->SetQAJetHistoBins();
	385	task->SetQATrackHistoBins();
	386
	387	if(FFMaxTrackPt>0) task->SetFFMaxTrackPt(FFMaxTrackPt);
	388	if(FFMinNTracks>0) task->SetFFMinNTracks(FFMinNTracks);
	389
	390	mgr->AddTask(task);
	391
	392	// Create ONLY the output containers for the data produced by the task.
	393	// Get and connect other common input/output containers via the manager as below
	394	//==============================================================================
	395
97bd2587	396	TString strList(Form("idfracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
e131b05f	397
	398	TString strDir(Form("%s:PWGJE_IDFragmentationFunction_%s_%s_%s_%s_cl%d",
	399	AliAnalysisManager::GetCommonFileName(), branchRecJets.Data(), branchGenJets. Data(),
	400	typeTracks.Data(), typeJets.Data(), eventClass));
	401
	402
	403	if(FFMaxTrackPt>0){
	404	strList += Form("_FFMaxPt%d", FFMaxTrackPt);
	405	strDir += Form("_FFMaxPt%d", FFMaxTrackPt);
	406	}
	407	if(FFMinNTracks>0){
	408	strList += Form("_minNTr%d",FFMinNTracks);
	409	strDir += Form("_minNTr%d",FFMinNTracks);
	410	}
	411
	412	if(radius<0){
	413	strList += "_trackRefs";
	414	strDir += "_trackRefs";
	415	}
	416	if(filterMaskTracks){
	417	strList += Form("_TrackFilter%05d",filterMaskTracks);
	418	strDir += Form("_TrackFilter%05d",filterMaskTracks);
	419	}
	420
	421
	422	AliAnalysisDataContainer *coutput_FragFunc = mgr->CreateContainer(strList,TList::Class(),
	423	AliAnalysisManager::kOutputContainer,
	424	strDir);
	425
	426	mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer());
	427	mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
	428	mgr->ConnectOutput (task, 1, coutput_FragFunc);
	429
	430	postConfig(task, suffixPIDtaskJets1, suffixPIDtaskJets2, suffixPIDtaskInclusive1, suffixPIDtaskInclusive2);
	431
	432	return task;
	433	}
	434