Undoing some unwanted method renames
[u/mrichter/AliRoot.git] / PWGJE / macros / AddTaskIDFragmentationFunction.C
CommitLineData
e131b05f 1/*************************************************************************************************
2*** Add Fragmentation Function Task ***
3**************************************************************************************************
4The ID fragmentation function task expects an ESD filter and jet finder running before this task.
5Or 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
21Typical 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
28void 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
87AliAnalysisTaskIDFragmentationFunction *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
137AliAnalysisTaskIDFragmentationFunction *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
192AliAnalysisTaskIDFragmentationFunction *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(),
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.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
c4856fb1 379 task->SetOnlyLeadingJets(onlyConsiderLeadingJets); // default: kFALSE
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