Add tracking without tilted pads as option
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Feb 2003 14:06:10 +0000 (14:06 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Feb 2003 14:06:10 +0000 (14:06 +0000)
TRD/AliTRDtrack.cxx
TRD/AliTRDtrack.h
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h

index 983add1394417bf3106a855d6fb38a163e65291e..1cb894dbfc5e2b6263f933c72c127da70059c53b 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.15  2003/01/27 16:34:49  cblume
+Update of tracking by Sergei and Chuncheng
+
 Revision 1.14  2002/11/07 15:52:09  cblume
 Update of tracking code for tilted pads
 
@@ -88,8 +91,8 @@ AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, UInt_t index,
   fCzy=cc[1];  fCzz=cc[2];
   fCey=cc[3];  fCez=cc[4];  fCee=cc[5];
   fCty=cc[6];  fCtz=cc[7];  fCte=cc[8];  fCtt=cc[9];
-  fCcy=cc[10]; fCcz=cc[11]; fCce=cc[12]; fCct=cc[13]; fCcc=cc[14];
-
+  fCcy=cc[10]; fCcz=cc[11]; fCce=cc[12]; fCct=cc[13]; fCcc=cc[14];  
+  
   fIndex[0]=index;
   SetNumberOfClusters(1);
 
@@ -102,6 +105,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDcluster *c, UInt_t index,
   if(s*s < 1) q *= TMath::Sqrt((1-s*s)/(1+t*t));
 
   fdQdl[0] = q;
+
 }                              
            
 //_____________________________________________________________________________
@@ -109,7 +113,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) {
   //
   // Copy constructor.
   //
-
+  
   SetLabel(t.GetLabel());
   fSeedLab=t.GetSeedLabel();
 
@@ -121,13 +125,13 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) {
   fAlpha=t.fAlpha;
   fX=t.fX;
 
-  fY=t.fY; fZ=t.fZ; fC=t.fC; fE=t.fE; fT=t.fT;
+  fY=t.fY; fZ=t.fZ; fE=t.fE; fT=t.fT; fC=t.fC;
 
   fCyy=t.fCyy;
   fCzy=t.fCzy;  fCzz=t.fCzz;
   fCey=t.fCey;  fCez=t.fCez;  fCee=t.fCee;
   fCty=t.fCty;  fCtz=t.fCtz;  fCte=t.fCte;  fCtt=t.fCtt;
-  fCcy=t.fCcy;  fCcz=t.fCcz;  fCce=t.fCce;  fCct=t.fCct;  fCcc=t.fCcc;
+  fCcy=t.fCcy;  fCcz=t.fCcz;  fCce=t.fCce;  fCct=t.fCct;  fCcc=t.fCcc;  
 
   Int_t n=t.GetNumberOfClusters(); 
   SetNumberOfClusters(n);
@@ -135,6 +139,7 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) {
     fIndex[i]=t.fIndex[i];
     fdQdl[i]=t.fdQdl[i];
   }
+
 }                                
 
 //_____________________________________________________________________________
@@ -146,6 +151,7 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
 
   SetLabel(t.GetLabel());
   SetChi2(0.);
+  SetMass(t.GetMass());
   SetNumberOfClusters(0);
 
   fdEdx=0;
@@ -162,11 +168,11 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
 
   x = GetConvConst();  
 
-  fY=p[0]; 
-  fZ=p[1]; 
+  fY=p[0];
+  fZ=p[1];
   fT=p[3];
   fC=p[4]/x;
-  fE=fX*fC-p[2]; 
+  fE=fC*fX - p[2];   
 
   //Conversion of the covariance matrix
   Double_t c[15]; t.GetExternalCovariance(c);
@@ -177,11 +183,11 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha)
   Double_t c32=fX*c[13] - c[8];
   Double_t c20=fX*c[10] - c[3], c21=fX*c[11] - c[4], c42=fX*c[14] - c[12];
 
-  fCyy=c[0];
-  fCzy=c[1];   fCzz=c[2];
-  fCey=c20;    fCez=c21;    fCee=c22;
-  fCty=c[6];   fCtz=c[7];   fCte=c32;   fCtt=c[9];
-  fCcy=c[10];  fCcz=c[11];  fCce=c42;   fCct=c[13];   fCcc=c[14];
+  fCyy=c[0 ];
+  fCzy=c[1 ];   fCzz=c[2 ];
+  fCey=c20;     fCez=c21;     fCee=c22;
+  fCty=c[6 ];   fCtz=c[7 ];   fCte=c32;   fCtt=c[9 ];
+  fCcy=c[10];   fCcz=c[11];   fCce=c42;   fCct=c[13]; fCcc=c[14];  
 
 }              
 
@@ -195,7 +201,7 @@ void AliTRDtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
      x[1]=GetZ();
      x[2]=GetSnp();
      x[3]=GetTgl();
-     x[4]=fC*GetConvConst();
+     x[4]=Get1Pt();
 }           
 
 //_____________________________________________________________________________
@@ -213,17 +219,20 @@ void AliTRDtrack::GetExternalCovariance(Double_t cc[15]) const {
   cc[1 ]=fCzy;   cc[2 ]=fCzz;
   cc[3 ]=c20;    cc[4 ]=c21;    cc[5 ]=c22;
   cc[6 ]=fCty;   cc[7 ]=fCtz;   cc[8 ]=c32;   cc[9 ]=fCtt;
-  cc[10]=fCcy*a; cc[11]=fCcz*a; cc[12]=c42*a; cc[13]=fCct*a; cc[14]=fCcc*a*a;
+  cc[10]=fCcy*a; cc[11]=fCcz*a; cc[12]=c42*a; cc[13]=fCct*a; cc[14]=fCcc*a*a; 
+  
 }               
                        
 
 //_____________________________________________________________________________
 void AliTRDtrack::GetCovariance(Double_t cc[15]) const {
+
   cc[0]=fCyy;
   cc[1]=fCzy;  cc[2]=fCzz;
   cc[3]=fCey;  cc[4]=fCez;  cc[5]=fCee;
   cc[6]=fCcy;  cc[7]=fCcz;  cc[8]=fCce;  cc[9]=fCcc;
   cc[10]=fCty; cc[11]=fCtz; cc[12]=fCte; cc[13]=fCct; cc[14]=fCtt;
+  
 }    
 
 //_____________________________________________________________________________
@@ -278,17 +287,14 @@ void AliTRDtrack::CookdEdx(Double_t low, Double_t up) {
 }                     
 
 
-
-
 //_____________________________________________________________________________
 Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
 {
   // Propagates a track of particle with mass=pm to a reference plane 
   // defined by x=xk through media of density=rho and radiationLength=x0
 
-  
   if (TMath::Abs(fC*xk - fE) >= 0.99999) {
-    Int_t n=GetNumberOfClusters(); 
+    Int_t n=GetNumberOfClusters();
     if (n>4) cerr<<n<<" AliTRDtrack warning: Propagation failed !\n";
     return 0;
   }
@@ -297,7 +303,7 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   Double_t c1=fC*x1 - fE;
   if((c1*c1) > 1) return 0;
   Double_t r1=sqrt(1.- c1*c1);
-  Double_t c2=fC*x2 - fE;
+  Double_t c2=fC*x2 - fE; 
   if((c2*c2) > 1) return 0;
   Double_t r2=sqrt(1.- c2*c2);
 
@@ -311,7 +317,7 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   Double_t cr=c1*r2+c2*r1;
   Double_t f12=-dx*fT*(2*cr + cc*(c2*c1/r1-r1 + c1*c2/r2-r2))/(cr*cr);
   Double_t f13= dx*cc/cr;
-  Double_t f14= dx*fT*(cr*xx-cc*(r1*x2-c2*c1*x1/r1+r2*x1-c1*c2*x2/r2))/(cr*cr);
+  Double_t f14=dx*fT*(cr*xx-cc*(r1*x2-c2*c1*x1/r1+r2*x1-c1*c2*x2/r2))/(cr*cr);
 
   //b = C*ft
   Double_t b00=f02*fCey + f04*fCcy, b01=f12*fCey + f14*fCcy + f13*fCty;
@@ -332,23 +338,19 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   fCzz += a11 + 2*b11;
   fCez += b21;
   fCtz += b31;
-  fCcz += b41;                  
-
-  fX=x2;
+  fCcz += b41;
 
+  fX=x2;                                                     
 
   //Multiple scattering  ******************
-
   Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fY)*(y1-fY)+(z1-fZ)*(z1-fZ));
-  Double_t p2=GetPt()*GetPt()*(1.+fT*fT);
-  p2 = TMath::Min(p2,1e+08);  // to avoid division by (1-1) for stiff tracks
+  Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
   Double_t beta2=p2/(p2 + GetMass()*GetMass());
+  Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
 
   Double_t ey=fC*fX - fE, ez=fT;
   Double_t xz=fC*ez, zz1=ez*ez+1, xy=fE+ey;
 
-  Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
-
   fCee += (2*ey*ez*ez*fE+1-ey*ey+ez*ez+fE*fE*ez*ez)*theta2;
   fCte += ez*zz1*xy*theta2;
   fCtt += zz1*zz1*theta2;
@@ -356,18 +358,16 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho)
   fCct += xz*zz1*theta2;
   fCcc += xz*xz*theta2;
 
-
   //Energy losses************************
-  if (x1 < x2) d=-d;
-  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d*rho;
-  //PH  SetLength(GetLength()+d);
+  if((5940*beta2/(1-beta2+1e-10) - beta2) < 0) return 0;
 
-  cc = fC;
+  Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
+  if (x1 < x2) dE=-dE;
+  cc=fC;
   fC*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
-  fE+=fX*(fC-cc);
-
-  return 1;        
+  fE+=fX*(fC-cc);    
 
+  return 1;            
 }     
 
 
@@ -376,81 +376,99 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index,
 {
   // Assignes found cluster to the track and updates track information
 
+  Bool_t fNoTilt = kTRUE;
+  if(TMath::Abs(h01) > 0.003) fNoTilt = kFALSE;
 
-  Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2()*100.0;
-
-  r00+=(fCyy+2.0*h01*fCzy+h01*h01*fCzz);
-  r01+=(fCzy+h01*fCzz);
-  r11+=fCzz;
-
+  Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2();
+  r00+=fCyy; r01+=fCzy; r11+=fCzz;
   Double_t det=r00*r11 - r01*r01;
   Double_t tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
 
-//  Double_t k00=fCyy*r00+fCzy*r01, k01=fCyy*r01+fCzy*r11;
-//  Double_t k10=fCzy*r00+fCzz*r01, k11=fCzy*r01+fCzz*r11;
-//  Double_t k20=fCey*r00+fCez*r01, k21=fCey*r01+fCez*r11;
-//  Double_t k30=fCty*r00+fCtz*r01, k31=fCty*r01+fCtz*r11;
-//  Double_t k40=fCcy*r00+fCcz*r01, k41=fCcy*r01+fCcz*r11;
-
-  Double_t k00=fCyy*r00+fCzy*(r01+h01*r00),k01=fCyy*r01+fCzy*(r11+h01*r01);
-  Double_t k10=fCzy*r00+fCzz*(r01+h01*r00),k11=fCzy*r01+fCzz*(r11+h01*r01);
-  Double_t k20=fCey*r00+fCez*(r01+h01*r00),k21=fCey*r01+fCez*(r11+h01*r01);
-  Double_t k30=fCty*r00+fCtz*(r01+h01*r00),k31=fCty*r01+fCtz*(r11+h01*r01);
-  Double_t k40=fCcy*r00+fCcz*(r01+h01*r00),k41=fCcy*r01+fCcz*(r11+h01*r01);
+  Double_t k00=fCyy*r00+fCzy*r01, k01=fCyy*r01+fCzy*r11;
+  Double_t k10=fCzy*r00+fCzz*r01, k11=fCzy*r01+fCzz*r11;
+  Double_t k20=fCey*r00+fCez*r01, k21=fCey*r01+fCez*r11;
+  Double_t k30=fCty*r00+fCtz*r01, k31=fCty*r01+fCtz*r11;
+  Double_t k40=fCcy*r00+fCcz*r01, k41=fCcy*r01+fCcz*r11;
 
   Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
-
-  dy=dy+h01*dz;
-
   Double_t cur=fC + k40*dy + k41*dz, eta=fE + k20*dy + k21*dz;
-  if (TMath::Abs(cur*fX-eta) >= 0.99999) {
-    Int_t n=GetNumberOfClusters(); 
-    if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
-    return 0;
-  }
-
-  fY += k00*dy + k01*dz;
-  fZ += k10*dy + k11*dz;
-  fE  = eta;
-  fT += k30*dy + k31*dz;
-  fC  = cur;
-
-
-  k01+=h01*k00;
-  k11+=h01*k10;
-  k21+=h01*k20;
-  k31+=h01*k30;
-  k41+=h01*k40;
 
   Double_t c01=fCzy, c02=fCey, c03=fCty, c04=fCcy;
   Double_t c12=fCez, c13=fCtz, c14=fCcz;
 
+  if(fNoTilt) {
+    if (TMath::Abs(cur*fX-eta) >= 0.99999) {
+      Int_t n=GetNumberOfClusters();
+      if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
+      return 0;
+    }
+    fY += k00*dy + k01*dz;
+    fZ += k10*dy + k11*dz;
+    fE  = eta;
+    fT += k30*dy + k31*dz;
+    fC  = cur;
+  }
+  else {
+    Double_t xu_factor = 100.;  // empirical factor set by C.Xu
+                                // in the first tilt version      
+    r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2()*xu_factor; 
+    r00+=(fCyy+2.0*h01*fCzy+h01*h01*fCzz);
+    r01+=(fCzy+h01*fCzz);  
+    det=r00*r11 - r01*r01;
+    tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
+
+    k00=fCyy*r00+fCzy*(r01+h01*r00),k01=fCyy*r01+fCzy*(r11+h01*r01);
+    k10=fCzy*r00+fCzz*(r01+h01*r00),k11=fCzy*r01+fCzz*(r11+h01*r01);
+    k20=fCey*r00+fCez*(r01+h01*r00),k21=fCey*r01+fCez*(r11+h01*r01);
+    k30=fCty*r00+fCtz*(r01+h01*r00),k31=fCty*r01+fCtz*(r11+h01*r01);
+    k40=fCcy*r00+fCcz*(r01+h01*r00),k41=fCcy*r01+fCcz*(r11+h01*r01);  
+
+    dy=c->GetY() - fY; dz=c->GetZ() - fZ; 
+    dy=dy+h01*dz;
+
+    cur=fC + k40*dy + k41*dz; eta=fE + k20*dy + k21*dz;
+    if (TMath::Abs(cur*fX-eta) >= 0.99999) {
+      Int_t n=GetNumberOfClusters();
+      if (n>4) cerr<<n<<" AliTRDtrack warning: Filtering failed !\n";
+      return 0;
+    }                           
+    fY += k00*dy + k01*dz;
+    fZ += k10*dy + k11*dz;
+    fE  = eta;
+    fT += k30*dy + k31*dz;
+    fC  = cur;
+    
+    k01+=h01*k00;
+    k11+=h01*k10;
+    k21+=h01*k20;
+    k31+=h01*k30;
+    k41+=h01*k40;  
+  }
+
   fCyy-=k00*fCyy+k01*fCzy; fCzy-=k00*c01+k01*fCzz;
   fCey-=k00*c02+k01*c12;   fCty-=k00*c03+k01*c13;
   fCcy-=k00*c04+k01*c14;
-
+  
   fCzz-=k10*c01+k11*fCzz;
   fCez-=k10*c02+k11*c12;   fCtz-=k10*c03+k11*c13;
   fCcz-=k10*c04+k11*c14;
-
+  
   fCee-=k20*c02+k21*c12;   fCte-=k20*c03+k21*c13;
   fCce-=k20*c04+k21*c14;
-
+  
   fCtt-=k30*c03+k31*c13;
-  fCct-=k40*c03+k41*c13;        
-
-  fCcc-=k40*c04+k41*c14;
+  fCct-=k40*c03+k41*c13;
+  
+  fCcc-=k40*c04+k41*c14;                 
 
-  Int_t n=GetNumberOfClusters();  
+  Int_t n=GetNumberOfClusters();
   fIndex[n]=index;
-  SetNumberOfClusters(n+1);  
-
-  SetChi2(GetChi2()+chisq); 
+  SetNumberOfClusters(n+1);
 
+  SetChi2(GetChi2()+chisq);
   //  cerr<<"in update: fIndex["<<fN<<"] = "<<index<<endl;
 
-  return 1;
-
+  return 1;     
 }                     
 
 
@@ -461,39 +479,35 @@ Int_t AliTRDtrack::Rotate(Double_t alpha)
 
   fAlpha += alpha;
   if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
-  if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();    
+  if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();
 
   Double_t x1=fX, y1=fY;
   Double_t ca=cos(alpha), sa=sin(alpha);
   Double_t r1=fC*fX - fE;
 
-  if (TMath::Abs(r1) >= 0.99999) {
-    Int_t n=GetNumberOfClusters(); 
-    if (n>4) cerr<<n<<" AliTRDtrack warning: Rotation failed !\n";
-    return 0;
-  }
-
   fX = x1*ca + y1*sa;
-  fY=-x1*sa + y1*ca;
+  fY =-x1*sa + y1*ca;
+  if((r1*r1) > 1) return 0;
   fE=fE*ca + (fC*y1 + sqrt(1.- r1*r1))*sa;
 
   Double_t r2=fC*fX - fE;
   if (TMath::Abs(r2) >= 0.99999) {
-    Int_t n=GetNumberOfClusters(); 
+    Int_t n=GetNumberOfClusters();
     if (n>4) cerr<<n<<" AliTRDtrack warning: Rotation failed !\n";
     return 0;
   }
 
+  if((r2*r2) > 1) return 0;
   Double_t y0=fY + sqrt(1.- r2*r2)/fC;
   if ((fY-y0)*fC >= 0.) {
-    Int_t n=GetNumberOfClusters(); 
+    Int_t n=GetNumberOfClusters();
     if (n>4) cerr<<n<<" AliTRDtrack warning: Rotation failed !!!\n";
     return 0;
   }
 
   //f = F - 1
   Double_t f00=ca-1,    f24=(y1 - r1*x1/sqrt(1.- r1*r1))*sa,
-           f20=fC*sa, f22=(ca + sa*r1/sqrt(1.- r1*r1))-1;
+           f20=fC*sa,  f22=(ca + sa*r1/sqrt(1.- r1*r1))-1;
 
   //b = C*ft
   Double_t b00=fCyy*f00, b02=fCyy*f20+fCcy*f24+fCey*f22;
@@ -505,8 +519,6 @@ Int_t AliTRDtrack::Rotate(Double_t alpha)
   //a = f*b = f*C*ft
   Double_t a00=f00*b00, a02=f00*b02, a22=f20*b02+f24*b42+f22*b22;
 
-  // *** Double_t dy2=fCyy;  
-          
   //F*C*Ft = C + (a + b + bt)
   fCyy += a00 + 2*b00;
   fCzy += b10;
@@ -518,10 +530,7 @@ Int_t AliTRDtrack::Rotate(Double_t alpha)
   fCee += a22 + 2*b22;
   fCce += b42;
 
-  // *** fCyy+=dy2*sa*sa*r1*r1/(1.- r1*r1);
-  // *** fCzz+=d2y*sa*sa*fT*fT/(1.- r1*r1);   
-
-  return 1;
+  return 1;                            
 }                         
 
 
@@ -529,24 +538,32 @@ Int_t AliTRDtrack::Rotate(Double_t alpha)
 Double_t AliTRDtrack::GetPredictedChi2(const AliTRDcluster *c, Double_t h01) const
 {
   
-  Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2();
-
-  r00+=fCyy; r01+=fCzy; r11+=fCzz;
-
-  Double_t det=r00*r11 - r01*r01;
-  if (TMath::Abs(det) < 1.e-10) {
-    Int_t n=GetNumberOfClusters(); 
-    if (n>4) cerr<<n<<" AliTRDtrack warning: Singular matrix !\n";
-    return 1e10;
+  Bool_t fNoTilt = kTRUE;
+  if(TMath::Abs(h01) > 0.003) fNoTilt = kFALSE;
+  Double_t chi2, dy, r00, r01, r11;
+
+  if(fNoTilt) {
+    dy=c->GetY() - fY;
+    r00=c->GetSigmaY2();    
+    chi2 = (dy*dy)/r00;    
   }
-  Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-
-  Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
-
-  dy=dy+h01*dz;
-
-  return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det; 
+  else {
+    r00=c->GetSigmaY2(); r01=0.; r11=c->GetSigmaZ2();
+    r00+=fCyy; r01+=fCzy; r11+=fCzz;
+
+    Double_t det=r00*r11 - r01*r01;
+    if (TMath::Abs(det) < 1.e-10) {
+      Int_t n=GetNumberOfClusters(); 
+      if (n>4) cerr<<n<<" AliTRDtrack warning: Singular matrix !\n";
+      return 1e10;
+    }
+    Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
+    Double_t dy=c->GetY() - fY, dz=c->GetZ() - fZ;
+    dy=dy+h01*dz;
 
+    chi2 = (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det; 
+  }
+  return chi2;
 }      
 
 
@@ -592,9 +609,9 @@ void AliTRDtrack::ResetCovariance() {
   //
 
   fCyy*=10.;
-  fCzy=0.;   fCzz*=10.;
-  fCey=0.;   fCez=0.;   fCee*=10.;
-  fCty=0.;   fCtz=0.;   fCte=0.;   fCtt*=10.;
-  fCcy=0.;   fCcz=0.;   fCce=0.;   fCct=0.;   fCcc*=10.;
-
+  fCzy=0.;  fCzz*=10.;
+  fCey=0.;  fCez=0.;  fCee*=10.;
+  fCty=0.;  fCtz=0.;  fCte=0.;  fCtt*=10.;
+  fCcy=0.;  fCcz=0.;  fCce=0.;  fCct=0.;  fCcc*=10.;  
 }                                                         
+
index 7ce17f052e8c405e3f96636ba4408e8e1d498ea3..84ff9ea5f4199eb407a08093fa2a7a2b94be8a23 100644 (file)
@@ -41,7 +41,7 @@ public:
 
    Double_t GetLikelihoodElectron() const { return fLhElectron; };
 
-   Double_t Get1Pt()   const {return TMath::Abs(fC*GetConvConst());
+   Double_t Get1Pt()   const {return (1e-9*TMath::Abs(fC)/fC + fC)*GetConvConst(); 
    Double_t GetP()     const {  
      return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
    }
@@ -76,8 +76,10 @@ public:
    void     SetSeedLabel(Int_t lab) { fSeedLab=lab; }
 
    Int_t    Update(const AliTRDcluster* c, Double_t chi2, UInt_t i, 
-                  Double_t h01);
+                   Double_t h01);
 
+   void     ResetParameters();   
+   void     CheckParameters(Int_t stage);   
 
 
 protected:
@@ -88,22 +90,23 @@ protected:
    Double_t fAlpha;       // rotation angle
    Double_t fX;           // running local X-coordinate of the track (time bin)
 
-   Double_t fY;           // Y-coordinate of the track
-   Double_t fZ;           // Z-coordinate of the track
-   Double_t fE;           // C*x0
-   Double_t fT;           // tangent of the track dip angle   
-   Double_t fC;           // track curvature
+
+   Double_t fY;             // Y-coordinate of the track
+   Double_t fZ;             // Z-coordinate of the track
+   Double_t fE;             // C*x0
+   Double_t fT;             // tangent of the track momentum dip angle
+   Double_t fC;             // track curvature
 
    Double_t fCyy;                         // covariance
    Double_t fCzy, fCzz;                   // matrix
    Double_t fCey, fCez, fCee;             // of the
    Double_t fCty, fCtz, fCte, fCtt;       // track
    Double_t fCcy, fCcz, fCce, fCct, fCcc; // parameters   
-
+   
    UInt_t  fIndex[kMAX_CLUSTERS_PER_TRACK];  // global indexes of clusters  
    Float_t fdQdl[kMAX_CLUSTERS_PER_TRACK];   // cluster amplitudes corrected 
                                              // for track angles    
-                          
+                           
    Float_t fLhElectron;    // Likelihood to be an electron    
 
    ClassDef(AliTRDtrack,2) // TRD reconstructed tracks
index 0ca865997028f571927480a1c140c76979fe444c..e71246a5e967da372e292f4b46dc56b2cde4fe99 100644 (file)
@@ -15,6 +15,9 @@
                                                       
 /*
 $Log$
+Revision 1.22  2003/01/30 15:19:58  cblume
+New set of  parameters
+
 Revision 1.21  2003/01/27 16:34:49  cblume
 Update of tracking by Sergei and Chuncheng
 
@@ -115,7 +118,7 @@ ClassImp(AliTRDtracker)
   const  Float_t     AliTRDtracker::fLabelFraction      = 0.8;  
   const  Float_t     AliTRDtracker::fWideRoad           = 20.;
 
-  const  Double_t    AliTRDtracker::fMaxChi2            = 20.; 
+  const  Double_t    AliTRDtracker::fMaxChi2            = 12.; 
 
 
 //____________________________________________________________________
@@ -126,11 +129,10 @@ AliTRDtracker::AliTRDtracker(const TFile *geomfile)
   //  
 
   Float_t fTzero = 0;
-  Int_t   version = 2;
-  
+   
   fAddTRDseeds = kFALSE;
-
   fGeom = NULL;
+  fNoTilt = kFALSE;
   
   TDirectory *savedir=gDirectory; 
   TFile *in=(TFile*)geomfile;  
@@ -148,9 +150,7 @@ AliTRDtracker::AliTRDtracker(const TFile *geomfile)
 
   if(fGeom) {
     //    fTzero = geo->GetT0();
-    fTzero = 0.;
-    version = fGeom->IsVersion();
-    printf("Found geometry version %d on file \n", version);
+    printf("Found geometry version %d on file \n", fGeom->IsVersion());
   }
   else { 
     printf("AliTRDtracker::AliTRDtracker(): cann't find TRD geometry!\n");
@@ -178,8 +178,16 @@ AliTRDtracker::AliTRDtracker(const TFile *geomfile)
     fTrSec[tr_s] = new AliTRDtrackingSector(fGeom, geom_s, fPar);
   }
 
-  fSY2corr = 0.025;
-  fSZ2corr = 12.;      
+  Float_t tilt_angle = TMath::Abs(fPar->GetTiltingAngle()); 
+  if(tilt_angle < 0.1) {
+    fNoTilt = kTRUE;
+  }
+
+  fSY2corr = 0.2;
+  fSZ2corr = 120.;      
+
+  if(fNoTilt && (tilt_angle > 0.1)) fSY2corr = fSY2corr + tilt_angle * 0.05; 
+
 
   // calculate max gap on track
 
@@ -338,7 +346,6 @@ Int_t AliTRDtracker::Clusters2Tracks(const TFile *inp, TFile *out)
   out->cd();
 
 
-
   // find tracks from loaded seeds
 
   Int_t nseed=fSeeds->GetEntriesFast();
@@ -684,19 +691,13 @@ Int_t AliTRDtracker::FollowProlongation(AliTRDtrack& t, Int_t rf)
 
     if(lookForCluster) {
 
-
       expectedNumberOfClusters++;       
-
       wIndex = (Float_t) t.GetLabel();
       wTB = nr;
 
-
       AliTRDpropagationLayer& time_bin=*(fTrSec[s]->GetLayer(nr-1));
 
-
       Double_t sy2=ExpectedSigmaY2(x,t.GetTgl(),t.GetPt());
-
-
       Double_t sz2=ExpectedSigmaZ2(x,t.GetTgl());
 
       Double_t road;
@@ -1394,6 +1395,12 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer, Int_t turn)
 
         // Tilt changes
         Double_t h01 = GetTiltFactor(r1[is]);
+       Double_t xu_factor = 100.;
+       if(fNoTilt) { 
+         h01 = 0;
+         xu_factor = 1;
+       }
+
         sy1=sy1+sz1*h01*h01;
         Double_t syz=sz1*(-h01);
         // end of tilt changes
@@ -1412,14 +1419,13 @@ void AliTRDtracker::MakeSeeds(Int_t inner, Int_t outer, Int_t turn)
         
         c[0]=sy1;
         //        c[1]=0.;       c[2]=sz1;
-        c[1]=syz;       c[2]=sz1*100;
+        c[1]=syz;       c[2]=sz1*xu_factor;
         c[3]=f20*sy1;  c[4]=0.;       c[5]=f20*sy1*f20+f22*sy2*f22+f23*sy3*f23;
         c[6]=f30*sy1;  c[7]=f31*sz1;  c[8]=f30*sy1*f20+f32*sy2*f22;
                        c[9]=f30*sy1*f30+f31*sz1*f31+f32*sy2*f32+f34*sz2*f34;
         c[10]=f40*sy1; c[11]=0.; c[12]=f40*sy1*f20+f42*sy2*f22+f43*sy3*f23;
         c[13]=f30*sy1*f40+f32*sy2*f42;
         c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;      
-
         
         UInt_t index=r1.GetIndex(is);
         
@@ -1492,8 +1498,8 @@ void AliTRDtracker::ReadClusters(TObjArray *array, const TFile *inp)
       AliTRDcluster *co = new AliTRDcluster(*c);
       co->SetSigmaY2(c->GetSigmaY2() * fSY2corr);
       Int_t ltb = co->GetLocalTimeBin();
-      if(ltb != 0) co->SetSigmaZ2(c->GetSigmaZ2() * fSZ2corr);
-      
+      if(ltb == 19) co->SetSigmaZ2(c->GetSigmaZ2());
+      else if(fNoTilt) co->SetSigmaZ2(c->GetSigmaZ2() * fSZ2corr);
       array->AddLast(co);
       delete ClusterArray->RemoveAt(iCluster); 
     }
@@ -1560,7 +1566,8 @@ void AliTRDtracker::ReadClusters(TObjArray *array, const Char_t *filename)
       AliTRDcluster *co = new AliTRDcluster(*c);
       co->SetSigmaY2(c->GetSigmaY2() * fSY2corr);
       Int_t ltb = co->GetLocalTimeBin();
-      if(ltb != 0) co->SetSigmaZ2(c->GetSigmaZ2() * fSZ2corr);
+      if(ltb == 19) co->SetSigmaZ2(c->GetSigmaZ2());
+      else if(fNoTilt) co->SetSigmaZ2(c->GetSigmaZ2() * fSZ2corr);
       array->AddLast(co);
       delete ClusterArray->RemoveAt(iCluster);
     }
@@ -2327,6 +2334,8 @@ Double_t AliTRDtracker::GetTiltFactor(const AliTRDcluster* c) {
   Int_t plane = fGeom->GetPlane(det);
 
   if((plane == 1) || (plane == 3) || (plane == 5)) h01=-h01;
+
+  if(fNoTilt) h01 = 0;
   
   return h01;
 }
index 9337f504a80a44ba16bc7a59b11afff4fc223739..2c537353a7fe1f675e99acd84a404588648aae52 100644 (file)
@@ -19,7 +19,7 @@ class AliTRDmcTrack;
 
 const unsigned kMAX_LAYERS_PER_SECTOR = 1000;  
 const unsigned kMAX_TIME_BIN_INDEX = 216;  // (30 drift + 6 ampl) * 6 planes  
-const unsigned kMAX_CLUSTER_PER_TIME_BIN = 3500; 
+const unsigned kMAX_CLUSTER_PER_TIME_BIN = 7000; 
 const unsigned kZONES = 5; 
 const Int_t kTRACKING_SECTORS = 18; 
 
@@ -39,6 +39,7 @@ class AliTRDtracker : public AliTracker {
   
   void          SetEventNumber(Int_t event) { fEvent = event; }
   void          SetAddTRDseeds() { fAddTRDseeds = kTRUE; }
+  void          SetNoTilt() { fNoTilt = kTRUE; }
 
   Double_t      GetTiltFactor(const AliTRDcluster* c);
 
@@ -80,7 +81,7 @@ class AliTRDtracker : public AliTracker {
    // *****************  internal class *******************
    public: 
      AliTRDpropagationLayer(Double_t x, Double_t dx, Double_t rho, 
-                           Double_t x0, Int_t tb_index); 
+                            Double_t x0, Int_t tb_index); 
 
      ~AliTRDpropagationLayer() { 
        if(fTimeBinIndex >= 0) { delete[] fClusters; delete[] fIndex; }
@@ -95,7 +96,7 @@ class AliTRDtracker : public AliTracker {
      Double_t       GetX0() const { return fX0; }
      Int_t          GetTimeBinIndex() const { return fTimeBinIndex; }     
      void           GetPropagationParameters(Double_t y, Double_t z,
-                               Double_t &dx, Double_t &rho, Double_t &x0, 
+                                Double_t &dx, Double_t &rho, Double_t &x0, 
                                 Bool_t &lookForCluster) const;
      Int_t          Find(Double_t y) const; 
      void           SetZmax(Int_t cham, Double_t center, Double_t w)
@@ -106,9 +107,9 @@ class AliTRDtracker : public AliTracker {
      Double_t       GetZc(Int_t c) const { return fZc[c]; }
      
      void           SetHole(Double_t Zmax, Double_t Ymax,
-                           Double_t rho = 1.29e-3, Double_t x0 = 36.66,
-                           Double_t Yc = 0, Double_t Zc = 0);
-                           
+                            Double_t rho = 1.29e-3, Double_t x0 = 36.66,
+                            Double_t Yc = 0, Double_t Zc = 0);
+                            
      void    Clear() {for(Int_t i=0; i<fN; i++) fClusters[i] = NULL; fN = 0;}
                    
    private:     
@@ -212,18 +213,18 @@ class AliTRDtracker : public AliTracker {
 
   static const Float_t  fSeedGap;     // Distance between inner and outer
                                       // time bin in seeding 
-                                     // (fraction of all time bins) 
+                                      // (fraction of all time bins) 
   
   static const Float_t  fSeedStep;    // Step in iterations
-  static const Float_t         fSeedDepth;   // Fraction of TRD allocated for seeding
+  static const Float_t  fSeedDepth;   // Fraction of TRD allocated for seeding
   static const Float_t  fSkipDepth;   // Fraction of TRD which can be skipped
-                                      // in track prolongation            
+                                      // in track prolongation             
   Int_t       fTimeBinsPerPlane;      // number of sensitive timebins per plane
   Int_t       fMaxGap;                // max gap (in time bins) in the track  
-                                      // in track prolongation            
+                                      // in track prolongation             
 
   static const Double_t fMaxChi2;     // max increment in track chi2 
-       
+        
   static const Float_t  fMinClustersInTrack; // min number of clusters in track
                                              // out of total timebins
 
@@ -244,6 +245,8 @@ class AliTRDtracker : public AliTracker {
 
   Bool_t                fVocal;   
   Bool_t                fAddTRDseeds;
+
+  Bool_t                fNoTilt;
  
   ClassDef(AliTRDtracker,1)           // manager base class