]>
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 | // $Id$ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////// | |
19 | // Class AliVertex | |
20 | // Creation and investigation of an AliVertex. | |
21 | // An AliVertex can be constructed by adding AliTracks and/or AliJets. | |
22 | // | |
23 | // Note : Also (secondary) vertices can be added to a vertex. | |
24 | // | |
25 | // To provide maximal flexibility to the user, two modes of vertex storage | |
26 | // are provided by means of the memberfunction SetVertexCopy(). | |
27 | // The same holds for the storage of jets via SetJetCopy(). | |
28 | // | |
29 | // a) SetVertexCopy(0) (which is the default). | |
30 | // Only the pointers of the 'added' vertices are stored. | |
31 | // This mode is typically used by making vertex studies based on a fixed list | |
32 | // of vertices which stays under user control or is contained for instance | |
33 | // in an AliEvent. | |
34 | // In this way the AliVertex just represents a 'logical structure' for the | |
35 | // physics analysis which can be embedded in e.g. an AliEvent or AliVertex. | |
36 | // Modifications made to the original vertices also affect the AliVertex objects | |
37 | // which are stored. | |
38 | // b) SetVertexCopy(1). | |
39 | // Of every 'added' vertex a private copy will be made of which the pointer | |
40 | // will be stored. | |
41 | // In this way the AliVertex represents an entity on its own and modifications | |
42 | // made to the original vertices do not affect the AliVertex objects which are | |
43 | // stored. | |
44 | // This mode will allow 'adding' many different AliVertex objects by | |
45 | // creating only one AliVertex instance in the main programme and using the | |
46 | // AliVertex::Reset() and AliVertex::AddTrack and parameter setting memberfunctions. | |
47 | // | |
48 | // Coding example to make 3 vertices v1, v2 and v3. | |
49 | // ------------------------------------------------ | |
50 | // v1 contains the tracks 1,2,3 and 4 | |
51 | // v2 contains many different tracks | |
52 | // v3 contains the jets 1 and 2 | |
53 | // | |
54 | // AliTrack t1,t2,t3,t4; | |
55 | // ... | |
56 | // ... // code to fill the track data | |
57 | // ... | |
58 | // | |
59 | // AliJet j1,j2; | |
60 | // ... | |
61 | // ... // code to fill the jet data | |
62 | // ... | |
63 | // | |
64 | // AliVertex v1; | |
65 | // v1.SetVertexCopy(1); | |
66 | // | |
67 | // v1.AddTrack(t1); | |
68 | // v1.AddTrack(t2); | |
69 | // v1.AddTrack(t3); | |
70 | // v1.AddTrack(t4); | |
71 | // | |
72 | // Float_t r1[3]={2.4,0.1,-8.5}; | |
73 | // v1.SetPosition(r1,"car"); | |
74 | // | |
75 | // AliVertex v2; | |
76 | // v2.SetTrackCopy(1); | |
77 | // | |
78 | // AliTrack* tx=new AliTrack(); | |
79 | // for (Int_t i=0; i<10; i++) | |
80 | // { | |
81 | // ... | |
82 | // ... // code to fill the track data | |
83 | // ... | |
84 | // v2.AddTrack(tx); | |
85 | // tx->Reset(); | |
86 | // } | |
87 | // | |
88 | // Float_t r2[3]={1.6,-3.2,5.7}; | |
89 | // v2.SetPosition(r2,"car"); | |
90 | // | |
91 | // AliVertex v3; | |
92 | // | |
93 | // v3.AddJet(j1); | |
94 | // v3.AddJet(j2); | |
95 | // | |
96 | // Float_t r3[3]={6.2,4.8,1.3}; | |
97 | // v3.SetPosition(r3,"car"); | |
98 | // | |
99 | // v1.Info("sph"); | |
100 | // v2.ListAll(); | |
101 | // v3.List("cyl"); | |
102 | // | |
103 | // Float_t e1=v1.GetEnergy(); | |
104 | // Ali3Vector p1=v1.Get3Momentum(); | |
105 | // Float_t loc[3]; | |
106 | // v1.GetPosition(loc,"sph"); | |
107 | // AliPosition r=v2.GetPosition(); | |
108 | // r.Info(); | |
109 | // Int_t nt=v2.GetNtracks(); | |
110 | // AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2 | |
111 | // | |
112 | // Specify the vertices v2 and v3 as secondary vertices of v1 | |
113 | // | |
114 | // v1.AddVertex(v2); | |
115 | // v1.AddVertex(v3); | |
116 | // | |
117 | // v1.List(); | |
118 | // | |
119 | // Int_t nv=v1.GetNvtx(); | |
120 | // AliVertex* vx=v1.GetVertex(1); // Access 1st secondary vertex of v1 | |
121 | // Float_t e=vx->GetEnergy(); | |
122 | // | |
123 | // Float_t M=v1.GetInvmass(); | |
124 | // | |
125 | // Reconstruct Vertex v1 from scratch | |
126 | // | |
127 | // v1.Reset(); | |
128 | // v1.SetNvmax(25); // Increase initial no. of sec. vertices | |
129 | // v1.AddTrack(t3); | |
130 | // v1.AddTrack(t4); | |
131 | // v1.AddJet(j2); | |
132 | // Float_t pos[3]={7,9,4}; | |
133 | // v1.SetPosition(pos,"car"); | |
134 | // | |
135 | // Note : All quantities are in GeV, GeV/c or GeV/c**2 | |
136 | // | |
137 | //--- Author: Nick van Eijndhoven 04-apr-1998 UU-SAP Utrecht | |
138 | //- Modified: NvE $Date$ UU-SAP Utrecht | |
139 | /////////////////////////////////////////////////////////////////////////// | |
140 | ||
141 | #include "AliVertex.h" | |
142 | ||
143 | ClassImp(AliVertex) // Class implementation to enable ROOT I/O | |
144 | ||
145 | AliVertex::AliVertex() | |
146 | { | |
147 | // Default constructor. | |
148 | // All variables initialised to 0. | |
149 | // Initial maximum number of tracks is set to the default value. | |
150 | // Initial maximum number of sec. vertices is set to the default value. | |
151 | fNvmax=0; | |
152 | fVertices=0; | |
153 | fConnects=0; | |
154 | fVertexCopy=0; | |
155 | fNjmax=0; | |
156 | fJets=0; | |
157 | fJetCopy=0; | |
158 | Reset(); | |
159 | SetNtinit(); | |
160 | SetNvmax(); | |
161 | SetNjmax(); | |
162 | } | |
163 | /////////////////////////////////////////////////////////////////////////// | |
164 | AliVertex::AliVertex(Int_t n) | |
165 | { | |
166 | // Create a vertex to hold initially a maximum of n tracks | |
167 | // All variables initialised to 0 | |
168 | fNvmax=0; | |
169 | fVertices=0; | |
170 | fConnects=0; | |
171 | fVertexCopy=0; | |
172 | fNjmax=0; | |
173 | fJets=0; | |
174 | fJetCopy=0; | |
175 | Reset(); | |
176 | if (n > 0) | |
177 | { | |
178 | SetNtinit(n); | |
179 | } | |
180 | else | |
181 | { | |
182 | cout << endl; | |
183 | cout << " *AliVertex* Initial max. number of tracks entered : " << n << endl; | |
184 | cout << " This is invalid. Default initial maximum will be used." << endl; | |
185 | cout << endl; | |
186 | SetNtinit(); | |
187 | } | |
188 | SetNvmax(); | |
189 | SetNjmax(); | |
190 | } | |
191 | /////////////////////////////////////////////////////////////////////////// | |
192 | AliVertex::~AliVertex() | |
193 | { | |
194 | // Default destructor | |
195 | if (fVertices) | |
196 | { | |
197 | if (fVertexCopy) fVertices->Delete(); | |
198 | delete fVertices; | |
199 | fVertices=0; | |
200 | } | |
201 | if (fConnects) | |
202 | { | |
203 | fConnects->Delete(); | |
204 | delete fConnects; | |
205 | fConnects=0; | |
206 | } | |
207 | if (fJets) | |
208 | { | |
209 | if (fJetCopy) fJets->Delete(); | |
210 | delete fJets; | |
211 | fJets=0; | |
212 | } | |
213 | } | |
214 | /////////////////////////////////////////////////////////////////////////// | |
215 | void AliVertex::SetNvmax(Int_t n) | |
216 | { | |
217 | // Set the initial maximum number of (secondary) vertices | |
218 | if (n > 0) | |
219 | { | |
220 | fNvmax=n; | |
221 | } | |
222 | else | |
223 | { | |
224 | fNvmax=1; | |
225 | } | |
226 | if (fVertices) | |
227 | { | |
228 | if (fVertexCopy) fVertices->Delete(); | |
229 | delete fVertices; | |
230 | fVertices=0; | |
231 | } | |
232 | } | |
233 | /////////////////////////////////////////////////////////////////////////// | |
234 | void AliVertex::SetNjmax(Int_t n) | |
235 | { | |
236 | // Set the initial maximum number of jets | |
237 | if (n > 0) | |
238 | { | |
239 | fNjmax=n; | |
240 | } | |
241 | else | |
242 | { | |
243 | fNjmax=1; | |
244 | } | |
245 | if (fJets) | |
246 | { | |
247 | if (fJetCopy) fJets->Delete(); | |
248 | delete fJets; | |
249 | fJets=0; | |
250 | } | |
251 | } | |
252 | /////////////////////////////////////////////////////////////////////////// | |
253 | void AliVertex::Reset() | |
254 | { | |
255 | // Reset all variables to 0 and reset all stored vertex and jet lists. | |
256 | // The max. number of tracks is set to the initial value again | |
257 | // The max. number of vertices is set to the default value again | |
258 | // The max. number of jets is set to the default value again | |
259 | ||
260 | AliJet::Reset(); | |
261 | ||
262 | Double_t a[3]={0,0,0}; | |
263 | SetPosition(a,"sph"); | |
264 | SetPositionErrors(a,"car"); | |
265 | ||
266 | fNvtx=0; | |
267 | if (fNvmax>0) SetNvmax(fNvmax); | |
268 | if (fConnects) | |
269 | { | |
270 | fConnects->Delete(); | |
271 | delete fConnects; | |
272 | fConnects=0; | |
273 | } | |
274 | ||
275 | fNjets=0; | |
276 | if (fNjmax>0) SetNjmax(fNjmax); | |
277 | } | |
278 | /////////////////////////////////////////////////////////////////////////// | |
279 | void AliVertex::ResetVertices() | |
280 | { | |
281 | // Reset the stored vertex list and delete all connecting tracks which | |
282 | // were generated automatically via connect=1 in AddVertex(). | |
283 | // The max. number of vertices is set to the default value again. | |
284 | // All physics quantities are updated according to the remaining structure | |
285 | // of connected tracks. | |
286 | AliTrack* t; | |
287 | if (fConnects) | |
288 | { | |
289 | for (Int_t i=0; i<=fConnects->GetLast(); i++) | |
290 | { | |
291 | t=(AliTrack*)fConnects->At(i); | |
292 | AliTrack* test=(AliTrack*)fTracks->Remove(t); | |
293 | if (test) fNtrk--; | |
294 | } | |
295 | fTracks->Compress(); | |
296 | } | |
297 | ||
298 | fQ=0; | |
299 | Double_t a[4]={0,0,0,0}; | |
300 | Ali4Vector::SetVector(a,"sph"); | |
301 | for (Int_t i=0; i<fNtrk; i++) | |
302 | { | |
303 | t=GetTrack(i); | |
304 | (*this)+=(Ali4Vector&)(*t); | |
305 | fQ+=t->GetCharge(); | |
306 | } | |
307 | ||
308 | fNvtx=0; | |
309 | if (fNvmax>0) SetNvmax(fNvmax); | |
310 | if (fConnects) | |
311 | { | |
312 | fConnects->Delete(); | |
313 | delete fConnects; | |
314 | fConnects=0; | |
315 | } | |
316 | } | |
317 | /////////////////////////////////////////////////////////////////////////// | |
318 | void AliVertex::AddJet(AliJet& j,Int_t tracks) | |
319 | { | |
320 | // Add a jet (and its tracks) to the vertex | |
321 | // In case the maximum number of jets has been reached, | |
322 | // the array space will be extended automatically | |
323 | // | |
324 | // Note : By default the tracks of the jet are added to the current (primary) | |
325 | // vertex. | |
326 | // The automatic addition of the tracks of the jet can be suppressed | |
327 | // by specifying tracks=0. In this case only the AliJet object will | |
328 | // be stored according to the mode specified by SetJetCopy(). | |
329 | // The latter will enable jet studies based on a fixed list of tracks | |
330 | // as contained e.g. in an AliVertex or AliEvent. | |
331 | if (!fJets) fJets=new TObjArray(fNjmax); | |
332 | if (fNjets == fNjmax) // Check if maximum jet number is reached | |
333 | { | |
334 | fNjmax++; | |
335 | fJets->Expand(fNjmax); | |
336 | } | |
337 | ||
338 | // Add the jet to the list | |
339 | fNjets++; | |
340 | if (fJetCopy) | |
341 | { | |
342 | AliJet* jx=new AliJet(j); | |
343 | fJets->Add(jx); | |
344 | } | |
345 | else | |
346 | { | |
347 | fJets->Add(&j); | |
348 | } | |
349 | ||
350 | // Add the tracks of the jet to this vertex | |
351 | if (tracks) | |
352 | { | |
353 | AliTrack* tj; | |
354 | for (Int_t i=1; i<=j.GetNtracks(); i++) | |
355 | { | |
356 | tj=j.GetTrack(i); | |
357 | AddTrack(tj); | |
358 | } | |
359 | } | |
360 | } | |
361 | /////////////////////////////////////////////////////////////////////////// | |
362 | void AliVertex::AddVertex(AliVertex& v,Int_t connect) | |
363 | { | |
364 | // Add a (secondary) vertex to the current vertex. | |
365 | // In case the maximum number of (secondary) vertices has been reached, | |
366 | // the array space will be extended automatically | |
367 | // | |
368 | // Note : By default the 4-momentum and charge of the current (primary) vertex | |
369 | // are updated by automatically creating the track connecting | |
370 | // both vertices. The track parameters are taken from the | |
371 | // 4-momentum and charge of the secondary vertex. | |
372 | // The automatic creation of the connecting track and updating | |
373 | // of the (primary) vertex 4-momentum and charge can be suppressed | |
374 | // by specifying connect=0. In this case, however, the user | |
375 | // has to introduce the connecting track lateron by hand | |
376 | // explicitly in order to match the kinematics and charge. | |
377 | // | |
378 | if (!fVertices) fVertices=new TObjArray(fNvmax); | |
379 | if (fNvtx == fNvmax) // Check if maximum vertex number is reached | |
380 | { | |
381 | fNvmax++; | |
382 | fVertices->Expand(fNvmax); | |
383 | } | |
384 | ||
385 | // Add the linked (secondary) vertex to the list | |
386 | fNvtx++; | |
387 | if (fVertexCopy) | |
388 | { | |
389 | AliVertex* vx=new AliVertex(v); | |
390 | fVertices->Add(vx); | |
391 | } | |
392 | else | |
393 | { | |
394 | fVertices->Add(&v); | |
395 | } | |
396 | ||
397 | // Create connecting track and update 4-momentum and charge for current vertex | |
398 | if (connect) | |
399 | { | |
400 | AliPosition r1=GetPosition(); | |
401 | AliPosition r2=v.GetPosition(); | |
402 | Float_t q=v.GetCharge(); | |
403 | Ali3Vector p=v.Get3Momentum(); | |
404 | Double_t v2=v.GetInvariant(); | |
405 | Double_t dv2=v.Ali4Vector::GetResultError(); | |
406 | ||
407 | AliTrack* t=new AliTrack; | |
408 | t->SetBeginPoint(r1); | |
409 | t->SetEndPoint(r2); | |
410 | t->SetCharge(q); | |
411 | t->Set3Momentum(p); | |
412 | t->SetInvariant(v2,dv2); | |
413 | ||
414 | AddTrack(t); | |
415 | ||
416 | if (!fConnects) fConnects=new TObjArray(fNvmax); | |
417 | fConnects->Add(t); | |
418 | } | |
419 | } | |
420 | /////////////////////////////////////////////////////////////////////////// | |
421 | void AliVertex::Info(TString f) | |
422 | { | |
423 | // Provide vertex information within the coordinate frame f | |
424 | cout << " *AliVertex::Info* Invmass : " << GetInvmass() | |
425 | << " Charge : " << GetCharge() << " Momentum : " << GetMomentum() | |
426 | << " Ntracks : " << GetNtracks() << " Nvertices : " << fNvtx | |
427 | << " Njets : " << fNjets << endl; | |
428 | cout << " "; | |
429 | Ali4Vector::Info(f); | |
430 | cout << " Position"; | |
431 | AliPosition::Info(f); | |
432 | } | |
433 | /////////////////////////////////////////////////////////////////////////// | |
434 | void AliVertex::List(TString f) | |
435 | { | |
436 | // Provide primary track and sec. vertex information within the coordinate frame f | |
437 | ||
438 | Info(f); // Information of the current vertex | |
439 | ||
440 | // The tracks of this vertex | |
441 | AliTrack* t; | |
442 | for (Int_t it=1; it<=GetNtracks(); it++) | |
443 | { | |
444 | t=GetTrack(it); | |
445 | if (t) | |
446 | { | |
447 | cout << " ---Track no. " << it << endl; | |
448 | cout << " "; | |
449 | t->Info(f); | |
450 | } | |
451 | else | |
452 | { | |
453 | cout << " *AliVertex::List* Error : No track present." << endl; | |
454 | } | |
455 | } | |
456 | ||
457 | // The secondary vertices of this vertex | |
458 | AliVertex* v; | |
459 | for (Int_t iv=1; iv<=GetNvertices(); iv++) | |
460 | { | |
461 | v=GetVertex(iv); | |
462 | if (v) | |
463 | { | |
464 | cout << " ---Level 1 sec. vertex no. " << iv << endl; | |
465 | cout << " "; | |
466 | v->Info(f); | |
467 | } | |
468 | else | |
469 | { | |
470 | cout << " *AliVertex::List* Error : No sec. vertex present." << endl; | |
471 | } | |
472 | } | |
473 | } | |
474 | /////////////////////////////////////////////////////////////////////////// | |
475 | void AliVertex::ListAll(TString f) | |
476 | { | |
477 | // Provide complete (sec) vertex and (decay) track info within the coordinate frame f | |
478 | ||
479 | Info(f); // Information of the current vertex | |
480 | ||
481 | // The tracks of this vertex | |
482 | AliTrack* t; | |
483 | for (Int_t it=1; it<=GetNtracks(); it++) | |
484 | { | |
485 | t=GetTrack(it); | |
486 | if (t) | |
487 | { | |
488 | cout << " ---Track no. " << it << endl; | |
489 | cout << " "; | |
490 | t->ListAll(f); | |
491 | } | |
492 | else | |
493 | { | |
494 | cout << " *AliVertex::ListAll* Error : No track present." << endl; | |
495 | } | |
496 | } | |
497 | ||
498 | AliVertex* v=this; | |
499 | Dump(v,1,f); // Information of all sec. vertices | |
500 | } | |
501 | ////////////////////////////////////////////////////////////////////////// | |
502 | void AliVertex::Dump(AliVertex* v,Int_t n,TString f) | |
503 | { | |
504 | // Recursively provide the info of all secondary vertices of this vertex | |
505 | AliVertex* vs; | |
506 | for (Int_t iv=1; iv<=v->GetNvertices(); iv++) | |
507 | { | |
508 | vs=v->GetVertex(iv); | |
509 | if (vs) | |
510 | { | |
511 | cout << " ---Level " << n << " sec. vertex no. " << iv << endl; | |
512 | cout << " "; | |
513 | vs->Info(f); | |
514 | ||
515 | // The tracks of this vertex | |
516 | AliTrack* t; | |
517 | for (Int_t it=1; it<=vs->GetNtracks(); it++) | |
518 | { | |
519 | t=vs->GetTrack(it); | |
520 | if (t) | |
521 | { | |
522 | cout << " ---Track no. " << it << endl; | |
523 | cout << " "; | |
524 | t->ListAll(f); | |
525 | } | |
526 | else | |
527 | { | |
528 | cout << " *AliVertex::Dump* Error : No track present." << endl; | |
529 | } | |
530 | } | |
531 | ||
532 | // Go for next sec. vertex level of this sec. vertex recursively | |
533 | Dump(vs,n+1,f); | |
534 | } | |
535 | else | |
536 | { | |
537 | cout << " *AliVertex::Dump* Error : No sec. vertex present." << endl; | |
538 | } | |
539 | } | |
540 | } | |
541 | ////////////////////////////////////////////////////////////////////////// | |
542 | Int_t AliVertex::GetNvertices() | |
543 | { | |
544 | // Return the current number of (secondary) vertices | |
545 | return fNvtx; | |
546 | } | |
547 | /////////////////////////////////////////////////////////////////////////// | |
548 | AliVertex* AliVertex::GetVertex(Int_t i) | |
549 | { | |
550 | // Return the i-th (secondary) vertex of the current vertex | |
551 | if (!fVertices) | |
552 | { | |
553 | cout << " *AliVertex*::GetVertex* No (secondary) vertices present." << endl; | |
554 | return 0; | |
555 | } | |
556 | else | |
557 | { | |
558 | if (i<=0 || i>fNvtx) | |
559 | { | |
560 | cout << " *AliVertex*::GetVertex* Invalid argument i : " << i | |
561 | << " Nvtx = " << fNvtx << endl; | |
562 | return 0; | |
563 | } | |
564 | else | |
565 | { | |
566 | return (AliVertex*)fVertices->At(i-1); | |
567 | } | |
568 | } | |
569 | } | |
570 | /////////////////////////////////////////////////////////////////////////// | |
571 | void AliVertex::SetVertexCopy(Int_t j) | |
572 | { | |
573 | // (De)activate the creation of private copies of the added vertices. | |
574 | // j=0 ==> No private copies are made; pointers of original vertices are stored. | |
575 | // j=1 ==> Private copies of the vertices are made and these pointers are stored. | |
576 | // | |
577 | // Note : Once the storage contains pointer(s) to AliVertex objects one cannot | |
578 | // change the VertexCopy mode anymore. | |
579 | // To change the VertexCopy mode for an existing AliVertex containing | |
580 | // vertices one first has to invoke Reset(). | |
581 | if (!fVertices) | |
582 | { | |
583 | if (j==0 || j==1) | |
584 | { | |
585 | fVertexCopy=j; | |
586 | } | |
587 | else | |
588 | { | |
589 | cout << "*AliVertex::SetVertexCopy* Invalid argument : " << j << endl; | |
590 | } | |
591 | } | |
592 | else | |
593 | { | |
594 | cout << "*AliVertex::SetVertexCopy* Storage already contained vertices." | |
595 | << " ==> VertexCopy mode not changed." << endl; | |
596 | } | |
597 | } | |
598 | /////////////////////////////////////////////////////////////////////////// | |
599 | Int_t AliVertex::GetVertexCopy() | |
600 | { | |
601 | // Provide value of the VertexCopy mode. | |
602 | // 0 ==> No private copies are made; pointers of original vertices are stored. | |
603 | // 1 ==> Private copies of the vertices are made and these pointers are stored. | |
604 | return fVertexCopy; | |
605 | } | |
606 | /////////////////////////////////////////////////////////////////////////// | |
607 | Int_t AliVertex::GetNjets() | |
608 | { | |
609 | // Return the current number of jets | |
610 | return fNjets; | |
611 | } | |
612 | /////////////////////////////////////////////////////////////////////////// | |
613 | AliJet* AliVertex::GetJet(Int_t i) | |
614 | { | |
615 | // Return the i-th jet of the current vertex | |
616 | if (!fJets) | |
617 | { | |
618 | cout << " *AliVertex*::GetJet* No jets present." << endl; | |
619 | return 0; | |
620 | } | |
621 | else | |
622 | { | |
623 | if (i<=0 || i>fNjets) | |
624 | { | |
625 | cout << " *AliVertex*::GetJet* Invalid argument i : " << i | |
626 | << " Njets = " << fNjets << endl; | |
627 | return 0; | |
628 | } | |
629 | else | |
630 | { | |
631 | return (AliJet*)fJets->At(i-1); | |
632 | } | |
633 | } | |
634 | } | |
635 | /////////////////////////////////////////////////////////////////////////// | |
636 | void AliVertex::SetJetCopy(Int_t j) | |
637 | { | |
638 | // (De)activate the creation of private copies of the added jets. | |
639 | // j=0 ==> No private copies are made; pointers of original jets are stored. | |
640 | // j=1 ==> Private copies of the jets are made and these pointers are stored. | |
641 | // | |
642 | // Note : Once the storage contains pointer(s) to AliJet objects one cannot | |
643 | // change the JetCopy mode anymore. | |
644 | // To change the JetCopy mode for an existing AliVertex containing | |
645 | // jets one first has to invoke Reset(). | |
646 | if (!fJets) | |
647 | { | |
648 | if (j==0 || j==1) | |
649 | { | |
650 | fJetCopy=j; | |
651 | } | |
652 | else | |
653 | { | |
654 | cout << "*AliVertex::SetJetCopy* Invalid argument : " << j << endl; | |
655 | } | |
656 | } | |
657 | else | |
658 | { | |
659 | cout << "*AliVertex::SetJetCopy* Storage already contained jets." | |
660 | << " ==> JetCopy mode not changed." << endl; | |
661 | } | |
662 | } | |
663 | /////////////////////////////////////////////////////////////////////////// | |
664 | Int_t AliVertex::GetJetCopy() | |
665 | { | |
666 | // Provide value of the JetCopy mode. | |
667 | // 0 ==> No private copies are made; pointers of original jets are stored. | |
668 | // 1 ==> Private copies of the jets are made and these pointers are stored. | |
669 | return fJetCopy; | |
670 | } | |
671 | /////////////////////////////////////////////////////////////////////////// |