PWGJE/macros/AddTaskFragmentationFunction.C

   1
   2 /*************************************************************************************************
   3 ***  Add Fragmentation Function Task ***
   4 **************************************************************************************************
   5 The fragmentation function task expects an ESD filter and jet finder running before this task.
   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
  24 AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(UInt_t iFlag=1, UInt_t filterMask=32, Int_t eventClass=0){
  25
  26         AliAnalysisTaskFragmentationFunction *ff=0;
  27
  28         // UA1 Jets
  29         // only reconstructed (default)
  30         if(iFlag&(1<<0)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "", "", "", filterMask, 0.4,0,1000., eventClass);
  31         // charged MC tracks and jets
  32         if(iFlag&(1<<1)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMC", "AODMC2", filterMask, 0.4,0,1000., eventClass);
  33         // charged MC tracks and jets with acceptance cuts
  34         if(iFlag&(1<<2)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODMCb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
  35         // kine tracks in acceptance, pythia jets in acceptance
  36         if(iFlag&(1<<3)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "", "KINEb", "KINEb", filterMask, 0.4,0,1000., eventClass);
  37         // reconstructed charged tracks after cuts, MC jets in acceptance
  38         if(iFlag&(1<<4)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsMC2b", "AODMCb", "AOD2b", filterMask, 0.4,0,1000., eventClass);
  39         // reconstruction efficiency: pointing with rec jet axis into gen tracks
  40         if(iFlag&(1<<5)) ff = AddTaskFragmentationFunction("jetsAOD_UA1", "", "jetsAODMC2_UA1", "AODb", "AODMC2b", filterMask, 0.4,0,1000., eventClass);
  41
  42
  43
  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
  53         // Jet background subtracted
  54         if(iFlag&(1<<23)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,2,150.,eventClass, "_Skip00");
  55         // charged MC tracks and jets
  56         if(iFlag&(1<<24)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMC", "AODMC2", filterMask, 0.4,2,150.,eventClass, "_Skip00");
  57         // charged MC tracks and jets with acceptance cuts
  58         if(iFlag&(1<<25)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "jetsAODMC2_FASTJET", "AODMCb", "AODMC2b", filterMask, 0.4,2,150., eventClass, "_Skip00");
  59
  60        if(iFlag&(1<<26)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,1,150.,eventClass, "_Skip00");
  61
  62        if(iFlag&(1<<27)) ff = AddTaskFragmentationFunction("clustersAOD_ANTIKT", "", "", "", "", filterMask, 0.4,3,150.,eventClass, "_Skip00");
  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
  69         return ff;
  70 }
  71
  72 // _______________________________________________________________________________________
  73
  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,
  83         Int_t PtTrackMin,
  84         TString BrOpt="",
  85         TString BrOpt2="",
  86         TString BrOpt3="",
  87         Float_t radiusBckg=0.4,
  88         Int_t   FFMaxTrackPt = -1,
  89         Float_t FFMinNTracks = 0)
  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,
 110                                       BrOpt3,
 111                                       radiusBckg
 112                                       FFMaxTrackPt,
 113                                       FFMinNTracks);
 114   }
 115
 116   return ff;
 117 }
 118
 119 // _______________________________________________________________________________________
 120
 121 AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(
 122         const char* recJetsBranch,
 123         const char* recJetsBackBranch,
 124         const char* genJetsBranch,
 125         const char* jetType,
 126         const char* trackType,
 127         UInt_t filterMask,
 128         Float_t radius,
 129         int kBackgroundMode,
 130         Int_t PtTrackMin,
 131         Int_t eventClass=0,
 132         TString BrOpt="",
 133         TString BrOpt2="",
 134         TString BrOpt3="",
 135         Float_t radiusBckg=0.4,
 136         Int_t FFMaxTrackPt = -1,
 137         Int_t FFMinNTracks = 0)
 138 {
 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
 150
 151    //******************************************************************************
 152
 153
 154
 155    // Get the pointer to the existing analysis manager via the static access method.
 156    //==============================================================================
 157    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 158    if (!mgr) {
 159           ::Error("AddTaskFragmentationFunction", "No analysis manager to connect to.");
 160           return NULL;
 161    }
 162
 163    // Check the analysis type using the event handlers connected to the analysis manager.
 164    //==============================================================================
 165    if (!mgr->GetInputEventHandler()) {
 166          ::Error("AddTaskFragmentationFunction", "This task requires an input event handler");
 167           return NULL;
 168    }
 169
 170    TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
 171    Printf("Data Type: %s", type.Data());
 172
 173    TString branchRecBackJets(recJetsBackBranch);
 174    TString branchRecJets(recJetsBranch);
 175    TString branchGenJets(genJetsBranch);
 176    TString typeJets(jetType);
 177    TString typeTracks(trackType);
 178
 179    if(branchRecBackJets.Length()==0) branchRecBackJets = "noRecBackJets";
 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
 185    // Create the task and configure it.
 186    //===========================================================================
 187
 188    AliAnalysisTaskFragmentationFunction *task = new AliAnalysisTaskFragmentationFunction(
 189         Form("Fragmentation Function %s %s %s %s", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(), typeTracks.Data()));
 190
 191    if(debug>=0) task->SetDebugLevel(debug);
 192
 193    Printf("Rec Jets %s", branchRecJets.Data());
 194    Printf("Back Rec Jets %s", branchRecBackJets.Data());
 195    Printf("Gen Jets %s", branchGenJets.Data());
 196    Printf("Jet Type %s", typeJets.Data());
 197    Printf("Track Type %s", typeTracks.Data());
 198
 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);
 204    cAdd += Form("_Cut%05d",PtTrackMin);
 205    cAdd += Form("%s",BrOpt.Data());
 206    cAdd += Form("%s",BrOpt2.Data());
 207
 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);
 214    cAddb += Form("_Cut%05d",PtTrackMin);
 215    cAddb += Form("%s",BrOpt.Data());
 216    cAddb += Form("%s",BrOpt2.Data());
 217
 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);
 224    cAddmc += Form("_Cut%05d",PtTrackMin);
 225    cAddmc += Form("%s",BrOpt3.Data());
 226
 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());
 240
 241    if(!branchRecJets.Contains("noRecJets")) task->SetBranchRecJets(branchRecJets);
 242    if(!branchRecBackJets.Contains("noRecBackJets")) task->SetBranchRecBackJets(branchRecBackJets);
 243    if(!branchGenJets.Contains("noGenJets")) task->SetBranchGenJets(branchGenJets);
 244
 245
 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
 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
 270    task->SetFilterMask(filterMask);
 271    task->SetEventClass(eventClass);
 272
 273    // Set default parameters
 274    // Cut selection
 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.001*PtTrackMin,-0.9, 0.9, 0., 2*TMath::Pi());
 280
 281
 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)
 285    task->SetFFRadius(radius);
 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
 291    task->SetDJMode(0);          // default: djMode = 1
 292    task->SetEffMode(0);         // default: effMode = 1
 293    task->SetPhiCorrMode(0);     // default: phiCorrMode = 1
 294    task->SetHighPtThreshold();  // default: pt > 5 Gev
 295    task->UseRecEffRecJetPtBins(); // efficiency in bins of rec/gen jet pt - default: kTRUE
 296
 297    task->SetBckgMode(1);        // default: bgMode = 1
 298    task->SetBckgType();
 299    task->SetBranchRecBackClusters(Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00",filterMask));
 300
 301    // Define histo bins
 302    task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70,  0., 7.,22,  0.,  1.1);
 303
 304    task->SetQAJetHistoBins();
 305    task->SetQATrackHistoBins();
 306    task->SetIJHistoBins();
 307    task->SetDiJetHistoBins();
 308    task->SetQADiJetHistoBins();
 309
 310    if(FFMaxTrackPt>0) task->SetFFMaxTrackPt(FFMaxTrackPt);
 311    if(FFMinNTracks>0) task->SetFFMinNTracks(FFMinNTracks);
 312
 313    mgr->AddTask(task);
 314
 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    //==============================================================================
 318
 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);
 338
 339    mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
 340    mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
 341    mgr->ConnectOutput (task, 1, coutput_FragFunc);
 342
 343    return task;
 344 }