38fd633c9b9cc1b5b8e3a7380cfc5b8d723e91e3
[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 //    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
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
259  AliJet::Reset();
260
261  Double_t a[3]={0,0,0};
262  SetPosition(a,"sph");
263  SetPositionErrors(a,"car");
264
265  fNvtx=0;
266  if (fNvmax>0) SetNvmax(fNvmax);
267  if (fConnects)
268  {
269   fConnects->Delete();
270   delete fConnects;
271   fConnects=0;
272  }
273
274  fNjets=0;
275  if (fNjmax>0) SetNjmax(fNjmax);
276 }
277 ///////////////////////////////////////////////////////////////////////////
278 void AliVertex::AddJet(AliJet& j,Int_t tracks)
279 {
280 // Add a jet (and its tracks) to the vertex
281 // In case the maximum number of jets has been reached,
282 // the array space will be extended automatically
283 //
284 // Note : By default the tracks of the jet are added to the current (primary)
285 //        vertex.
286 //        The automatic addition of the tracks of the jet can be suppressed
287 //        by specifying tracks=0. In this case only the AliJet object will
288 //        be stored according to the mode specified by SetJetCopy().
289 //        The latter will enable jet studies based on a fixed list of tracks
290 //        as contained e.g. in an AliVertex or AliEvent. 
291  if (!fJets) fJets=new TObjArray(fNjmax);
292  if (fNjets == fNjmax) // Check if maximum jet number is reached
293  {
294   fNjmax++;
295   fJets->Expand(fNjmax);
296  }
297
298  // Add the jet to the list 
299  fNjets++;
300  if (fJetCopy)
301  {
302   AliJet* jx=new AliJet(j);
303   fJets->Add(jx);
304  }
305  else
306  {
307   fJets->Add(&j);
308  }
309
310  // Add the tracks of the jet to this vertex
311  if (tracks)
312  {
313   AliTrack* tj;
314   for (Int_t i=1; i<=j.GetNtracks(); i++)
315   {
316    tj=j.GetTrack(i);
317    AddTrack(tj);
318   }
319  }
320 }
321 ///////////////////////////////////////////////////////////////////////////
322 void AliVertex::AddVertex(AliVertex& v,Int_t connect)
323 {
324 // Add a (secondary) vertex to the current vertex.
325 // In case the maximum number of (secondary) vertices has been reached,
326 // the array space will be extended automatically
327 //
328 // Note : By default the 4-momentum and charge of the current (primary) vertex
329 //        are updated by automatically creating the track connecting
330 //        both vertices. The track parameters are taken from the
331 //        4-momentum and charge of the secondary vertex.
332 //        The automatic creation of the connecting track and updating
333 //        of the (primary) vertex 4-momentum and charge can be suppressed
334 //        by specifying connect=0. In this case, however, the user
335 //        has to introduce the connecting track lateron by hand
336 //        explicitly in order to match the kinematics and charge.
337 //
338  if (!fVertices) fVertices=new TObjArray(fNvmax);
339  if (fNvtx == fNvmax) // Check if maximum vertex number is reached
340  {
341   fNvmax++;
342   fVertices->Expand(fNvmax);
343  }
344
345  // Add the linked (secondary) vertex to the list 
346  fNvtx++;
347  if (fVertexCopy)
348  {
349   AliVertex* vx=new AliVertex(v);
350   fVertices->Add(vx);
351  }
352  else
353  {
354   fVertices->Add(&v);
355  }
356
357  // Create connecting track and update 4-momentum and charge for current vertex
358  if (connect)
359  {
360   AliPosition r1=GetPosition();
361   AliPosition r2=v.GetPosition();
362   Float_t q=v.GetCharge();
363   Ali3Vector p=v.Get3Momentum();
364   Double_t v2=v.GetInvariant();
365   Double_t dv2=v.Ali4Vector::GetResultError();
366
367   AliTrack* t=new AliTrack;
368   t->SetBeginPoint(r1);
369   t->SetEndPoint(r2);
370   t->SetCharge(q);
371   t->Set3Momentum(p);
372   t->SetInvariant(v2,dv2);
373
374   AddTrack(t);
375
376   if (!fConnects) fConnects=new TObjArray(fNvmax);
377   fConnects->Add(t);
378  }
379 }
380 ///////////////////////////////////////////////////////////////////////////
381 void AliVertex::Info(TString f)
382 {
383 // Provide vertex information within the coordinate frame f
384  cout << " *AliVertex::Info* Invmass : " << GetInvmass()
385       << " Charge : " << GetCharge() << " Momentum : " << GetMomentum()
386       << " Ntracks : " << GetNtracks() << " Nvertices : " << fNvtx 
387       << " Njets : " << fNjets << endl;
388  cout << " ";
389  Ali4Vector::Info(f);
390  cout << "  Position";
391  AliPosition::Info(f); 
392
393 ///////////////////////////////////////////////////////////////////////////
394 void AliVertex::List(TString f)
395 {
396 // Provide primary track and sec. vertex information within the coordinate frame f
397
398  Info(f); // Information of the current vertex
399
400  // The tracks of this vertex
401  AliTrack* t; 
402  for (Int_t it=1; it<=GetNtracks(); it++)
403  {
404   t=GetTrack(it);
405   if (t)
406   {
407    cout << "  ---Track no. " << it << endl;
408    cout << " ";
409    t->Info(f); 
410   }
411   else
412   {
413    cout << " *AliVertex::List* Error : No track present." << endl; 
414   }
415  }
416
417  // The secondary vertices of this vertex
418  AliVertex* v; 
419  for (Int_t iv=1; iv<=GetNvertices(); iv++)
420  {
421   v=GetVertex(iv);
422   if (v)
423   {
424    cout << "  ---Level 1 sec. vertex no. " << iv << endl;
425    cout << " ";
426    v->Info(f); 
427   }
428   else
429   {
430    cout << " *AliVertex::List* Error : No sec. vertex present." << endl; 
431   }
432  }
433
434 ///////////////////////////////////////////////////////////////////////////
435 void AliVertex::ListAll(TString f)
436 {
437 // Provide complete (sec) vertex and (decay) track info within the coordinate frame f
438
439  Info(f); // Information of the current vertex
440
441  // The tracks of this vertex
442  AliTrack* t; 
443  for (Int_t it=1; it<=GetNtracks(); it++)
444  {
445   t=GetTrack(it);
446   if (t)
447   {
448    cout << "  ---Track no. " << it << endl;
449    cout << " ";
450    t->ListAll(f); 
451   }
452   else
453   {
454    cout << " *AliVertex::ListAll* Error : No track present." << endl; 
455   }
456  }
457
458  AliVertex* v=this;
459  Dump(v,1,f); // Information of all sec. vertices
460 }
461 //////////////////////////////////////////////////////////////////////////
462 void AliVertex::Dump(AliVertex* v,Int_t n,TString f)
463 {
464 // Recursively provide the info of all secondary vertices of this vertex
465  AliVertex* vs; 
466  for (Int_t iv=1; iv<=v->GetNvertices(); iv++)
467  {
468   vs=v->GetVertex(iv);
469   if (vs)
470   {
471    cout << "  ---Level " << n << " sec. vertex no. " << iv << endl;
472    cout << " ";
473    vs->Info(f); 
474
475    // The tracks of this vertex
476    AliTrack* t; 
477    for (Int_t it=1; it<=vs->GetNtracks(); it++)
478    {
479     t=vs->GetTrack(it);
480     if (t)
481     {
482      cout << "  ---Track no. " << it << endl;
483      cout << " ";
484      t->ListAll(f); 
485     }
486     else
487     {
488      cout << " *AliVertex::Dump* Error : No track present." << endl; 
489     }
490    }
491
492    // Go for next sec. vertex level of this sec. vertex recursively
493    Dump(vs,n+1,f);
494   }
495   else
496   {
497    cout << " *AliVertex::Dump* Error : No sec. vertex present." << endl; 
498   }
499  }
500
501 //////////////////////////////////////////////////////////////////////////
502 Int_t AliVertex::GetNvertices()
503 {
504 // Return the current number of (secondary) vertices
505  return fNvtx;
506 }
507 ///////////////////////////////////////////////////////////////////////////
508 AliVertex* AliVertex::GetVertex(Int_t i)
509 {
510 // Return the i-th (secondary) vertex of the current vertex
511  if (!fVertices)
512  {
513   cout << " *AliVertex*::GetVertex* No (secondary) vertices present." << endl;
514   return 0;
515  }
516  else
517  {
518   if (i<=0 || i>fNvtx)
519   {
520    cout << " *AliVertex*::GetVertex* Invalid argument i : " << i
521         << " Nvtx = " << fNvtx << endl;
522    return 0;
523   }
524   else
525   {
526    return (AliVertex*)fVertices->At(i-1);
527   }
528  }
529 }
530 ///////////////////////////////////////////////////////////////////////////
531 void AliVertex::SetVertexCopy(Int_t j)
532 {
533 // (De)activate the creation of private copies of the added vertices.
534 // j=0 ==> No private copies are made; pointers of original vertices are stored.
535 // j=1 ==> Private copies of the vertices are made and these pointers are stored.
536 //
537 // Note : Once the storage contains pointer(s) to AliVertex objects one cannot
538 //        change the VertexCopy mode anymore.
539 //        To change the VertexCopy mode for an existing AliVertex containing
540 //        vertices one first has to invoke Reset().
541  if (!fVertices)
542  {
543   if (j==0 || j==1)
544   {
545    fVertexCopy=j;
546   }
547   else
548   {
549    cout << "*AliVertex::SetVertexCopy* Invalid argument : " << j << endl;
550   }
551  }
552  else
553  {
554   cout << "*AliVertex::SetVertexCopy* Storage already contained vertices."
555        << "  ==> VertexCopy mode not changed." << endl; 
556  }
557 }
558 ///////////////////////////////////////////////////////////////////////////
559 Int_t AliVertex::GetVertexCopy()
560 {
561 // Provide value of the VertexCopy mode.
562 // 0 ==> No private copies are made; pointers of original vertices are stored.
563 // 1 ==> Private copies of the vertices are made and these pointers are stored.
564  return fVertexCopy;
565 }
566 ///////////////////////////////////////////////////////////////////////////
567 Int_t AliVertex::GetNjets()
568 {
569 // Return the current number of jets
570  return fNjets;
571 }
572 ///////////////////////////////////////////////////////////////////////////
573 AliJet* AliVertex::GetJet(Int_t i)
574 {
575 // Return the i-th jet of the current vertex
576  if (!fJets)
577  {
578   cout << " *AliVertex*::GetJet* No jets present." << endl;
579   return 0;
580  }
581  else
582  {
583   if (i<=0 || i>fNjets)
584   {
585    cout << " *AliVertex*::GetJet* Invalid argument i : " << i
586         << " Njets = " << fNjets << endl;
587    return 0;
588   }
589   else
590   {
591    return (AliJet*)fJets->At(i-1);
592   }
593  }
594 }
595 ///////////////////////////////////////////////////////////////////////////
596 void AliVertex::SetJetCopy(Int_t j)
597 {
598 // (De)activate the creation of private copies of the added jets.
599 // j=0 ==> No private copies are made; pointers of original jets are stored.
600 // j=1 ==> Private copies of the jets are made and these pointers are stored.
601 //
602 // Note : Once the storage contains pointer(s) to AliJet objects one cannot
603 //        change the JetCopy mode anymore.
604 //        To change the JetCopy mode for an existing AliVertex containing
605 //        jets one first has to invoke Reset().
606  if (!fJets)
607  {
608   if (j==0 || j==1)
609   {
610    fJetCopy=j;
611   }
612   else
613   {
614    cout << "*AliVertex::SetJetCopy* Invalid argument : " << j << endl;
615   }
616  }
617  else
618  {
619   cout << "*AliVertex::SetJetCopy* Storage already contained jets."
620        << "  ==> JetCopy mode not changed." << endl; 
621  }
622 }
623 ///////////////////////////////////////////////////////////////////////////
624 Int_t AliVertex::GetJetCopy()
625 {
626 // Provide value of the JetCopy mode.
627 // 0 ==> No private copies are made; pointers of original jets are stored.
628 // 1 ==> Private copies of the jets are made and these pointers are stored.
629  return fJetCopy;
630 }
631 ///////////////////////////////////////////////////////////////////////////