ITS/AliITSPid.cxx

   1 //------------------------------------------------------------//
   2 // Class for identification of pions,kaons and protons in ITS //
   3 // Prior particles population (probabilities) are taken from  //
   4 // Hijing event generator.                                   //
   5 //------------------------------------------------------------//
   6 // #include <stdlib.h>
   7 #include "AliITSPid.h"
   8 //#include "TMath.h"
   9 #include <Riostream.h>
  10 #include <TClonesArray.h>
  11 #include <TVector.h>
  12 #include "AliKalmanTrack.h"
  13 #include "AliITSIOTrack.h"
  14 #include "AliITStrackV2.h"
  15 #include <TF1.h>
  16
  17 ClassImp(AliITSPid)
  18
  19
  20 AliITSPid::AliITSPid(const AliITSPid &source) : TObject(source),
  21 fMxtrs(source.fMxtrs),
  22 fTrs(source.fTrs),
  23 fWpi(source.fWpi),
  24 fWk(source.fWk),
  25 fWp(source.fWp),
  26 fRpik(source.fRpik),
  27 fRppi(source.fRppi),
  28 fRpka(source.fRpka),
  29 fRp(source.fRp),
  30 fPcode(source.fPcode),
  31 fSigmin(source.fSigmin),
  32 fSilent(source.fSilent),
  33 fCutKa(source.fCutKa),
  34 fCutPr(source.fCutPr),
  35 fggpi(source.fggpi),
  36 fggka(source.fggka),
  37 fggpr(source.fggpr){
  38     // Copy constructor. This is a function which is not allowed to be
  39
  40
  41 }
  42
  43 //______________________________________________________________________
  44 AliITSPid& AliITSPid::operator=(const AliITSPid& source){
  45   // Assignment operator. This is a function which is not allowed to be
  46   this->~AliITSPid();
  47   new(this) AliITSPid(source);
  48   return *this;
  49 }
  50
  51 //
  52   Float_t AliITSPid::Qtrm(Int_t track) {
  53 //
  54 // This calculates truncated mean signal for given track.
  55 //
  56     TVector q(*( this->GetVec(track)  ));
  57     Int_t ml=(Int_t)q(0);
  58     if(ml<1)return 0.;
  59     if(ml>6)ml=6;
  60     float vf[6];
  61     Int_t nl=0; for(Int_t i=0;i<ml;i++){if(q(i)>fSigmin){vf[nl]=q(i+1);nl++;}}
  62     if(nl==0)return 0.;
  63     switch(nl){
  64       case  1:q(6)=q(1); break;
  65       case  2:q(6)=(q(1)+q(2))/2.; break;
  66       default:
  67         for(int fi=0;fi<2;fi++){
  68           Int_t swap;
  69           do{ swap=0; float qmin=vf[fi];
  70           for(int j=fi+1;j<nl;j++)
  71             if(qmin>vf[j]){qmin=vf[j];vf[j]=vf[fi];vf[fi]=qmin;swap=1;};
  72           }while(swap==1);
  73         }
  74         q(6)= (vf[0]+vf[1])/2.;
  75         break;
  76     }
  77     for(Int_t i=0;i<nl;i++){q(i+1)=vf[i];} this->SetVec(track,q);
  78     return (q(6));
  79 }
  80
  81 Float_t AliITSPid::Qtrm(Float_t qarr[6],Int_t narr) const{
  82 //
  83 //This calculates truncated mean signal for given signal set.
  84 //
  85   Float_t q[6],qm,qmin;
  86   Int_t nl,ml;
  87   if(narr>0&&narr<7){ml=narr;}else{return 0;};
  88   nl=0; for(Int_t i=0;i<ml;i++){if(qarr[i]>fSigmin){q[nl]=qarr[i];nl++;}}
  89   if(nl==0)return 0.;
  90     switch(nl){
  91       case  1:qm=q[0]; break;
  92       case  2:qm=(q[0]+q[1])/2.; break;
  93       default:
  94         Int_t swap;
  95         for(int fi=0;fi<2;fi++){
  96           do{ swap=0; qmin=q[fi];
  97           for(int j=fi+1;j<nl;j++)
  98             if(qmin>q[j]){qmin=q[j];q[j]=q[fi];q[fi]=qmin;swap=1;};
  99           }while(swap==1);
 100         }
 101         qm= (q[0]+q[1])/2.;
 102         break;
 103     }
 104     return qm;
 105 }
 106
 107 Int_t   AliITSPid::Wpik(Float_t pm,Float_t q){
 108   //Calcutates probabilityes of pions and kaons
 109   //Returns particle code for dominant probability.
 110   Double_t par[6];
 111   for(int i=0;i<6;i++){par[i]=fGGpi[i]->Eval(pm);}
 112   fggpi->SetParameters(par);
 113
 114   for(int i=0;i<3;i++){par[i]=fGGka[i]->Eval(pm);}
 115   fggka->SetParameters(par);
 116
 117   Float_t ppi=fggpi->Eval(q);
 118   Float_t pka=fggka->Eval(q);
 119   Float_t p=ppi+pka;
 120   /*
 121   if(!fSilent){
 122     fggka->Print();
 123     fggpi->Print();
 124     if(p>0)cout<<" ppi,pka="<<ppi/p<<"  "<<pka/p<<endl;
 125   }
 126   */
 127
 128   if(p>0){
 129     ppi=ppi/p;
 130     pka=pka/p;
 131     fWp=0.; fWpi=ppi; fWk=pka;
 132     if( pka>ppi){return fPcode=321;}else{return fPcode=211;}
 133   }else{return 0;}
 134 }
 135 //-----------------------------------------------------------
 136 Int_t   AliITSPid::Wpikp(Float_t pm,Float_t q){
 137   //
 138   //Calcutates probabilityes of pions,kaons and protons.
 139   //Returns particle code for dominant probability.
 140   Double_t par[6];
 141   for(int i=0;i<6;i++){par[i]=fGGpi[i]->Eval(pm);}
 142   fggpi->SetParameters(par);
 143
 144   for(int i=0;i<3;i++){par[i]=fGGka[i]->Eval(pm);}
 145   fggka->SetParameters(par);
 146
 147   for(int i=0;i<3;i++){par[i]=fGGpr[i]->Eval(pm);}
 148   fggpr->SetParameters(par);
 149
 150   Float_t p,ppi,pka,ppr;
 151   if( q>(fggpr->GetParameter(1)+fggpr->GetParameter(2)) )
 152       { p=1.0; ppr=1.0; ppi=pka=0.0;
 153     }else{
 154     ppi=fggpi->Eval(q);
 155     pka=fggka->Eval(q);
 156     ppr=fggpr->Eval(q);
 157     p=ppi+pka+ppr;
 158   }
 159   if(p>0){
 160     ppi=ppi/p;
 161     pka=pka/p;
 162     ppr=ppr/p;
 163     fWp=ppr; fWpi=ppi; fWk=pka;
 164     //if(!fSilent)cout<<" ppi,pka,ppr="<<ppi<<"  "<<pka<<" "<<ppr<<endl;
 165
 166    if( ppi>pka&&ppi>ppr )
 167            {return fPcode=211;}
 168    else{ if(pka>ppr){return fPcode=321;}else{return fPcode=2212;}
 169    }
 170
 171   }else{return 0;}
 172 }
 173 //-----------------------------------------------------------
 174 Int_t   AliITSPid::GetPcode(TClonesArray* rps,Float_t pm)
 175 {
 176   //Returns particle code
 177   Info("GetPcode","method not implemented - Inputs TClonesArray *%x , Float_t %f",rps,pm);
 178     return 0;
 179 }
 180 //-----------------------------------------------------------
 181 Int_t   AliITSPid::GetPcode(AliKalmanTrack *track)
 182 {
 183   //Returns particle code for given track.
 184       Double_t xk,par[5]; track->GetExternalParameters(xk,par);
 185       Float_t phi=TMath::ASin(par[2]) + track->GetAlpha();
 186       if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
 187       if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
 188       Float_t lam=TMath::ATan(par[3]);
 189       Float_t pt1=TMath::Abs(par[4]);
 190       Float_t mom=1./(pt1*TMath::Cos(lam));
 191       Float_t dedx=track->GetPIDsignal();
 192     Int_t pcode=GetPcode(dedx/40.,mom);
 193 //    cout<<"TPCtrack dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
 194     return pcode?pcode:211;
 195     }
 196 //------------------------------------------------------------
 197 Int_t   AliITSPid::GetPcode(AliITSIOTrack *track)
 198 {
 199   //Returns particle code for given track(V1).
 200     Double_t px,py,pz;
 201     px=track->GetPx();
 202     py=track->GetPy();
 203     pz=track->GetPz();
 204     Float_t mom=TMath::Sqrt(px*px+py*py+pz*pz);
 205 //???????????????????
 206     // Float_t dedx=1.0;
 207     Float_t dedx=track->GetdEdx();
 208 //???????????????????
 209     Int_t pcode=GetPcode(dedx,mom);
 210 //    cout<<"ITSV1 dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
 211 return pcode?pcode:211;
 212 }
 213 //-----------------------------------------------------------
 214 Int_t   AliITSPid::GetPcode(AliITStrackV2 *track)
 215 {
 216 //Returns particle code for given track(V2).
 217   if(track==0)return 0;
 218   //      track->Propagate(track->GetAlpha(),3.,0.1/65.19*1.848,0.1*1.848);
 219       track->PropagateTo(3.,0.0028,65.19);
 220       //track->PropagateToVertex();          Not needed. (I.B.)
 221     Double_t xk,par[5]; track->GetExternalParameters(xk,par);
 222     Float_t lam=TMath::ATan(par[3]);
 223     Float_t pt1=TMath::Abs(par[4]);
 224     Float_t mom=0.;
 225     if( (pt1*TMath::Cos(lam))!=0. ){ mom=1./(pt1*TMath::Cos(lam)); }else{mom=0.;};
 226     Float_t dedx=track->GetdEdx();
 227 //    cout<<"lam,pt1,mom,dedx="<<lam<<","<<pt1<<","<<mom<<","<<dedx<<endl;
 228     Int_t pcode=GetPcode(dedx,mom);
 229 //    cout<<"ITS V2 dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
 230 return pcode?pcode:211;
 231 }
 232 //-----------------------------------------------------------
 233 Int_t   AliITSPid::GetPcode(Float_t q,Float_t pm)
 234 {
 235   //Returns particle code for given signal and momentum.
 236     fWpi=fWk=fWp=0.;     fPcode=0;
 237
 238     if ( pm<=0.400 )
 239         { if( q<fCutKa->Eval(pm) )
 240             {return Pion();}
 241         else{ if( q<fCutPr->Eval(pm) )
 242                 {return Kaon();}
 243             else{return Proton();}
 244             }
 245         }
 246     if ( pm<=0.750 )
 247         if ( q>fCutPr->Eval(pm)  )
 248             {return Proton();} else {return Wpik(pm,q);};
 249     if( pm<=1.10 ){ return Wpikp(pm,q); }
 250     return fPcode;
 251 }
 252 //-----------------------------------------------------------
 253 void    AliITSPid::SetCut(Int_t n,Float_t pm,Float_t pilo,Float_t pihi,
 254                         Float_t klo,Float_t khi,Float_t plo,Float_t phi)
 255 {
 256   // The cut-table initializer method.
 257     fCut[n][0]=pm;
 258     fCut[n][1]=pilo;
 259     fCut[n][2]=pihi;
 260     fCut[n][3]=klo;
 261     fCut[n][4]=khi;
 262     fCut[n][5]=plo;
 263     fCut[n][6]=phi;
 264     return ;
 265 }
 266 //------------------------------------------------------------
 267 void AliITSPid::SetVec(Int_t ntrack,const TVector& info) const
 268 {
 269   //Store track info in tracls table
 270 TClonesArray& arr=*fTrs;
 271     new( arr[ntrack] ) TVector(info);
 272 }
 273 //-----------------------------------------------------------
 274 TVector* AliITSPid::GetVec(Int_t ntrack) const
 275 {
 276   //Get given track from track table
 277 TClonesArray& arr=*fTrs;
 278     return (TVector*)arr[ntrack];
 279 }
 280 //-----------------------------------------------------------
 281 void AliITSPid::SetEdep(Int_t track,Float_t Edep)
 282 {
 283   //Set dEdx for given track
 284     TVector xx(0,11);
 285     if( ((TVector*)fTrs->At(track))->IsValid() )
 286         {TVector yy( *((TVector*)fTrs->At(track)) );xx=yy; }
 287     Int_t j=(Int_t)xx(0); if(j>4)return;
 288     xx(++j)=Edep;xx(0)=j;
 289     TClonesArray &arr=*fTrs;
 290     new(arr[track])TVector(xx);
 291 }
 292 //-----------------------------------------------------------
 293 void AliITSPid::SetPmom(Int_t track,Float_t Pmom)
 294 {
 295   //Set momentum for given track
 296     TVector xx(0,11);
 297     if( ((TVector*)fTrs->At(track))->IsValid() )
 298         {TVector yy( *((TVector*)fTrs->At(track)) );xx=yy; }
 299     xx(10)=Pmom;
 300     TClonesArray &arr=*fTrs;
 301     new(arr[track])TVector(xx);
 302 }
 303 //-----------------------------------------------------------
 304 void AliITSPid::SetPcod(Int_t track,Int_t partcode)
 305 {
 306   //Set particle code for given track
 307     TVector xx(0,11);
 308     if( ((TVector*)fTrs->At(track))->IsValid() )
 309         {TVector yy( *((TVector*)fTrs->At(track)) );xx=yy; }
 310     if(xx(11)==0)
 311         {xx(11)=partcode; fMxtrs++;
 312         TClonesArray &arr=*fTrs;
 313         new(arr[track])TVector(xx);
 314         }
 315 }
 316 //-----------------------------------------------------------
 317 void AliITSPid::Print(Int_t track)
 318 {
 319   //Prints information for given track
 320 cout<<fMxtrs<<" tracks in AliITSPid obj."<<endl;
 321     if( ((TVector*)fTrs->At(track))->IsValid() )
 322         {TVector xx( *((TVector*)fTrs->At(track)) );
 323          xx.Print();
 324          }
 325     else
 326         {cout<<"No data for track "<<track<<endl;return;}
 327 }
 328 //-----------------------------------------------------------
 329 void AliITSPid::Tab(void)
 330 {
 331   //Make PID for tracks stored in tracks table
 332 if(fTrs->GetEntries()==0){cout<<"No entries in TAB"<<endl;return;}
 333 cout<<"------------------------------------------------------------------------"<<endl;
 334 cout<<"Nq"<<"   q1  "<<"   q2  "<<"   q3  "<<"   q4  "<<"   q5   "<<
 335       " Qtrm    "    <<"  Wpi  "<<"  Wk   "<<"  Wp  "<<"Pmom  "<<endl;
 336 cout<<"------------------------------------------------------------------------"<<endl;
 337 for(Int_t i=0;i<fTrs->GetEntries();i++)
 338 {
 339   TVector xx( *((TVector*)fTrs->At(i)) );
 340     if( xx.IsValid() && xx(0)>0 )
 341         {
 342             TVector xx( *((TVector*)fTrs->At(i)) );
 343             if(xx(0)>=2)
 344                 {
 345 //       1)Calculate Qtrm
 346                     xx(6)=(this->Qtrm(i));
 347
 348                  }else{
 349                      xx(6)=xx(1);
 350                  }
 351 //       2)Calculate Wpi,Wk,Wp
 352             this->GetPcode(xx(6),xx(10)/1000.);
 353             xx(7)=GetWpi();
 354             xx(8)=GetWk();
 355             xx(9)=GetWp();
 356 //       3)Print table
 357             if(xx(0)>0){
 358 //                  cout<<xx(0)<<" ";
 359                     for(Int_t j=1;j<11;j++){
 360                       if(i<7){ cout.width(7);cout.precision(4);cout<<xx(j);}
 361                       if(i>7){ cout.width(7);cout.precision(5);cout<<xx(j);}
 362                     }
 363                     cout<<endl;
 364                 }
 365 //        4)Update data in TVector
 366             TClonesArray &arr=*fTrs;
 367             new(arr[i])TVector(xx);
 368         }
 369     else
 370       {/*cout<<"No data for track "<<i<<endl;*/}
 371 }// End loop for tracks
 372 }
 373 void AliITSPid::Reset(void)
 374 {
 375   //Reset tracks table
 376   for(Int_t i=0;i<fTrs->GetEntries();i++){
 377     TVector xx(0,11);
 378     TClonesArray &arr=*fTrs;
 379     new(arr[i])TVector(xx);
 380   }
 381 }
 382 //-----------------------------------------------------------
 383 AliITSPid::AliITSPid(Int_t ntrack):
 384 fMxtrs(0),
 385 fTrs(0),
 386 fWpi(0),
 387 fWk(0),
 388 fWp(0),
 389 fRpik(0),
 390 fRppi(0),
 391 fRpka(0),
 392 fRp(0),
 393 fPcode(0),
 394 fSigmin(0.01),
 395 fSilent(0),
 396 fCutKa(0),
 397 fCutPr(0),
 398 fggpi(0),
 399 fggka(0),
 400 fggpr(0){
 401   //Constructor for AliITSPid class
 402
 403     fTrs = new TClonesArray("TVector",ntrack);
 404     TClonesArray &arr=*fTrs;
 405     for(Int_t i=0;i<ntrack;i++)new(arr[i])TVector(0,11);
 406      //
 407     fCutKa=new TF1("fcutka","pol4",0.05,0.4);
 408     Double_t ka[5]={25.616, -161.59, 408.97, -462.17, 192.86};
 409     fCutKa->SetParameters(ka);
 410     //
 411     fCutPr=new TF1("fcutpr","[0]/x/x+[1]",0.05,1.1);
 412     Double_t pr[2]={0.70675,0.4455};
 413     fCutPr->SetParameters(pr);
 414     //
 415     //---------- signal fit ----------
 416 {//Pions
 417 fGGpi[0]=new TF1("fp1pi","pol4",0.34,1.2);
 418   Double_t parpi0[10]={ -1.9096471071e+03, 4.5354331545e+04, -1.1860738840e+05,
 419    1.1405329025e+05, -3.8289694496e+04  };
 420   fGGpi[0]->SetParameters(parpi0);
 421 fGGpi[1]=new TF1("fp2pi","[0]/x/x+[1]",0.34,1.2);
 422   Double_t parpi1[10]={ 1.0791668283e-02, 9.7347716496e-01  };
 423   fGGpi[1]->SetParameters(parpi1);
 424 fGGpi[2]=new TF1("fp3pi","[0]/x/x+[1]",0.34,1.2);
 425   Double_t parpi2[10]={ 5.8191602279e-04, 9.7285601334e-02  };
 426   fGGpi[2]->SetParameters(parpi2);
 427 fGGpi[3]=new TF1("fp4pi","pol4",0.34,1.2);
 428   Double_t parpi3[10]={ 6.6267353195e+02, 7.1595101104e+02, -5.3095111914e+03,
 429    6.2900977606e+03, -2.2935862292e+03  };
 430   fGGpi[3]->SetParameters(parpi3);
 431 fGGpi[4]=new TF1("fp5pi","[0]/x/x+[1]",0.34,1.2);
 432   Double_t parpi4[10]={ 9.0419011783e-03, 1.1628922525e+00  };
 433   fGGpi[4]->SetParameters(parpi4);
 434 fGGpi[5]=new TF1("fp6pi","[0]/x/x+[1]",0.34,1.2);
 435   Double_t parpi5[10]={ 1.8324872519e-03, 2.1503968838e-01  };
 436   fGGpi[5]->SetParameters(parpi5);
 437 }//End Pions
 438 {//Kaons
 439 fGGka[0]=new TF1("fp1ka","pol4",0.24,1.2);
 440   Double_t parka0[20]={
 441   -1.1204243395e+02,4.6716191428e+01,2.2584059281e+03,
 442   -3.7123338009e+03,1.6003647641e+03  };
 443   fGGka[0]->SetParameters(parka0);
 444 fGGka[1]=new TF1("fp2ka","[0]/x/x+[1]",0.24,1.2);
 445   Double_t parka1[20]={
 446   2.5181172905e-01,8.7566001814e-01  };
 447   fGGka[1]->SetParameters(parka1);
 448 fGGka[2]=new TF1("fp3ka","pol6",0.24,1.2);
 449   Double_t parka2[20]={
 450   8.6236021573e+00,-7.0970427531e+01,2.4846827669e+02,
 451   -4.6094401290e+02,4.7546751408e+02,-2.5807112462e+02,
 452   5.7545491696e+01  };
 453   fGGka[2]->SetParameters(parka2);
 454 }//End Kaons
 455 {//Protons
 456 fGGpr[0]=new TF1("fp1pr","pol4",0.4,1.2);
 457   Double_t parpr0[10]={
 458   6.0150106543e+01,-8.8176206410e+02,3.1222644604e+03,
 459   -3.5269200901e+03,1.2859128345e+03  };
 460   fGGpr[0]->SetParameters(parpr0);
 461 fGGpr[1]=new TF1("fp2pr","[0]/x/x+[1]",0.4,1.2);
 462   Double_t parpr1[10]={
 463   9.4970837607e-01,7.3573504201e-01  };
 464   fGGpr[1]->SetParameters(parpr1);
 465 fGGpr[2]=new TF1("fp3pr","[0]/x/x+[1]",0.4,1.2);
 466   Double_t parpr2[10]={
 467   1.2498403757e-01,2.7845072306e-02  };
 468   fGGpr[2]->SetParameters(parpr2);
 469 }//End Protons
 470     //----------- end fit -----------
 471
 472     fggpr=new TF1("ggpr","gaus",0.4,1.2);
 473     fggpi=new TF1("ggpi","gaus+gaus(3)",0.4,1.2);
 474     fggka=new TF1("ggka","gaus",0.4,1.2);
 475
 476     //-------------------------------------------------
 477 const int kInf=10;
 478 //         Ncut Pmom   pilo  pihi    klo    khi     plo    phi
 479 //       cut[j] [0]    [1]    [2]    [3]    [4]     [5]    [6]
 480 //----------------------------------------------------------------
 481     SetCut(  1, 0.12 ,  0.  ,  0.  , kInf  , kInf   , kInf  , kInf  );
 482     SetCut(  2, 0.20 ,  0.  ,  6.0 , 6.0  , kInf   , kInf  , kInf  );
 483     SetCut(  3, 0.30 ,  0.  ,  3.5 , 3.5  , 9.0   , 9.0  , kInf  );
 484     SetCut(  4, 0.41 ,  0.  ,  1.9 , 1.9  , 4.0   , 4.0  , kInf  );
 485 //----------------------------------------------------------------
 486     SetCut(  5, 0.47 , 0.935, 0.139, 1.738 , 0.498  , 3.5  , kInf  );  //410-470
 487     SetCut(  6, 0.53 , 0.914, 0.136, 1.493 , 0.436  , 3.0  , kInf  );  //470-530
 488 //----------------------------------------------------------------
 489     SetCut(  7, 0.59 , 0.895, 0.131, 1.384 , 0.290 , 2.7  , kInf  );    //530-590
 490     SetCut(  8, 0.65 , 0.887, 0.121, 1.167 , 0.287 , 2.5  , kInf  );     //590-650
 491     SetCut(  9, 0.73 , 0.879, 0.120, 1.153 , 0.257 , 2.0  , kInf  );     //650-730
 492 //----------------------------------------------------------------
 493     SetCut( 10, 0.83 , 0.880, 0.126, 1.164 , 0.204 , 2.308 , 0.297 );       //730-830
 494     SetCut( 11, 0.93 , 0.918, 0.145, 1.164 , 0.204 , 2.00 , 0.168 );        //830-930
 495     SetCut( 12, 1.03 , 0.899, 0.128, 1.164 , 0.204  ,1.80 , 0.168);
 496     //------------------------ pi,K ---------------------
 497     fAprob[0][0]=1212;     fAprob[1][0]=33.;   // fAprob[0][i] - const for pions,cut[i+5]
 498     fAprob[0][1]=1022;     fAprob[1][1]=46.2 ; // fAprob[1][i] -           kaons
 499     //---------------------------------------------------
 500     fAprob[0][2]= 889.7;   fAprob[1][2]=66.58; fAprob[2][2]=14.53;
 501     fAprob[0][3]= 686.;    fAprob[1][3]=88.8;  fAprob[2][3]=19.27;
 502     fAprob[0][4]= 697.;    fAprob[1][4]=125.6; fAprob[2][4]=28.67;
 503     //------------------------ pi,K,p -------------------
 504     fAprob[0][5]= 633.7;   fAprob[1][5]=100.1;   fAprob[2][5]=37.99;   // fAprob[2][i] -  protons
 505     fAprob[0][6]= 469.5;   fAprob[1][6]=20.74;   fAprob[2][6]=25.43;
 506     fAprob[0][7]= 355.;    fAprob[1][7]=
 507                           355.*(20.74/469.5);  fAprob[2][7]=34.08;
 508 }
 509 //End AliITSPid.cxx