Continuation of TFlukaGeo based on TGeo.
[u/mrichter/AliRoot.git] / RALICE / AliVertex.cxx
CommitLineData
4c039060 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
f531a546 16// $Id$
4c039060 17
959fbac5 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//
f34f4acb 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.
35044448 36//
37// Note :
f34f4acb 38// Modifications made to the original vertices also affect the AliVertex objects
35044448 39// which are stored.
40//
f34f4acb 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
35044448 49// AliVertex::Reset, AliVertex::AddTrack and parameter setting memberfunctions.
f34f4acb 50//
8e8e6c7f 51// See also the documentation provided for the memberfunction SetOwner().
52//
959fbac5 53// Coding example to make 3 vertices v1, v2 and v3.
54// ------------------------------------------------
55// v1 contains the tracks 1,2,3 and 4
f34f4acb 56// v2 contains many different tracks
959fbac5 57// v3 contains the jets 1 and 2
58//
f34f4acb 59// AliTrack t1,t2,t3,t4;
959fbac5 60// ...
61// ... // code to fill the track data
62// ...
63//
64// AliJet j1,j2;
65// ...
66// ... // code to fill the jet data
67// ...
68//
f34f4acb 69// AliVertex v1;
70// v1.SetVertexCopy(1);
959fbac5 71//
f531a546 72// v1.AddTrack(t1);
73// v1.AddTrack(t2);
74// v1.AddTrack(t3);
75// v1.AddTrack(t4);
959fbac5 76//
77// Float_t r1[3]={2.4,0.1,-8.5};
78// v1.SetPosition(r1,"car");
79//
f34f4acb 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// }
959fbac5 92//
93// Float_t r2[3]={1.6,-3.2,5.7};
94// v2.SetPosition(r2,"car");
95//
96// AliVertex v3;
97//
f531a546 98// v3.AddJet(j1);
99// v3.AddJet(j2);
959fbac5 100//
101// Float_t r3[3]={6.2,4.8,1.3};
102// v3.SetPosition(r3,"car");
103//
84bb7c66 104// v1.Data("sph");
959fbac5 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();
84bb7c66 113// r.Data();
959fbac5 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//
f531a546 119// v1.AddVertex(v2);
120// v1.AddVertex(v3);
959fbac5 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
f531a546 134// v1.AddTrack(t3);
f34f4acb 135// v1.AddTrack(t4);
f531a546 136// v1.AddJet(j2);
959fbac5 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
f531a546 143//- Modified: NvE $Date$ UU-SAP Utrecht
959fbac5 144///////////////////////////////////////////////////////////////////////////
145
d88f97cc 146#include "AliVertex.h"
c72198f1 147#include "Riostream.h"
d88f97cc 148
149ClassImp(AliVertex) // Class implementation to enable ROOT I/O
150
c72198f1 151AliVertex::AliVertex() : AliJet(),AliPosition()
d88f97cc 152{
959fbac5 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.
6516b62d 157 Init();
d88f97cc 158 Reset();
d88f97cc 159 SetNvmax();
f34f4acb 160 SetNjmax();
d88f97cc 161}
162///////////////////////////////////////////////////////////////////////////
6516b62d 163void AliVertex::Init()
d88f97cc 164{
6516b62d 165// Initialisation of pointers etc...
d88f97cc 166 fNvmax=0;
167 fVertices=0;
29beb80d 168 fConnects=0;
f34f4acb 169 fVertexCopy=0;
170 fNjmax=0;
171 fJets=0;
6516b62d 172 fJetTracks=0;
f34f4acb 173 fJetCopy=0;
a37bb40e 174 fLines=0;
6516b62d 175}
176///////////////////////////////////////////////////////////////////////////
c72198f1 177AliVertex::AliVertex(Int_t n) : AliJet(n),AliPosition()
6516b62d 178{
179// Create a vertex to hold initially a maximum of n tracks
180// All variables initialised to 0
c72198f1 181 if (n<=0)
d88f97cc 182 {
c72198f1 183 cout << " *** This AliJet initialisation was invoked via the AliVertex ctor." << endl;
d88f97cc 184 }
c72198f1 185 Init();
186 Reset();
d88f97cc 187 SetNvmax();
f34f4acb 188 SetNjmax();
d88f97cc 189}
190///////////////////////////////////////////////////////////////////////////
191AliVertex::~AliVertex()
192{
193// Default destructor
f34f4acb 194 if (fVertices)
195 {
f34f4acb 196 delete fVertices;
197 fVertices=0;
198 }
29beb80d 199 if (fConnects)
200 {
29beb80d 201 delete fConnects;
202 fConnects=0;
203 }
f34f4acb 204 if (fJets)
205 {
f34f4acb 206 delete fJets;
207 fJets=0;
208 }
6516b62d 209 if (fJetTracks)
210 {
211 delete fJetTracks;
212 fJetTracks=0;
213 }
a37bb40e 214 if (fLines)
215 {
216 delete fLines;
217 fLines=0;
218 }
6516b62d 219}
220///////////////////////////////////////////////////////////////////////////
8e8e6c7f 221void 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///////////////////////////////////////////////////////////////////////////
261c0caf 252AliVertex::AliVertex(const AliVertex& v) : AliJet(v.fNtinit),AliPosition(v)
6516b62d 253{
254// Copy constructor
255 Init();
c72198f1 256 fNvtx=0;
257 fNjets=0;
258 SetNvmax(v.fNvmax);
259 SetNjmax(v.fNjmax);
6516b62d 260 SetTrackCopy(v.GetTrackCopy());
261 SetVertexCopy(v.GetVertexCopy());
262 SetJetCopy(v.GetJetCopy());
263 SetId(v.GetId());
6516b62d 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 }
d88f97cc 322}
323///////////////////////////////////////////////////////////////////////////
324void 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 }
f34f4acb 335 if (fVertices)
336 {
f34f4acb 337 delete fVertices;
338 fVertices=0;
339 }
340}
341///////////////////////////////////////////////////////////////////////////
342void 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 {
f34f4acb 355 delete fJets;
356 fJets=0;
357 }
d88f97cc 358}
359///////////////////////////////////////////////////////////////////////////
360void AliVertex::Reset()
361{
7849a8ab 362// Reset all variables to 0 and reset all stored vertex and jet lists.
d88f97cc 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
7849a8ab 365// The max. number of jets is set to the default value again
d88f97cc 366
367 AliJet::Reset();
368
f531a546 369 Double_t a[3]={0,0,0};
370 SetPosition(a,"sph");
371 SetPositionErrors(a,"car");
372
d88f97cc 373 fNvtx=0;
374 if (fNvmax>0) SetNvmax(fNvmax);
29beb80d 375 if (fConnects)
376 {
29beb80d 377 delete fConnects;
378 fConnects=0;
379 }
f34f4acb 380
381 fNjets=0;
382 if (fNjmax>0) SetNjmax(fNjmax);
6516b62d 383 if (fJetTracks)
384 {
385 delete fJetTracks;
386 fJetTracks=0;
387 }
a37bb40e 388
389 if (fLines)
390 {
391 delete fLines;
392 fLines=0;
393 }
d88f97cc 394}
395///////////////////////////////////////////////////////////////////////////
7849a8ab 396void 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.
35044448 401// All physics quantities are updated according to the removal of the
402// connecting tracks.
7849a8ab 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);
35044448 410 if (test)
411 {
412 fNtrk--;
413 (Ali4Vector&)(*this)-=(Ali4Vector&)(*t);
414 fQ-=t->GetCharge();
6516b62d 415 if (fTrackCopy) delete t;
35044448 416 }
7849a8ab 417 }
418 fTracks->Compress();
419 }
420
7849a8ab 421 fNvtx=0;
422 if (fNvmax>0) SetNvmax(fNvmax);
423 if (fConnects)
424 {
7849a8ab 425 delete fConnects;
426 fConnects=0;
427 }
428}
429///////////////////////////////////////////////////////////////////////////
f34f4acb 430void AliVertex::AddJet(AliJet& j,Int_t tracks)
d88f97cc 431{
f34f4acb 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.
5f25234b 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
6516b62d 452 if (!fJets)
453 {
454 fJets=new TObjArray(fNjmax);
455 if (fJetCopy) fJets->SetOwner();
456 }
f34f4acb 457 if (fNjets == fNjmax) // Check if maximum jet number is reached
d88f97cc 458 {
f34f4acb 459 fNjmax++;
460 fJets->Expand(fNjmax);
461 }
462
463 // Add the jet to the list
6516b62d 464 AliJet* jx=&j;
5f25234b 465 if (fJetCopy) jx=(AliJet*)j.Clone();
6516b62d 466
467 if (jx)
f34f4acb 468 {
6516b62d 469 fNjets++;
470 fJets->Add(jx);
f34f4acb 471 }
472
473 // Add the tracks of the jet to this vertex
474 if (tracks)
475 {
6516b62d 476 if (!fJetTracks)
477 {
478 fJetTracks=new TObjArray();
479 }
480 Int_t copy=1-(jx->GetTrackCopy());
f34f4acb 481 AliTrack* tj;
6516b62d 482 for (Int_t i=1; i<=jx->GetNtracks(); i++)
f34f4acb 483 {
6516b62d 484 tj=jx->GetTrack(i);
485 if (tj)
486 {
487 AddTrack(tj,copy);
488 fJetTracks->Add(tj);
489 }
f34f4acb 490 }
d88f97cc 491 }
492}
493///////////////////////////////////////////////////////////////////////////
f531a546 494void AliVertex::AddVertex(AliVertex& v,Int_t connect)
d88f97cc 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//
29beb80d 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.
d88f97cc 509//
5f25234b 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
6516b62d 518 if (!fVertices)
519 {
520 fVertices=new TObjArray(fNvmax);
521 if (fVertexCopy) fVertices->SetOwner();
522 }
d88f97cc 523 if (fNvtx == fNvmax) // Check if maximum vertex number is reached
524 {
525 fNvmax++;
526 fVertices->Expand(fNvmax);
527 }
29beb80d 528
529 // Add the linked (secondary) vertex to the list
6516b62d 530 AliVertex* vx=&v;
5f25234b 531 if (fVertexCopy) vx=(AliVertex*)v.Clone();
6516b62d 532
533 if (vx)
f34f4acb 534 {
6516b62d 535 fNvtx++;
536 fVertices->Add(vx);
537 }
29beb80d 538
539 // Create connecting track and update 4-momentum and charge for current vertex
540 if (connect)
541 {
43bfa5be 542 AliTrack* t=new AliTrack();
6516b62d 543 t->SetBeginPoint(GetPosition());
544 t->SetEndPoint(v.GetPosition());
545 t->SetCharge(v.GetCharge());
546 t->Set4Momentum((Ali4Vector&)v);
29beb80d 547
6516b62d 548 AddTrack(t,0);
29beb80d 549
6516b62d 550 if (!fConnects)
551 {
552 fConnects=new TObjArray(fNvmax);
553 if (!fTrackCopy) fConnects->SetOwner();
554 }
29beb80d 555 fConnects->Add(t);
556 }
d88f97cc 557}
558///////////////////////////////////////////////////////////////////////////
84bb7c66 559void AliVertex::Data(TString f)
d88f97cc 560{
561// Provide vertex information within the coordinate frame f
47dddbe4 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;
387a745b 568 cout << " Id : " << fUserId << " Invmass : " << GetInvmass()
d88f97cc 569 << " Charge : " << GetCharge() << " Momentum : " << GetMomentum()
f34f4acb 570 << " Ntracks : " << GetNtracks() << " Nvertices : " << fNvtx
571 << " Njets : " << fNjets << endl;
d88f97cc 572 cout << " ";
84bb7c66 573 Ali4Vector::Data(f);
d88f97cc 574 cout << " Position";
84bb7c66 575 AliPosition::Data(f);
d88f97cc 576}
577///////////////////////////////////////////////////////////////////////////
578void AliVertex::List(TString f)
579{
580// Provide primary track and sec. vertex information within the coordinate frame f
581
84bb7c66 582 Data(f); // Information of the current vertex
d88f97cc 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 << " ";
84bb7c66 593 t->Data(f);
d88f97cc 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 << " ";
84bb7c66 610 v->Data(f);
d88f97cc 611 }
612 else
613 {
614 cout << " *AliVertex::List* Error : No sec. vertex present." << endl;
615 }
616 }
617}
618///////////////////////////////////////////////////////////////////////////
619void AliVertex::ListAll(TString f)
620{
621// Provide complete (sec) vertex and (decay) track info within the coordinate frame f
622
84bb7c66 623 Data(f); // Information of the current vertex
d88f97cc 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;
1c01b4f8 643 Dumps(v,1,f); // Information of all sec. vertices
d88f97cc 644}
645//////////////////////////////////////////////////////////////////////////
1c01b4f8 646void AliVertex::Dumps(AliVertex* v,Int_t n,TString f)
d88f97cc 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 << " ";
84bb7c66 657 vs->Data(f);
d88f97cc 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 {
1c01b4f8 672 cout << " *AliVertex::Dumps* Error : No track present." << endl;
d88f97cc 673 }
674 }
675
676 // Go for next sec. vertex level of this sec. vertex recursively
1c01b4f8 677 Dumps(vs,n+1,f);
d88f97cc 678 }
679 else
680 {
1c01b4f8 681 cout << " *AliVertex::Dumps* Error : No sec. vertex present." << endl;
d88f97cc 682 }
683 }
684}
685//////////////////////////////////////////////////////////////////////////
261c0caf 686Int_t AliVertex::GetNvertices() const
d88f97cc 687{
688// Return the current number of (secondary) vertices
689 return fNvtx;
690}
691///////////////////////////////////////////////////////////////////////////
261c0caf 692AliVertex* AliVertex::GetVertex(Int_t i) const
d88f97cc 693{
694// Return the i-th (secondary) vertex of the current vertex
f34f4acb 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///////////////////////////////////////////////////////////////////////////
261c0caf 715AliVertex* AliVertex::GetIdVertex(Int_t id) const
43bfa5be 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///////////////////////////////////////////////////////////////////////////
f34f4acb 736void 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///////////////////////////////////////////////////////////////////////////
261c0caf 764Int_t AliVertex::GetVertexCopy() const
f34f4acb 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///////////////////////////////////////////////////////////////////////////
261c0caf 772Int_t AliVertex::GetNjets() const
f34f4acb 773{
774// Return the current number of jets
775 return fNjets;
776}
777///////////////////////////////////////////////////////////////////////////
261c0caf 778AliJet* AliVertex::GetJet(Int_t i) const
f34f4acb 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///////////////////////////////////////////////////////////////////////////
261c0caf 801AliJet* AliVertex::GetIdJet(Int_t id) const
43bfa5be 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///////////////////////////////////////////////////////////////////////////
f34f4acb 822void 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///////////////////////////////////////////////////////////////////////////
261c0caf 850Int_t AliVertex::GetJetCopy() const
f34f4acb 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;
d88f97cc 856}
857///////////////////////////////////////////////////////////////////////////
261c0caf 858Int_t AliVertex::IsConnectTrack(AliTrack* t) const
6516b62d 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///////////////////////////////////////////////////////////////////////////
261c0caf 872Int_t AliVertex::IsJetTrack(AliTrack* t) const
6516b62d 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///////////////////////////////////////////////////////////////////////////
a37bb40e 886void 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//
1c01b4f8 898// secs = 1 --> Draw secondary vertices. (Default)
a37bb40e 899// 0 --> Don't draw secondary vertices.
900//
1c01b4f8 901// cons = 1 --> Draw (auto generated) connecting tracks. (Default)
a37bb40e 902// 0 --> Don't draw (auto generated) connecting tracks.
903//
904// jets = 1 --> Mark tracks belonging to jets.
1c01b4f8 905// 0 --> Don't mark jet-tracks. (Default)
a37bb40e 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;
c72198f1 916 AliPosition* r=0;
a37bb40e 917 Ali3Vector p;
1c01b4f8 918 Float_t charge;
a37bb40e 919
c72198f1 920 AliPosition dummy;
921
a37bb40e 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
1c01b4f8 933 charge=tx->GetCharge();
a37bb40e 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();
c72198f1 943 if (!r) r=&dummy;
944 r->GetPosition(vec,"car");
a37bb40e 945 line->SetNextPoint(vec[0],vec[1],vec[2]);
946 r=tx->GetEndPoint();
c72198f1 947 if (!r) r=&dummy;
948 r->GetPosition(vec,"car");
a37bb40e 949 line->SetNextPoint(vec[0],vec[1],vec[2]);
950 line->SetLineWidth(1);
951 }
952 }
953 else
954 {
955 r=tx->GetClosestPoint();
c72198f1 956 if (!r) r=&dummy;
957 r->GetPosition(vec,"car");
a37bb40e 958 line->SetNextPoint(vec[0],vec[1],vec[2]);
959 p=tx->Get3Momentum();
c72198f1 960 p=p+(*r);
a37bb40e 961 p.GetVector(vec,"car");
962 line->SetNextPoint(vec[0],vec[1],vec[2]);
963 line->SetLineWidth(3);
964 }
965
1c01b4f8 966 line->SetLineColor(kGreen); // Neutral track
967 if (charge>0) line->SetLineColor(kRed); // Positive track
968 if (charge<0) line->SetLineColor(kBlue); // Negative track
a37bb40e 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///////////////////////////////////////////////////////////////////////////
261c0caf 995TObject* AliVertex::Clone(const char* name) const
5f25234b 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///////////////////////////////////////////////////////////////////////////