HLT/TPCLib/AliHLTTPCMerger.cxx

   1 //$Id$
   2 // Original: AliHLTMerger.cxx,v 1.16 2005/06/14 10:55:21 cvetan
   3
   4 /**************************************************************************
   5  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   6  *                                                                        *
   7  * Authors: Uli Frankenfeld                                               *
   8  *          Matthias Richter <Matthias.Richter@ift.uib.no>                *
   9  *          for The ALICE Off-line Project.                               *
  10  *                                                                        *
  11  * Permission to use, copy, modify and distribute this software and its   *
  12  * documentation strictly for non-commercial purposes is hereby granted   *
  13  * without fee, provided that the above copyright notice appears in all   *
  14  * copies and that both the copyright notice and this permission notice   *
  15  * appear in the supporting documentation. The authors make no claims     *
  16  * about the suitability of this software for any purpose. It is          *
  17  * provided "as is" without express or implied warranty.                  *
  18  **************************************************************************/
  19
  20 /** @file   AliHLTTPCMerger.cxx
  21     @author Uli Frankenfeld, maintained by Matthias Richter
  22     @date
  23     @brief  The HLT TPC merger base class
  24 */
  25
  26 #include "AliHLTTPCLogging.h"
  27 #include "AliHLTTPCMerger.h"
  28 #include "AliHLTTPCTrack.h"
  29 #include "AliHLTTPCTrackSegmentData.h"
  30 #include "AliHLTTPCTransform.h"
  31 #include "AliHLTTPCTrackArray.h"
  32
  33 #ifdef use_root //use root ntuple for slow merge
  34 #include <TNtuple.h>
  35 #include <TTree.h>
  36 #include <TFile.h>
  37 #endif
  38
  39 #if __GNUC__ >= 3
  40 using namespace std;
  41 #endif
  42
  43 ClassImp(AliHLTTPCMerger)
  44
  45 AliHLTTPCMerger::AliHLTTPCMerger()
  46 {
  47   //Default constructor
  48   fInTrack=0;
  49   fOutTrack=0;
  50   fCurrentTracks=0;
  51   fNIn=0;
  52 }
  53
  54 AliHLTTPCMerger::AliHLTTPCMerger(const AliHLTTPCMerger&)
  55 {
  56   // dummy copy constructor
  57   //HLTFatal("copy constructor untested");
  58 }
  59
  60 AliHLTTPCMerger& AliHLTTPCMerger::operator=(const AliHLTTPCMerger&)
  61 {
  62   // dummy assignment operator
  63   //HLTFatal("assignment operator untested");
  64   return *this;
  65 }
  66
  67 AliHLTTPCMerger::~AliHLTTPCMerger()
  68 {
  69   //Destructor
  70   DeleteArray();
  71 }
  72
  73 void AliHLTTPCMerger::InitMerger(Int_t ntrackarrays,Char_t *tracktype)
  74 {
  75   //Used to setup all arrays
  76
  77   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  78   else if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
  79 #ifdef INCLUDE_TPC_HOUGH
  80   else if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
  81 #endif
  82   else
  83     LOG(AliHLTTPCLog::kError,"AliHLTTPCMerger::AliHLTTPCMerger","Track types")
  84       <<"Unknown tracktype"<<ENDLOG;
  85   SetArray(ntrackarrays);
  86   fCurrentTracks=0;
  87
  88 }
  89
  90 void AliHLTTPCMerger::DeleteArray()
  91 {
  92   //delete arrays
  93   for(Int_t i=0; i<fNIn;i++)
  94     {
  95       if(!fInTrack[i]) continue;
  96       delete fInTrack[i];
  97       fInTrack[i]=0;
  98     }
  99   if(fInTrack)
 100     delete[] fInTrack;
 101   if(fOutTrack)
 102     delete fOutTrack;
 103   fInTrack=0;
 104   fOutTrack=0;
 105 }
 106
 107 void AliHLTTPCMerger::SetArray(Int_t nin)
 108 {
 109   //set arrays
 110   DeleteArray();//Make sure arrays are cleaned
 111
 112   fNIn = nin;
 113   fInTrack = new AliHLTTPCTrackArray*[fNIn];
 114   for(Int_t i=0; i<fNIn;i++)
 115     {
 116 #ifdef INCLUDE_TPC_HOUGH
 117       if(fTrackType=='h')
 118         fInTrack[i] = new AliHLTTPCTrackArray("AliHLTTPCHoughTrack");
 119       else
 120 #endif
 121         fInTrack[i] = new AliHLTTPCTrackArray("AliHLTTPCTrack");
 122
 123     }
 124 #ifdef INCLUDE_TPC_HOUGH
 125   if(fTrackType=='h')
 126     fOutTrack= new AliHLTTPCTrackArray("AliHLTTPCHoughTrack");
 127   else
 128 #endif
 129     fOutTrack= new AliHLTTPCTrackArray("AliHLTTPCTrack");
 130 }
 131
 132 void AliHLTTPCMerger::Reset()
 133 {
 134   //reset
 135   for(Int_t i=0; i<fNIn;i++)
 136     {
 137       fInTrack[i]->Reset();
 138     }
 139   fOutTrack->Reset();
 140 }
 141
 142 void AliHLTTPCMerger::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr)
 143 {
 144   //Read tracks from shared memory (or memory)
 145   AliHLTTPCTrackArray *destination = GetInTracks(fCurrentTracks);
 146   if(Is2Global())
 147     destination->FillTracks(ntracks, tr, fSlice);
 148   else
 149     destination->FillTracks(ntracks, tr);
 150 }
 151
 152 void AliHLTTPCMerger::AddAllTracks()
 153 {
 154   //add all tracks
 155   for(Int_t i=0; i<GetNIn();i++)
 156     {
 157       AliHLTTPCTrackArray *in = GetInTracks(i);
 158       AliHLTTPCTrackArray *out = GetOutTracks();
 159       out->AddTracks(in);
 160     }
 161 }
 162
 163 void AliHLTTPCMerger::SortGlobalTracks(AliHLTTPCTrack **tracks, Int_t ntrack)
 164 {
 165   //sort global tracks
 166   AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[ntrack];
 167   for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
 168   Int_t *t = new Int_t[ntrack];
 169   for(Int_t i=0;i<ntrack;i++) t[i]=-1;
 170
 171   for(Int_t j=0;j<ntrack;j++)
 172     {
 173       Double_t minr=300;
 174       Int_t    mini=0;
 175       for(Int_t i=0;i<ntrack;i++)
 176         {
 177           if(!tracks[i]) continue;
 178           Double_t rr=pow(tracks[i]->GetFirstPointX(),2)+pow(tracks[i]->GetFirstPointY(),2);
 179           Double_t r=sqrt(rr);
 180           if(r<minr){
 181             minr=r;
 182             mini=i;
 183           }
 184         }
 185       t[j]=mini;
 186       tracks[mini]=0;
 187     }
 188   for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
 189   delete[] t;
 190   delete[] tmp;
 191 }
 192
 193 void AliHLTTPCMerger::SortTracks(AliHLTTPCTrack **tracks, Int_t ntrack) const
 194 {
 195   //sort tracks
 196   AliHLTTPCTrack **tmp = new  AliHLTTPCTrack*[ntrack];
 197   for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
 198   Int_t *t = new Int_t[ntrack];
 199   for(Int_t i=0;i<ntrack;i++) t[i]=-1;
 200
 201   for(Int_t j=0;j<ntrack;j++)
 202     {
 203       Double_t minx=300;
 204       Int_t    mini=0;
 205       for(Int_t i=0;i<ntrack;i++)
 206         {
 207           if(!tracks[i]) continue;
 208           if(tracks[i]->GetFirstPointX()<minx)
 209             {
 210               minx=tracks[i]->GetFirstPointX();
 211               mini=i;
 212             }
 213         }
 214       t[j]=mini;
 215       tracks[mini]=0;
 216     }
 217   for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
 218   delete[] t;
 219   delete[] tmp;
 220 }
 221
 222 void AliHLTTPCMerger::AddTrack(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *track)
 223 {
 224   // add tracks
 225   AliHLTTPCTrack *t[1];
 226   t[0] = track;
 227   MultiMerge(mergedtrack,t,1);
 228 }
 229
 230 AliHLTTPCTrack * AliHLTTPCMerger::MergeTracks(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *t0,AliHLTTPCTrack *t1)
 231 {
 232   //merge tracks
 233   AliHLTTPCTrack *t[2];
 234   t[0] = t0;
 235   t[1] = t1;
 236   SortTracks(t,2);
 237   return MultiMerge(mergedtrack,t,2);
 238 }
 239
 240 AliHLTTPCTrack * AliHLTTPCMerger::MultiMerge(AliHLTTPCTrackArray *mergedtracks,AliHLTTPCTrack **tracks, Int_t ntrack)
 241 {
 242   //multi merge the tracks
 243   //check npoints
 244   Int_t nps = 0;
 245   for(Int_t i=0;i<ntrack;i++)
 246     {
 247       nps+=tracks[i]->GetNHits();
 248     }
 249   if(nps>AliHLTTPCTransform::GetNRows())
 250     {
 251       LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMerger::MultiMerge","Adding Points")
 252         <<AliHLTTPCLog::kDec<<"Too many Points: "<<nps<<ENDLOG;
 253       return 0;
 254     }
 255
 256   //create new track
 257   AliHLTTPCTrack *newtrack = mergedtracks->NextTrack();
 258   //copy points
 259   UInt_t * nn = new UInt_t[AliHLTTPCTransform::GetNRows()];
 260   nps = 0;
 261
 262   //  for(Int_t i=0;i<ntrack;i++){
 263   for(Int_t i=ntrack-1;i>=0;i--)
 264     {
 265       memcpy(&nn[nps],tracks[i]->GetHitNumbers(),tracks[i]->GetNHits()*sizeof(UInt_t));
 266       nps+=tracks[i]->GetNHits();
 267     }
 268   AliHLTTPCTrack *tpf=tracks[0];
 269   AliHLTTPCTrack *tpl=tracks[ntrack-1];
 270   AliHLTTPCTrack *best = tpf;
 271   if(tpf->GetNHits()<tpl->GetNHits() && Is2Global())
 272     best = tpl;//Best means = most points and therefore best fit (in global case)
 273
 274   newtrack->SetNHits(nps);
 275   newtrack->SetHits(nps,nn);
 276   newtrack->SetFirstPoint(tpf->GetFirstPointX(),tpf->GetFirstPointY(),tpf->GetFirstPointZ());
 277   newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
 278   newtrack->SetPt(best->GetPt());
 279   newtrack->SetPsi(best->GetPsi());
 280   newtrack->SetTgl(best->GetTgl());
 281   newtrack->SetCharge(tpf->GetCharge());
 282   delete [] nn;
 283   return newtrack;
 284 }
 285
 286 void* AliHLTTPCMerger::GetNtuple(char *varlist) const
 287 {
 288   //get ntuple
 289 #ifdef use_root
 290   TNtuple* nt = new TNtuple("ntuple","ntuple",varlist);
 291   return (void*) nt;
 292 #else
 293   return 0;
 294 #endif
 295 }
 296
 297 void* AliHLTTPCMerger::GetNtuple() const
 298 {
 299   //get ntuple
 300 #ifdef use_root
 301   TNtuple* nt = new TNtuple("ntuple","ntuple",
 302                             "dx:dy:dz:dk:dpsi:dtgl:dq:disx:disy:disz:dis:n0:n1:diff:drx:dry:drz");
 303   return (void*) nt;
 304 #else
 305   return 0;
 306 #endif
 307 }
 308
 309 Bool_t AliHLTTPCMerger::WriteNtuple(char *filename, void* nt) const
 310 {
 311   //write ntuple
 312 #ifdef use_root
 313   TNtuple *ntuple=(TNtuple *) nt;
 314   TFile *f = new TFile(filename,"RECREATE");
 315   ntuple->Write();
 316   f->Close();
 317   delete ntuple;
 318   return kTRUE;
 319 #else
 320   return kFALSE;
 321 #endif
 322 }
 323
 324 void AliHLTTPCMerger::FillNtuple(void *nt,AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
 325 {
 326   //fill ntuple
 327   Float_t data[17];
 328   if(outertrack->IsPoint()&&innertrack->IsPoint())
 329     {
 330       data[0] =Float_t(innertrack->GetPointX()-outertrack->GetPointX());
 331       data[1] =Float_t(innertrack->GetPointY()-outertrack->GetPointY());
 332       data[2] =Float_t(innertrack->GetPointZ()-outertrack->GetPointZ());
 333       data[3] =Float_t(innertrack->GetKappa()-outertrack->GetKappa());
 334       Double_t psi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
 335       if(psi>AliHLTTPCTransform::Pi()) psi-=AliHLTTPCTransform::TwoPi();
 336       else if(psi<-AliHLTTPCTransform::Pi()) psi+=AliHLTTPCTransform::TwoPi();
 337       data[4] =Float_t(psi);
 338       data[5] =Float_t(innertrack->GetTgl()-outertrack->GetTgl());
 339       data[6] =Float_t(innertrack->GetCharge()-outertrack->GetCharge());
 340       data[7] =Float_t(innertrack->GetLastPointX()-outertrack->GetFirstPointX());
 341       data[8] =Float_t(innertrack->GetLastPointY()-outertrack->GetFirstPointY());
 342       data[9] =Float_t(innertrack->GetLastPointZ()-outertrack->GetFirstPointZ());
 343       data[10] =sqrt(pow(data[7],2)+pow(data[8],2)+pow(data[9],2));
 344       data[11]= outertrack->GetNHits();
 345       data[12]= innertrack->GetNHits();
 346       data[13] = Float_t(TrackDiff(innertrack,outertrack));
 347       data[14]=0;
 348       data[15]=0;
 349       data[16]=0;
 350 #ifdef use_root
 351       TNtuple *ntuple = (TNtuple *) nt;
 352       ntuple->Fill(data);
 353 #endif
 354     }
 355 }
 356
 357 void AliHLTTPCMerger::FillNtuple(void *nt,Float_t *data) const
 358 {
 359   //fill ntuple
 360 #ifdef use_root
 361   TNtuple *ntuple = (TNtuple *) nt;
 362   ntuple->Fill(data);
 363 #endif
 364 }
 365
 366 Double_t AliHLTTPCMerger::GetAngle(Double_t a1,Double_t a2)
 367 {
 368   //get angle
 369   Double_t da = a1 - a2 + 4*AliHLTTPCTransform::Pi();
 370   da = fmod(da,AliHLTTPCTransform::TwoPi());
 371   if(da>AliHLTTPCTransform::Pi()) da = AliHLTTPCTransform::TwoPi()-da;
 372   return da;
 373 }
 374
 375 void AliHLTTPCMerger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxkappa, Double_t maxpsi, Double_t maxtgl)
 376 {
 377   //set parameters for merger
 378   fMaxY = maxy;
 379   fMaxZ = maxz;
 380   fMaxKappa = maxkappa;
 381   fMaxPsi = maxpsi;
 382   fMaxTgl = maxtgl;
 383 }
 384
 385 Bool_t AliHLTTPCMerger::IsTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
 386 {
 387   //is track to be merged
 388   if(innertrack->GetCharge()!=outertrack->GetCharge()) return kFALSE;
 389   if( (!innertrack->IsPoint()) || (!outertrack->IsPoint()) )  return kFALSE;
 390   if(innertrack->GetNHits()+outertrack->GetNHits()>AliHLTTPCTransform::GetNRows()) return kFALSE;
 391
 392   if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
 393   if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
 394   if(fabs(innertrack->GetKappa()-outertrack->GetKappa())   >fMaxKappa) return kFALSE;
 395   if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
 396   if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
 397   //if no rejection up to this point: merge!!
 398   return kTRUE;
 399 }
 400
 401 Bool_t AliHLTTPCMerger::IsRTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
 402 {
 403   //same as IsTrack
 404   return IsTrack(innertrack,outertrack);
 405 }
 406
 407 Double_t AliHLTTPCMerger::TrackDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
 408 {
 409   //return track difference
 410   Double_t diff =-1;
 411   Double_t x[4],y[4],z[4],dy[4],dz[4];
 412   AliHLTTPCTrack *tracks[2];
 413
 414   tracks[0] = innertrack;
 415   tracks[1] = outertrack;
 416   SortGlobalTracks(tracks,2);
 417   innertrack = tracks[0];
 418   outertrack = tracks[1];
 419
 420   x[0] = innertrack->GetFirstPointX();
 421   x[1] = innertrack->GetLastPointX();
 422   x[2] = outertrack->GetFirstPointX();
 423   x[3] = outertrack->GetLastPointX();
 424
 425   y[0] = innertrack->GetFirstPointY();
 426   y[1] = innertrack->GetLastPointY();
 427   y[2] = outertrack->GetFirstPointY();
 428   y[3] = outertrack->GetLastPointY();
 429
 430   z[0] = innertrack->GetFirstPointZ();
 431   z[1] = innertrack->GetLastPointZ();
 432   z[2] = outertrack->GetFirstPointZ();
 433   z[3] = outertrack->GetLastPointZ();
 434
 435
 436   outertrack->CalculatePoint(x[0]);
 437   if(!outertrack->IsPoint()) return diff;
 438   dy[0] = fabs(y[0] - outertrack->GetPointY());
 439   dz[0] = fabs(z[0] - outertrack->GetPointZ());
 440
 441   outertrack->CalculatePoint(x[1]);
 442   if(!outertrack->IsPoint()) return diff;
 443   dy[1] = fabs(y[1] - outertrack->GetPointY());
 444   dz[1] = fabs(z[1] - outertrack->GetPointZ());
 445
 446   innertrack->CalculatePoint(x[2]);
 447   if(!innertrack->IsPoint()) return diff;
 448   dy[2] = fabs(y[2] - innertrack->GetPointY());
 449   dz[2] = fabs(z[2] - innertrack->GetPointZ());
 450
 451   innertrack->CalculatePoint(x[3]);
 452   if(!innertrack->IsPoint()) return diff;
 453   dy[3] = fabs(y[3] - innertrack->GetPointY());
 454   dz[3] = fabs(z[3] - innertrack->GetPointZ());
 455
 456   diff=0;
 457   for(Int_t i=0;i<4;i++)
 458     diff+=sqrt(dy[i]*dy[i]+dz[i]*dz[i]);
 459   return diff;
 460 }
 461
 462 void AliHLTTPCMerger::PrintDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
 463 {
 464   // print difference
 465   if(!innertrack->IsPoint()||!outertrack->IsPoint())
 466     {
 467       LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::PrintDiff","No Points")<<ENDLOG;
 468       //cerr<<"AliHLTTPCMerger::PrintDiff: No Points"<<endl;
 469       //cerr<<"---------------------------"<<endl;
 470       return;
 471     }
 472
 473   Double_t dx = innertrack->GetPointX()-outertrack->GetPointX();
 474   Double_t dy = innertrack->GetPointY()-outertrack->GetPointY();
 475   Double_t dz = innertrack->GetPointZ()-outertrack->GetPointZ();
 476   Double_t dk = innertrack->GetKappa()-outertrack->GetKappa();
 477   Double_t dpsi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
 478   if(dpsi>AliHLTTPCTransform::Pi()) dpsi-=AliHLTTPCTransform::TwoPi();
 479   else if(dpsi<-AliHLTTPCTransform::Pi())dpsi+=AliHLTTPCTransform::TwoPi();
 480   //Double_t dpsi = GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi());
 481   Double_t dtgl= innertrack->GetTgl()-outertrack->GetTgl();
 482   Double_t dq =innertrack->GetCharge()-outertrack->GetCharge();
 483
 484   LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::PrintDiff","Points") <<"dx: "<<dx<<" dy: "<<dy<<" dz: "<<dz<<" dk: "<<dk<<" dpsi: "<<dpsi<<" dtgl: "<<dtgl<<" dq: "<<dq<<ENDLOG;
 485   //fprintf(stderr,"dx: %4f dy: %4f dz: %4f dk: %4f dpsi: %4f dtgl: %4f dq: %4f\n",dx,dy,dz,dk,dpsi,dtgl,dq);
 486   //cerr<<"---------------------------"<<endl;
 487
 488 }
 489
 490 void AliHLTTPCMerger::Print()
 491 {
 492   // print some infos
 493   for(Int_t i=0; i<fNIn; i++)
 494     {
 495       AliHLTTPCTrackArray *ttt= GetInTracks(i);
 496       for(Int_t j =0;j<ttt->GetNTracks();j++)
 497         {
 498           AliHLTTPCTrack *track=ttt->GetCheckedTrack(j);
 499           if(!track) continue;
 500           track->CalculateHelix();
 501           //      Double_t angle = atan2(track->GetLastPointY(),track->GetLastPointX());
 502           //      if(angle<0) angle+=AliHLTTPCTransform::Pi();
 503           if(track->CalculatePoint(135))
 504             //      if(!track->CalculateEdgePoint(angle)) cerr<<"**************"<<endl;
 505             //      if(track->CalculatePoint(track->GetLastPointX()))
 506             //      if(track->CalculatePoint(0))
 507             {
 508               //      PrintTrack(track);
 509               //      track->CalculateReferencePoint(AliHLTTPCTransform::Pi()/180.);
 510               track->CalculateReferencePoint(0.001);
 511               Float_t dx=(float)track->GetPointX()-track->GetPointX();
 512               Float_t dy=(float)track->GetPointY()-track->GetPointY();
 513               Float_t dz=(float)track->GetPointZ()-track->GetPointZ();
 514               LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::Print","RefPoint") <<"npt: "<<track->GetNHits()<<" dx: "<<dx<<" dy: "<<dy<<" dz: "<<dz<<ENDLOG;
 515
 516               //fprintf(stderr,"npt: %3d dx: %8.5f dy: %8.5f dz: %8.5f\n",track->GetNHits(),dx,dy,dz);
 517               //cerr<<"---------------------------"<<endl;
 518             }
 519         }
 520     }
 521 }
 522
 523 void AliHLTTPCMerger::PrintTrack(AliHLTTPCTrack *track)
 524 {
 525   //print track info
 526   fprintf(stderr,"npt: %3d pt: %.2f psi: %.2f tgl: %5.2f q: %2d\n",
 527           track->GetNHits(),track->GetPt(),track->GetPsi(),
 528           track->GetTgl(),track->GetCharge());
 529   fprintf(stderr,
 530           "x1: %6.2f y1: %6.2f z1: %6.2f xl: %6.2f yl: %6.2f zl: %6.2f\n",
 531           track->GetFirstPointX(),track->GetFirstPointY(),track->GetFirstPointZ(),
 532           track->GetLastPointX(),track->GetLastPointY(),track->GetLastPointZ());
 533   if(track->IsPoint())
 534     {
 535       fprintf(stderr,
 536               "R: %.2f Xc: %.2f Yc: %.2f Xp: %.2f Yp: %.2f Zp: %.2f Psip: %.2f\n",
 537               track->GetRadius(),track->GetCenterX(),track->GetCenterY(),
 538               track->GetPointX(),track->GetPointY(),track->GetPointZ(),
 539               track->GetPointPsi());
 540     }
 541 }