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