1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////
20 // Creation and investigation of an AliVertex.
21 // An AliVertex can be constructed by adding AliTracks and/or AliJets.
23 // Note : Also (secondary) vertices can be added to a vertex.
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().
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
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.
38 // Modifications made to the original vertices also affect the AliVertex objects
41 // b) SetVertexCopy(1).
42 // Of every 'added' vertex a private copy will be made of which the pointer
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
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.
51 // See also the documentation provided for the memberfunction SetOwner().
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
59 // AliTrack t1,t2,t3,t4;
61 // ... // code to fill the track data
66 // ... // code to fill the jet data
70 // v1.SetVertexCopy(1);
77 // Float_t r1[3]={2.4,0.1,-8.5};
78 // v1.SetPosition(r1,"car");
81 // v2.SetTrackCopy(1);
83 // AliTrack* tx=new AliTrack();
84 // for (Int_t i=0; i<10; i++)
87 // ... // code to fill the track data
93 // Float_t r2[3]={1.6,-3.2,5.7};
94 // v2.SetPosition(r2,"car");
101 // Float_t r3[3]={6.2,4.8,1.3};
102 // v3.SetPosition(r3,"car");
108 // Float_t e1=v1.GetEnergy();
109 // Ali3Vector p1=v1.Get3Momentum();
111 // v1.GetPosition(loc,"sph");
112 // AliPosition r=v2.GetPosition();
114 // Int_t nt=v2.GetNtracks();
115 // AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
117 // Specify the vertices v2 and v3 as secondary vertices of v1
124 // Int_t nv=v1.GetNvtx();
125 // AliVertex* vx=v1.GetVertex(1); // Access 1st secondary vertex of v1
126 // Float_t e=vx->GetEnergy();
128 // Float_t M=v1.GetInvmass();
130 // Reconstruct Vertex v1 from scratch
133 // v1.SetNvmax(25); // Increase initial no. of sec. vertices
137 // Float_t pos[3]={7,9,4};
138 // v1.SetPosition(pos,"car");
140 // Note : By default all quantities are in meter, GeV, GeV/c or GeV/c**2
141 // but the user can indicate the usage of a different scale for
142 // the metric and/or energy-momentum units via the SetUnitScale()
143 // and SetEscale() memberfunctions, respectively.
144 // The actual metric and energy-momentum unit scales in use can be
145 // obtained via the GetUnitScale() and GetEscale() memberfunctions.
147 //--- Author: Nick van Eijndhoven 04-apr-1998 UU-SAP Utrecht
148 //- Modified: NvE $Date$ UU-SAP Utrecht
149 ///////////////////////////////////////////////////////////////////////////
151 #include "AliVertex.h"
152 #include "Riostream.h"
154 ClassImp(AliVertex) // Class implementation to enable ROOT I/O
156 AliVertex::AliVertex() : AliJet(),AliPosition()
158 // Default constructor.
159 // All variables initialised to 0.
160 // Initial maximum number of tracks is set to the default value.
161 // Initial maximum number of sec. vertices is set to the default value.
167 ///////////////////////////////////////////////////////////////////////////
168 void AliVertex::Init()
170 // Initialisation of pointers etc...
181 ///////////////////////////////////////////////////////////////////////////
182 AliVertex::AliVertex(Int_t n) : AliJet(n),AliPosition()
184 // Create a vertex to hold initially a maximum of n tracks
185 // All variables initialised to 0
188 cout << " *** This AliJet initialisation was invoked via the AliVertex ctor." << endl;
195 ///////////////////////////////////////////////////////////////////////////
196 AliVertex::~AliVertex()
198 // Default destructor
225 ///////////////////////////////////////////////////////////////////////////
226 void AliVertex::SetOwner(Bool_t own)
228 // Set ownership of all added objects.
229 // The default parameter is own=kTRUE.
231 // Invokation of this memberfunction also sets all the copy modes
232 // (e.g. TrackCopy & co.) according to the value of own.
234 // This function (with own=kTRUE) is particularly useful when reading data
235 // from a tree/file, since Reset() will then actually remove all the
236 // added objects from memory irrespective of the copy mode settings
237 // during the tree/file creation process. In this way it provides a nice way
238 // of preventing possible memory leaks in the reading/analysis process.
240 // In addition this memberfunction can also be used as a shortcut to set all
241 // copy modes in one go during a tree/file creation process.
242 // However, in this case the user has to take care to only set/change the
243 // ownership (and copy mode) for empty objects (e.g. newly created objects
244 // or after invokation of the Reset() memberfunction) otherwise it will
245 // very likely result in inconsistent destructor behaviour.
249 if (fVertices) fVertices->SetOwner(own);
251 if (fJets) fJets->SetOwner(own);
254 AliJet::SetOwner(own);
256 ///////////////////////////////////////////////////////////////////////////
257 AliVertex::AliVertex(const AliVertex& v) : AliJet(v.fNtinit),AliPosition(v)
265 SetTrackCopy(v.GetTrackCopy());
266 SetVertexCopy(v.GetVertexCopy());
267 SetJetCopy(v.GetJetCopy());
270 // Copy all tracks except the ones coming from jets
272 Int_t jetflag=0,connect=0;
274 for (Int_t it=1; it<=v.fNtrk; it++)
279 jetflag=v.IsJetTrack(tx);
280 connect=v.IsConnectTrack(tx);
282 if (!jetflag && !connect) AddTrack(tx);
288 fConnects=new TObjArray(fNvmax);
289 if (!fTrackCopy) fConnects->SetOwner();
291 tx2=new AliTrack(*tx);
298 // Copy all the (secondary) vertices without re-creating connecting tracks
299 // The connecting tracks have already been copied above
301 for (Int_t iv=1; iv<=v.GetNvertices(); iv++)
304 if (vx) AddVertex(vx,0);
307 // Copy all the jets including the jet tracks for these jets for which
308 // this was also the case in the original vertex
310 for (Int_t ij=1; ij<=v.GetNjets(); ij++)
316 if (jx->GetNtracks())
321 jetflag=v.IsJetTrack(tx);
328 ///////////////////////////////////////////////////////////////////////////
329 void AliVertex::SetNvmax(Int_t n)
331 // Set the initial maximum number of (secondary) vertices
346 ///////////////////////////////////////////////////////////////////////////
347 void AliVertex::SetNjmax(Int_t n)
349 // Set the initial maximum number of jets
364 ///////////////////////////////////////////////////////////////////////////
365 void AliVertex::Reset()
367 // Reset all variables to 0 and reset all stored vertex and jet lists.
368 // The max. number of tracks is set to the initial value again
369 // The max. number of vertices is set to the default value again
370 // The max. number of jets is set to the default value again
374 Double_t a[3]={0,0,0};
375 SetPosition(a,"sph");
376 SetPositionErrors(a,"car");
379 if (fNvmax>0) SetNvmax(fNvmax);
387 if (fNjmax>0) SetNjmax(fNjmax);
400 ///////////////////////////////////////////////////////////////////////////
401 void AliVertex::ResetVertices()
403 // Reset the stored vertex list and delete all connecting tracks which
404 // were generated automatically via connect=1 in AddVertex().
405 // The max. number of vertices is set to the default value again.
406 // All physics quantities are updated according to the removal of the
407 // connecting tracks.
411 for (Int_t i=0; i<=fConnects->GetLast(); i++)
413 t=(AliTrack*)fConnects->At(i);
414 AliTrack* test=(AliTrack*)fTracks->Remove(t);
418 (Ali4Vector&)(*this)-=(Ali4Vector&)(*t);
420 if (fTrackCopy) delete t;
427 if (fNvmax>0) SetNvmax(fNvmax);
434 ///////////////////////////////////////////////////////////////////////////
435 void AliVertex::AddJet(AliJet& j,Int_t tracks)
437 // Add a jet (and its tracks) to the vertex
438 // In case the maximum number of jets has been reached,
439 // the array space will be extended automatically
441 // Note : By default the tracks of the jet are added to the current (primary)
443 // The automatic addition of the tracks of the jet can be suppressed
444 // by specifying tracks=0. In this case only the AliJet object will
445 // be stored according to the mode specified by SetJetCopy().
446 // The latter will enable jet studies based on a fixed list of tracks
447 // as contained e.g. in an AliVertex or AliEvent.
449 // In case a private copy is made, this is performed via the Clone() memberfunction.
450 // All AliJet and derived classes have the default TObject::Clone() memberfunction.
451 // However, derived classes generally contain an internal data structure which may
452 // include pointers to other objects. Therefore it is recommended to provide
453 // for all derived classes a specific copy constructor and override the default Clone()
454 // memberfunction using this copy constructor.
455 // An example for this may be seen from AliJet.
459 fJets=new TObjArray(fNjmax);
460 if (fJetCopy) fJets->SetOwner();
462 if (fNjets == fNjmax) // Check if maximum jet number is reached
465 fJets->Expand(fNjmax);
468 // Add the jet to the list
470 if (fJetCopy) jx=(AliJet*)j.Clone();
478 // Add the tracks of the jet to this vertex
483 fJetTracks=new TObjArray();
485 Int_t copy=1-(jx->GetTrackCopy());
487 for (Int_t i=1; i<=jx->GetNtracks(); i++)
498 ///////////////////////////////////////////////////////////////////////////
499 void AliVertex::AddVertex(AliVertex& v,Int_t connect)
501 // Add a (secondary) vertex to the current vertex.
502 // In case the maximum number of (secondary) vertices has been reached,
503 // the array space will be extended automatically
505 // Note : By default the 4-momentum and charge of the current (primary) vertex
506 // are updated by automatically creating the track connecting
507 // both vertices. The track parameters are taken from the
508 // 4-momentum and charge of the secondary vertex.
509 // The automatic creation of the connecting track and updating
510 // of the (primary) vertex 4-momentum and charge can be suppressed
511 // by specifying connect=0. In this case, however, the user
512 // has to introduce the connecting track lateron by hand
513 // explicitly in order to match the kinematics and charge.
515 // In case a private copy is made, this is performed via the Clone() memberfunction.
516 // All AliVertex and derived classes have the default TObject::Clone() memberfunction.
517 // However, derived classes generally contain an internal data structure which may
518 // include pointers to other objects. Therefore it is recommended to provide
519 // for all derived classes a specific copy constructor and override the default Clone()
520 // memberfunction using this copy constructor.
521 // An example for this may be seen from AliVertex.
525 fVertices=new TObjArray(fNvmax);
526 if (fVertexCopy) fVertices->SetOwner();
528 if (fNvtx == fNvmax) // Check if maximum vertex number is reached
531 fVertices->Expand(fNvmax);
534 // Add the linked (secondary) vertex to the list
536 if (fVertexCopy) vx=(AliVertex*)v.Clone();
544 // Create connecting track and update 4-momentum and charge for current vertex
547 AliTrack* t=new AliTrack();
548 t->SetBeginPoint(GetPosition());
549 t->SetEndPoint(v.GetPosition());
550 t->SetCharge(v.GetCharge());
551 t->Set4Momentum((Ali4Vector&)v);
557 fConnects=new TObjArray(fNvmax);
558 if (!fTrackCopy) fConnects->SetOwner();
563 ///////////////////////////////////////////////////////////////////////////
564 void AliVertex::Data(TString f,TString u)
566 // Provide vertex information within the coordinate frame f
568 // The string argument "u" allows to choose between different angular units
569 // in case e.g. a spherical frame is selected.
570 // u = "rad" : angles provided in radians
571 // "deg" : angles provided in degrees
573 // The defaults are f="car" and u="rad".
575 const char* name=GetName();
576 const char* title=GetTitle();
577 cout << " *AliVertex::Data*";
578 if (strlen(name)) cout << " Name : " << GetName();
579 if (strlen(title)) cout << " Title : " << GetTitle();
581 cout << " Id : " << fUserId << " Invmass : " << GetInvmass()
582 << " Charge : " << GetCharge() << " Momentum : " << GetMomentum()
583 << " Ntracks : " << GetNtracks() << endl;
584 cout << " Nvertices : " << fNvtx << " Njets : " << fNjets
585 << " Energy scale : " << fEscale << " GeV" << endl;
587 Ali4Vector::Data(f,u);
589 AliPosition::Data(f,u);
591 ///////////////////////////////////////////////////////////////////////////
592 void AliVertex::List(TString f,TString u)
594 // Provide primary track and sec. vertex information within the coordinate frame f
596 // The string argument "u" allows to choose between different angular units
597 // in case e.g. a spherical frame is selected.
598 // u = "rad" : angles provided in radians
599 // "deg" : angles provided in degrees
601 // The defaults are f="car" and u="rad".
603 Data(f,u); // Information of the current vertex
605 // The tracks of this vertex
607 for (Int_t it=1; it<=GetNtracks(); it++)
612 cout << " ---Track no. " << it << endl;
618 cout << " *AliVertex::List* Error : No track present." << endl;
622 // The secondary vertices of this vertex
624 for (Int_t iv=1; iv<=GetNvertices(); iv++)
629 cout << " ---Level 1 sec. vertex no. " << iv << endl;
635 cout << " *AliVertex::List* Error : No sec. vertex present." << endl;
639 ///////////////////////////////////////////////////////////////////////////
640 void AliVertex::ListAll(TString f,TString u)
642 // Provide complete (sec) vertex and (decay) track info within the coordinate frame f
644 // The string argument "u" allows to choose between different angular units
645 // in case e.g. a spherical frame is selected.
646 // u = "rad" : angles provided in radians
647 // "deg" : angles provided in degrees
649 // The defaults are f="car" and u="rad".
651 Data(f,u); // Information of the current vertex
653 // The tracks of this vertex
655 for (Int_t it=1; it<=GetNtracks(); it++)
660 cout << " ---Track no. " << it << endl;
666 cout << " *AliVertex::ListAll* Error : No track present." << endl;
671 Dumps(v,1,f,u); // Information of all sec. vertices
673 //////////////////////////////////////////////////////////////////////////
674 void AliVertex::Dumps(AliVertex* v,Int_t n,TString f,TString u)
676 // Recursively provide the info of all secondary vertices of this vertex
678 for (Int_t iv=1; iv<=v->GetNvertices(); iv++)
683 cout << " ---Level " << n << " sec. vertex no. " << iv << endl;
687 // The tracks of this vertex
689 for (Int_t it=1; it<=vs->GetNtracks(); it++)
694 cout << " ---Track no. " << it << endl;
700 cout << " *AliVertex::Dumps* Error : No track present." << endl;
704 // Go for next sec. vertex level of this sec. vertex recursively
709 cout << " *AliVertex::Dumps* Error : No sec. vertex present." << endl;
713 //////////////////////////////////////////////////////////////////////////
714 Int_t AliVertex::GetNvertices() const
716 // Return the current number of (secondary) vertices
719 ///////////////////////////////////////////////////////////////////////////
720 AliVertex* AliVertex::GetVertex(Int_t i) const
722 // Return the i-th (secondary) vertex of the current vertex
725 cout << " *AliVertex*::GetVertex* No (secondary) vertices present." << endl;
732 cout << " *AliVertex*::GetVertex* Invalid argument i : " << i
733 << " Nvtx = " << fNvtx << endl;
738 return (AliVertex*)fVertices->At(i-1);
742 ///////////////////////////////////////////////////////////////////////////
743 AliVertex* AliVertex::GetIdVertex(Int_t id) const
745 // Return the (sec.) vertex with user identifier "id"
750 cout << " *AliVertex*::GetIdVertex* No (secondary) vertices present." << endl;
755 for (Int_t i=0; i<fNvtx; i++)
757 vx=(AliVertex*)fVertices->At(i);
758 if (id == vx->GetId()) v=vx;
763 ///////////////////////////////////////////////////////////////////////////
764 void AliVertex::SetVertexCopy(Int_t j)
766 // (De)activate the creation of private copies of the added vertices.
767 // j=0 ==> No private copies are made; pointers of original vertices are stored.
768 // j=1 ==> Private copies of the vertices are made and these pointers are stored.
770 // Note : Once the storage contains pointer(s) to AliVertex objects one cannot
771 // change the VertexCopy mode anymore.
772 // To change the VertexCopy mode for an existing AliVertex containing
773 // vertices one first has to invoke Reset().
782 cout << "*AliVertex::SetVertexCopy* Invalid argument : " << j << endl;
787 cout << "*AliVertex::SetVertexCopy* Storage already contained vertices."
788 << " ==> VertexCopy mode not changed." << endl;
791 ///////////////////////////////////////////////////////////////////////////
792 Int_t AliVertex::GetVertexCopy() const
794 // Provide value of the VertexCopy mode.
795 // 0 ==> No private copies are made; pointers of original vertices are stored.
796 // 1 ==> Private copies of the vertices are made and these pointers are stored.
799 ///////////////////////////////////////////////////////////////////////////
800 Int_t AliVertex::GetNjets() const
802 // Return the current number of jets
805 ///////////////////////////////////////////////////////////////////////////
806 AliJet* AliVertex::GetJet(Int_t i) const
808 // Return the i-th jet of the current vertex
811 cout << " *AliVertex*::GetJet* No jets present." << endl;
816 if (i<=0 || i>fNjets)
818 cout << " *AliVertex*::GetJet* Invalid argument i : " << i
819 << " Njets = " << fNjets << endl;
824 return (AliJet*)fJets->At(i-1);
828 ///////////////////////////////////////////////////////////////////////////
829 AliJet* AliVertex::GetIdJet(Int_t id) const
831 // Return the jet with user identifier "id"
836 cout << " *AliVertex*::GetIdJet* No jets present." << endl;
841 for (Int_t i=0; i<fNjets; i++)
843 jx=(AliJet*)fJets->At(i);
844 if (id == jx->GetId()) j=jx;
849 ///////////////////////////////////////////////////////////////////////////
850 void AliVertex::SetJetCopy(Int_t j)
852 // (De)activate the creation of private copies of the added jets.
853 // j=0 ==> No private copies are made; pointers of original jets are stored.
854 // j=1 ==> Private copies of the jets are made and these pointers are stored.
856 // Note : Once the storage contains pointer(s) to AliJet objects one cannot
857 // change the JetCopy mode anymore.
858 // To change the JetCopy mode for an existing AliVertex containing
859 // jets one first has to invoke Reset().
868 cout << "*AliVertex::SetJetCopy* Invalid argument : " << j << endl;
873 cout << "*AliVertex::SetJetCopy* Storage already contained jets."
874 << " ==> JetCopy mode not changed." << endl;
877 ///////////////////////////////////////////////////////////////////////////
878 Int_t AliVertex::GetJetCopy() const
880 // Provide value of the JetCopy mode.
881 // 0 ==> No private copies are made; pointers of original jets are stored.
882 // 1 ==> Private copies of the jets are made and these pointers are stored.
885 ///////////////////////////////////////////////////////////////////////////
886 Int_t AliVertex::IsConnectTrack(AliTrack* t) const
888 // Indicate whether a track from the tracklist was created via the
889 // connection of a (secondary) vertex or not.
890 // In case the track was the result of (secondary) vertex addition the
891 // return value is 1, otherwise the value 0 will be returned.
895 if (fConnects->FindObject(t)) connect=1;
899 ///////////////////////////////////////////////////////////////////////////
900 Int_t AliVertex::IsJetTrack(AliTrack* t) const
902 // Indicate whether a track from the tracklist was created via the
903 // addition of a jet or not.
904 // In case the track was the result of jet addition the return value is 1,
905 // otherwise the value 0 will be returned.
909 if (fJetTracks->FindObject(t)) jetflag=1;
913 ///////////////////////////////////////////////////////////////////////////
914 void AliVertex::Draw(Int_t secs,Int_t cons,Int_t jets)
916 // 3-Dimensional visualisation of an AliVertex with its attributes.
917 // The displayed tracklength is proportional to the momentum of the track.
919 // Color conventions :
920 // -------------------
921 // positive track : red
922 // neutral track : green
923 // negative track : blue
924 // jet-track : magenta (if explicit marking selected)
926 // secs = 1 --> Draw secondary vertices. (Default)
927 // 0 --> Don't draw secondary vertices.
929 // cons = 1 --> Draw (auto generated) connecting tracks. (Default)
930 // 0 --> Don't draw (auto generated) connecting tracks.
932 // jets = 1 --> Mark tracks belonging to jets.
933 // 0 --> Don't mark jet-tracks. (Default)
937 // Auto generated connecting tracks will be drawn as thin lines.
938 // Tracks belonging to jets will be marked as somewhat thinner magenta lines.
939 // This memberfunction is used recursively.
941 Double_t vec[3]={0,0,0};
950 if (fLines) delete fLines;
951 fLines=new TObjArray();
954 Int_t ntk=GetNtracks();
955 for (Int_t jtk=1; jtk<=ntk; jtk++)
961 charge=tx->GetCharge();
963 TPolyLine3D* line=new TPolyLine3D();
966 if (IsConnectTrack(tx))
970 r=tx->GetBeginPoint();
972 r->GetPosition(vec,"car");
973 line->SetNextPoint(vec[0],vec[1],vec[2]);
976 r->GetPosition(vec,"car");
977 line->SetNextPoint(vec[0],vec[1],vec[2]);
978 line->SetLineWidth(1);
983 r=tx->GetClosestPoint();
985 r->GetPosition(vec,"car");
986 line->SetNextPoint(vec[0],vec[1],vec[2]);
987 p=tx->Get3Momentum();
989 p.GetVector(vec,"car");
990 line->SetNextPoint(vec[0],vec[1],vec[2]);
991 line->SetLineWidth(3);
994 line->SetLineColor(kGreen); // Neutral track
995 if (charge>0) line->SetLineColor(kRed); // Positive track
996 if (charge<0) line->SetLineColor(kBlue); // Negative track
998 // Mark tracks belonging to jets
1003 line->SetLineWidth(2);
1004 line->SetLineColor(kMagenta);
1011 // Go for secondary vertices if selected
1014 Int_t nvtx=GetNvertices();
1015 for (Int_t jvtx=1; jvtx<=nvtx; jvtx++)
1018 if (vx) vx->Draw(secs,cons,jets);
1022 ///////////////////////////////////////////////////////////////////////////
1023 TObjArray* AliVertex::SortJets(Int_t mode,TObjArray* jets)
1025 // Order the references to an array of jets by looping over the input array "jets"
1026 // and checking the value of a certain observable.
1027 // The ordered array is returned as a TObjArray.
1028 // In case jets=0 (default), the registered jets of the current vertex are used.
1029 // Note that the original jet array is not modified.
1030 // Via the "mode" argument the user can specify the observable to be checked upon
1031 // and specify whether sorting should be performed in decreasing order (mode<0)
1032 // or in increasing order (mode>0).
1034 // The convention for the observable selection is the following :
1035 // mode : 1 ==> Number of tracks in the jet
1037 // 3 ==> Jet momentum
1038 // 4 ==> Invariant mass of the jet
1039 // 5 ==> Transverse momentum of the jet
1040 // 6 ==> Longitudinal momentum of the jet
1041 // 7 ==> Transverse energy of the jet
1042 // 8 ==> Longitudinal energy of the jet
1043 // 9 ==> Transverse mass of the jet
1044 // 10 ==> Jet rapidity
1045 // 11 ==> Pseudo-rapidity of the jet
1046 // 12 ==> Number of associated signals
1047 // 13 ==> Total charge of the jet
1049 // The default is mode=-1.
1051 // Note : This sorting routine uses a common area in memory, which is used
1052 // by various other sorting facilities as well.
1053 // This means that the resulting sorted TObjArray may be overwritten
1054 // when another sorting is invoked.
1055 // To retain the sorted list of pointers, the user is advised to copy
1056 // the pointers contained in the returned TObjArray into a private
1057 // TObjArray instance.
1065 if (!jets) jets=fJets;
1067 if (!mode || abs(mode)>13 || !jets) return fSelected;
1069 Int_t njets=jets->GetEntries();
1076 fSelected=new TObjArray(njets);
1079 Double_t val1,val2; // Values of the observable to be tested upon
1082 for (Int_t i=0; i<njets; i++) // Loop over all jets of the array
1084 AliJet* jx=(AliJet*)jets->At(i);
1088 if (nord == 0) // store the first jet at the first ordered position
1091 fSelected->AddAt(jx,nord-1);
1095 for (Int_t j=0; j<=nord; j++) // put jet in the right ordered position
1097 if (j == nord) // jet has smallest (mode<0) or largest (mode>0) observable value seen so far
1100 fSelected->AddAt(jx,j); // add jet at the end
1101 break; // go for next jet
1110 val1=jx->GetNtracks();
1111 val2=((AliJet*)fSelected->At(j))->GetNtracks();
1114 val1=jx->GetEnergy(1);
1115 val2=((AliJet*)fSelected->At(j))->GetEnergy(1);
1118 val1=jx->GetMomentum(1);
1119 val2=((AliJet*)fSelected->At(j))->GetMomentum(1);
1122 val1=jx->GetInvmass(1);
1123 val2=((AliJet*)fSelected->At(j))->GetInvmass(1);
1127 val2=((AliJet*)fSelected->At(j))->GetPt(1);
1131 val2=((AliJet*)fSelected->At(j))->GetPl(1);
1135 val2=((AliJet*)fSelected->At(j))->GetEt(1);
1139 val2=((AliJet*)fSelected->At(j))->GetEl(1);
1143 val2=((AliJet*)fSelected->At(j))->GetMt(1);
1146 val1=jx->GetRapidity();
1147 val2=((AliJet*)fSelected->At(j))->GetRapidity();
1150 val1=jx->GetPseudoRapidity();
1151 val2=((AliJet*)fSelected->At(j))->GetPseudoRapidity();
1154 val1=jx->GetNsignals();
1155 val2=((AliJet*)fSelected->At(j))->GetNsignals();
1158 val1=jx->GetCharge();
1159 val2=((AliJet*)fSelected->At(j))->GetCharge();
1163 if (mode<0 && val1 <= val2) continue;
1164 if (mode>0 && val1 >= val2) continue;
1167 for (Int_t k=nord-1; k>j; k--) // create empty position
1169 fSelected->AddAt(fSelected->At(k-1),k);
1171 fSelected->AddAt(jx,j); // put jet at empty position
1172 break; // go for next jet
1177 ///////////////////////////////////////////////////////////////////////////
1178 TObject* AliVertex::Clone(const char* name) const
1180 // Make a deep copy of the current object and provide the pointer to the copy.
1181 // This memberfunction enables automatic creation of new objects of the
1182 // correct type depending on the object type, a feature which may be very useful
1183 // for containers when adding objects in case the container owns the objects.
1184 // This feature allows e.g. AliEvent to store either AliVertex objects or
1185 // objects derived from AliVertex via the AddVertex memberfunction, provided
1186 // these derived classes also have a proper Clone memberfunction.
1188 AliVertex* vtx=new AliVertex(*this);
1191 if (strlen(name)) vtx->SetName(name);
1195 ///////////////////////////////////////////////////////////////////////////