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,
  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 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   TString suffixPIDtaskJets1 = "",
 211   TString suffixPIDtaskJets2 = "",
 212   TString suffixPIDtaskInclusive1 = "",
 213   TString suffixPIDtaskInclusive2 = "")
 214 {
 215    // Creates a fragmentation function task,
 216    // configures it and adds it to the analysis manager.
 217
 218    //******************************************************************************
 219    //*** Configuration Parameter **************************************************
 220    //******************************************************************************
 221
 222    // space for configuration parameter: histo bin, cuts, ...
 223    // so far only default parameter used
 224
 225    Int_t debug = -1; // debug level, -1: not set here
 226
 227    //******************************************************************************
 228
 229
 230
 231    // Get the pointer to the existing analysis manager via the static access method.
 232    //==============================================================================
 233    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 234    if (!mgr) {
 235     ::Error("AddTaskIDFragmentationFunction", "No analysis manager to connect to.");
 236     return NULL;
 237    }
 238
 239    // Check the analysis type using the event handlers connected to the analysis manager.
 240    //==============================================================================
 241    if (!mgr->GetInputEventHandler()) {
 242    ::Error("AddTaskIDFragmentationFunction", "This task requires an input event handler");
 243     return NULL;
 244    }
 245
 246    TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
 247    Printf("Data Type: %s", type.Data());
 248
 249    TString branchRecBackJets(recJetsBackBranch);
 250    TString branchRecJets(recJetsBranch);
 251    TString branchGenJets(genJetsBranch);
 252    TString typeJets(jetType);
 253    TString typeTracks(trackType);
 254
 255    if(branchRecBackJets.Length()==0) branchRecBackJets = "noRecBackJets";
 256    if(branchRecJets.Length()==0) branchRecJets = "noRecJets";
 257    if(branchGenJets.Length()==0) branchGenJets = "noGenJets";
 258    if(typeTracks.Length()==0) typeTracks = "trackTypeUndef";
 259    if(typeJets.Length()==0)   typeJets   = "jetTypeUndef";
 260
 261    // Create the task and configure it.
 262    //===========================================================================
 263
 264    AliAnalysisTaskIDFragmentationFunction *task = new AliAnalysisTaskIDFragmentationFunction(
 265         Form("Fragmentation Function %s %s %s %s", branchRecJets.Data(), branchGenJets.Data(), typeJets.Data(), typeTracks.Data()));
 266
 267    if(debug>=0) task->SetDebugLevel(debug);
 268
 269    Printf("Rec Jets %s", branchRecJets.Data());
 270    Printf("Back Rec Jets %s", branchRecBackJets.Data());
 271    Printf("Gen Jets %s", branchGenJets.Data());
 272    Printf("Jet Type %s", typeJets.Data());
 273    Printf("Track Type %s", typeTracks.Data());
 274
 275    // attach the filter mask and options
 276    TString cAdd = "";
 277    cAdd += Form("%02d",(int)((TMath::Abs(radius)+0.01)*10.));
 278    cAdd += Form("_B%d",(int)((kBackgroundMode)));
 279    cAdd += Form("_Filter%05d",filterMask);
 280    cAdd += Form("_Cut%05d",PtTrackMin);
 281    cAdd += Form("%s",BrOpt.Data());
 282    cAdd += Form("%s",BrOpt2.Data());
 283
 284    Printf("%s",cAdd.Data());
 285
 286    TString cAddb = "";
 287    cAddb += Form("%02d",(int)((radiusBckg+0.01)*10.));
 288    cAddb += Form("_B%d",(int)((kBackgroundMode)));
 289    cAddb += Form("_Filter%05d",filterMask);
 290    cAddb += Form("_Cut%05d",PtTrackMin);
 291    cAddb += Form("%s",BrOpt.Data());
 292    cAddb += Form("%s",BrOpt2.Data());
 293
 294    Printf("%s",cAddb.Data());
 295
 296    TString cAddmc = "";
 297    cAddmc += Form("%02d",(int)((TMath::Abs(radius)+0.01)*10.));
 298    cAddmc += Form("_B%d",(int)((kBackgroundMode)));
 299    cAddmc += Form("_Filter%05d",filterMask);
 300    cAddmc += Form("_Cut%05d",PtTrackMin);
 301    cAddmc += Form("%s",BrOpt3.Data());
 302
 303    Printf("%s",cAddmc.Data());
 304
 305
 306    if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("jets")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
 307    if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("cluster")&&!branchRecJets.Contains("MC"))branchRecJets = branchRecJets + cAdd;
 308
 309    if(branchRecBackJets.Contains("back")&&branchRecBackJets.Contains("cluster")&&!branchRecBackJets.Contains("MC"))branchRecBackJets = branchRecBackJets + cAddb;
 310
 311    if(branchGenJets.Contains("AOD")&&branchGenJets.Contains("MC"))branchGenJets = branchGenJets + cAddmc;
 312
 313    Printf("Gen jets branch %s: ", branchGenJets.Data());
 314    Printf("Rec jets branch %s: ", branchRecJets.Data());
 315    Printf("Jet backg branch %s: ", branchRecBackJets.Data());
 316
 317    if(!branchRecJets.Contains("noRecJets")) task->SetBranchRecJets(branchRecJets);
 318    if(!branchRecBackJets.Contains("noRecBackJets")) task->SetBranchRecBackJets(branchRecBackJets);
 319    if(!branchGenJets.Contains("noGenJets")) task->SetBranchGenJets(branchGenJets);
 320
 321
 322    if(typeTracks.Contains("AODMC2b"))      task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCChargedAcceptance);
 323    else if(typeTracks.Contains("AODMC2"))  task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCCharged);
 324    else if(typeTracks.Contains("AODMC"))   task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODMCAll);
 325    else if(typeTracks.Contains("KINE2b"))  task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineChargedAcceptance);
 326    else if(typeTracks.Contains("KINE2"))   task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineCharged);
 327    else if(typeTracks.Contains("KINE"))    task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackKineAll);
 328    else if(typeTracks.Contains("AODb"))    task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAODCuts);
 329    else if(typeTracks.Contains("AOD"))     task->SetTrackTypeGen(AliAnalysisTaskIDFragmentationFunction::kTrackAOD);
 330    else if(typeTracks.Contains("trackTypeUndef")) task->SetTrackTypeGen(0); // undefined
 331    else Printf("trackType %s not found", typeTracks.Data());
 332
 333    if(typeJets.Contains("AODMCb"))         task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsGenAcceptance);
 334    else if(typeJets.Contains("AODMC"))     task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsGen);
 335    else if(typeJets.Contains("KINEb"))     task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsKineAcceptance);
 336    else if(typeJets.Contains("KINE"))      task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsKine);
 337    else if(typeJets.Contains("AODb"))      task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsRecAcceptance);
 338    else if(typeJets.Contains("AOD"))       task->SetJetTypeGen(AliAnalysisTaskIDFragmentationFunction::kJetsRec);
 339    else if(typeJets.Contains("jetTypeUndef")) task->SetJetTypeGen(0); // undefined
 340    else Printf("jetType %s not found", typeJets.Data());
 341
 342    if(typeJets.Contains("AODMCb")) task->SetJetTypeRecEff(AliAnalysisTaskIDFragmentationFunction::kJetsGenAcceptance); // kJetsRecAcceptance
 343    else if(typeJets.Contains("AODb")) task->SetJetTypeRecEff(AliAnalysisTaskIDFragmentationFunction::kJetsRecAcceptance);
 344    else task->SetJetTypeRecEff(0);
 345
 346    if(!filterMaskTracks) task->SetFilterMask(filterMask);
 347    else task->SetFilterMask(filterMaskTracks);
 348
 349    task->SetEventSelectionMask(AliVEvent::kMB);
 350    task->SetEventClass(eventClass);
 351
 352    // Set default parameters
 353    // Cut selection
 354
 355    if(PtTrackMin == 150)       task->SetTrackCuts();  // default : pt > 0.150 GeV, |eta|<0.9, full phi acc
 356    else if(PtTrackMin == 1000) task->SetTrackCuts(1.0, -0.9, 0.9, 0., 2*TMath::Pi());
 357    else if(PtTrackMin == 2000) task->SetTrackCuts(2.0, -0.9, 0.9, 0., 2*TMath::Pi());
 358    else                        task->SetTrackCuts(0.001*PtTrackMin,-0.9, 0.9, 0., 2*TMath::Pi());
 359
 360
 361    task->SetJetCuts();          // default: jet pt > 5 GeV, |eta|<0.5, full phi acc
 362    task->SetFFRadius(radius);
 363    task->SetFFBckgRadius();     // default: R = 0.7
 364    task->SetQAMode();           // default: qaMode = 3
 365    task->SetFFMode();           // default: ffMode = 1
 366    task->SetIDFFMode(0);        // default: IDffMode = 0
 367    task->SetEffMode(0);         // default: effMode = 1
 368    task->SetHighPtThreshold();  // default: pt > 5 Gev
 369
 370    task->SetBckgMode(1);        // default: bgMode = 1
 371    task->SetBckgType();
 372    task->SetBranchRecBackClusters(Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00",filterMask));
 373
 374    // Define histo bins
 375    task->SetFFHistoBins(23, 5, 120, 480, 0., 120.,70,  0., 7.,22,  0.,  1.1);
 376
 377    task->SetQAJetHistoBins();
 378    task->SetQATrackHistoBins();
 379
 380    if(FFMaxTrackPt>0) task->SetFFMaxTrackPt(FFMaxTrackPt);
 381    if(FFMinNTracks>0) task->SetFFMinNTracks(FFMinNTracks);
 382
 383    mgr->AddTask(task);
 384
 385    // Create ONLY the output containers for the data produced by the task.
 386    // Get and connect other common input/output containers via the manager as below
 387    //==============================================================================
 388
 389    TString strList(Form("fracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
 390
 391    TString strDir(Form("%s:PWGJE_IDFragmentationFunction_%s_%s_%s_%s_cl%d",
 392            AliAnalysisManager::GetCommonFileName(), branchRecJets.Data(), branchGenJets. Data(),
 393            typeTracks.Data(), typeJets.Data(), eventClass));
 394
 395
 396    if(FFMaxTrackPt>0){
 397      strList += Form("_FFMaxPt%d", FFMaxTrackPt);
 398      strDir  += Form("_FFMaxPt%d", FFMaxTrackPt);
 399    }
 400    if(FFMinNTracks>0){
 401      strList += Form("_minNTr%d",FFMinNTracks);
 402      strDir  += Form("_minNTr%d",FFMinNTracks);
 403    }
 404
 405    if(radius<0){
 406      strList += "_trackRefs";
 407      strDir  += "_trackRefs";
 408    }
 409    if(filterMaskTracks){
 410      strList += Form("_TrackFilter%05d",filterMaskTracks);
 411      strDir  += Form("_TrackFilter%05d",filterMaskTracks);
 412    }
 413
 414
 415    AliAnalysisDataContainer *coutput_FragFunc = mgr->CreateContainer(strList,TList::Class(),
 416                      AliAnalysisManager::kOutputContainer,
 417                      strDir);
 418
 419    mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
 420    mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
 421    mgr->ConnectOutput (task, 1, coutput_FragFunc);
 422
 423    postConfig(task, suffixPIDtaskJets1, suffixPIDtaskJets2, suffixPIDtaskInclusive1, suffixPIDtaskInclusive2);
 424
 425    return task;
 426 }
 427