Floating point data members moved to double precision (Francesco)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Mar 2011 10:53:52 +0000 (10:53 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Mar 2011 10:53:52 +0000 (10:53 +0000)
ITS/AliITSclusterTable.cxx
ITS/AliITSclusterTable.h
ITS/AliITStrackerSA.cxx
ITS/AliITStrackerSA.h

index 9c287c2..96780d4 100644 (file)
@@ -49,7 +49,7 @@ fLam(0){
 
 }
 //_______________________________________________________________
-AliITSclusterTable::AliITSclusterTable(Float_t x, Float_t y, Float_t z, Float_t sx, Float_t sy, Float_t sz, Double_t phi, Double_t lambda, Int_t index):
+AliITSclusterTable::AliITSclusterTable(Double_t x, Double_t y, Double_t z, Double_t sx, Double_t sy, Double_t sz, Double_t phi, Double_t lambda, Int_t index):
 fOrInd(index),
 fX(x),
 fY(y),
index 3588ff8..e11eec4 100644 (file)
@@ -25,32 +25,32 @@ class AliITSclusterTable : public TObject {
  public:
 
   AliITSclusterTable();
-  AliITSclusterTable(Float_t x, Float_t y, Float_t z, Float_t sx, Float_t sy, Float_t sz, Double_t phi, Double_t lambda, Int_t index);
+  AliITSclusterTable(Double_t x, Double_t y, Double_t z, Double_t sx, Double_t sy, Double_t sz, Double_t phi, Double_t lambda, Int_t index);
   virtual ~AliITSclusterTable(){;}
 
   Int_t   GetOrInd() const {return fOrInd;}
-  Float_t GetX() const {return fX;}
-  Float_t GetY() const {return fY;}
-  Float_t GetZ() const {return fZ;}
-  Float_t GetSx() const {return fSx;}
-  Float_t GetSy() const {return fSy;}
-  Float_t GetSz() const {return fSz;}
-  Float_t GetPhi() const {return fPhi;}
-  Float_t GetLambda() const {return fLam;}
+  Double_t GetX() const {return fX;}
+  Double_t GetY() const {return fY;}
+  Double_t GetZ() const {return fZ;}
+  Double_t GetSx() const {return fSx;}
+  Double_t GetSy() const {return fSy;}
+  Double_t GetSz() const {return fSz;}
+  Double_t GetPhi() const {return fPhi;}
+  Double_t GetLambda() const {return fLam;}
 
  protected: 
 
   Int_t   fOrInd; //! original index in tracker
-  Float_t fX;  //!x of cluster 
-  Float_t fY;  //!y of cluster
-  Float_t fZ;  //!z of cluster
-  Float_t fSx; //! error on x
-  Float_t fSy; //! error on y
-  Float_t fSz; //! error on z
+  Double_t fX;  //!x of cluster 
+  Double_t fY;  //!y of cluster
+  Double_t fZ;  //!z of cluster
+  Double_t fSx; //! error on x
+  Double_t fSy; //! error on y
+  Double_t fSz; //! error on z
   Double_t fPhi; //! azimuthal angle
   Double_t fLam; //! lambda angle
 
-  ClassDef(AliITSclusterTable,2)
+  ClassDef(AliITSclusterTable,3)
 };
 
 #endif
index 8c307a4..21d1de5 100644 (file)
@@ -433,8 +433,8 @@ Int_t AliITStrackerSA::FindTracks(AliESDEvent* event, Bool_t useAllClusters){
        if(cls->GetQ()==0) continue;
        if(ilay>1 && cls->GetQ()<=fMinQ) continue; 
        Double_t phi=0;Double_t lambda=0;
-       Float_t x=0;Float_t y=0;Float_t z=0;
-       Float_t sx=0;Float_t sy=0;Float_t sz=0;
+       Double_t x=0;Double_t y=0;Double_t z=0;
+       Double_t sx=0;Double_t sy=0;Double_t sz=0;
        GetCoorAngles(cls,phi,lambda,x,y,z,primaryVertex);
        GetCoorErrors(cls,sx,sy,sz);
        new (clulay[dmar[ilay]]) AliITSRecPoint(*cls);
@@ -696,8 +696,8 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
              Int_t module1 = p1->GetDetectorIndex()+firstmod[firstLay]; 
              Int_t layer,ladder,detector;
              AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector);
-             Float_t yclu1 = p1->GetY();
-             Float_t zclu1 = p1->GetZ();
+             Double_t yclu1 = p1->GetY();
+             Double_t zclu1 = p1->GetZ();
 
              Double_t x1,y1,z1;
              Double_t x2,y2,z2;
@@ -851,7 +851,7 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
   AliITSlayer &lay = fgLayers[layer];
   Double_t r=lay.GetR();
   if(pflag==1){      
-    Float_t cx1,cx2,cy1,cy2;
+    Double_t cx1,cx2,cy1,cy2;
     FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
     if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
        return 0;
@@ -866,8 +866,6 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
 
   Int_t ncl = fCluLayer[layer]->GetEntriesFast();
   for (Int_t index=0; index<ncl; index++) {
-    AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->UncheckedAt(index);
-    if (!c) continue;
     
     AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
 
@@ -929,12 +927,12 @@ void AliITStrackerSA::UpdatePoints(){
 }
 
 //___________________________________________________________________
-Int_t AliITStrackerSA::FindEquation(Float_t x1, Float_t y1, Float_t x2, Float_t y2, Float_t x3, Float_t y3,Float_t& a, Float_t& b, Float_t& c){
+Int_t AliITStrackerSA::FindEquation(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3,Double_t& a, Double_t& b, Double_t& c){
 
    //given (x,y) of three recpoints (in global coordinates) 
    //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
 
-   Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
+   Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
    if(den==0) return 0;
    a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
    b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
@@ -942,7 +940,7 @@ Int_t AliITStrackerSA::FindEquation(Float_t x1, Float_t y1, Float_t x2, Float_t
    return 1;
  }
 //__________________________________________________________________________
- Int_t AliITStrackerSA::FindIntersection(Float_t a1, Float_t b1, Float_t c1, Float_t c2,Float_t& x1,Float_t& y1, Float_t& x2, Float_t& y2){
+ Int_t AliITStrackerSA::FindIntersection(Double_t a1, Double_t b1, Double_t c1, Double_t c2,Double_t& x1,Double_t& y1, Double_t& x2, Double_t& y2){
  
  //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
  //c2 is -rlayer*rlayer
@@ -1079,18 +1077,18 @@ Int_t AliITStrackerSA::FindLabel(AliITStrackV2* track){
   return label;
 }
 //_____________________________________________________________________________
-void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Float_t phimin, Float_t phimax, Float_t lambdamin, Float_t lambdamax){
+void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Double_t phimin, Double_t phimax, Double_t lambdamin, Double_t lambdamax){
   // Set sizes of the phi and lambda windows used for track finding
   fNloop = n;
   if(fPhiWin) delete [] fPhiWin;
   if(fLambdaWin) delete [] fLambdaWin;
   fPhiWin = new Double_t[fNloop];
   fLambdaWin = new Double_t[fNloop];
-  Float_t stepPhi=(phimax-phimin)/(Float_t)(fNloop-1);
-  Float_t stepLambda=(lambdamax-lambdamin)/(Float_t)(fNloop-1);
+  Double_t stepPhi=(phimax-phimin)/(Double_t)(fNloop-1);
+  Double_t stepLambda=(lambdamax-lambdamin)/(Double_t)(fNloop-1);
   for(Int_t k=0;k<fNloop;k++){
-    Float_t phi=phimin+k*stepPhi;
-    Float_t lam=lambdamin+k*stepLambda;
+    Double_t phi=phimin+k*stepPhi;
+    Double_t lam=lambdamin+k*stepLambda;
     fPhiWin[k]=phi;
     fLambdaWin[k]=lam;
   }
@@ -1139,19 +1137,19 @@ void AliITStrackerSA::SetFixedWindowSizes(Int_t n, Double_t *phi, Double_t *lam)
 
 }
 //_______________________________________________________________________
-void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z,Double_t* vertex){
+void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Double_t &x, Double_t &y,Double_t &z,Double_t* vertex){
   //Returns values of phi (azimuthal) and lambda angles for a given cluster
 /*  
   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
   Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det);
-  Float_t tx,ty,tz;  fGeom->GetTrans(lay,lad,det,tx,ty,tz);     
+  Double_t tx,ty,tz;  fGeom->GetTrans(lay,lad,det,tx,ty,tz);     
 
   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
   Double_t phi1=TMath::Pi()/2+alpha;
   if (lay==1) phi1+=TMath::Pi();
 
-  Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
-  Float_t r=tx*cp+ty*sp;
+  Double_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
+  Double_t r=tx*cp+ty*sp;
 
   xyz= r*cp - cl->GetY()*sp;
   y= r*sp + cl->GetY()*cp;
@@ -1168,7 +1166,7 @@ void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &l
 }
 
 //________________________________________________________________________
-void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
+void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Double_t &sx,Double_t &sy, Double_t &sz){
 
   //returns sigmax, y, z of cluster in global coordinates
 /*
@@ -1180,7 +1178,7 @@ void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy,
   Double_t phi=TMath::Pi()/2+alpha;
   if (lay==1) phi+=TMath::Pi();
 
-  Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
+  Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
 */
   Float_t covm[6];
   cl->GetGlobalCov(covm);
index 69a9142..85903d6 100644 (file)
@@ -63,11 +63,11 @@ class AliITStrackerSA : public AliITStrackerMI {
   void SetSAFlag(Bool_t fl){fITSStandAlone=fl;}  // StandAlone flag setter
   Bool_t GetSAFlag() const {return fITSStandAlone;} // StandAlone flag getter
   void SetFixedWindowSizes(Int_t n=46, Double_t *phi=0, Double_t *lam=0);
-  void SetCalculatedWindowSizes(Int_t n=10, Float_t phimin=0.002, Float_t phimax=0.0145, Float_t lambdamin=0.003, Float_t lambdamax=0.008);
+  void SetCalculatedWindowSizes(Int_t n=10, Double_t phimin=0.002, Double_t phimax=0.0145, Double_t lambdamin=0.003, Double_t lambdamax=0.008);
 
   void SetMinNPoints(Int_t np){fMinNPoints=np;}
   Int_t GetMinNPoints() const {return fMinNPoints;}
-  void SetMinimumChargeSDDSSD(Float_t minq=0.){fMinQ=minq;}
+  void SetMinimumChargeSDDSSD(Double_t minq=0.){fMinQ=minq;}
   enum {kSAflag=0x8000}; //flag to mark clusters used in the SA tracker
  protected:
 
@@ -81,18 +81,18 @@ class AliITStrackerSA : public AliITStrackerMI {
 
   Double_t ChoosePoint(Double_t p1, Double_t p2, Double_t pp); 
 
-  static Int_t   FindIntersection(Float_t a1, Float_t b1, Float_t c1, Float_t c2, 
-                           Float_t& x1,Float_t& y1, Float_t& x2, Float_t& y2);
-  static Int_t   FindEquation(Float_t x1, Float_t y1, Float_t x2, Float_t y2, 
-                       Float_t x3, Float_t y3,Float_t& a, Float_t& b, 
-                       Float_t& c);
+  static Int_t   FindIntersection(Double_t a1, Double_t b1, Double_t c1, Double_t c2, 
+                           Double_t& x1,Double_t& y1, Double_t& x2, Double_t& y2);
+  static Int_t   FindEquation(Double_t x1, Double_t y1, Double_t x2, Double_t y2, 
+                       Double_t x3, Double_t y3,Double_t& a, Double_t& b, 
+                       Double_t& c);
  
   Int_t FindLabel(AliITStrackV2* track);
   Int_t SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, 
                        AliITStrackSA* trs,Double_t zvertex,Int_t flagp); 
 
-  void GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda,Float_t &x,Float_t &y,Float_t &z,Double_t* vertex);
-  void GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz);
+  void GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda,Double_t &x,Double_t &y,Double_t &z,Double_t* vertex);
+  void GetCoorErrors(AliITSRecPoint* cl,Double_t &sx,Double_t &sy, Double_t &sz);
 
   AliITSclusterTable* GetClusterCoord(Int_t layer,Int_t n) const {return (AliITSclusterTable*)fCluCoord[layer]->UncheckedAt(n);}
   void RemoveClusterCoord(Int_t layer, Int_t n) {fCluCoord[layer]->RemoveAt(n);fCluCoord[layer]->Compress();}
@@ -100,15 +100,15 @@ class AliITStrackerSA : public AliITStrackerMI {
 
   Double_t fPhiEstimate; //Estimation of phi angle on next layer
   Bool_t fITSStandAlone; //Tracking is performed in the ITS alone if kTRUE
-  Float_t fPoint1[2];   //! coord. of 1-st point to evaluate the curvature
-  Float_t fPoint2[2];   //! coord. of 2-nd point to evaluate the curvature
-  Float_t fPoint3[2];   //! coord. of 3-rd point to evaluate the curvature
-  Float_t fPointc[2];   //! current point coord (for curvature eval.)
+  Double_t fPoint1[2];   //! coord. of 1-st point to evaluate the curvature
+  Double_t fPoint2[2];   //! coord. of 2-nd point to evaluate the curvature
+  Double_t fPoint3[2];   //! coord. of 3-rd point to evaluate the curvature
+  Double_t fPointc[2];   //! current point coord (for curvature eval.)
   Double_t fLambdac;    //! current value of the Lambda angle in the window
   Double_t fPhic;       //! current value of the Phi angle in the window
-  Float_t fCoef1;       //! param. of the equation of the circ. approx a layer
-  Float_t fCoef2;       //! param. of the equation of the circ. approx a layer
-  Float_t fCoef3;       //! param. of the equation of the circ. approx a layer
+  Double_t fCoef1;       //! param. of the equation of the circ. approx a layer
+  Double_t fCoef2;       //! param. of the equation of the circ. approx a layer
+  Double_t fCoef3;       //! param. of the equation of the circ. approx a layer
   Int_t fNloop;         //  Number of iterqations on phi and lambda windows
   Double_t *fPhiWin;    // phi window sizes
   Double_t *fLambdaWin; // lambda window sizes
@@ -121,7 +121,7 @@ class AliITStrackerSA : public AliITStrackerMI {
   Int_t fOuterStartLayer;     // Outward search for tracks with <6 points: outer layer to start from
   Int_t fInnerStartLayer;     // Inward search for tracks with <6 points: inner layer to start from
   Int_t fMinNPoints;        // minimum number of clusters for a track
-  Float_t fMinQ;              // lower cut on cluster charge (SDD and SSD)
+  Double_t fMinQ;              // lower cut on cluster charge (SDD and SSD)
 
   TClonesArray** fCluLayer; //! array with clusters 
   TClonesArray** fCluCoord; //! array with cluster info
@@ -130,7 +130,7 @@ class AliITStrackerSA : public AliITStrackerMI {
   AliITStrackerSA(const AliITStrackerSA& tracker);
   AliITStrackerSA& operator=(const AliITStrackerSA& source);
 
-  ClassDef(AliITStrackerSA,10)
+  ClassDef(AliITStrackerSA,11)
 };
 
 #endif