PWGJE/macros/AddTaskIDFragmentationFunction.C

   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),
  23 -0.4, 0, 1000*AliAnalysisManager::GetGlobalDbl("kTrackPtCut", gDebug), 0, "_Skip00", "", "_Skip00", 0.4, -1, 0, 0, kFALSE,
  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,
 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,
 207   Int_t FFMaxTrackPt = -1,
 208   Int_t FFMinNTracks = 0,
 209   UInt_t filterMaskTracks = 0,
 210   Bool_t onlyConsiderLeadingJets = kFALSE,
 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(
 266         Form("Fragmentation_Function_%s_%s_%s_%s_filterMaskTracks%d", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(),
 267              typeTracks.Data(), filterMaskTracks));
 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
 277    Printf("Radius cut: %f", radius);
 278    Printf("FilterMaskTracks: %d", filterMaskTracks);
 279
 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.001*PtTrackMin,-0.9, 0.9, 0., 2*TMath::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
 379    task->SetOnlyLeadingJets(onlyConsiderLeadingJets); // default: kFALSE
 380
 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
 396    TString strList(Form("idfracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
 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