HLT/TPCLib/AliHLTTPCTrackArray.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan
   3
   4 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
   5 //*-- Copyright &copy ALICE HLT Group
   6
   7 #include "AliHLTTPCLogging.h"
   8 #include "AliHLTTPCTrackArray.h"
   9 #ifdef INCLUDE_TPC_HOUGH
  10 #include "AliHLTTPCHoughTrack.h"
  11 #endif
  12 #include "AliHLTTPCModelTrack.h"
  13 #include "AliHLTTPCConfMapTrack.h"
  14 #include "AliHLTTPCTrackSegmentData.h"
  15 #include "AliHLTTPCTransform.h"
  16 #include "AliHLTTPCConfMapPoint.h"
  17
  18 /** \class AliHLTTPCTrackArray
  19 <pre>
  20 //_____________________________________________________________
  21 // AliHLTTPCTrackArray
  22 //
  23 // Track array class
  24 //
  25 </pre>
  26 */
  27
  28 #if __GNUC__ >= 3
  29 using namespace std;
  30 #endif
  31
  32 ClassImp(AliHLTTPCTrackArray)
  33
  34 AliHLTTPCTrackArray::AliHLTTPCTrackArray()
  35 {
  36   //Default constructor
  37   fSize = 0;
  38   fNTracks=0;
  39   fNAbsent=0;
  40   fTrackType='t';
  41   SetSize();
  42 }
  43
  44
  45 AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
  46 {
  47   //Constructor.
  48   fSize = 0;
  49   fNTracks=0;
  50   fNAbsent=0;
  51   fTrackType='t';
  52   SetSize(ntrack);
  53 }
  54
  55 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
  56 {
  57   //Constructor.
  58   fSize = 0;
  59   fNTracks=0;
  60   fNAbsent=0;
  61   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  62   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
  63 #ifdef INCLUDE_TPC_HOUGH
  64   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
  65 #endif
  66   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
  67   SetSize(ntrack);
  68 }
  69
  70 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
  71 {
  72   //Constructor.
  73   fSize = 0;
  74   fNTracks=0;
  75   fNAbsent=0;
  76   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  77   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
  78 #ifdef INCLUDE_TPC_HOUGH
  79   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
  80 #endif
  81   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
  82   SetSize();
  83 }
  84
  85 AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
  86 {
  87   //Destructor
  88   DeleteArray();
  89 }
  90
  91
  92 AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
  93 {
  94   //next track in array
  95   if(fNTracks<fSize) return fTrack[fNTracks++];
  96   SetSize(fSize+100);
  97    return fTrack[fNTracks++];
  98 }
  99
 100 void AliHLTTPCTrackArray::DeleteArray()
 101 {
 102   //delete array
 103   for(Int_t i=0; i<fSize;i++)
 104     delete fTrack[i];
 105   delete[] fIsPresent;
 106   delete[] fTrack;
 107 }
 108
 109 Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
 110 {
 111   //set size
 112   if(newsize<=fSize) return kFALSE; //shrink comes later!!
 113   if(!fSize){
 114     fSize = newsize;
 115     fTrack = new AliHLTTPCTrack*[fSize];
 116     fIsPresent = new Bool_t[fSize];
 117     switch(fTrackType){
 118       case 't':
 119         for(Int_t i=0;i<fSize;i++){
 120           fTrack[i]   = new AliHLTTPCTrack();
 121           fIsPresent[i] = kTRUE;
 122         }
 123         break;
 124       case 'c':
 125         for(Int_t i=0;i<fSize;i++){
 126           fTrack[i]   = new AliHLTTPCConfMapTrack();
 127           fIsPresent[i] = kTRUE;
 128         }
 129         break;
 130 #ifdef INCLUDE_TPC_HOUGH
 131       case 'h':
 132         for(Int_t i=0;i<fSize;i++){
 133           fTrack[i]   = new AliHLTTPCHoughTrack();
 134           fIsPresent[i] = kTRUE;
 135         }
 136         break;
 137 #endif
 138        case 'm':
 139         for(Int_t i=0;i<fSize;i++){
 140           fTrack[i]   = new AliHLTTPCModelTrack();
 141           fIsPresent[i] = kTRUE;
 142         }
 143         break;
 144       default:
 145         return kFALSE;
 146     }
 147     return kTRUE;
 148   }
 149   AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
 150   Bool_t *pre = new Bool_t[fSize];
 151   for(Int_t i=0; i<fSize;i++){
 152     tmp[i] = fTrack[i];
 153     pre[i] = fIsPresent[i];
 154   }
 155   delete[]  fTrack;
 156   delete[] fIsPresent;
 157   fTrack =  new AliHLTTPCTrack*[newsize];
 158   fIsPresent = new Bool_t[newsize];
 159   for(Int_t i=0; i<fSize;i++){
 160     fTrack[i]   = tmp[i];
 161     fIsPresent[i] = pre[i];
 162   }
 163   delete[] tmp;
 164   delete[] pre;
 165   switch(fTrackType){
 166     case 't':
 167       for(Int_t i=fSize;i<newsize;i++){
 168         fTrack[i]   = new AliHLTTPCTrack();
 169         fIsPresent[i] = kTRUE;
 170       }
 171       break;
 172     case 'c':
 173       for(Int_t i=fSize;i<newsize;i++){
 174         fTrack[i]   = new AliHLTTPCConfMapTrack();
 175         fIsPresent[i] = kTRUE;
 176       }
 177       break;
 178 #ifdef INCLUDE_TPC_HOUGH
 179     case 'h':
 180       for(Int_t i=fSize;i<newsize;i++){
 181         fTrack[i]   = new AliHLTTPCHoughTrack();
 182         fIsPresent[i] = kTRUE;
 183       }
 184       break;
 185 #endif
 186     case 'm':
 187       for(Int_t i=fSize;i<newsize;i++){
 188         fTrack[i]   = new AliHLTTPCModelTrack();
 189         fIsPresent[i] = kTRUE;
 190       }
 191       break;
 192     default:
 193       return kFALSE;
 194   }
 195   fSize = newsize;
 196   return kTRUE;
 197 }
 198
 199 void AliHLTTPCTrackArray::Reset()
 200 {
 201   //reset
 202   fNTracks=0;
 203   fNAbsent=0;
 204   for(Int_t i=0; i<fSize;i++)
 205     fIsPresent[i] = kTRUE;
 206 }
 207
 208 void AliHLTTPCTrackArray::Remove(Int_t track)
 209 {
 210   //remove track
 211   if(fIsPresent[track]){
 212     fIsPresent[track]=kFALSE;
 213     fNAbsent++;
 214   }
 215 }
 216
 217 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr){
 218   //Read tracks from shared memory (or memory)
 219   AliHLTTPCTrackSegmentData *trs = tr;
 220    for(Int_t i=0; i<ntracks; i++){
 221     AliHLTTPCTrack *track = NextTrack();
 222     track->SetPt(trs->fPt);
 223     track->SetPsi(trs->fPsi);
 224     track->SetTgl(trs->fTgl);
 225     track->SetPterr(trs->fPterr);
 226     track->SetPsierr(trs->fPsierr);
 227     track->SetTglerr(trs->fTglerr);
 228     track->SetNHits(trs->fNPoints);
 229     track->SetCharge(trs->fCharge);
 230     track->SetFirstPoint(trs->fX,trs->fY,trs->fZ);
 231     track->SetLastPoint(trs->fLastX,trs->fLastY,trs->fLastZ);
 232     track->SetHits( trs->fNPoints, trs->fPointIDs );
 233 #ifdef INCLUDE_TPC_HOUGH
 234 #ifdef ROWHOUGHPARAMS
 235     if(GetTrackType()=='h') {
 236       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
 237       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
 238     }
 239     track->SetMCid(trs->fTrackID);
 240     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
 241     track->SetSector(trs->fSector);
 242     track->SetPID(trs->fPID);
 243 #endif
 244 #endif // INCLUDE_TPC_HOUGH
 245     UChar_t *tmpP = (UChar_t*)trs;
 246     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 247     trs = (AliHLTTPCTrackSegmentData*)tmpP;
 248   }
 249 }
 250
 251 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice)
 252 {
 253   //Read tracks from shared memory (or memory)
 254   AliHLTTPCTrackSegmentData *trs = tr;
 255   for(Int_t i=0; i<ntracks; i++){
 256     AliHLTTPCTrack *track = NextTrack();
 257     track->SetPt(trs->fPt);
 258     track->SetPterr(trs->fPterr);
 259     Float_t psi[1];
 260     psi[0]=trs->fPsi;
 261     AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
 262     track->SetPsi(psi[0]);
 263     track->SetTgl(trs->fTgl);
 264     track->SetPsierr(trs->fPsierr);
 265     track->SetTglerr(trs->fTglerr);
 266     track->SetNHits(trs->fNPoints);
 267     track->SetCharge(trs->fCharge);
 268     Float_t first[3];
 269     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
 270     AliHLTTPCTransform::Local2Global(first,slice);
 271     track->SetFirstPoint(first[0],first[1],first[2]);
 272     Float_t last[3];
 273     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
 274     AliHLTTPCTransform::Local2Global(last,slice);
 275     track->SetLastPoint(last[0],last[1],last[2]);
 276     track->SetHits( trs->fNPoints, trs->fPointIDs );
 277 // BEGINN ############################################## MODIFIY JMT
 278     track->SetSector(slice);
 279     track->CalculateHelix();
 280 // END ################################################# MODIFIY JMT
 281 #ifdef INCLUDE_TPC_HOUGH
 282 #ifdef ROWHOUGHPARAMS
 283     if(GetTrackType()=='h') {
 284       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
 285       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
 286     }
 287     track->SetMCid(trs->fTrackID);
 288     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
 289     track->SetSector(slice);
 290     track->SetPID(trs->fPID);
 291 #endif
 292 #endif // INCLUDE_TPC_HOUGH
 293     UChar_t *tmpP = (UChar_t*)trs;
 294     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 295     trs = (AliHLTTPCTrackSegmentData*)tmpP;
 296   }
 297 }
 298
 299 UInt_t AliHLTTPCTrackArray::GetOutSize()
 300 {
 301   //get size for IO
 302   UInt_t count = GetOutCount();   //use only present tracks
 303   UInt_t tHits = 0;
 304   for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
 305     AliHLTTPCTrack *track = GetCheckedTrack(i);  //use only present tracks
 306     if(track)                                       //use only present tracks
 307       tHits += track->GetNHits();
 308   }
 309
 310   //calculate size of track
 311   return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
 312 }
 313
 314 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
 315 {
 316   //write tracks
 317   ntracks = GetOutCount();
 318   return WriteTracks(tr);
 319 }
 320
 321 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
 322 {
 323   //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
 324   AliHLTTPCTrackSegmentData *tP = tr;
 325   UInt_t *pP;
 326   UInt_t size = 0;
 327   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 328     AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
 329     if(!track) continue;                           //use only present tracks
 330     tP->fX = track->GetFirstPointX();
 331     tP->fY = track->GetFirstPointY();
 332     tP->fZ = track->GetFirstPointZ();
 333     tP->fPt = track->GetPt();
 334     tP->fPterr = track->GetPterr();
 335     tP->fLastX = track->GetLastPointX();
 336     tP->fLastY = track->GetLastPointY();
 337     tP->fLastZ = track->GetLastPointZ();
 338     tP->fPsi = track->GetPsi();
 339     tP->fTgl = track->GetTgl();
 340     tP->fPsierr = track->GetPsierr();
 341     tP->fTglerr = track->GetTglerr();
 342     tP->fCharge = track->GetCharge();
 343     tP->fNPoints = track->GetNHits();
 344 #ifdef INCLUDE_TPC_HOUGH
 345 #ifdef ROWHOUGHPARAMS
 346     if(GetTrackType()=='h') {
 347       tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
 348       tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
 349       tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
 350       tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
 351       tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
 352     }
 353     tP->fTrackID = track->GetMCid();
 354     tP->fRowRange1 = track->GetFirstRow();
 355     tP->fRowRange2 = track->GetLastRow();
 356     tP->fSector = track->GetSector();
 357     tP->fPID = track->GetPID();
 358 #endif
 359 #endif // INCLUDE_TPC_HOUGH
 360     pP = (UInt_t*)track->GetHitNumbers();
 361     for (UInt_t j=0;j<tP->fNPoints;j++){
 362       tP->fPointIDs[j] = pP[j];
 363     }
 364     Byte_t *tmpP = (Byte_t *)tP;
 365     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 366     size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 367     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 368
 369 // BEGINN ############################################## MODIFIY JMT
 370 //    LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
 371 //    track->Rotate(0,kFALSE);
 372 //    track->Print();
 373 // END ################################################# MODIFIY JMT
 374
 375   }
 376   return size;
 377 }
 378
 379 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
 380 {
 381   // use first and last point objects
 382   AliHLTTPCTrackSegmentData *tP = tr;
 383   UInt_t *pP;
 384   UInt_t size = 0;
 385   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 386     AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
 387     if(!track) continue;                           //use only present tracks
 388     AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
 389     AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
 390     tP->fX = hit->GetX();
 391     tP->fY = hit->GetY();
 392     tP->fZ = hit->GetZ();
 393     tP->fLastX = lastHit->GetX();
 394     tP->fLastY = lastHit->GetY();
 395     tP->fLastZ = lastHit->GetZ();
 396
 397 //    tP->fX = track->GetFirstPointX();
 398 //    tP->fY = track->GetFirstPointY();
 399 //    tP->fZ = track->GetFirstPointZ();
 400     tP->fPt = track->GetPt();
 401     tP->fPterr = track->GetPterr();
 402 //    tP->fLastX = track->GetLastPointX();
 403 //    tP->fLastY = track->GetLastPointY();
 404 //    tP->fLastZ = track->GetLastPointZ();
 405     tP->fPsi = track->GetPsi();
 406     tP->fTgl = track->GetTgl();
 407     tP->fPsierr = track->GetPsierr();
 408     tP->fTglerr = track->GetTglerr();
 409     tP->fCharge = track->GetCharge();
 410 #ifdef INCLUDE_TPC_HOUGH
 411 #ifdef ROWHOUGHPARAMS
 412     tP->fTrackID = track->GetMCid();
 413     tP->fRowRange1 = track->GetFirstRow();
 414     tP->fRowRange2 = track->GetLastRow();
 415     tP->fSector = track->GetSector();
 416     tP->fPID = track->GetPID();
 417 #endif
 418 #endif // INCLUDE_TPC_HOUGH
 419     tP->fNPoints = track->GetNHits();
 420     pP = (UInt_t*)track->GetHitNumbers();
 421     for (UInt_t j=0;j<tP->fNPoints;j++){
 422       tP->fPointIDs[j] = pP[j];
 423     }
 424     Byte_t *tmpP = (Byte_t *)tP;
 425     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 426     size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 427     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 428   }
 429   return size;
 430 }
 431
 432 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
 433 {
 434   //add track to last position
 435   AliHLTTPCTrack *tpt = NextTrack();
 436   tpt->Set(track);
 437
 438 }
 439
 440 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
 441 {
 442   //add tracks
 443   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
 444     {
 445       LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
 446         <<"Bad idea to add tracks of different types"<<ENDLOG;
 447       return;
 448     }
 449   if(fSize < fNTracks+newtrack->GetNPresent())
 450     SetSize(fSize+newtrack->GetSize());
 451   for(Int_t i =0;i<newtrack->GetNTracks();i++){
 452     AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
 453     if(!tpt) continue;
 454     if(remove_old)
 455       newtrack->Remove(i);
 456     AliHLTTPCTrack *track = NextTrack();
 457     track->Set(tpt);
 458     if(slice>=0)
 459       track->Rotate(slice); //Rotate track to global coordinates
 460     /*
 461       AliHLTTPCTrack *track;
 462 #ifdef INCLUDE_TPC_HOUGH
 463       if(GetTrackType()=='h')
 464       track = (AliHLTTPCHoughTrack*)NextTrack();
 465       else
 466 #endif
 467       track = NextTrack();
 468       track->Set(tpt);
 469     */
 470   }
 471 }
 472
 473 void AliHLTTPCTrackArray::Compress()
 474 {
 475   //compress array
 476   if(GetNPresent()==GetNTracks()) return;
 477   AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
 478   Int_t present=0;
 479   Int_t absent=GetNPresent();
 480   for(Int_t i=0;i<GetNTracks();i++){
 481     if(fIsPresent[i]) tmp[present++] = fTrack[i];
 482     else tmp[absent++] = fTrack[i];
 483   }
 484   for(Int_t i=0;i<GetNTracks();i++)
 485     fIsPresent[i]=kTRUE;
 486
 487   //Copy pointers back
 488   for(Int_t i=0; i<GetNTracks();i++){
 489     fTrack[i]=tmp[i];
 490   }
 491
 492   delete[] tmp;
 493
 494   fNTracks = GetNPresent();
 495   fNAbsent = 0;
 496 }
 497
 498 void AliHLTTPCTrackArray::QSort()
 499 {
 500   // compress and sort
 501   Compress();
 502   QSort(fTrack,0,fNTracks);
 503 }
 504
 505 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
 506 {
 507    // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
 508    // Uses TrackCompare() to compare objects.
 509    // Thanks to Root!
 510
 511    static AliHLTTPCTrack *tmp;
 512    static int i;           // "static" to save stack space
 513    int j;
 514
 515    while (last - first > 1) {
 516       i = first;
 517       j = last;
 518       for (;;) {
 519         while (++i < last && TrackCompare(a[i], a[first]) < 0)
 520           ;
 521         while (--j > first && TrackCompare(a[j], a[first]) > 0)
 522           ;
 523          if (i >= j)
 524             break;
 525
 526          tmp  = a[i];
 527          a[i] = a[j];
 528          a[j] = tmp;
 529       }
 530       if (j == first) {
 531          ++first;
 532          continue;
 533       }
 534       tmp = a[first];
 535       a[first] = a[j];
 536       a[j] = tmp;
 537       if (j - first < last - (j + 1)) {
 538          QSort(a, first, j);
 539          first = j + 1;   // QSort(j + 1, last);
 540       } else {
 541          QSort(a, j + 1, last);
 542          last = j;        // QSort(first, j);
 543       }
 544    }
 545 }
 546
 547 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
 548 {
 549    // Compare the two tracks.
 550
 551   return b->Compare(a);
 552
 553   /*
 554 #ifdef INCLUDE_TPC_HOUGH
 555     if(fTrackType=='h')
 556     {
 557     AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
 558     AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
 559     if(tra->GetWeight() < trb->GetWeight()) return 1;
 560     if(tra->GetWeight() > trb->GetWeight()) return -1;
 561     }
 562     else
 563 #endif
 564     {
 565     if(a->GetNHits() < b->GetNHits()) return 1;
 566     if(a->GetNHits() > b->GetNHits()) return -1;
 567     }
 568
 569     return 0;
 570   */
 571 }
 572
 573