Code clean-up (Massimo)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Oct 2011 12:42:18 +0000 (12:42 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Oct 2011 12:42:18 +0000 (12:42 +0000)
HLT/ITS/AliHLTITSVertexerZ.cxx
HLT/ITS/AliHLTITSVertexerZ.h
ITS/AliITSgeom.cxx
ITS/AliITSgeom.h
ITS/AliITShit.cxx
ITS/AliITShit.h
ITS/AliITSmodule.cxx
ITS/AliITSsegmentation.h

index 6d1f57c..5c476f3 100644 (file)
@@ -23,6 +23,7 @@
 #include <AliITS.h>
 #include "AliITSLoader.h"
 #include <AliITSgeom.h>
+#include <AliITSgeomTGeo.h>
 #include <AliITSRecPoint.h>
 #include <AliITSclusterV2.h>
 
@@ -59,13 +60,13 @@ AliHLTITSVertexerZ::~AliHLTITSVertexerZ()
 }
 
 //______________________________________________________________________
-AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR){
+AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom* /* geom */,TTree *tR){
   // Defines the AliESDVertex for the current event
 
   fCurrentVertex = 0;
 
-  Float_t lc[3]; for(Int_t ii=0; ii<3; ii++) lc[ii]=0.;
-  Float_t gc[3]; for(Int_t ii=0; ii<3; ii++) gc[ii]=0.;
+  Double_t lc[3]; for(Int_t ii=0; ii<3; ii++) lc[ii]=0.;
+  Double_t gc[3]; for(Int_t ii=0; ii<3; ii++) gc[ii]=0.;
   //Float_t lc2[3]; for(Int_t ii=0; ii<3; ii++) lc2[ii]=0.;
   //Float_t gc2[3]; for(Int_t ii=0; ii<3; ii++) gc2[ii]=0.;
 
@@ -127,7 +128,8 @@ AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTr
       AliITSclusterV2 *recp = (AliITSclusterV2*)clusters->UncheckedAt(j);
       lc[0]=-recp->GetY()+yshift;
       lc[2]=-recp->GetZ()+zshift[module%4];
-      geom->LtoG(module,lc,gc);
+      AliITSgeomTGeo::LocalToGlobal(module,lc,gc);
+      //      geom->LtoG(module,lc,gc);
       gc[0]-=GetNominalPos()[0];
       gc[1]-=GetNominalPos()[1];
       Float_t xc1,yc1;
@@ -156,7 +158,8 @@ AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTr
       AliITSclusterV2 *recp = (AliITSclusterV2*)clusters->UncheckedAt(j);
       lc[0]=recp->GetY()+yshift;
       lc[2]=-recp->GetZ()+zshift[module%4];
-      geom->LtoG(module,lc,gc);
+      AliITSgeomTGeo::LocalToGlobal(module,lc,gc);
+      //      geom->LtoG(module,lc,gc);
       gc[0]-=GetNominalPos()[0];
       gc[1]-=GetNominalPos()[1];
       Float_t xc2,yc2;
index 9679f16..4cdc1c6 100644 (file)
@@ -29,7 +29,7 @@ public:
   AliHLTITSVertexerZ(Float_t x0, Float_t y0);
   virtual ~AliHLTITSVertexerZ();
 
-  AliESDVertex* FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR);
+  AliESDVertex* FindVertexForCurrentEvent(AliITSgeom* /* geom */,TTree *tR);
 
   void SetBinWidthFine(Float_t bw=0.0005){fStepFine = bw;}
 
index 9da3611..502f8b0 100644 (file)
@@ -587,270 +587,7 @@ void AliITSgeom::PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det)const{
     fprintf(fp,"        dfr= %e %e %e\n",m[2][0],m[2][1],m[2][2]);
     return;
 }
-/*
-//______________________________________________________________________
-void AliITSgeom::PrintGeom(ostream *wb)const{
-    //     Stream out an object of class AliITSgeom to standard output.
-    // Intputs:
-    //     ofstream *wb    The output streaming buffer.
-    // Outputs:
-    //     none.
-    // Return:
-    //     none.
-  Int_t i;
-
-    wb->setf(ios::scientific);
-    streamsize stsiz = wb->precision();
-    *wb << fTrans << " ";
-    *wb << fNmodules << " ";
-    *wb << fNlayers << " ";
-    for(i=0;i<fNlayers;i++) *wb << fNlad[i] << " ";
-    for(i=0;i<fNlayers;i++) *wb << fNdet[i] << "\n";
-    for(i=0;i<fNmodules;i++) {
-        *wb <<setprecision(16) << *(GetGeomMatrix(i)) << "\n";
-    } // end for i
-    *wb << setprecision (stsiz);
-    return;
-}
-*/
-//______________________________________________________________________
-//     The following routines modify the transformation of "this"
-// geometry transformations in a number of different ways.
-//______________________________________________________________________
-void AliITSgeom::GlobalChange(const Float_t *tran,const Float_t *rot){
-    //     This function performs a Cartesian translation and rotation of
-    // the full ITS from its default position by an amount determined by
-    // the three element arrays tran and rot. If every element
-    // of tran and rot are zero then there is no change made
-    // the geometry. The change is global in that the exact same translation
-    // and rotation is done to every detector element in the exact same way.
-    // The units of the translation are those of the Monte Carlo, usually cm,
-    // and those of the rotation are in radians. The elements of tran
-    // are tran[0] = x, tran[1] = y, and tran[2] = z.
-    // The elements of rot are rot[0] = rx, rot[1] = ry, and
-    // rot[2] = rz. A change in x will move the hole ITS in the ALICE
-    // global x direction, the same for a change in y. A change in z will
-    // result in a translation of the ITS as a hole up or down the beam line.
-    // A change in the angles will result in the inclination of the ITS with
-    // respect to the beam line, except for an effective rotation about the
-    // beam axis which will just rotate the ITS as a hole about the beam axis.
-    // Intputs:
-    //     Float_t *tran   A 3 element array representing the global 
-    //                     translations. the elements are x,y,z in cm.
-    //     Float_t *rot    A 3 element array representing the global rotation
-    //                     angles about the three axis x,y,z in radians
-    // Outputs:
-    //     none.
-    // Return:
-    //     none.
-    Int_t    i,j;
-    Double_t t[3],r[3];
-    AliITSgeomMatrix *g;
-
-    fTrans = (fTrans && 0xfffd) + 2;  // set bit 1 true.
-    for(i=0;i<fNmodules;i++){
-        g = this->GetGeomMatrix(i);
-        g->GetTranslation(t);
-        g->GetAngles(r);
-        for(j=0;j<3;j++){
-            t[j] += tran[j];
-            r[j] += rot[j];
-        } // end for j
-        g->SetTranslation(t);
-        g->SetAngles(r);
-    } // end for i
-    return;
-}
-//______________________________________________________________________
-void AliITSgeom::GlobalCylindericalChange(const Float_t *tran,
-                                         const Float_t *rot){
-    //     This function performs a cylindrical translation and rotation of
-    // each ITS element by a fixed about in radius, rphi, and z from its
-    // default position by an amount determined by the three element arrays
-    // tran and rot. If every element of tran and
-    // rot are zero then there is no change made the geometry. The
-    // change is global in that the exact same distance change in translation
-    // and rotation is done to every detector element in the exact same way.
-    // The units of the translation are those of the Monte Carlo, usually cm,
-    // and those of the rotation are in radians. The elements of tran
-    // are tran[0] = r, tran[1] = rphi, and tran[2] = z.
-    // The elements of rot are rot[0] = rx, rot[1] = ry, and
-    // rot[2] = rz. A change in r will results in the increase of the
-    // radius of each layer by the same about. A change in rphi will results in
-    // the rotation of each layer by a different angle but by the same
-    // circumferential distance. A change in z will result in a translation
-    // of the ITS as a hole up or down the beam line. A change in the angles
-    // will result in the inclination of the ITS with respect to the beam
-    // line, except for an effective rotation about the beam axis which will
-    // just rotate the ITS as a hole about the beam axis.
-    // Intputs:
-    //     Float_t *tran   A 3 element array representing the global 
-    //                     translations. the elements are r,theta,z in 
-    //                     cm/radians.
-    //     Float_t *rot    A 3 element array representing the global rotation
-    //                     angles about the three axis x,y,z in radians
-    // Outputs:
-    //     none.
-    // Return:
-    //     none.
-    Int_t    i,j;
-    Double_t t[3],ro[3],r,r0,phi,rphi;
-    AliITSgeomMatrix *g;
-
-    fTrans = (fTrans && 0xfffd) + 2;  // set bit 1 true.
-    for(i=0;i<fNmodules;i++){
-        g = this->GetGeomMatrix(i);
-        g->GetTranslation(t);
-        g->GetAngles(ro);
-        r = r0= TMath::Hypot(t[1],t[0]);
-        phi   = TMath::ATan2(t[1],t[0]);
-        rphi  = r0*phi;
-        r    += tran[0];
-        rphi += tran[1];
-        phi   = rphi/r0;
-        t[0]  = r*TMath::Cos(phi);
-        t[1]  = r*TMath::Sin(phi);
-        t[2] += tran[2];
-        for(j=0;j<3;j++){
-            ro[j] += rot[j];
-        } // end for j
-        g->SetTranslation(t);
-        g->SetAngles(ro);
-    } // end for i
-    return;
-}
-//______________________________________________________________________
-void AliITSgeom::RandomChange(const Float_t *stran,const Float_t *srot){
-    //     This function performs a Gaussian random displacement and/or
-    // rotation about the present global position of each active
-    // volume/detector of the ITS. The sigma of the random displacement
-    // is determined by the three element array stran, for the
-    // x y and z translations, and the three element array srot,
-    // for the three rotation about the axis x y and z.
-    // Intputs:
-    //     Float_t *stran  A 3 element array representing the global 
-    //                     translations variances. The elements are x,
-    //                     y,z in cm.
-    //     Float_t *srot   A 3 element array representing the global rotation
-    //                     angles variances about the three axis x,y,z in 
-    //                     radians.
-    // Outputs:
-    //     none.
-    // Return:
-    //     none.
-    Int_t    i,j;
-    Double_t t[3],r[3];
-    AliITSgeomMatrix *g;
 
-    fTrans = (fTrans && 0xfffd) + 2;  // set bit 1 true.
-    for(i=0;i<fNmodules;i++){
-        g = this->GetGeomMatrix(i);
-        g->GetTranslation(t);
-        g->GetAngles(r);
-        for(j=0;j<3;j++){
-            t[j] += gRandom->Gaus(0.0,stran[j]);
-            r[j] += gRandom->Gaus(0.0, srot[j]);
-        } // end for j
-        g->SetTranslation(t);
-        g->SetAngles(r);
-    } // end for i
-    return;
-}
-//______________________________________________________________________
-void AliITSgeom::RandomCylindericalChange(const Float_t *stran,
-                                         const Float_t *srot){
-    //     This function performs a Gaussian random displacement and/or
-    // rotation about the present global position of each active
-    // volume/detector of the ITS. The sigma of the random displacement
-    // is determined by the three element array stran, for the
-    // r rphi and z translations, and the three element array srot,
-    // for the three rotation about the axis x y and z. This random change
-    // in detector position allow for the simulation of a random uncertainty
-    // in the detector positions of the ITS.
-    // Intputs:
-    //     Float_t *stran  A 3 element array representing the global 
-    //                     translations variances. The elements are r,
-    //                     theta,z in cm/radians.
-    //     Float_t *srot   A 3 element array representing the global rotation
-    //                     angles variances about the three axis x,y,z in 
-    //                     radians.
-    // Outputs:
-    //     none.
-    // Return:
-    //     none.
-    Int_t    i,j;
-    Double_t t[3],ro[3],r,r0,phi,rphi;
-    TRandom ran;
-    AliITSgeomMatrix *g;
-
-    fTrans = (fTrans && 0xfffd) + 2;  // set bit 1 true.
-    for(i=0;i<fNmodules;i++){
-        g = this->GetGeomMatrix(i);
-        g->GetTranslation(t);
-        g->GetAngles(ro);
-        r = r0= TMath::Hypot(t[1],t[0]);
-        phi   = TMath::ATan2(t[1],t[0]);
-        rphi  = r0*phi;
-        r    += ran.Gaus(0.0,stran[0]);
-        rphi += ran.Gaus(0.0,stran[1]);
-        phi   = rphi/r0;
-        t[0]  = r*TMath::Cos(phi);
-        t[1]  = r*TMath::Sin(phi);
-        t[2] += ran.Gaus(0.0,stran[2]);
-        for(j=0;j<3;j++){
-            ro[j] += ran.Gaus(0.0, srot[j]);
-        } // end for j
-        g->SetTranslation(t);
-        g->SetAngles(ro);
-    } // end for i
-    return;
-}
-//______________________________________________________________________
-void AliITSgeom::GeantToTracking(const AliITSgeom &source){
-    //     Copy the geometry data but change it to go between the ALICE
-    // Global coordinate system to that used by the ITS tracking. A slightly
-    // different coordinate system is used when tracking. This coordinate 
-    // system is only relevant when the geometry represents the cylindrical
-    // ALICE ITS geometry. For tracking the Z axis is left alone but X-> -Y
-    // and Y-> X such that X always points out of the ITS cylinder for every
-    // layer including layer 1 (where the detectors are mounted upside down).
-    //Begin_Html
-    /*
-      <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
-    */
-    //End_Html
-    // Input:
-    //     AliITSgeom &source  The AliITSgeom class with which to make this
-    //                         a copy of.
-    // Output:
-    //     none.
-    // Return:
-    //     none.
-    Int_t    i,j,k,l,id[3];
-    Double_t r0[3][3],r1[3][3];
-    Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
-    Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
-
-    *this = source;  // copy everything
-    for(i=0;i<GetIndexMax();i++){
-        GetGeomMatrix(i)->GetIndex(id);
-        GetGeomMatrix(i)->GetMatrix(r0);
-        if(id[0]==1){ // Layer 1 is treated different from the others.
-            for(j=0;j<3;j++) for(k=0;k<3;k++){
-                r1[j][k] = 0.;
-                for(l=0;l<3;l++) r1[j][k] += a0[j][l]*r0[l][k];
-            } // end for j,k
-        }else{
-            for(j=0;j<3;j++) for(k=0;k<3;k++){
-                r1[j][k] = 0.;
-                for(l=0;l<3;l++) r1[j][k] += a1[j][l]*r0[l][k];
-            } // end for j,k
-        } // end if
-        GetGeomMatrix(i)->SetMatrix(r1);
-    } // end for i
-    this->fTrans = (this->fTrans && 0xfffe) + 1;  // set bit 0 true.
-    return;
-}
 //______________________________________________________________________
 Int_t AliITSgeom::GetNearest(const Double_t g[3],Int_t lay)const{
     //      Finds the Detector (Module) that is nearest the point g [cm] in
index 5a71ae5..6fda161 100644 (file)
@@ -335,358 +335,7 @@ class AliITSgeom : public TObject {
     // given in two Double point arrays g[3], and l[3].
     void GtoL(Int_t index,const Double_t g[3],Double_t l[3])const{
         GetGeomMatrix(index)->GtoLPosition(g,l);}
-    //
-    //     Transforms from the ALICE Global coordinate system
-    // to the detector local coordinate system (used for ITS tracking)
-    // for the detector module index number. The global and local
-    // coordinate are given in two Double point arrays g[3], and l[3].
-    void GtoLtracking(Int_t index,const Double_t *g,Double_t *l)const{
-        if(IsGeantToTracking()) GtoL(index,g,l);
-        else GetGeomMatrix(index)->GtoLPositionTracking(g,l);}
-    //     Transforms from the ALICE Global coordinate system
-    // to the detector local coordinate system (used for ITS tracking)
-    // for the detector id[3]. The global and local
-    // coordinate are given in two Double point arrays g[3], and l[3].
-    void GtoLtracking(const Int_t *id,const Double_t *g,Double_t *l)const{
-        GtoLtracking(GetModuleIndex(id),g,l);}
-    //     Transforms from the ALICE Global coordinate system
-    // to the detector local coordinate system (used for ITS tracking)
-    // for the detector layer ladder and detector numbers. The global
-    // and local coordinate are given in two Double point arrays g[3],
-    // and l[3].
-    void GtoLtracking(Int_t lay,Int_t lad,Int_t det,
-                      const Double_t *g,Double_t *l)const{
-        GtoLtracking(GetModuleIndex(lay,lad,det),g,l);}
-    //
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // for the detector layer ladder and detector numbers. The global
-    // and local coordinate are given in two float point arrays g[3],
-    // and l[3].
-    void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
-                      const Float_t *g,Float_t *l)const{
-        GtoLMomentum(GetModuleIndex(lay,lad,det),g,l);}
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // for the detector module index number. The global and local
-    // coordinate are given in two float point arrays g[3], and l[3].
-    void GtoLMomentum(Int_t index,const Float_t *g,Float_t *l)const{
-        Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
-        GetGeomMatrix(index)->GtoLMomentum(dg,dl);
-        for(i=0;i<3;i++) l[i] =dl[i];}
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // for the detector layer ladder and detector numbers. The global
-    // and local coordinate are given in two Double point arrays g[3],
-    // and l[3].
-    void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
-                      const Double_t *g,Double_t *l)const{
-        GtoLMomentum(GetModuleIndex(lay,lad,det),g,l);}
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // for the detector module index number. The global and local
-    // coordinate are given in two Double point arrays g[3], and l[3].
-    void GtoLMomentum(Int_t index,const Double_t *g,Double_t *l)const{
-        Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
-        GetGeomMatrix(index)->GtoLMomentum(dg,dl);
-        for(i=0;i<3;i++) l[i] =dl[i];}
-    //
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // (used for ITS tracking) for the detector module index number.
-    // The global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void GtoLMomentumTracking(Int_t index,const Double_t *g,Double_t *l)const{
-        if(IsGeantToTracking()) GtoLMomentum(index,g,l);
-        else GetGeomMatrix(index)->GtoLMomentumTracking(g,l);}
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // (used for ITS tracking) for the detector id[3].
-    // The global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void GtoLMomentumTracking(const Int_t *id,
-                             const Double_t *g,Double_t *l)const{
-        GtoLMomentumTracking(GetModuleIndex(id),g,l);}
-    //     Transforms of momentum types of quantities from the ALICE
-    // Global coordinate system to the detector local coordinate system
-    // (used for ITS tracking) for the detector layer ladder and detector
-    // numbers. The global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void GtoLMomentumTracking(Int_t lay,Int_t lad,Int_t det,
-                              const Double_t *g,Double_t *l)const{
-        GtoLMomentumTracking(GetModuleIndex(lay,lad,det),g,l);}
-    //
-    //     Transforms from the detector local coordinate system
-    // to the ALICE Global coordinate  system for the detector
-    // defined by the layer, ladder, and detector numbers. The
-    // global and local coordinate are given in two floating point
-    // arrays g[3], and l[3].
-    void LtoG(Int_t lay,Int_t lad,Int_t det,
-              const Float_t *l,Float_t *g)const{
-        LtoG(GetModuleIndex(lay,lad,det),l,g);}
-    //     Transforms from the detector local coordinate system
-    // to the ALICE Global coordinate system for the detector
-    // defined by the id[0], id[1], and id[2] numbers. The
-    // global and local coordinate are given in two floating point
-    // arrays g[3], and l[3].
-    void LtoG(const Int_t *id,const Float_t *l,Float_t *g)const{
-        LtoG(GetModuleIndex(id),l,g);}
-    //     Transforms from the detector local coordinate system
-    // to the ALICE Global coordinate system for the detector
-    // module index number. The global and local coordinate are
-    // given in two floating point arrays g[3], and l[3].
-    void LtoG(Int_t index,const Float_t *l,Float_t *g)const{
-        Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
-        GetGeomMatrix(index)->LtoGPosition(dl,dg);
-        for(i=0;i<3;i++) g[i] =dg[i];}
-    //     Transforms from the detector local coordinate system
-    // to the ALICE Global coordinate system for the detector
-    // defined by the layer, ladder, and detector numbers. The
-    // global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void LtoG(Int_t lay,Int_t lad,Int_t det,
-              const Double_t *l,Double_t *g)const{
-        LtoG(GetModuleIndex(lay,lad,det),l,g);}
-    //     Transforms from the detector local coordinate system
-    // to the ALICE Global coordinate system for the detector
-    // defined by the id[0], id[1], and id[2] numbers. The
-    // global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void LtoG(const Int_t *id,const Double_t *l,Double_t *g)const{
-        LtoG(GetModuleIndex(id),l,g);}
-    //     Transforms from the detector local coordinate system
-    // to the ALICE Global coordinate system for the detector
-    // module index number. The global and local coordinate are
-    // given in two Double point arrays g[3], and l[3].
-    void LtoG(Int_t index,const Double_t *l,Double_t *g)const{
-        GetGeomMatrix(index)->LtoGPosition(l,g);}
-    //
-    //     Transforms from the detector local coordinate system (used
-    // for ITS tracking) to the ALICE Global coordinate system 
-    // for the detector module index number. The global and local
-    // coordinate are given in two Double point arrays g[3], and l[3].
-    void LtoGtracking(Int_t index,const Double_t *l,Double_t *g)const{
-        if(IsGeantToTracking()) LtoG(index,l,g);
-        else GetGeomMatrix(index)->LtoGPositionTracking(l,g);}
-    //     Transforms from the detector local coordinate system (used
-    // for ITS tracking) to the ALICE Global coordinate system 
-    // for the detector id[3]. The global and local
-    // coordinate are given in two Double point arrays g[3], and l[3].
-    void LtoGtracking(const Int_t *id,const Double_t *l,Double_t *g)const{
-        LtoGtracking(GetModuleIndex(id),l,g);}
-    //     Transforms from the detector local coordinate system (used
-    // for ITS tracking) to the detector local coordinate system
-    // for the detector layer ladder and detector numbers. The global
-    // and local coordinate are given in two Double point arrays g[3],
-    // and l[3].
-    void LtoGtracking(Int_t lay,Int_t lad,Int_t det,
-                      const Double_t *l,Double_t *g)const{
-        LtoGtracking(GetModuleIndex(lay,lad,det),l,g);}
-    //
-    //     Transforms of momentum types of quantities from the detector
-    // local coordinate system to the ALICE Global coordinate system
-    // for the detector layer ladder and detector numbers. The global
-    // and local coordinate are given in two float point arrays g[3],
-    // and l[3].
-    void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
-                      const Float_t *l,Float_t *g)const{
-        LtoGMomentum(GetModuleIndex(lay,lad,det),l,g);}
-    //     Transforms of momentum types of quantities from the detector
-    // local coordinate system to the ALICE Global coordinate system
-    // for the detector module index number. The global and local
-    // coordinate are given in two float point arrays g[3], and l[3].
-    void LtoGMomentum(Int_t index,const Float_t *l,Float_t *g)const{
-        Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
-        GetGeomMatrix(index)->LtoGMomentum(dl,dg);
-        for(i=0;i<3;i++) g[i] =dg[i];}
-    //     Transforms of momentum types of quantities from the detector
-    // local coordinate system to the ALICE Global coordinate system
-    // for the detector layer ladder and detector numbers. The global
-    // and local coordinate are given in two Double point arrays g[3],
-    // and l[3].
-    void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
-                      const Double_t *l,Double_t *g)const{
-        LtoGMomentum(GetModuleIndex(lay,lad,det),l,g);}
-    //     Transforms of momentum types of quantities from the detector
-    // local coordinate system to the ALICE Global coordinate system
-    // for the detector module index number. The global and local
-    // coordinate are given in two Double point arrays g[3], and l[3].
-    void LtoGMomentum(Int_t index,const Double_t *l,Double_t *g)const{
-        GetGeomMatrix(index)->LtoGMomentum(l,g);}
-    //
-    //     Transforms of momentum types of quantities from the detector 
-    // local coordinate system (used for ITS tracking) to the detector
-    // system ALICE Global for the detector module index number.
-    // The global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void LtoGMomentumTracking(Int_t index,const Double_t *l,Double_t *g)const{
-        if(IsGeantToTracking()) LtoGMomentum(index,l,g);
-        else GetGeomMatrix(index)->LtoGMomentumTracking(l,g);}
-    //     Transforms of momentum types of quantities from the detector
-    // local coordinate system (used for ITS tracking) to the ALICE
-    // Global coordinate system for the detector id[3].
-    // The global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void LtoGMomentumTracking(const Int_t *id,const Double_t *l,Double_t *g)
-        const{LtoGMomentumTracking(GetModuleIndex(id),l,g);}
-    //     Transforms of momentum types of quantities from the detector
-    // local coordinate system (used for ITS tracking) to the ALICE
-    // Global coordinate system for the detector layer ladder and detector
-    // numbers. The global and local coordinate are given in two Double point
-    // arrays g[3], and l[3].
-    void LtoGMomentumTracking(Int_t lay,Int_t lad,Int_t det,
-                              const Double_t *l,Double_t *g)const{
-                        LtoGMomentumTracking(GetModuleIndex(lay,lad,det),l,g);}
-    //
-    //     Transforms from one detector local coordinate system
-    // to another detector local coordinate system for the detector
-    // module index1 number to the detector module index2 number. The
-    //  local coordinates are given in two Double point arrays l1[3],
-    // and l2[3].
-    void LtoL(Int_t index1,Int_t index2,Double_t *l1,Double_t *l2)const{
-        Double_t g[3]; LtoG(index1,l1,g);GtoL(index2,g,l2);}
-    //     Transforms from one detector local coordinate system
-    // to another detector local coordinate system for the detector
-    // id1[3] to the detector id2[3]. The local coordinates are given
-    // in two Double point arrays l1[3], and l2[3].
-    void LtoL(const Int_t *id1,const Int_t *id2,Double_t *l1,Double_t *l2)
-        const{LtoL(GetModuleIndex(id1[0],id1[1],id1[2]),
-              GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
-    //
-    //     Transforms from one detector local coordinate system (used for
-    // ITS tracking) to another detector local coordinate system (used
-    // for ITS tracking) for the detector module index1 number to the
-    // detector module index2 number. The local coordinates are given
-    // in two Double point arrays l1[3], and l2[3].
-    void LtoLtracking(Int_t index1,Int_t index2,
-                      Double_t *l1,Double_t *l2)const{
-        Double_t g[3]; LtoGtracking(index1,l1,g);GtoLtracking(index2,g,l2);}
-    //     Transforms from one detector local coordinate system (used for
-    // ITS tracking) to another detector local coordinate system (used
-    // for ITS tracking) for the detector id1[3] to the detector id2[3].
-    // The local coordinates are given in two Double point arrays l1[3],
-    // and l2[3].
-    void LtoLtracking(const Int_t *id1,const Int_t *id2,
-                      Double_t *l1,Double_t *l2)const{
-        LtoLtracking(GetModuleIndex(id1[0],id1[1],id1[2]),
-                     GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
-    //
-    //     Transforms of momentum types of quantities from one detector
-    // local coordinate system to another detector local coordinate
-    // system for the detector module index1 number to the detector
-    // module index2 number. The local coordinates are given in two
-    // Double point arrays l1[3], and l2[3].
-    void LtoLMomentum(Int_t index1,Int_t index2,
-                      const Double_t *l1,Double_t *l2)const{
-        Double_t g[3]; LtoGMomentum(index1,l1,g);GtoLMomentum(index2,g,l2);}
-    //     Transforms of momentum types of quantities from one detector
-    // local coordinate system to another detector local coordinate
-    // system for the detector id1[3] to the detector id2[3]. The local
-    // coordinates are given in two Double point arrays l1[3], and l2[3].
-    void LtoLMomentum(const Int_t *id1,const Int_t *id2,
-                      const Double_t *l1,Double_t *l2)const{
-        LtoLMomentum(GetModuleIndex(id1[0],id1[1],id1[2]),
-                     GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
-    //
-    //     Transforms of momentum types of quantities from one detector
-    // local coordinate system (used by ITS tracking) to another detector
-    // local coordinate system (used by ITS tracking) for the detector
-    // module index1 number to the detector module index2 number. The
-    // local coordinates are given in two Double point arrays l1[3],
-    // and l2[3].
-    void LtoLMomentumTracking(Int_t index1,Int_t index2,
-                              Double_t *l1,Double_t *l2)const{
-        Double_t g[3]; LtoGMomentumTracking(index1,l1,g);
-        GtoLMomentumTracking(index2,g,l2);}
-    //     Transforms of momentum types of quantities from one detector
-    // local coordinate system (used by ITS tracking) to another detector
-    // local coordinate system (used by ITS tracking) for the detector
-    // id1[3] to the detector id2[3]. The local coordinates are given in
-    // two Double point arrays l1[3], and l2[3].
-    void LtoLMomentumTracking(const Int_t *id1,const Int_t *id2,
-                              Double_t *l1,Double_t *l2)const{
-        LtoLMomentumTracking(GetModuleIndex(id1[0],id1[1],id1[2]),
-                              GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // the ALICE Global coordinate system to a detector local coordinate
-    // system. The specific detector is determined by the module index
-    // number.
-    void GtoLErrorMatrix(Int_t index,const Double_t **g,Double_t **l)const{
-        GetGeomMatrix(index)->GtoLPositionError(
-            (Double_t (*)[3])g,(Double_t (*)[3])l);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // the ALICE Global coordinate system to a detector local coordinate
-    // system (used by ITS tracking). The specific detector is determined
-    // by the module index number.
-    void GtoLErrorMatrixTracking(Int_t index,const Double_t **g,
-                                 Double_t **l)const{
-        if(IsGeantToTracking()) GetGeomMatrix(index)->GtoLPositionError((
-                                    Double_t (*)[3])g,(Double_t (*)[3])l);
-        else GetGeomMatrix(index)->GtoLPositionErrorTracking(
-            (Double_t (*)[3])g,(Double_t (*)[3])l);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // the detector local coordinate system to a ALICE Global coordinate
-    // system. The specific detector is determined by the module index
-    // number.
-    void LtoGErrorMatrix(Int_t index,const Double_t **l,Double_t **g)const{
-        GetGeomMatrix(index)->LtoGPositionError(
-            (Double_t (*)[3])l,(Double_t (*)[3])g);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // the detector local coordinate system to a ALICE Global coordinate
-    // system. The specific detector is determined by the module index
-    // number.
-    void LtoGErrorMatrix(Int_t index,const Double_t l[3][3],Double_t g[3][3])
-        const{
-        GetGeomMatrix(index)->LtoGPositionError(
-            (Double_t (*)[3])l,(Double_t (*)[3])g);}
-
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // the detector local coordinate system (used by ITS tracking) to a
-    // ALICE Global coordinate system. The specific detector is determined
-    // by the module index number.
-    void LtoGErrorMatrixTracking(Int_t index,const Double_t **l,
-                                 Double_t **g)const{
-        if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError(
-            (Double_t (*)[3])g,(Double_t (*)[3])l);
-        else GetGeomMatrix(index)->LtoGPositionErrorTracking(
-            (Double_t (*)[3])l,(Double_t (*)[3])g);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // the detector local coordinate system (used by ITS tracking) to a
-    // ALICE Global coordinate system. The specific detector is determined
-    // by the module index number.
-    void LtoGErrorMatrixTracking(Int_t index,const Double_t l[3][3],
-                                 Double_t g[3][3])const{
-        if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError(
-            (Double_t (*)[3])g,(Double_t (*)[3])l);
-        else GetGeomMatrix(index)->LtoGPositionErrorTracking(
-            (Double_t (*)[3])l,(Double_t (*)[3])g);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // one detector local coordinate system to another detector local
-    // coordinate system. The specific detector is determined by the
-    // two module index number index1 and index2.
-    void LtoLErrorMatrix(Int_t index1,Int_t index2,
-                         const Double_t **l1,Double_t **l2)const{
-        Double_t g[3][3];
-        LtoGErrorMatrix(index1,l1,(Double_t **)g);
-        GtoLErrorMatrix(index2,(const Double_t **)g,l2);}
-    //
-    //     Transforms a matrix, like an Uncertainty or Error matrix from
-    // one detector local coordinate system (used by ITS tracking) to
-    // another detector local coordinate system (used by ITS tracking).
-    // The specific detector is determined by the two module index number
-    // index1 and index2.
-    void LtoLErrorMatrixTraking(Int_t index1,Int_t index2,
-                                const Double_t **l1,Double_t **l2)const{
-        Double_t g[3][3];
-        LtoGErrorMatrixTracking(index1,l1,(Double_t **)g);
-        GtoLErrorMatrixTracking(index2,(const Double_t **)g,l2);}
     //  Find Specific Modules
     // Locate the nearest module to the point g, in ALICE global Cartesian
     // coordinates [cm] in a give layer. If layer = 0 then it search in
@@ -701,30 +350,6 @@ class AliITSgeom : public TObject {
     // the detector/module specified by the the module index number.
     Double_t Distance(Int_t index,const Double_t g[3])const{
         return  TMath::Sqrt(GetGeomMatrix(index)->Distance2(g));}
-    //  Geometry manipulation
-    // This function performs a Cartesian translation and rotation of
-    // the full ITS from its default position by an amount determined by
-    // the three element arrays tran and rot.
-    void GlobalChange(const Float_t  *tran,const Float_t  *rot);
-    // This function performs a Cylindrical translation and rotation of
-    // the full ITS from its default position by an amount determined by
-    // the three element arrays tran and rot.
-    void GlobalCylindericalChange(const Float_t *tran,const Float_t *rot);
-    // This function performs a Gaussian random displacement and/or
-    // rotation about the present global position of each active
-    // volume/detector of the ITS with variances given by stran and srot.
-    void RandomChange(const Float_t *stran,const Float_t *srot);
-    // This function performs a Gaussian random displacement and/or
-    // rotation about the present global position of each active
-    // volume/detector of the ITS with variances given by stran and srot.
-    // But in Cylindrical coordinates.
-    void RandomCylindericalChange(const Float_t *stran,const Float_t *srot);
-    // This function converts these transformations from Alice global and
-    // local to Tracking global and local.
-    //
-    // This converts the geometry
-    void GeantToTracking(const AliITSgeom &source);
-    //  Other routines.
     // This routine prints, to a file, the contents of this class.
     void PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det)const;
     // This function prints out this class in a single stream. This steam
index e6352ed..2942ad0 100644 (file)
@@ -476,37 +476,7 @@ void AliITShit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,
     tof = ft0;
     return;
 }
-//______________________________________________________________________
-void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
-    //     Returns the momentum of this hit in the local coordinates of this
-    // module, and in the units of the Monte Carlo.
-    // Inputs:
-    //   none.
-    // Outputs:
-    //   Float_t px   Track x momentum at this hit [GeV/c]
-    //   Float_t py   Track y momentum at this hit [GeV/c]
-    //   Float_t pz   Track z momentum at this hit [GeV/c]
-    // Return:
-    //   none.
-    AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
-    Float_t g[3],l[3];
 
-    g[0] = fPx;
-    g[1] = fPy;
-    g[2] = fPz;
-    if (gm) {
-        gm->GtoLMomentum(fModule,g,l);
-        px = l[0];
-        py = l[1];
-        pz = l[2];
-    } else {
-        Error("AliITShit","NULL pointer to the geometry! return smth else");
-        px=fPx;
-        py=fPy;
-        pz=fPz;
-    } // end if
-    return;
-}
 //______________________________________________________________________
 TParticle * AliITShit::GetParticle() const {
     //     Returns the pointer to the TParticle for the particle that created
index 9dda3f9..b2bc9cd 100644 (file)
@@ -196,6 +196,7 @@ class AliITShit : public AliHit {
     virtual Float_t GetZL(){
         // Returns particle Z position at this hit in local coordinates.
         Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);return zf;}
+  
     // Get Monti Carlo information about hit.
     virtual void GetMomentumG(Float_t &px,Float_t &py,Float_t &pz)const {
         // returns the particle momentum in the Global frame
@@ -212,18 +213,6 @@ class AliITShit : public AliHit {
     virtual Float_t GetPZG()const {// Returns particle Z momentum at
         // this hit in global coordinates.
         return fPz;}
-    virtual void GetMomentumL(Float_t &px,Float_t &py,Float_t &pz);
-    virtual void GetMomentumL(Double_t &px,Double_t &py,Double_t &pz){
-        // Returns particle 3 momentum at this hit in local coordinates.        
-        Float_t x,y,z;GetMomentumL(x,y,z);px=x,py=y,pz=z;}
-    virtual Float_t GetPXL(){Float_t px,py,pz;GetMomentumL(px,py,pz);
-                             return px;}
-    // Returns particle X momentum at this hit in local coordinates.
-    virtual Float_t GetPYL(){Float_t px,py,pz;GetMomentumL(px,py,pz);
-                             return py;}
-    // Returns particle Y momentum at this hit in local coordinates.
-    virtual Float_t GetPZL(){Float_t px,py,pz;GetMomentumL(px,py,pz);
-                             return pz;}
     // Returns particle Z momentum at this hit in local coordinates.
     virtual TParticle * GetParticle() const; // Returns ptr to this particle.
     Bool_t StatusInside() const {// checks if the particle is "inside"
index 18ed233..446c5e9 100644 (file)
@@ -23,7 +23,7 @@
 #include "AliITS.h"
 #include "AliITShit.h"
 #include "AliITSmodule.h"
-#include "AliITSgeom.h"
+#include "AliITSgeomTGeo.h"
 
 ClassImp(AliITSmodule)
 
@@ -274,11 +274,10 @@ Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
     // passing through a volume. Returns kFALSE untill the the track leaves
     // the volume.
     // median hit
-   AliITSgeom *gm = fITS->GetITSgeom();
    Float_t x1l=0.,y1l=0.,z1l=0.;
    Float_t x2l=0.,y2l=0.,z2l=0.;
    Float_t xMl,yMl=0,zMl;
-   Float_t l[3], g[3];
+   Double_t l[3], g[3];
 
    h1->GetPositionG(x1l,y1l,z1l);
    h2->GetPositionG(x2l,y2l,z2l);
@@ -294,7 +293,7 @@ Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
    l[0] = xMl;
    l[1] = yMl;
    l[2] = zMl;
-   gm->LtoG(h1->GetModule(),l,g);
+   AliITSgeomTGeo::LocalToGlobal(h1->GetModule(),l,g);
    x = g[0];
    y = g[1];
    z = g[2];
@@ -306,16 +305,15 @@ void AliITSmodule::MedianHitG(Int_t index,
                              Float_t hitx2,Float_t hity2,Float_t hitz2,
                              Float_t &xMg, Float_t &yMg, Float_t &zMg){
   // median hit
-   AliITSgeom *gm = fITS->GetITSgeom();
    Float_t x1l,y1l,z1l;
    Float_t x2l,y2l,z2l;
    Float_t xMl,yMl=0,zMl;
-   Float_t l[3], g[3];
+   Double_t l[3], g[3];
 
    g[0] = hitx1;
    g[1] = hity1;
    g[2] = hitz1;
-   gm->GtoL(index,g,l);
+   AliITSgeomTGeo::GlobalToLocal(index,g,l);
    x1l = l[0];
    y1l = l[1];
    z1l = l[2];
@@ -323,7 +321,7 @@ void AliITSmodule::MedianHitG(Int_t index,
    g[0] = hitx2;
    g[1] = hity2;
    g[2] = hitz2;
-   gm->GtoL(index,g,l);
+   AliITSgeomTGeo::GlobalToLocal(index,g,l);
    x2l = l[0];
    y2l = l[1];
    z2l = l[2];
@@ -339,7 +337,7 @@ void AliITSmodule::MedianHitG(Int_t index,
    l[0] = xMl;
    l[1] = yMl;
    l[2] = zMl;
-   gm->LtoG(index,l,g);
+   AliITSgeomTGeo::LocalToGlobal(index,l,g);
    xMg = g[0];
    yMg = g[1];
    zMg = g[2];
@@ -388,7 +386,7 @@ void AliITSmodule::MedianHit(Int_t index,
 //___________________________________________________________________________
 void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
   // get ID
-       fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
-       return ;
+  AliITSgeomTGeo::GetModuleId(fIndex,lay,lad,det);
+  return ;
 }
 
index 2f11127..def0ffc 100644 (file)
@@ -54,18 +54,6 @@ public TObject {
     // Transformation from detector segmentation/cell coordiantes starting
     // from (0,0) to Geant cm detector center local coordinates.
     virtual void    DetToLocal(Int_t,Int_t,Float_t &,Float_t &) const = 0;
-
-    // Transform from real global to local coordinates
-    void GetLocal(Int_t module,Float_t *g ,Float_t *l, AliITSgeom *geom) const {
-      if(geom) geom->GtoL(module,g,l);
-      else AliFatal("Pointer to ITS geometry class (AliITSgeom) is null\n");
-    }
-    // Transform from real local to global coordinates
-    void GetGlobal(Int_t module,Float_t *l ,Float_t *g, AliITSgeom *geom) const {
-      if(geom) geom->LtoG(module,l,g);
-      else AliFatal("Pointer to ITS geometry class (AliITSgeom) is null\n");
-    }
-
     // Initialisation
     virtual void Init() = 0;
     //