55847baab1a47955a55ab1fc395a4ef7f97d2315
[u/mrichter/AliRoot.git] / RALICE / AliVertex.cxx
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 //
37 //    Note :
38 //    Modifications made to the original vertices also affect the AliVertex objects
39 //    which are stored.
40 // 
41 // b) SetVertexCopy(1).
42 //    Of every 'added' vertex a private copy will be made of which the pointer
43 //    will be stored.
44 //    In this way the AliVertex represents an entity on its own and modifications
45 //    made to the original vertices do not affect the AliVertex objects which are
46 //    stored. 
47 //    This mode will allow 'adding' many different AliVertex objects by
48 //    creating only one AliVertex instance in the main programme and using the
49 //    AliVertex::Reset, AliVertex::AddTrack and parameter setting memberfunctions.
50 //
51 // See also the documentation provided for the memberfunction SetOwner(). 
52 //
53 // Coding example to make 3 vertices v1, v2 and v3.
54 // ------------------------------------------------
55 // v1 contains the tracks 1,2,3 and 4
56 // v2 contains many different tracks
57 // v3 contains the jets 1 and 2
58 //
59 //        AliTrack t1,t2,t3,t4;
60 //         ...
61 //         ... // code to fill the track data
62 //         ...
63 //
64 //        AliJet j1,j2;
65 //         ...
66 //         ... // code to fill the jet data
67 //         ...
68 //
69 //        AliVertex v1;
70 //        v1.SetVertexCopy(1);
71 //
72 //        v1.AddTrack(t1);
73 //        v1.AddTrack(t2);
74 //        v1.AddTrack(t3);
75 //        v1.AddTrack(t4);
76 //
77 //        Float_t r1[3]={2.4,0.1,-8.5};
78 //        v1.SetPosition(r1,"car");
79 //
80 //        AliVertex v2;
81 //        v2.SetTrackCopy(1);
82 //
83 //        AliTrack* tx=new AliTrack();
84 //        for (Int_t i=0; i<10; i++)
85 //        {
86 //         ...
87 //         ... // code to fill the track data
88 //         ...
89 //         v2.AddTrack(tx);
90 //         tx->Reset(); 
91 //        }
92 //
93 //        Float_t r2[3]={1.6,-3.2,5.7};
94 //        v2.SetPosition(r2,"car");
95 //
96 //        AliVertex v3;
97 //
98 //        v3.AddJet(j1);
99 //        v3.AddJet(j2);
100 //
101 //        Float_t r3[3]={6.2,4.8,1.3};
102 //        v3.SetPosition(r3,"car");
103 //
104 //        v1.Data("sph");
105 //        v2.ListAll();
106 //        v3.List("cyl");
107 //
108 //        Float_t e1=v1.GetEnergy();
109 //        Ali3Vector p1=v1.Get3Momentum();
110 //        Float_t loc[3];
111 //        v1.GetPosition(loc,"sph");
112 //        AliPosition r=v2.GetPosition();
113 //        r.Data(); 
114 //        Int_t nt=v2.GetNtracks();
115 //        AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
116 //
117 // Specify the vertices v2 and v3 as secondary vertices of v1
118 //
119 //        v1.AddVertex(v2);
120 //        v1.AddVertex(v3);
121 //
122 //        v1.List();
123 //
124 //        Int_t nv=v1.GetNvtx();
125 //        AliVertex* vx=v1.GetVertex(1); // Access 1st secondary vertex of v1
126 //        Float_t e=vx->GetEnergy();
127 //
128 //        Float_t M=v1.GetInvmass(); 
129 //
130 // Reconstruct Vertex v1 from scratch
131 //
132 //        v1.Reset();
133 //        v1.SetNvmax(25); // Increase initial no. of sec. vertices
134 //        v1.AddTrack(t3);
135 //        v1.AddTrack(t4);
136 //        v1.AddJet(j2);
137 //        Float_t pos[3]={7,9,4};
138 //        v1.SetPosition(pos,"car");
139 //
140 // Note : All quantities are in GeV, GeV/c or GeV/c**2
141 //
142 //--- Author: Nick van Eijndhoven 04-apr-1998 UU-SAP Utrecht
143 //- Modified: NvE $Date$ UU-SAP Utrecht
144 ///////////////////////////////////////////////////////////////////////////
145
146 #include "AliVertex.h"
147 #include "Riostream.h"
148  
149 ClassImp(AliVertex) // Class implementation to enable ROOT I/O
150  
151 AliVertex::AliVertex() : AliJet(),AliPosition()
152 {
153 // Default constructor.
154 // All variables initialised to 0.
155 // Initial maximum number of tracks is set to the default value.
156 // Initial maximum number of sec. vertices is set to the default value.
157  Init();
158  Reset();
159  SetNvmax();
160  SetNjmax();
161 }
162 ///////////////////////////////////////////////////////////////////////////
163 void AliVertex::Init()
164 {
165 // Initialisation of pointers etc...
166  fNvmax=0;
167  fVertices=0;
168  fConnects=0;
169  fVertexCopy=0;
170  fNjmax=0;
171  fJets=0;
172  fJetTracks=0;
173  fJetCopy=0;
174  fLines=0;
175 }
176 ///////////////////////////////////////////////////////////////////////////
177 AliVertex::AliVertex(Int_t n) : AliJet(n),AliPosition()
178 {
179 // Create a vertex to hold initially a maximum of n tracks
180 // All variables initialised to 0
181  if (n<=0)
182  {
183   cout << " *** This AliJet initialisation was invoked via the AliVertex ctor." << endl;
184  }
185  Init();
186  Reset();
187  SetNvmax();
188  SetNjmax();
189 }
190 ///////////////////////////////////////////////////////////////////////////
191 AliVertex::~AliVertex()
192 {
193 // Default destructor
194  if (fVertices)
195  {
196   delete fVertices;
197   fVertices=0;
198  }
199  if (fConnects)
200  {
201   delete fConnects;
202   fConnects=0;
203  }
204  if (fJets)
205  {
206   delete fJets;
207   fJets=0;
208  }
209  if (fJetTracks)
210  {
211   delete fJetTracks;
212   fJetTracks=0;
213  }
214  if (fLines)
215  {
216   delete fLines;
217   fLines=0;
218  }
219 }
220 ///////////////////////////////////////////////////////////////////////////
221 void AliVertex::SetOwner(Bool_t own)
222 {
223 // Set ownership of all added objects. 
224 // The default parameter is own=kTRUE.
225 //
226 // Invokation of this memberfunction also sets all the copy modes
227 // (e.g. TrackCopy & co.) according to the value of own.
228 //
229 // This function (with own=kTRUE) is particularly useful when reading data
230 // from a tree/file, since Reset() will then actually remove all the
231 // added objects from memory irrespective of the copy mode settings
232 // during the tree/file creation process. In this way it provides a nice way
233 // of preventing possible memory leaks in the reading/analysis process.
234 //
235 // In addition this memberfunction can also be used as a shortcut to set all
236 // copy modes in one go during a tree/file creation process.
237 // However, in this case the user has to take care to only set/change the
238 // ownership (and copy mode) for empty objects (e.g. newly created objects
239 // or after invokation of the Reset() memberfunction) otherwise it will
240 // very likely result in inconsistent destructor behaviour.
241
242  Int_t mode=1;
243  if (!own) mode=0;
244  if (fVertices) fVertices->SetOwner(own);
245  fVertexCopy=mode;
246  if (fJets) fJets->SetOwner(own);
247  fJetCopy=mode;
248
249  AliJet::SetOwner(own);
250 }
251 ///////////////////////////////////////////////////////////////////////////
252 AliVertex::AliVertex(AliVertex& v) : AliJet(v.fNtinit),AliPosition(v)
253 {
254 // Copy constructor
255  Init();
256  fNvtx=0;
257  fNjets=0;
258  SetNvmax(v.fNvmax);
259  SetNjmax(v.fNjmax);
260  SetTrackCopy(v.GetTrackCopy());
261  SetVertexCopy(v.GetVertexCopy());
262  SetJetCopy(v.GetJetCopy());
263  SetId(v.GetId());
264
265  // Copy all tracks except the ones coming from jets
266  AliTrack* tx=0;
267  Int_t jetflag=0,connect=0;
268  AliTrack* tx2=0;
269  for (Int_t it=1; it<=v.GetNtracks(); it++)
270  {
271   tx=v.GetTrack(it);
272   if (tx)
273   {
274    jetflag=v.IsJetTrack(tx);
275    connect=v.IsConnectTrack(tx);
276
277    if (!jetflag && !connect) AddTrack(tx);
278
279    if (connect)
280    {
281     if (!fConnects)
282     {
283      fConnects=new TObjArray(fNvmax);
284      if (!fTrackCopy) fConnects->SetOwner();
285     }
286     tx2=new AliTrack(*tx);
287     fConnects->Add(tx2);
288     AddTrack(tx2,0);
289    } 
290   }
291  }
292
293  // Copy all the (secondary) vertices without re-creating connecting tracks
294  // The connecting tracks have already been copied above
295  AliVertex* vx=0;
296  for (Int_t iv=1; iv<=v.GetNvertices(); iv++)
297  {
298   vx=v.GetVertex(iv);
299   if (vx) AddVertex(vx,0); 
300  }
301
302  // Copy all the jets including the jet tracks for these jets for which
303  // this was also the case in the original vertex
304  AliJet* jx=0;
305  for (Int_t ij=1; ij<=v.GetNjets(); ij++)
306  {
307   jx=v.GetJet(ij);
308   if (jx)
309   {
310    jetflag=0;
311    if (jx->GetNtracks())
312    {
313     tx=jx->GetTrack(1);
314     if (tx)
315     {
316      jetflag=v.IsJetTrack(tx);
317     }
318    }
319    AddJet(jx,jetflag);
320   } 
321  }
322 }
323 ///////////////////////////////////////////////////////////////////////////
324 void AliVertex::SetNvmax(Int_t n)
325 {
326 // Set the initial maximum number of (secondary) vertices
327  if (n > 0)
328  {
329   fNvmax=n;
330  }
331  else
332  {
333   fNvmax=1;
334  }
335  if (fVertices)
336  {
337   delete fVertices;
338   fVertices=0;
339  }
340 }
341 ///////////////////////////////////////////////////////////////////////////
342 void AliVertex::SetNjmax(Int_t n)
343 {
344 // Set the initial maximum number of jets
345  if (n > 0)
346  {
347   fNjmax=n;
348  }
349  else
350  {
351   fNjmax=1;
352  }
353  if (fJets)
354  {
355   delete fJets;
356   fJets=0;
357  }
358 }
359 ///////////////////////////////////////////////////////////////////////////
360 void AliVertex::Reset()
361 {
362 // Reset all variables to 0 and reset all stored vertex and jet lists.
363 // The max. number of tracks is set to the initial value again
364 // The max. number of vertices is set to the default value again
365 // The max. number of jets is set to the default value again
366
367  AliJet::Reset();
368
369  Double_t a[3]={0,0,0};
370  SetPosition(a,"sph");
371  SetPositionErrors(a,"car");
372
373  fNvtx=0;
374  if (fNvmax>0) SetNvmax(fNvmax);
375  if (fConnects)
376  {
377   delete fConnects;
378   fConnects=0;
379  }
380
381  fNjets=0;
382  if (fNjmax>0) SetNjmax(fNjmax);
383  if (fJetTracks)
384  {
385   delete fJetTracks;
386   fJetTracks=0;
387  }
388  
389  if (fLines)
390  {
391   delete fLines;
392   fLines=0;
393  }
394 }
395 ///////////////////////////////////////////////////////////////////////////
396 void AliVertex::ResetVertices()
397 {
398 // Reset the stored vertex list and delete all connecting tracks which
399 // were generated automatically via connect=1 in AddVertex().
400 // The max. number of vertices is set to the default value again.
401 // All physics quantities are updated according to the removal of the
402 // connecting tracks.
403  AliTrack* t;
404  if (fConnects)
405  {
406   for (Int_t i=0; i<=fConnects->GetLast(); i++)
407   {
408    t=(AliTrack*)fConnects->At(i);
409    AliTrack* test=(AliTrack*)fTracks->Remove(t);
410    if (test)
411    {
412     fNtrk--;
413     (Ali4Vector&)(*this)-=(Ali4Vector&)(*t);
414     fQ-=t->GetCharge();
415     if (fTrackCopy) delete t;
416    }
417   }
418   fTracks->Compress();
419  }
420
421  fNvtx=0;
422  if (fNvmax>0) SetNvmax(fNvmax);
423  if (fConnects)
424  {
425   delete fConnects;
426   fConnects=0;
427  }
428 }
429 ///////////////////////////////////////////////////////////////////////////
430 void AliVertex::AddJet(AliJet& j,Int_t tracks)
431 {
432 // Add a jet (and its tracks) to the vertex
433 // In case the maximum number of jets has been reached,
434 // the array space will be extended automatically
435 //
436 // Note : By default the tracks of the jet are added to the current (primary)
437 //        vertex.
438 //        The automatic addition of the tracks of the jet can be suppressed
439 //        by specifying tracks=0. In this case only the AliJet object will
440 //        be stored according to the mode specified by SetJetCopy().
441 //        The latter will enable jet studies based on a fixed list of tracks
442 //        as contained e.g. in an AliVertex or AliEvent. 
443 //
444 // In case a private copy is made, this is performed via the Clone() memberfunction.
445 // All AliJet and derived classes have the default TObject::Clone() memberfunction.
446 // However, derived classes generally contain an internal data structure which may
447 // include pointers to other objects. Therefore it is recommended to provide
448 // for all derived classes a specific copy constructor and override the default Clone()
449 // memberfunction using this copy constructor.
450 // An example for this may be seen from AliJet.   
451
452  if (!fJets)
453  {
454   fJets=new TObjArray(fNjmax);
455   if (fJetCopy) fJets->SetOwner();
456  }
457  if (fNjets == fNjmax) // Check if maximum jet number is reached
458  {
459   fNjmax++;
460   fJets->Expand(fNjmax);
461  }
462
463  // Add the jet to the list 
464  AliJet* jx=&j;
465  if (fJetCopy) jx=(AliJet*)j.Clone();
466
467  if (jx)
468  {
469   fNjets++;
470   fJets->Add(jx); 
471  }
472
473  // Add the tracks of the jet to this vertex
474  if (tracks)
475  {
476   if (!fJetTracks)
477   {
478    fJetTracks=new TObjArray();
479   }
480   Int_t copy=1-(jx->GetTrackCopy());
481   AliTrack* tj;
482   for (Int_t i=1; i<=jx->GetNtracks(); i++)
483   {
484    tj=jx->GetTrack(i);
485    if (tj)
486    {
487     AddTrack(tj,copy);
488     fJetTracks->Add(tj);
489    }
490   }
491  }
492 }
493 ///////////////////////////////////////////////////////////////////////////
494 void AliVertex::AddVertex(AliVertex& v,Int_t connect)
495 {
496 // Add a (secondary) vertex to the current vertex.
497 // In case the maximum number of (secondary) vertices has been reached,
498 // the array space will be extended automatically
499 //
500 // Note : By default the 4-momentum and charge of the current (primary) vertex
501 //        are updated by automatically creating the track connecting
502 //        both vertices. The track parameters are taken from the
503 //        4-momentum and charge of the secondary vertex.
504 //        The automatic creation of the connecting track and updating
505 //        of the (primary) vertex 4-momentum and charge can be suppressed
506 //        by specifying connect=0. In this case, however, the user
507 //        has to introduce the connecting track lateron by hand
508 //        explicitly in order to match the kinematics and charge.
509 //
510 // In case a private copy is made, this is performed via the Clone() memberfunction.
511 // All AliVertex and derived classes have the default TObject::Clone() memberfunction.
512 // However, derived classes generally contain an internal data structure which may
513 // include pointers to other objects. Therefore it is recommended to provide
514 // for all derived classes a specific copy constructor and override the default Clone()
515 // memberfunction using this copy constructor.
516 // An example for this may be seen from AliVertex.   
517
518  if (!fVertices)
519  {
520   fVertices=new TObjArray(fNvmax);
521   if (fVertexCopy) fVertices->SetOwner();
522  }
523  if (fNvtx == fNvmax) // Check if maximum vertex number is reached
524  {
525   fNvmax++;
526   fVertices->Expand(fNvmax);
527  }
528
529  // Add the linked (secondary) vertex to the list 
530  AliVertex* vx=&v;
531  if (fVertexCopy) vx=(AliVertex*)v.Clone();
532
533  if (vx)
534  {
535   fNvtx++;
536   fVertices->Add(vx);
537  } 
538
539  // Create connecting track and update 4-momentum and charge for current vertex
540  if (connect)
541  {
542   AliTrack* t=new AliTrack();
543   t->SetBeginPoint(GetPosition());
544   t->SetEndPoint(v.GetPosition());
545   t->SetCharge(v.GetCharge());
546   t->Set4Momentum((Ali4Vector&)v);
547
548   AddTrack(t,0);
549
550   if (!fConnects)
551   {
552    fConnects=new TObjArray(fNvmax);
553    if (!fTrackCopy) fConnects->SetOwner();
554   }
555   fConnects->Add(t);
556  }
557 }
558 ///////////////////////////////////////////////////////////////////////////
559 void AliVertex::Data(TString f)
560 {
561 // Provide vertex information within the coordinate frame f
562  const char* name=GetName();
563  const char* title=GetTitle();
564  cout << " *AliVertex::Data*";
565  if (strlen(name))  cout << " Name : " << GetName();
566  if (strlen(title)) cout << " Title : " << GetTitle();
567  cout << endl;
568  cout << " Id : " << fUserId << " Invmass : " << GetInvmass()
569       << " Charge : " << GetCharge() << " Momentum : " << GetMomentum()
570       << " Ntracks : " << GetNtracks() << " Nvertices : " << fNvtx 
571       << " Njets : " << fNjets << endl;
572  cout << " ";
573  Ali4Vector::Data(f);
574  cout << "  Position";
575  AliPosition::Data(f); 
576
577 ///////////////////////////////////////////////////////////////////////////
578 void AliVertex::List(TString f)
579 {
580 // Provide primary track and sec. vertex information within the coordinate frame f
581
582  Data(f); // Information of the current vertex
583
584  // The tracks of this vertex
585  AliTrack* t; 
586  for (Int_t it=1; it<=GetNtracks(); it++)
587  {
588   t=GetTrack(it);
589   if (t)
590   {
591    cout << "  ---Track no. " << it << endl;
592    cout << " ";
593    t->Data(f); 
594   }
595   else
596   {
597    cout << " *AliVertex::List* Error : No track present." << endl; 
598   }
599  }
600
601  // The secondary vertices of this vertex
602  AliVertex* v; 
603  for (Int_t iv=1; iv<=GetNvertices(); iv++)
604  {
605   v=GetVertex(iv);
606   if (v)
607   {
608    cout << "  ---Level 1 sec. vertex no. " << iv << endl;
609    cout << " ";
610    v->Data(f); 
611   }
612   else
613   {
614    cout << " *AliVertex::List* Error : No sec. vertex present." << endl; 
615   }
616  }
617
618 ///////////////////////////////////////////////////////////////////////////
619 void AliVertex::ListAll(TString f)
620 {
621 // Provide complete (sec) vertex and (decay) track info within the coordinate frame f
622
623  Data(f); // Information of the current vertex
624
625  // The tracks of this vertex
626  AliTrack* t; 
627  for (Int_t it=1; it<=GetNtracks(); it++)
628  {
629   t=GetTrack(it);
630   if (t)
631   {
632    cout << "  ---Track no. " << it << endl;
633    cout << " ";
634    t->ListAll(f); 
635   }
636   else
637   {
638    cout << " *AliVertex::ListAll* Error : No track present." << endl; 
639   }
640  }
641
642  AliVertex* v=this;
643  Dumps(v,1,f); // Information of all sec. vertices
644 }
645 //////////////////////////////////////////////////////////////////////////
646 void AliVertex::Dumps(AliVertex* v,Int_t n,TString f)
647 {
648 // Recursively provide the info of all secondary vertices of this vertex
649  AliVertex* vs; 
650  for (Int_t iv=1; iv<=v->GetNvertices(); iv++)
651  {
652   vs=v->GetVertex(iv);
653   if (vs)
654   {
655    cout << "  ---Level " << n << " sec. vertex no. " << iv << endl;
656    cout << " ";
657    vs->Data(f); 
658
659    // The tracks of this vertex
660    AliTrack* t; 
661    for (Int_t it=1; it<=vs->GetNtracks(); it++)
662    {
663     t=vs->GetTrack(it);
664     if (t)
665     {
666      cout << "  ---Track no. " << it << endl;
667      cout << " ";
668      t->ListAll(f); 
669     }
670     else
671     {
672      cout << " *AliVertex::Dumps* Error : No track present." << endl; 
673     }
674    }
675
676    // Go for next sec. vertex level of this sec. vertex recursively
677    Dumps(vs,n+1,f);
678   }
679   else
680   {
681    cout << " *AliVertex::Dumps* Error : No sec. vertex present." << endl; 
682   }
683  }
684
685 //////////////////////////////////////////////////////////////////////////
686 Int_t AliVertex::GetNvertices()
687 {
688 // Return the current number of (secondary) vertices
689  return fNvtx;
690 }
691 ///////////////////////////////////////////////////////////////////////////
692 AliVertex* AliVertex::GetVertex(Int_t i)
693 {
694 // Return the i-th (secondary) vertex of the current vertex
695  if (!fVertices)
696  {
697   cout << " *AliVertex*::GetVertex* No (secondary) vertices present." << endl;
698   return 0;
699  }
700  else
701  {
702   if (i<=0 || i>fNvtx)
703   {
704    cout << " *AliVertex*::GetVertex* Invalid argument i : " << i
705         << " Nvtx = " << fNvtx << endl;
706    return 0;
707   }
708   else
709   {
710    return (AliVertex*)fVertices->At(i-1);
711   }
712  }
713 }
714 ///////////////////////////////////////////////////////////////////////////
715 AliVertex* AliVertex::GetIdVertex(Int_t id)
716 {
717 // Return the (sec.) vertex with user identifier "id"
718  AliVertex* vx=0;
719  AliVertex* v=0;
720  if (!fVertices)
721  {
722   cout << " *AliVertex*::GetIdVertex* No (secondary) vertices present." << endl;
723   return 0;
724  }
725  else
726  {
727   for (Int_t i=0; i<fNvtx; i++)
728   {
729    vx=(AliVertex*)fVertices->At(i);
730    if (id == vx->GetId()) v=vx;
731   }
732   return v;
733  }
734 }
735 ///////////////////////////////////////////////////////////////////////////
736 void AliVertex::SetVertexCopy(Int_t j)
737 {
738 // (De)activate the creation of private copies of the added vertices.
739 // j=0 ==> No private copies are made; pointers of original vertices are stored.
740 // j=1 ==> Private copies of the vertices are made and these pointers are stored.
741 //
742 // Note : Once the storage contains pointer(s) to AliVertex objects one cannot
743 //        change the VertexCopy mode anymore.
744 //        To change the VertexCopy mode for an existing AliVertex containing
745 //        vertices one first has to invoke Reset().
746  if (!fVertices)
747  {
748   if (j==0 || j==1)
749   {
750    fVertexCopy=j;
751   }
752   else
753   {
754    cout << "*AliVertex::SetVertexCopy* Invalid argument : " << j << endl;
755   }
756  }
757  else
758  {
759   cout << "*AliVertex::SetVertexCopy* Storage already contained vertices."
760        << "  ==> VertexCopy mode not changed." << endl; 
761  }
762 }
763 ///////////////////////////////////////////////////////////////////////////
764 Int_t AliVertex::GetVertexCopy()
765 {
766 // Provide value of the VertexCopy mode.
767 // 0 ==> No private copies are made; pointers of original vertices are stored.
768 // 1 ==> Private copies of the vertices are made and these pointers are stored.
769  return fVertexCopy;
770 }
771 ///////////////////////////////////////////////////////////////////////////
772 Int_t AliVertex::GetNjets()
773 {
774 // Return the current number of jets
775  return fNjets;
776 }
777 ///////////////////////////////////////////////////////////////////////////
778 AliJet* AliVertex::GetJet(Int_t i)
779 {
780 // Return the i-th jet of the current vertex
781  if (!fJets)
782  {
783   cout << " *AliVertex*::GetJet* No jets present." << endl;
784   return 0;
785  }
786  else
787  {
788   if (i<=0 || i>fNjets)
789   {
790    cout << " *AliVertex*::GetJet* Invalid argument i : " << i
791         << " Njets = " << fNjets << endl;
792    return 0;
793   }
794   else
795   {
796    return (AliJet*)fJets->At(i-1);
797   }
798  }
799 }
800 ///////////////////////////////////////////////////////////////////////////
801 AliJet* AliVertex::GetIdJet(Int_t id)
802 {
803 // Return the jet with user identifier "id"
804  AliJet* jx=0;
805  AliJet* j=0;
806  if (!fJets)
807  {
808   cout << " *AliVertex*::GetIdJet* No jets present." << endl;
809   return 0;
810  }
811  else
812  {
813   for (Int_t i=0; i<fNjets; i++)
814   {
815    jx=(AliJet*)fJets->At(i);
816    if (id == jx->GetId()) j=jx;
817   }
818   return j;
819  }
820 }
821 ///////////////////////////////////////////////////////////////////////////
822 void AliVertex::SetJetCopy(Int_t j)
823 {
824 // (De)activate the creation of private copies of the added jets.
825 // j=0 ==> No private copies are made; pointers of original jets are stored.
826 // j=1 ==> Private copies of the jets are made and these pointers are stored.
827 //
828 // Note : Once the storage contains pointer(s) to AliJet objects one cannot
829 //        change the JetCopy mode anymore.
830 //        To change the JetCopy mode for an existing AliVertex containing
831 //        jets one first has to invoke Reset().
832  if (!fJets)
833  {
834   if (j==0 || j==1)
835   {
836    fJetCopy=j;
837   }
838   else
839   {
840    cout << "*AliVertex::SetJetCopy* Invalid argument : " << j << endl;
841   }
842  }
843  else
844  {
845   cout << "*AliVertex::SetJetCopy* Storage already contained jets."
846        << "  ==> JetCopy mode not changed." << endl; 
847  }
848 }
849 ///////////////////////////////////////////////////////////////////////////
850 Int_t AliVertex::GetJetCopy()
851 {
852 // Provide value of the JetCopy mode.
853 // 0 ==> No private copies are made; pointers of original jets are stored.
854 // 1 ==> Private copies of the jets are made and these pointers are stored.
855  return fJetCopy;
856 }
857 ///////////////////////////////////////////////////////////////////////////
858 Int_t AliVertex::IsConnectTrack(AliTrack* t)
859 {
860 // Indicate whether a track from the tracklist was created via the
861 // connection of a (secondary) vertex or not.
862 // In case the track was the result of (secondary) vertex addition the
863 // return value is 1, otherwise the value 0 will be returned.
864  Int_t connect=0;
865  if (fConnects)
866  {
867   if (fConnects->FindObject(t)) connect=1;
868  }
869  return connect;
870 }
871 ///////////////////////////////////////////////////////////////////////////
872 Int_t AliVertex::IsJetTrack(AliTrack* t)
873 {
874 // Indicate whether a track from the tracklist was created via the
875 // addition of a jet or not.
876 // In case the track was the result of jet addition the return value is 1,
877 // otherwise the value 0 will be returned.
878  Int_t jetflag=0;
879  if (fJetTracks)
880  {
881   if (fJetTracks->FindObject(t)) jetflag=1;
882  }
883  return jetflag;
884 }
885 ///////////////////////////////////////////////////////////////////////////
886 void AliVertex::Draw(Int_t secs,Int_t cons,Int_t jets)
887 {
888 // 3-Dimensional visualisation of an AliVertex with its attributes.
889 // The displayed tracklength is proportional to the momentum of the track.
890 //
891 // Color conventions :
892 // -------------------
893 // positive track : red
894 // neutral  track : green
895 // negative track : blue
896 // jet-track      : magenta (if explicit marking selected)
897 //
898 // secs = 1 --> Draw secondary vertices. (Default)
899 //        0 --> Don't draw secondary vertices.
900 //
901 // cons = 1 --> Draw (auto generated) connecting tracks. (Default) 
902 //        0 --> Don't draw (auto generated) connecting tracks.
903 //                  
904 // jets = 1 --> Mark tracks belonging to jets.
905 //        0 --> Don't mark jet-tracks. (Default)
906 //
907 // Notes :
908 // -------
909 // Auto generated connecting tracks will be drawn as thin lines.
910 // Tracks belonging to jets will be marked as somewhat thinner magenta lines.
911 // This memberfunction is used recursively.
912 //
913  Double_t vec[3]={0,0,0};
914  AliTrack* tx=0;
915  AliVertex* vx=0;
916  AliPosition* r=0;
917  Ali3Vector p;
918  Float_t charge;
919
920  AliPosition dummy;
921
922  if (fLines) delete fLines;
923  fLines=new TObjArray();
924  fLines->SetOwner();
925
926  Int_t ntk=GetNtracks();
927  for (Int_t jtk=1; jtk<=ntk; jtk++)
928  {
929   tx=GetTrack(jtk);
930
931   if (!tx) continue;
932
933   charge=tx->GetCharge();
934
935   TPolyLine3D* line=new TPolyLine3D();
936   fLines->Add(line);
937
938   if (IsConnectTrack(tx))
939   {
940    if (cons==1)
941    {
942     r=tx->GetBeginPoint();
943     if (!r) r=&dummy;
944     r->GetPosition(vec,"car");
945     line->SetNextPoint(vec[0],vec[1],vec[2]);
946     r=tx->GetEndPoint();
947     if (!r) r=&dummy;
948     r->GetPosition(vec,"car");
949     line->SetNextPoint(vec[0],vec[1],vec[2]);
950     line->SetLineWidth(1);
951    }
952   }
953   else
954   {
955    r=tx->GetClosestPoint();
956    if (!r) r=&dummy;
957    r->GetPosition(vec,"car");
958    line->SetNextPoint(vec[0],vec[1],vec[2]);
959    p=tx->Get3Momentum();
960    p=p+(*r);
961    p.GetVector(vec,"car");
962    line->SetNextPoint(vec[0],vec[1],vec[2]);
963    line->SetLineWidth(3);
964   }
965
966   line->SetLineColor(kGreen);              // Neutral track
967   if (charge>0) line->SetLineColor(kRed);  // Positive track
968   if (charge<0) line->SetLineColor(kBlue); // Negative track
969  
970   // Mark tracks belonging to jets
971   if (IsJetTrack(tx))
972   {
973    if (jets==1)
974    {
975     line->SetLineWidth(2);
976     line->SetLineColor(kMagenta);
977    }
978   }
979     
980   line->Draw();
981  }
982
983  // Go for secondary vertices if selected
984  if (secs==1)
985  {
986   Int_t nvtx=GetNvertices();
987   for (Int_t jvtx=1; jvtx<=nvtx; jvtx++)
988   {
989    vx=GetVertex(jvtx);
990    if (vx) vx->Draw(secs,cons,jets);
991   }
992  }
993 }
994 ///////////////////////////////////////////////////////////////////////////
995 TObject* AliVertex::Clone(const char* name)
996 {
997 // Make a deep copy of the current object and provide the pointer to the copy.
998 // This memberfunction enables automatic creation of new objects of the
999 // correct type depending on the object type, a feature which may be very useful
1000 // for containers when adding objects in case the container owns the objects.
1001 // This feature allows e.g. AliEvent to store either AliVertex objects or
1002 // objects derived from AliVertex via the AddVertex memberfunction, provided
1003 // these derived classes also have a proper Clone memberfunction. 
1004
1005  AliVertex* vtx=new AliVertex(*this);
1006  if (name)
1007  {
1008   if (strlen(name)) vtx->SetName(name);
1009  }
1010  return vtx;
1011 }
1012 ///////////////////////////////////////////////////////////////////////////