STEER/AliESDtrack.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 //           Implementation of the ESD track class
  17 //   ESD = Event Summary Data
  18 //   This is the class to deal with during the phisical analysis of data
  19 //      Origin: Iouri Belikov, CERN
  20 //      e-mail: Jouri.Belikov@cern.ch
  21 //-----------------------------------------------------------------
  22
  23 #include "TMath.h"
  24
  25 #include "AliESDtrack.h"
  26 #include "AliKalmanTrack.h"
  27
  28 ClassImp(AliESDtrack)
  29
  30 //_______________________________________________________________________
  31 AliESDtrack::AliESDtrack() :
  32 fFlags(0),
  33 fLabel(0),
  34 fTrackLength(0),
  35 fStopVertex(0),
  36 fRalpha(0),
  37 fRx(0),
  38 fCalpha(0),
  39 fCx(0),
  40 fCchi2(1e10),
  41 fIalpha(0),
  42 fIx(0),
  43 fOalpha(0),
  44 fOx(0),
  45 fITSchi2(0),
  46 fITSncls(0),
  47 fITSsignal(0),
  48 fTPCchi2(0),
  49 fTPCncls(0),
  50 fTPCClusterMap(159),//number of padrows
  51 fTPCsignal(0),
  52 fTRDchi2(0),
  53 fTRDncls(0),
  54 fTRDsignal(0),
  55 fTOFchi2(0),
  56 fTOFindex(0),
  57 fTOFsignal(-1),
  58 fPHOSsignal(-1),
  59 fRICHsignal(-1)
  60 {
  61   //
  62   // The default ESD constructor
  63   //
  64   for (Int_t i=0; i<kSPECIES; i++) {
  65     fTrackTime[i]=0.;
  66     fR[i]=1.;
  67     fITSr[i]=1.;
  68     fTPCr[i]=1.;
  69     fTRDr[i]=1.;
  70     fTOFr[i]=1.;
  71     fRICHr[i]=1.;
  72   }
  73
  74   for (Int_t i=0; i<kSPECIESN; i++)
  75     fPHOSr[i]= 1.;
  76
  77   fPHOSpos[0]=fPHOSpos[1]=fPHOSpos[2]=0.;
  78   Int_t i;
  79   for (i=0; i<5; i++)  { fRp[i]=0.; fCp[i]=0.; fIp[i]=0.; fOp[i]=0.;}
  80   for (i=0; i<15; i++) { fRc[i]=0.; fCc[i]=0.; fIc[i]=0.; fOc[i]=0.;   }
  81   for (i=0; i<6; i++)  { fITSindex[i]=0; }
  82   for (i=0; i<180; i++){ fTPCindex[i]=0; }
  83   for (i=0; i<90; i++) { fTRDindex[i]=0; }
  84   fTPCLabel = 0;
  85   fTRDLabel = 0;
  86   fITSLabel = 0;
  87
  88 }
  89
  90 //_______________________________________________________________________
  91 Double_t AliESDtrack::GetMass() const {
  92   // Returns the mass of the most probable particle type
  93   Float_t max=0.;
  94   Int_t k=-1;
  95   for (Int_t i=0; i<kSPECIES; i++) {
  96     if (fR[i]>max) {k=i; max=fR[i];}
  97   }
  98   if (k==0) return 0.00051;
  99   if (k==1) return 0.10566;
 100   if (k==2||k==-1) return 0.13957;
 101   if (k==3) return 0.49368;
 102   if (k==4) return 0.93827;
 103   Warning("GetMass()","Undefined mass !");
 104   return 0.13957;
 105 }
 106
 107 //_______________________________________________________________________
 108 Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
 109   //
 110   // This function updates track's running parameters
 111   //
 112   SetStatus(flags);
 113   fLabel=t->GetLabel();
 114
 115   if (t->IsStartedTimeIntegral()) {
 116     SetStatus(kTIME);
 117     Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
 118     SetIntegratedLength(t->GetIntegratedLength());
 119   }
 120
 121   fRalpha=t->GetAlpha();
 122   t->GetExternalParameters(fRx,fRp);
 123   t->GetExternalCovariance(fRc);
 124
 125   switch (flags) {
 126
 127   case kITSin: case kITSout: case kITSrefit:
 128     fITSncls=t->GetNumberOfClusters();
 129     fITSchi2=t->GetChi2();
 130     for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
 131     fITSsignal=t->GetPIDsignal();
 132     fITSLabel = t->GetLabel();
 133     fITSFakeRatio = t->GetFakeRatio();
 134     break;
 135
 136   case kTPCin: case kTPCrefit:
 137     fTPCLabel = t->GetLabel();
 138     fIalpha=fRalpha;
 139     fIx=fRx;
 140     {
 141       Int_t i;
 142       for (i=0; i<5; i++) fIp[i]=fRp[i];
 143       for (i=0; i<15;i++) fIc[i]=fRc[i];
 144     }
 145   case kTPCout:
 146
 147     fTPCncls=t->GetNumberOfClusters();
 148     fTPCchi2=t->GetChi2();
 149
 150      {//prevrow must be declared in separate namespace, otherwise compiler cries:
 151       //"jump to case label crosses initialization of `Int_t prevrow'"
 152        Int_t prevrow = -1;
 153        //       for (Int_t i=0;i<fTPCncls;i++)
 154        for (Int_t i=0;i<160;i++)
 155         {
 156           fTPCindex[i]=t->GetClusterIndex(i);
 157
 158           // Piotr's Cluster Map for HBT
 159           // ### please change accordingly if cluster array is changing
 160           // to "New TPC Tracking" style (with gaps in array)
 161           Int_t idx = fTPCindex[i];
 162           Int_t sect = (idx&0xff000000)>>24;
 163           Int_t row = (idx&0x00ff0000)>>16;
 164           if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
 165
 166           fTPCClusterMap.SetBitNumber(row,kTRUE);
 167
 168           //Fill the gap between previous row and this row with 0 bits
 169           //In case  ###  pleas change it as well - just set bit 0 in case there
 170           //is no associated clusters for current "i"
 171           if (prevrow < 0)
 172            {
 173              prevrow = row;//if previous bit was not assigned yet == this is the first one
 174            }
 175           else
 176            { //we don't know the order (inner to outer or reverse)
 177              //just to be save in case it is going to change
 178              Int_t n = 0, m = 0;
 179              if (prevrow < row)
 180               {
 181                 n = prevrow;
 182                 m = row;
 183               }
 184              else
 185               {
 186                 n = row;
 187                 m = prevrow;
 188               }
 189
 190              for (Int_t j = n+1; j < m; j++)
 191               {
 192                 fTPCClusterMap.SetBitNumber(j,kFALSE);
 193               }
 194              prevrow = row;
 195            }
 196           // End Of Piotr's Cluster Map for HBT
 197         }
 198      }
 199     fTPCsignal=t->GetPIDsignal();
 200     {Double_t mass=t->GetMass();    // preliminary mass setting
 201     if (mass>0.5) fR[4]=1.;         //        used by
 202     else if (mass<0.4) fR[2]=1.;    // the ITS reconstruction
 203     else fR[3]=1.;}
 204                      //
 205     break;
 206
 207   case kTRDout:
 208     { //requested by the PHOS  ("temporary solution")
 209       Double_t r=460.;
 210       if (t->PropagateTo(r,30.,0.)) {
 211          fOalpha=t->GetAlpha();
 212          t->GetExternalParameters(fOx,fOp);
 213          t->GetExternalCovariance(fOc);
 214       }
 215     }
 216   case kTOFin:
 217     break;
 218   case kTOFout:
 219     break;
 220   case kTRDin: case kTRDrefit:
 221     fTRDLabel = t->GetLabel();
 222
 223     fTRDncls=t->GetNumberOfClusters();
 224     fTRDchi2=t->GetChi2();
 225     for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
 226     fTRDsignal=t->GetPIDsignal();
 227     break;
 228   case kTRDStop:
 229     break;
 230   default:
 231     Error("UpdateTrackParams()","Wrong flag !\n");
 232     return kFALSE;
 233   }
 234
 235   return kTRUE;
 236 }
 237
 238 //_______________________________________________________________________
 239 void
 240 AliESDtrack::SetConstrainedTrackParams(AliKalmanTrack *t, Double_t chi2) {
 241   //
 242   // This function sets the constrained track parameters
 243   //
 244   fCalpha=t->GetAlpha();
 245   t->GetExternalParameters(fCx,fCp);
 246   t->GetExternalCovariance(fCc);
 247   fCchi2=chi2;
 248 }
 249
 250
 251 //_______________________________________________________________________
 252 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
 253   //---------------------------------------------------------------------
 254   // This function returns external representation of the track parameters
 255   //---------------------------------------------------------------------
 256   x=fRx;
 257   for (Int_t i=0; i<5; i++) p[i]=fRp[i];
 258 }
 259 //_______________________________________________________________________
 260 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
 261   //---------------------------------------------------------------------
 262   // This function returns external representation of the cov. matrix
 263   //---------------------------------------------------------------------
 264   for (Int_t i=0; i<15; i++) cov[i]=fRc[i];
 265 }
 266
 267
 268 //_______________________________________________________________________
 269 void
 270 AliESDtrack::GetConstrainedExternalParameters(Double_t &x, Double_t p[5])const{
 271   //---------------------------------------------------------------------
 272   // This function returns the constrained external track parameters
 273   //---------------------------------------------------------------------
 274   x=fCx;
 275   for (Int_t i=0; i<5; i++) p[i]=fCp[i];
 276 }
 277 //_______________________________________________________________________
 278 void
 279 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
 280   //---------------------------------------------------------------------
 281   // This function returns the constrained external cov. matrix
 282   //---------------------------------------------------------------------
 283   for (Int_t i=0; i<15; i++) c[i]=fCc[i];
 284 }
 285
 286
 287 Double_t AliESDtrack::GetP() const {
 288   //---------------------------------------------------------------------
 289   // This function returns the track momentum
 290   //---------------------------------------------------------------------
 291   if (TMath::Abs(fRp[4])<=0) return 0;
 292   Double_t pt=1./TMath::Abs(fRp[4]);
 293   return pt*TMath::Sqrt(1.+ fRp[3]*fRp[3]);
 294 }
 295
 296 void AliESDtrack::GetConstrainedPxPyPz(Double_t *p) const {
 297   //---------------------------------------------------------------------
 298   // This function returns the constrained global track momentum components
 299   //---------------------------------------------------------------------
 300   if (TMath::Abs(fCp[4])<=0) {
 301     p[0]=p[1]=p[2]=0;
 302     return;
 303   }
 304   Double_t phi=TMath::ASin(fCp[2]) + fCalpha;
 305   Double_t pt=1./TMath::Abs(fCp[4]);
 306   p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fCp[3];
 307 }
 308 void AliESDtrack::GetConstrainedXYZ(Double_t *xyz) const {
 309   //---------------------------------------------------------------------
 310   // This function returns the global track position
 311   //---------------------------------------------------------------------
 312   Double_t phi=TMath::ATan2(fCp[0],fCx) + fCalpha;
 313   Double_t r=TMath::Sqrt(fCx*fCx + fCp[0]*fCp[0]);
 314   xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fCp[1];
 315 }
 316
 317 void AliESDtrack::GetPxPyPz(Double_t *p) const {
 318   //---------------------------------------------------------------------
 319   // This function returns the global track momentum components
 320   //---------------------------------------------------------------------
 321   if (TMath::Abs(fRp[4])<=0) {
 322     p[0]=p[1]=p[2]=0;
 323     return;
 324   }
 325   Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
 326   Double_t pt=1./TMath::Abs(fRp[4]);
 327   p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fRp[3];
 328 }
 329 void AliESDtrack::GetXYZ(Double_t *xyz) const {
 330   //---------------------------------------------------------------------
 331   // This function returns the global track position
 332   //---------------------------------------------------------------------
 333   Double_t phi=TMath::ATan2(fRp[0],fRx) + fRalpha;
 334   Double_t r=TMath::Sqrt(fRx*fRx + fRp[0]*fRp[0]);
 335   xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fRp[1];
 336 }
 337
 338
 339 void AliESDtrack::GetInnerPxPyPz(Double_t *p) const {
 340   //---------------------------------------------------------------------
 341   // This function returns the global track momentum components
 342   // af the entrance of the TPC
 343   //---------------------------------------------------------------------
 344   if (fIx==0) {p[0]=p[1]=p[2]=0.; return;}
 345   Double_t phi=TMath::ASin(fIp[2]) + fIalpha;
 346   Double_t pt=1./TMath::Abs(fIp[4]);
 347   p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fIp[3];
 348 }
 349
 350 void AliESDtrack::GetInnerXYZ(Double_t *xyz) const {
 351   //---------------------------------------------------------------------
 352   // This function returns the global track position
 353   // af the entrance of the TPC
 354   //---------------------------------------------------------------------
 355   if (fIx==0) {xyz[0]=xyz[1]=xyz[2]=0.; return;}
 356   Double_t phi=TMath::ATan2(fIp[0],fIx) + fIalpha;
 357   Double_t r=TMath::Sqrt(fIx*fIx + fIp[0]*fIp[0]);
 358   xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fIp[1];
 359 }
 360
 361 void AliESDtrack::GetInnerExternalParameters(Double_t &x, Double_t p[5]) const
 362 {
 363   //skowron
 364  //---------------------------------------------------------------------
 365   // This function returns external representation of the track parameters at Inner Layer of TPC
 366   //---------------------------------------------------------------------
 367   x=fIx;
 368   for (Int_t i=0; i<5; i++) p[i]=fIp[i];
 369 }
 370 void AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const
 371 {
 372  //skowron
 373  //---------------------------------------------------------------------
 374  // This function returns external representation of the cov. matrix at Inner Layer of TPC
 375  //---------------------------------------------------------------------
 376  for (Int_t i=0; i<15; i++) cov[i]=fIc[i];
 377
 378 }
 379
 380 void AliESDtrack::GetOuterPxPyPz(Double_t *p) const {
 381   //---------------------------------------------------------------------
 382   // This function returns the global track momentum components
 383   // af the radius of the PHOS
 384   //---------------------------------------------------------------------
 385   if (fOx==0) {p[0]=p[1]=p[2]=0.; return;}
 386   Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
 387   Double_t pt=1./TMath::Abs(fOp[4]);
 388   p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fOp[3];
 389 }
 390
 391 void AliESDtrack::GetOuterXYZ(Double_t *xyz) const {
 392   //---------------------------------------------------------------------
 393   // This function returns the global track position
 394   // af the radius of the PHOS
 395   //---------------------------------------------------------------------
 396   if (fOx==0) {xyz[0]=xyz[1]=xyz[2]=0.; return;}
 397   Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
 398   Double_t r=TMath::Sqrt(fOx*fOx + fOp[0]*fOp[0]);
 399   xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fOp[1];
 400 }
 401
 402 //_______________________________________________________________________
 403 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
 404   // Returns the array with integrated times for each particle hypothesis
 405   for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
 406 }
 407
 408 //_______________________________________________________________________
 409 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
 410   // Sets the array with integrated times for each particle hypotesis
 411   for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
 412 }
 413
 414 //_______________________________________________________________________
 415 void AliESDtrack::SetITSpid(const Double_t *p) {
 416   // Sets values for the probability of each particle type (in ITS)
 417   for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
 418   SetStatus(AliESDtrack::kITSpid);
 419 }
 420
 421 void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
 422   for (Int_t i=0; i<6; i++) fITSchi2MIP[i]=chi2mip[i];
 423 }
 424 //_______________________________________________________________________
 425 void AliESDtrack::GetITSpid(Double_t *p) const {
 426   // Gets the probability of each particle type (in ITS)
 427   for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
 428 }
 429
 430 //_______________________________________________________________________
 431 Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
 432   //---------------------------------------------------------------------
 433   // This function returns indices of the assgined ITS clusters
 434   //---------------------------------------------------------------------
 435   for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
 436   return fITSncls;
 437 }
 438
 439 //_______________________________________________________________________
 440 Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
 441   //---------------------------------------------------------------------
 442   // This function returns indices of the assgined ITS clusters
 443   //---------------------------------------------------------------------
 444   if (idx!=0)
 445     for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i];  // MI I prefer some constant
 446   return fTPCncls;
 447 }
 448
 449 //_______________________________________________________________________
 450 void AliESDtrack::SetTPCpid(const Double_t *p) {
 451   // Sets values for the probability of each particle type (in TPC)
 452   for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
 453   SetStatus(AliESDtrack::kTPCpid);
 454 }
 455
 456 //_______________________________________________________________________
 457 void AliESDtrack::GetTPCpid(Double_t *p) const {
 458   // Gets the probability of each particle type (in TPC)
 459   for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
 460 }
 461
 462 //_______________________________________________________________________
 463 Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
 464   //---------------------------------------------------------------------
 465   // This function returns indices of the assgined TRD clusters
 466   //---------------------------------------------------------------------
 467   if (idx!=0)
 468     for (Int_t i=0; i<90; i++) idx[i]=fTRDindex[i];  // MI I prefer some constant
 469   return fTRDncls;
 470 }
 471
 472 //_______________________________________________________________________
 473 void AliESDtrack::SetTRDpid(const Double_t *p) {
 474   // Sets values for the probability of each particle type (in TRD)
 475   for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
 476   SetStatus(AliESDtrack::kTRDpid);
 477 }
 478
 479 //_______________________________________________________________________
 480 void AliESDtrack::GetTRDpid(Double_t *p) const {
 481   // Gets the probability of each particle type (in TRD)
 482   for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
 483 }
 484
 485 //_______________________________________________________________________
 486 void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
 487 {
 488   // Sets the probability of particle type iSpecies to p (in TRD)
 489   fTRDr[iSpecies] = p;
 490 }
 491
 492 Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
 493 {
 494   // Returns the probability of particle type iSpecies (in TRD)
 495   return fTRDr[iSpecies];
 496 }
 497
 498 //_______________________________________________________________________
 499 void AliESDtrack::SetTOFpid(const Double_t *p) {
 500   // Sets the probability of each particle type (in TOF)
 501   for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
 502   SetStatus(AliESDtrack::kTOFpid);
 503 }
 504
 505 //_______________________________________________________________________
 506 void AliESDtrack::GetTOFpid(Double_t *p) const {
 507   // Gets probabilities of each particle type (in TOF)
 508   for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
 509 }
 510
 511
 512
 513 //_______________________________________________________________________
 514 void AliESDtrack::SetPHOSpid(const Double_t *p) {
 515   // Sets the probability of each particle type (in PHOS)
 516   for (Int_t i=0; i<kSPECIESN; i++) fPHOSr[i]=p[i];
 517   SetStatus(AliESDtrack::kPHOSpid);
 518 }
 519
 520 //_______________________________________________________________________
 521 void AliESDtrack::GetPHOSpid(Double_t *p) const {
 522   // Gets probabilities of each particle type (in PHOS)
 523   for (Int_t i=0; i<kSPECIESN; i++) p[i]=fPHOSr[i];
 524 }
 525
 526
 527 //_______________________________________________________________________
 528 void AliESDtrack::SetRICHpid(const Double_t *p) {
 529   // Sets the probability of each particle type (in RICH)
 530   for (Int_t i=0; i<kSPECIES; i++) fRICHr[i]=p[i];
 531   SetStatus(AliESDtrack::kRICHpid);
 532 }
 533
 534 //_______________________________________________________________________
 535 void AliESDtrack::GetRICHpid(Double_t *p) const {
 536   // Gets probabilities of each particle type (in RICH)
 537   for (Int_t i=0; i<kSPECIES; i++) p[i]=fRICHr[i];
 538 }
 539
 540
 541
 542 //_______________________________________________________________________
 543 void AliESDtrack::SetESDpid(const Double_t *p) {
 544   // Sets the probability of each particle type for the ESD track
 545   for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
 546   SetStatus(AliESDtrack::kESDpid);
 547 }
 548
 549 //_______________________________________________________________________
 550 void AliESDtrack::GetESDpid(Double_t *p) const {
 551   // Gets probability of each particle type for the ESD track
 552   for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
 553 }
 554
 555 //_______________________________________________________________________
 556 void AliESDtrack::Print(Option_t *) const {
 557   // Prints info on the track
 558
 559   Info("Print","Track info") ;
 560   Double_t p[kSPECIESN] ;
 561   Int_t index = 0 ;
 562   if( IsOn(kITSpid) ){
 563     printf("From ITS: ") ;
 564     GetITSpid(p) ;
 565     for(index = 0 ; index < kSPECIES; index++)
 566       printf("%f, ", p[index]) ;
 567     printf("\n           signal = %f\n", GetITSsignal()) ;
 568   }
 569   if( IsOn(kTPCpid) ){
 570     printf("From TPC: ") ;
 571     GetTPCpid(p) ;
 572     for(index = 0 ; index < kSPECIES; index++)
 573       printf("%f, ", p[index]) ;
 574     printf("\n           signal = %f\n", GetTPCsignal()) ;
 575   }
 576   if( IsOn(kTRDpid) ){
 577     printf("From TRD: ") ;
 578     GetTRDpid(p) ;
 579     for(index = 0 ; index < kSPECIES; index++)
 580       printf("%f, ", p[index]) ;
 581     printf("\n           signal = %f\n", GetTRDsignal()) ;
 582   }
 583   if( IsOn(kTOFpid) ){
 584     printf("From TOF: ") ;
 585     GetTOFpid(p) ;
 586     for(index = 0 ; index < kSPECIES; index++)
 587       printf("%f, ", p[index]) ;
 588     printf("\n           signal = %f\n", GetTOFsignal()) ;
 589   }
 590   if( IsOn(kRICHpid) ){
 591     printf("From TOF: ") ;
 592     GetRICHpid(p) ;
 593     for(index = 0 ; index < kSPECIES; index++)
 594       printf("%f, ", p[index]) ;
 595     printf("\n           signal = %f\n", GetRICHsignal()) ;
 596   }
 597   if( IsOn(kPHOSpid) ){
 598     printf("From PHOS: ") ;
 599     GetPHOSpid(p) ;
 600     for(index = 0 ; index < kSPECIESN; index++)
 601       printf("%f, ", p[index]) ;
 602     printf("\n           signal = %f\n", GetPHOSsignal()) ;
 603   }
 604 }