]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | ||
17 | //--------------------------------------------------------------------- | |
18 | // FastJet v2.3.4 finder algorithm interface | |
19 | // Last modification: Neutral cell energy included in the jet reconstruction | |
20 | // | |
21 | // Authors: Rafael.Diaz.Valdes@cern.ch | |
22 | // Magali.estienne@subatech.in2p3.fr (neutral part + bg subtraction option) | |
23 | // | |
24 | //--------------------------------------------------------------------- | |
25 | ||
26 | ||
27 | #include <Riostream.h> | |
28 | #include <TLorentzVector.h> | |
29 | #include <TFile.h> | |
30 | #include <TH1F.h> | |
31 | #include <TH2F.h> | |
32 | #include <TArrayF.h> | |
33 | #include <TClonesArray.h> | |
34 | ||
35 | #include "AliFastJetFinder.h" | |
36 | #include "AliFastJetHeaderV1.h" | |
37 | #include "AliJetReaderHeader.h" | |
38 | #include "AliJetReader.h" | |
39 | #include "AliJetUnitArray.h" | |
40 | #include "AliFastJetInput.h" | |
41 | #include "AliJetBkg.h" | |
42 | #include "AliAODJetEventBackground.h" | |
43 | #include "AliAODTrack.h" | |
44 | ||
45 | #include "fastjet/PseudoJet.hh" | |
46 | #include "fastjet/ClusterSequenceArea.hh" | |
47 | #include "fastjet/AreaDefinition.hh" | |
48 | #include "fastjet/JetDefinition.hh" | |
49 | // get info on how fastjet was configured | |
50 | #include "fastjet/config.h" | |
51 | ||
52 | #ifdef ENABLE_PLUGIN_SISCONE | |
53 | #include "fastjet/SISConePlugin.hh" | |
54 | #endif | |
55 | ||
56 | #include<sstream> // needed for internal io | |
57 | #include<vector> | |
58 | #include <cmath> | |
59 | ||
60 | using namespace std; | |
61 | ||
62 | ||
63 | ClassImp(AliFastJetFinder) | |
64 | ||
65 | ||
66 | //____________________________________________________________________________ | |
67 | ||
68 | AliFastJetFinder::AliFastJetFinder(): | |
69 | AliJetFinder(), | |
70 | fInputFJ(new AliFastJetInput()), | |
71 | fJetBkg(new AliJetBkg()) | |
72 | { | |
73 | // Constructor | |
74 | } | |
75 | ||
76 | //____________________________________________________________________________ | |
77 | ||
78 | AliFastJetFinder::~AliFastJetFinder() | |
79 | { | |
80 | // destructor | |
81 | delete fInputFJ; fInputFJ = 0; | |
82 | delete fJetBkg; fJetBkg = 0; | |
83 | } | |
84 | ||
85 | //______________________________________________________________________________ | |
86 | void AliFastJetFinder::FindJets() | |
87 | { | |
88 | ||
89 | //pick up fastjet header | |
90 | AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader; | |
91 | Int_t debug = header->GetDebug(); // debug option | |
92 | Bool_t bgMode = header->GetBGMode(); // choose to subtract BG or not | |
93 | if(debug)cout<<"----------in AliFastJetFinder::FindJets() ------------------"<<endl; | |
94 | ||
95 | // check if we are reading AOD jets | |
96 | TRefArray *refs = 0; | |
97 | Bool_t fromAod = !strcmp(fReader->ClassName(),"AliJetAODReader"); | |
98 | if (fromAod) { refs = fReader->GetReferences(); } | |
99 | ||
100 | // RUN ALGORITHM | |
101 | // read input particles ----------------------------- | |
102 | ||
103 | vector<fastjet::PseudoJet> inputParticles=fInputFJ->GetInputParticles(); | |
104 | if(inputParticles.size()==0){ | |
105 | if(debug)Printf("%s:%d No input particles found, skipping event",(char*)__FILE__,__LINE__); | |
106 | return; | |
107 | } | |
108 | ||
109 | // create an object that represents your choice of jet algorithm, and | |
110 | // the associated parameters | |
111 | double rParam = header->GetRparam(); | |
112 | double rBkgParam = header->GetRparamBkg(); | |
113 | fastjet::Strategy strategy = header->GetStrategy(); | |
114 | fastjet::RecombinationScheme recombScheme = header->GetRecombScheme(); | |
115 | fastjet::JetAlgorithm algorithm = header->GetAlgorithm(); | |
116 | fastjet::JetDefinition jetDef(algorithm, rParam, recombScheme, strategy); | |
117 | ||
118 | // create an object that specifies how we to define the area | |
119 | fastjet::AreaDefinition areaDef; | |
120 | double ghostEtamax = header->GetGhostEtaMax(); | |
121 | double ghostArea = header->GetGhostArea(); | |
122 | int activeAreaRepeats = header->GetActiveAreaRepeats(); | |
123 | ||
124 | // now create the object that holds info about ghosts | |
125 | fastjet::GhostedAreaSpec ghostSpec(ghostEtamax, activeAreaRepeats, ghostArea); | |
126 | // and from that get an area definition | |
127 | fastjet::AreaType areaType = header->GetAreaType(); | |
128 | areaDef = fastjet::AreaDefinition(areaType,ghostSpec); | |
129 | ||
130 | //***************************** JETS FINDING | |
131 | // run the jet clustering with the above jet definition | |
132 | fastjet::ClusterSequenceArea clust_seq(inputParticles, jetDef, areaDef); | |
133 | ||
134 | vector<fastjet::PseudoJet> jets; | |
135 | ||
136 | if(bgMode) // Do BG subtraction directly with the same algorithm (cambridge or kt) for jet signal and background | |
137 | { | |
138 | //***************************** CLUSTER JETS FINDING FOR RHO ESTIMATION | |
139 | // run the jet clustering with the above jet definition | |
140 | fastjet::JetAlgorithm algorithmBkg = header->GetBGAlgorithm(); | |
141 | fastjet::JetDefinition jetDefBkg(algorithmBkg, rBkgParam, recombScheme, strategy); | |
142 | fastjet::ClusterSequenceArea clust_seq_bkg(inputParticles, jetDefBkg, areaDef); | |
143 | ||
144 | // save a comment in the header | |
145 | TString comment = "Running FastJet algorithm with the following setup. "; | |
146 | comment+= "Jet definition: "; | |
147 | comment+= TString(jetDef.description()); | |
148 | comment+= "Jet bckg definition: "; | |
149 | comment+= TString(jetDefBkg.description()); | |
150 | comment+= ". Area definition: "; | |
151 | comment+= TString(areaDef.description()); | |
152 | comment+= ". Strategy adopted by FastJet and bkg: "; | |
153 | comment+= TString(clust_seq.strategy_string()); | |
154 | header->SetComment(comment); | |
155 | if(debug){ | |
156 | cout << "--------------------------------------------------------" << endl; | |
157 | cout << comment << endl; | |
158 | cout << "--------------------------------------------------------" << endl; | |
159 | } | |
160 | //header->PrintParameters(); | |
161 | ||
162 | // extract the inclusive jets with pt > ptmin, sorted by pt | |
163 | double ptmin = header->GetPtMin(); | |
164 | vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(); | |
165 | ||
166 | //subtract background // =========================================== | |
167 | // set the rapididty , phi range within which to study the background | |
168 | double rapMax = header->GetRapMax(); | |
169 | double rapMin = header->GetRapMin(); | |
170 | double phiMax = header->GetPhiMax(); | |
171 | double phiMin = header->GetPhiMin(); | |
172 | fastjet::RangeDefinition range(rapMin, rapMax, phiMin, phiMax); | |
173 | ||
174 | // Extract rho and sigma | |
175 | Double_t rho = 0.; | |
176 | Double_t sigma = 0.; | |
177 | Double_t meanarea = 0.; | |
178 | Bool_t Use4VectorArea = header->Use4VectorArea(); | |
179 | vector<fastjet::PseudoJet> bkgJets = clust_seq_bkg.inclusive_jets(); | |
180 | clust_seq_bkg.get_median_rho_and_sigma(bkgJets,range, Use4VectorArea, rho, sigma, meanarea, false); | |
181 | ||
182 | // subtract background and extract jets bkg subtracted | |
183 | vector<fastjet::PseudoJet> subJets = clust_seq.subtracted_jets(rho,ptmin); | |
184 | ||
185 | // print out | |
186 | //cout << "Printing inclusive sub jets with pt > "<< ptmin<<" GeV\n"; | |
187 | //cout << "---------------------------------------\n"; | |
188 | //cout << endl; | |
189 | //printf(" ijet rap phi Pt area +- err\n"); | |
190 | ||
191 | // sort jets into increasing pt | |
192 | jets = sorted_by_pt(subJets); | |
193 | ||
194 | } | |
195 | else { // No BG subtraction!!!!!!!! Default header is bgmode=0. | |
196 | ||
197 | // save a comment in the header | |
198 | TString comment = "Running FastJet algorithm with the following setup. "; | |
199 | comment+= "Jet definition: "; | |
200 | comment+= TString(jetDef.description()); | |
201 | comment+= ". Strategy adopted by FastJet: "; | |
202 | comment+= TString(clust_seq.strategy_string()); | |
203 | header->SetComment(comment); | |
204 | if(debug){ | |
205 | cout << "--------------------------------------------------------" << endl; | |
206 | cout << comment << endl; | |
207 | cout << "--------------------------------------------------------" << endl; | |
208 | } | |
209 | //header->PrintParameters(); | |
210 | ||
211 | // extract the inclusive jets with pt > ptmin, sorted by pt | |
212 | double ptmin = header->GetPtMin(); | |
213 | vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(ptmin); | |
214 | ||
215 | jets = sorted_by_pt(inclusiveJets); // Added by me | |
216 | ||
217 | } | |
218 | ||
219 | for (size_t j = 0; j < jets.size(); j++) { // loop for jets | |
220 | ||
221 | double area = clust_seq.area(jets[j]); | |
222 | double areaError = clust_seq.area_error(jets[j]); | |
223 | ||
224 | if(debug) printf("Jet found %5d %9.5f %8.5f %10.3f %8.3f +- %6.3f\n", (Int_t)j,jets[j].rap(),jets[j].phi(),jets[j].perp(), area, areaError); | |
225 | ||
226 | vector<fastjet::PseudoJet> constituents = clust_seq.constituents(jets[j]); | |
227 | int nCon= constituents.size(); | |
228 | TArrayI ind(nCon); | |
229 | ||
230 | if ((jets[j].eta() > (header->GetJetEtaMax())) || | |
231 | (jets[j].eta() < (header->GetJetEtaMin())) || | |
232 | (jets[j].phi() > (header->GetJetPhiMax())) || | |
233 | (jets[j].phi() < (header->GetJetPhiMin())) || | |
234 | (jets[j].perp() < header->GetPtMin())) continue; // acceptance eta range and etmin | |
235 | ||
236 | // go to write AOD info | |
237 | AliAODJet aodjet (jets[j].px(), jets[j].py(), jets[j].pz(), jets[j].E()); | |
238 | aodjet.SetEffArea(area,areaError); | |
239 | //cout << "Printing jet " << endl; | |
240 | if(debug) aodjet.Print(""); | |
241 | ||
242 | Int_t count=0; | |
243 | for (int i=0; i < nCon; i++) | |
244 | { | |
245 | fastjet::PseudoJet mPart=constituents[i]; | |
246 | ind[i]=mPart.user_index(); | |
247 | // cout<<i<<" index="<<ind[i]<<endl; | |
248 | ||
249 | if(fromAod) | |
250 | { | |
251 | if(fReader->GetReaderHeader()->GetDetector()==0) | |
252 | { | |
253 | for (Int_t iref = 0; iref < refs->GetEntries(); iref++) | |
254 | { | |
255 | if(iref==ind[i]){ | |
256 | AliAODTrack * track = (AliAODTrack*)refs->At(iref); | |
257 | aodjet.AddTrack(track); | |
258 | } | |
259 | } | |
260 | ||
261 | } else { | |
262 | ||
263 | TClonesArray* fUnit = fReader->GetUnitArray(); //Big mmentum array | |
264 | if(fUnit == 0) { cout << "Could not get the momentum array" << endl; return; } | |
265 | Int_t nIn = fUnit->GetEntries(); | |
266 | ||
267 | //internal loop over all the unit cells | |
268 | Int_t ipart = 0; | |
269 | ||
270 | for(Int_t ii=0; ii<nIn; ii++) | |
271 | { | |
272 | AliJetUnitArray *uArray = (AliJetUnitArray*)fUnit->At(ii); | |
273 | if(uArray->GetUnitEnergy()>0.){ | |
274 | uArray->SetUnitTrackID(ipart);//used to have the index available in AliJEtBkg | |
275 | if(ipart==ind[i]){ | |
276 | TRefArray* trackArray = (TRefArray*)uArray->GetUnitTrackRef(); | |
277 | Int_t tracksInCell = trackArray->GetEntries(); | |
278 | for(int ji = 0; ji < tracksInCell; ji++){ | |
279 | AliAODTrack * track = (AliAODTrack*)trackArray->At(ji); | |
280 | aodjet.AddTrack(track); | |
281 | } | |
282 | ||
283 | count++; | |
284 | } | |
285 | ipart++; | |
286 | } | |
287 | } | |
288 | } | |
289 | } | |
290 | } | |
291 | ||
292 | AddJet(aodjet); | |
293 | ||
294 | ||
295 | } // End loop on jets | |
296 | ||
297 | } | |
298 | ||
299 | //____________________________________________________________________________ | |
300 | void AliFastJetFinder::RunTest(const char* datafile) | |
301 | ||
302 | { | |
303 | ||
304 | // This simple test run the kt algorithm for an ascii file testdata.dat | |
305 | // read input particles ----------------------------- | |
306 | vector<fastjet::PseudoJet> inputParticles; | |
307 | Float_t px,py,pz,en; | |
308 | ifstream in; | |
309 | Int_t nlines = 0; | |
310 | // we assume a file basic.dat in the current directory | |
311 | // this file has 3 columns of float data | |
312 | in.open(datafile); | |
313 | while (1) { | |
314 | in >> px >> py >> pz >> en; | |
315 | if (!in.good()) break; | |
316 | //printf("px=%8f, py=%8f, pz=%8fn",px,py,pz); | |
317 | nlines++; | |
318 | inputParticles.push_back(fastjet::PseudoJet(px,py,pz,en)); | |
319 | } | |
320 | //printf(" found %d pointsn",nlines); | |
321 | in.close(); | |
322 | ////////////////////////////////////////////////// | |
323 | ||
324 | // create an object that represents your choice of jet algorithm, and | |
325 | // the associated parameters | |
326 | double rParam = 1.0; | |
327 | fastjet::Strategy strategy = fastjet::Best; | |
328 | fastjet::RecombinationScheme recombScheme = fastjet::BIpt_scheme; | |
329 | fastjet::JetDefinition jetDef(fastjet::kt_algorithm, rParam, recombScheme, strategy); | |
330 | ||
331 | ||
332 | ||
333 | // create an object that specifies how we to define the area | |
334 | fastjet::AreaDefinition areaDef; | |
335 | double ghostEtamax = 7.0; | |
336 | double ghostArea = 0.05; | |
337 | int activeAreaRepeats = 1; | |
338 | ||
339 | ||
340 | // now create the object that holds info about ghosts | |
341 | fastjet::GhostedAreaSpec ghostSpec(ghostEtamax, activeAreaRepeats, ghostArea); | |
342 | // and from that get an area definition | |
343 | areaDef = fastjet::AreaDefinition(fastjet::active_area,ghostSpec); | |
344 | ||
345 | ||
346 | // run the jet clustering with the above jet definition | |
347 | fastjet::ClusterSequenceArea clust_seq(inputParticles, jetDef, areaDef); | |
348 | ||
349 | ||
350 | // tell the user what was done | |
351 | cout << "--------------------------------------------------------" << endl; | |
352 | cout << "Jet definition was: " << jetDef.description() << endl; | |
353 | cout << "Area definition was: " << areaDef.description() << endl; | |
354 | cout << "Strategy adopted by FastJet was "<< clust_seq.strategy_string()<<endl<<endl; | |
355 | cout << "--------------------------------------------------------" << endl; | |
356 | ||
357 | ||
358 | // extract the inclusive jets with pt > 5 GeV, sorted by pt | |
359 | double ptmin = 5.0; | |
360 | vector<fastjet::PseudoJet> inclusiveJets = clust_seq.inclusive_jets(ptmin); | |
361 | ||
362 | cout << "Number of unclustered particles: " << clust_seq.unclustered_particles().size() << endl; | |
363 | ||
364 | ||
365 | //subtract background // =========================================== | |
366 | // set the rapididty range within which to study the background | |
367 | double rapMax = ghostEtamax - rParam; | |
368 | fastjet::RangeDefinition range(rapMax); | |
369 | // subtract background | |
370 | vector<fastjet::PseudoJet> subJets = clust_seq.subtracted_jets(range,ptmin); | |
371 | ||
372 | // print them out //================================================ | |
373 | cout << "Printing inclusive jets after background subtraction \n"; | |
374 | cout << "------------------------------------------------------\n"; | |
375 | // sort jets into increasing pt | |
376 | vector<fastjet::PseudoJet> jets = sorted_by_pt(subJets); | |
377 | ||
378 | printf(" ijet rap phi Pt area +- err\n"); | |
379 | for (size_t j = 0; j < jets.size(); j++) { | |
380 | ||
381 | double area = clust_seq.area(jets[j]); | |
382 | double areaError = clust_seq.area_error(jets[j]); | |
383 | ||
384 | printf("%5d %9.5f %8.5f %10.3f %8.3f +- %6.3f\n",(Int_t)j,jets[j].rap(), | |
385 | jets[j].phi(),jets[j].perp(), area, areaError); | |
386 | } | |
387 | cout << endl; | |
388 | // ================================================================ | |
389 | ||
390 | ||
391 | ||
392 | } | |
393 | ||
394 | //____________________________________________________________________________ | |
395 | ||
396 | void AliFastJetFinder::WriteJHeaderToFile() const | |
397 | { | |
398 | fHeader->Write(); | |
399 | } | |
400 | ||
401 | //____________________________________________________________________________ | |
402 | ||
403 | Float_t AliFastJetFinder::EtaToTheta(Float_t arg) | |
404 | { | |
405 | // return (180./TMath::Pi())*2.*atan(exp(-arg)); | |
406 | return 2.*atan(exp(-arg)); | |
407 | ||
408 | ||
409 | } | |
410 | ||
411 | //____________________________________________________________________________ | |
412 | ||
413 | void AliFastJetFinder::InitTask(TChain *tree) | |
414 | { | |
415 | ||
416 | printf("Fast jet finder initialization ******************"); | |
417 | fReader->CreateTasks(tree); | |
418 | ||
419 | } | |
420 | ||
421 | ||
422 | Bool_t AliFastJetFinder::ProcessEvent() | |
423 | { | |
424 | // | |
425 | // Process one event | |
426 | // from meomntum array | |
427 | ||
428 | Bool_t ok = fReader->FillMomentumArray(); | |
429 | ||
430 | if (!ok) return kFALSE; | |
431 | fInputFJ->SetHeader(fHeader); | |
432 | fInputFJ->SetReader(fReader); | |
433 | fInputFJ->FillInput(); | |
434 | // Jets | |
435 | FindJets(); | |
436 | ||
437 | ||
438 | if( fAODEvBkg){ | |
439 | fJetBkg->SetHeader(fHeader); | |
440 | fJetBkg->SetReader(fReader); | |
441 | Double_t sigma1 = 0,meanarea1= 0,sigma2 = 0,meanarea2 = 0; | |
442 | Double_t bkg1 = 0,bkg2 = 0; | |
443 | ||
444 | fJetBkg->SetFastJetInput(fInputFJ); | |
445 | fJetBkg->BkgFastJetb(bkg1,sigma1,meanarea1); | |
446 | fJetBkg->BkgFastJetWoHardest(bkg2,sigma2,meanarea2); | |
447 | fAODEvBkg->SetBackground(0,bkg1,sigma1,meanarea1); | |
448 | fAODEvBkg->SetBackground(1,bkg2,sigma2,meanarea2); | |
449 | } | |
450 | ||
451 | ||
452 | ||
453 | ||
454 | /* | |
455 | fJetBkg->SetFastJetInput(fInputFJ); | |
456 | Double_t bkg1=fJetBkg->BkgFastJet(); | |
457 | Double_t bkg2=fJetBkg->BkgChargedFastJet(); | |
458 | Double_t bkg3=fJetBkg->BkgFastJetCone(fAODjets); | |
459 | Double_t bkg4=fJetBkg->BkgRemoveJetLeading(fAODjets); | |
460 | ||
461 | fAODEvBkg->SetBackground(0,bkg1); | |
462 | fAODEvBkg->SetBackground(1,bkg2); | |
463 | fAODEvBkg->SetBackground(2,bkg3); | |
464 | fAODEvBkg->SetBackground(3,bkg4); | |
465 | */ | |
466 | Reset(); | |
467 | return kTRUE; | |
468 | ||
469 | } | |
470 | ||
471 | Bool_t AliFastJetFinder::ProcessEvent2() | |
472 | { | |
473 | // | |
474 | // Process one event | |
475 | // Charged only or charged+neutral jets | |
476 | // | |
477 | ||
478 | TRefArray* ref = new TRefArray(); | |
479 | Bool_t procid = kFALSE; | |
480 | Bool_t ok = fReader->ExecTasks(procid,ref); | |
481 | ||
482 | // Delete reference pointer | |
483 | if (!ok) {delete ref; return kFALSE;} | |
484 | ||
485 | // Leading particles | |
486 | fInputFJ->SetHeader(fHeader); | |
487 | fInputFJ->SetReader(fReader); | |
488 | fInputFJ->FillInput(); | |
489 | ||
490 | // Jets | |
491 | FindJets(); | |
492 | ||
493 | if( fAODEvBkg){ | |
494 | fJetBkg->SetHeader(fHeader); | |
495 | fJetBkg->SetReader(fReader); | |
496 | fJetBkg->SetFastJetInput(fInputFJ); | |
497 | Double_t sigma1,meanarea1,sigma2,meanarea2; | |
498 | Double_t bkg1,bkg2; | |
499 | fJetBkg->BkgFastJetb(bkg1,sigma1,meanarea1); | |
500 | fJetBkg->BkgFastJetWoHardest(bkg2,sigma2,meanarea2); | |
501 | fAODEvBkg->SetBackground(0,bkg1,sigma1,meanarea1); | |
502 | fAODEvBkg->SetBackground(1,bkg2,sigma2,meanarea2); | |
503 | } | |
504 | ||
505 | ||
506 | // Double_t bkg1=fJetBkg->BkgFastJet(); | |
507 | // Double_t bkg2=fJetBkg->BkgChargedFastJet(); | |
508 | // Double_t bkg3=fJetBkg->BkgFastJetCone(fAODjets); | |
509 | // Double_t bkg4=fJetBkg->BkgRemoveJetLeading(fAODjets); | |
510 | ||
511 | // fAODEvBkg->SetBackground(0,bkg1); | |
512 | // fAODEvBkg->SetBackground(1,bkg2); | |
513 | // fAODEvBkg->SetBackground(2,bkg3); | |
514 | // fAODEvBkg->SetBackground(3,bkg4); | |
515 | ||
516 | Int_t nEntRef = ref->GetEntries(); | |
517 | ||
518 | for(Int_t i=0; i<nEntRef; i++) | |
519 | { | |
520 | // Reset the UnitArray content which were referenced | |
521 | ((AliJetUnitArray*)ref->At(i))->SetUnitTrackID(0); | |
522 | ((AliJetUnitArray*)ref->At(i))->SetUnitEnergy(0.); | |
523 | ((AliJetUnitArray*)ref->At(i))->SetUnitCutFlag(kPtSmaller); | |
524 | ((AliJetUnitArray*)ref->At(i))->SetUnitCutFlag2(kPtSmaller); | |
525 | ((AliJetUnitArray*)ref->At(i))->SetUnitSignalFlag(kBad); | |
526 | ((AliJetUnitArray*)ref->At(i))->SetUnitSignalFlagC(kTRUE,kBad); | |
527 | ((AliJetUnitArray*)ref->At(i))->SetUnitDetectorFlag(kTpc); | |
528 | ((AliJetUnitArray*)ref->At(i))->SetUnitFlag(kOutJet); | |
529 | ((AliJetUnitArray*)ref->At(i))->ClearUnitTrackRef(); | |
530 | ||
531 | // Reset process ID | |
532 | AliJetUnitArray* uA = (AliJetUnitArray*)ref->At(i); | |
533 | uA->ResetBit(kIsReferenced); | |
534 | uA->SetUniqueID(0); | |
535 | } | |
536 | ||
537 | // Delete the reference pointer | |
538 | ref->Delete(); | |
539 | delete ref; | |
540 | ||
541 | Reset(); | |
542 | ||
543 | return kTRUE; | |
544 | } |