remove props
[u/mrichter/AliRoot.git] / ITS / AliITSgeomMatrix.cxx
index cb6f221..5134615 100644 (file)
 /* 
 $Id$ 
 */
-/*
- This is the implementation file for AliITSgeomMatrix class. It 
- contains the routines to manipulate, setup, and queary the geometry 
- of a given ITS module. An ITS module may be one of at least three
- ITS detector technologies, Silicon Pixel, Drift, or Strip Detectors,
- and variations of these in size and/or layout. These routines let
- one go between ALICE global coordiantes (cm) to a given modules 
- specific local coordinates (cm).
-*/
+////////////////////////////////////////////////////////////////////////
+// This is the implementation file for AliITSgeomMatrix class. It 
+// contains the routines to manipulate, setup, and queary the geometry 
+// of a given ITS module. An ITS module may be one of at least three
+// ITS detector technologies, Silicon Pixel, Drift, or Strip Detectors,
+// and variations of these in size and/or layout. These routines let
+// one go between ALICE global coordiantes (cm) to a given modules 
+// specific local coordinates (cm).
+////////////////////////////////////////////////////////////////////////
 
 #include <Riostream.h>
+#include <TClass.h>
 #include <TMath.h>
 #include <TBuffer.h>
-#include <TClass.h>
 #include <TCanvas.h>
+#if ROOT_VERSION_CODE>= 331523
+#include <TView3D.h>
+#else
 #include <TView.h>
+#endif
 #include <TPolyLine3D.h>
-//#include <TPolyLineShape.h>
 #include <TNode.h>
 #include <TPCON.h>
 #include <TBRIK.h>
 #include <TXTRU.h>
 
+#include "AliLog.h"
 #include "AliITSgeomMatrix.h"
 
 ClassImp(AliITSgeomMatrix)
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix():
-TObject(),
+TObject(),         // Base Class.
 fDetectorIndex(0), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
@@ -81,13 +85,22 @@ fPath(){     // Path in geometry to this module
        fid[i] = 0;
        frot[i] = ftran[i] = 0.0;
        for(j=0;j<3;j++) fm[i][j] = 0.0;
-       fCylR = fCylPhi = 0.0;
     }// end for i
     fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
 }
+
 //----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) : 
-    TObject(sourse){
+AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &source) : 
+TObject(source),         // Base Class.
+fDetectorIndex(source.fDetectorIndex),// Detector type index (like 
+                                      // fShapeIndex was)
+fid(),       // layer, ladder, detector numbers.
+frot(),      //! vector of rotations about x,y,z [radians].
+ftran(),     // Translation vector of module x,y,z.
+fCylR(source.fCylR),  //! R Translation in Cylinderical coordinates
+fCylPhi(source.fCylPhi),//! Phi Translation vector in Cylindrical coord.
+fm(),        // Rotation matrix based on frot.
+fPath(source.fPath){
     // The standard Copy constructor. This make a full / proper copy of
     // this class.
     // Inputs:
@@ -96,21 +109,17 @@ AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) :
     //    none.
     // Return:
     //    A copy constructes AliITSgeomMatrix class.
-       Int_t i,j;
+    Int_t i,j;
 
-       this->fDetectorIndex = sourse.fDetectorIndex;
-       for(i=0;i<3;i++){
-               this->fid[i]     = sourse.fid[i];
-               this->frot[i]    = sourse.frot[i];
-               this->ftran[i]   = sourse.ftran[i];
-               this->fCylR      = sourse.fCylR;
-               this->fCylPhi    = sourse.fCylPhi;
-               for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
-       }// end for i
-     this->fPath   = sourse.fPath;
+    for(i=0;i<3;i++){
+        this->fid[i]     = source.fid[i];
+        this->frot[i]    = source.frot[i];
+        this->ftran[i]   = source.ftran[i];
+        for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
+    }// end for i
 }
 //----------------------------------------------------------------------
-void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
+AliITSgeomMatrix& AliITSgeomMatrix::operator=(const AliITSgeomMatrix &source){
     // The standard = operator. This make a full / proper copy of
     // this class.
     // The standard Copy constructor. This make a full / proper copy of
@@ -121,24 +130,27 @@ void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
     //    none.
     // Return:
     //    A copy of the source AliITSgeomMatrix class.
-       Int_t i,j;
 
-       this->fDetectorIndex = sourse.fDetectorIndex;
-       for(i=0;i<3;i++){
-               this->fid[i]     = sourse.fid[i];
-               this->frot[i]    = sourse.frot[i];
-               this->ftran[i]   = sourse.ftran[i];
-               this->fCylR      = sourse.fCylR;
-               this->fCylPhi    = sourse.fCylPhi;
-               for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
-       }// end for i
-     this->fPath   = sourse.fPath;
+    if(this == &source)return *this;
+    Int_t i,j;
+
+    this->fDetectorIndex = source.fDetectorIndex;
+    this->fCylR      = source.fCylR;
+    this->fCylPhi    = source.fCylPhi;
+    for(i=0;i<3;i++){
+        this->fid[i]     = source.fid[i];
+        this->frot[i]    = source.frot[i];
+        this->ftran[i]   = source.ftran[i];
+        for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
+    } // end for i
+    this->fPath   = source.fPath;
+    return *this;
 }
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
                         const Double_t rot[3],const Double_t tran[3]):
-TObject(),
-fDetectorIndex(0), // Detector type index (like fShapeIndex was)
+TObject(),           // Base class
+fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
 ftran(),     // Translation vector of module x,y,z.
@@ -171,7 +183,6 @@ fPath(){     // Path in geometry to this moduel
     //    A properly inilized AliITSgeomMatrix class.
     Int_t i;
 
-    fDetectorIndex = idt; // a value never defined.
     for(i=0;i<3;i++){
        fid[i]   = id[i];
        frot[i]  = rot[i];
@@ -179,15 +190,15 @@ fPath(){     // Path in geometry to this moduel
     }// end for i
     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
-    if(fCylPhi<0.0) fCylPhi += TMath::Pi();
+    if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
     this->MatrixFromAngle();
 }
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt, const Int_t id[3],
                                    Double_t matrix[3][3],
                                    const Double_t tran[3]):
-TObject(),
-fDetectorIndex(0), // Detector type index (like fShapeIndex was)
+TObject(),            // Base class
+fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
 ftran(),     // Translation vector of module x,y,z.
@@ -221,7 +232,6 @@ fPath(){     // Path in geometry to this module
     //    A properly inilized AliITSgeomMatrix class.
     Int_t i,j;
 
-    fDetectorIndex = idt; // a value never defined.
     for(i=0;i<3;i++){
        fid[i]   = id[i];
        ftran[i] = tran[i];
@@ -229,11 +239,11 @@ fPath(){     // Path in geometry to this module
     }// end for i
     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
-    if(fCylPhi<0.0) fCylPhi += TMath::Pi();
+    if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
     this->AngleFromMatrix();
 }
 //----------------------------------------------------------------------
-void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang){
+void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang)const{
     // This function returns the 6 GEANT 3.21 rotation angles [degrees] in
     // the array ang which must be at least [6] long.
     // Inputs:
@@ -243,19 +253,20 @@ void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang){
     // Return:
     //   noting
     Double_t si,c=180./TMath::Pi();
+    const Double_t epsil=1.e-15;
 
     ang[1] = TMath::ATan2(fm[0][1],fm[0][0]);
-    if(TMath::Cos(ang[1])!=0.0) si = fm[0][0]/TMath::Cos(ang[1]);
+    if( !(TMath::AreEqualAbs(TMath::Cos(ang[1]),0.,epsil))) si = fm[0][0]/TMath::Cos(ang[1]);
     else si = fm[0][1]/TMath::Sin(ang[1]);
     ang[0] = TMath::ATan2(si,fm[0][2]);
 
     ang[3] = TMath::ATan2(fm[1][1],fm[1][0]);
-    if(TMath::Cos(ang[3])!=0.0) si = fm[1][0]/TMath::Cos(ang[3]);
+    if(!(TMath::AreEqualAbs(TMath::Cos(ang[3]),0.,epsil))) si = fm[1][0]/TMath::Cos(ang[3]);
     else si = fm[1][1]/TMath::Sin(ang[3]);
     ang[2] = TMath::ATan2(si,fm[1][2]);
 
     ang[5] = TMath::ATan2(fm[2][1],fm[2][0]);
-    if(TMath::Cos(ang[5])!=0.0) si = fm[2][0]/TMath::Cos(ang[5]);
+    if(!(TMath::AreEqualAbs(TMath::Cos(ang[5]),0.,epsil))) si = fm[2][0]/TMath::Cos(ang[5]);
     else si = fm[2][1]/TMath::Sin(ang[5]);
     ang[4] = TMath::ATan2(si,fm[2][2]);
 
@@ -275,39 +286,40 @@ void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
     //   noting
     Int_t    i,j;
     Double_t si,lr[9],c=TMath::Pi()/180.;
+    const Double_t epsil = 1.e-15;
 
     si    = TMath::Sin(c*ang[0]);
-    if(ang[0]== 90.0)                 si = +1.0;
-    if(ang[0]==270.0)                 si = -1.0;
-    if(ang[0]==  0.0||ang[0]==180.) si =  0.0;
+    if(TMath::AreEqualAbs(ang[0],90.,epsil)) si = +1.0;
+    if(TMath::AreEqualAbs(ang[0],270.,epsil)) si = -1.0;
+    if(TMath::AreEqualAbs(ang[0],0.,epsil) ||TMath::AreEqualAbs(ang[0],180.,epsil)) si =  0.0;
     lr[0] = si * TMath::Cos(c*ang[1]);
     lr[1] = si * TMath::Sin(c*ang[1]);
     lr[2] = TMath::Cos(c*ang[0]);
-    if(ang[0]== 90.0||ang[0]==270.) lr[2] =  0.0;
-    if(ang[0]== 0.0)                  lr[2] = +1.0;
-    if(ang[0]==180.0)                 lr[2] = -1.0;
+    if(TMath::AreEqualAbs(ang[0],90.,epsil)||TMath::AreEqualAbs(ang[0],270.,epsil)) lr[2] =  0.0;
+    if(TMath::AreEqualAbs(ang[0],0.,epsil))                  lr[2] = +1.0;
+    if(TMath::AreEqualAbs(ang[0],180.,epsil))                 lr[2] = -1.0;
 //
     si    =  TMath::Sin(c*ang[2]);
-    if(ang[2]== 90.0)                 si = +1.0; 
-    if(ang[2]==270.0)                 si = -1.0;
-    if(ang[2]==  0.0||ang[2]==180.) si =  0.0;
+    if(TMath::AreEqualAbs(ang[2],90.,epsil))                 si = +1.0; 
+    if(TMath::AreEqualAbs(ang[2],270.,epsil))                 si = -1.0;
+    if(TMath::AreEqualAbs(ang[2],0.,epsil) || TMath::AreEqualAbs(ang[2],180.,epsil)) si =  0.0;
     lr[3] = si * TMath::Cos(c*ang[3]);
     lr[4] = si * TMath::Sin(c*ang[3]);
     lr[5] = TMath::Cos(c*ang[2]);
-    if(ang[2]== 90.0||ang[2]==270.) lr[5] =  0.0;
-    if(ang[2]==  0.0)                 lr[5] = +1.0;
-    if(ang[2]==180.0)                 lr[5] = -1.0;
+    if(TMath::AreEqualAbs(ang[2],90.,epsil) || TMath::AreEqualAbs(ang[2],270.,epsil)) lr[5] =  0.0;
+    if(TMath::AreEqualAbs(ang[2],0.,epsil))                 lr[5] = +1.0;
+    if(TMath::AreEqualAbs(ang[2],180.,epsil))                 lr[5] = -1.0;
 //
     si    = TMath::Sin(c*ang[4]);
-    if(ang[4]== 90.0)                 si = +1.0;
-    if(ang[4]==270.0)                 si = -1.0;
-    if(ang[4]==  0.0||ang[4]==180.) si =  0.0;
+    if(TMath::AreEqualAbs(ang[4],90.,epsil))                 si = +1.0;
+    if(TMath::AreEqualAbs(ang[4],270.0,epsil))                 si = -1.0;
+    if(TMath::AreEqualAbs(ang[4],0.,epsil)|| TMath::AreEqualAbs(ang[4],180.,epsil)) si =  0.0;
     lr[6] = si * TMath::Cos(c*ang[5]);
     lr[7] = si * TMath::Sin(c*ang[5]);
     lr[8] = TMath::Cos(c*ang[4]);
-    if(ang[4]== 90.0||ang[4]==270.0) lr[8] =  0.0;
-    if(ang[4]==  0.0)                  lr[8] = +1.0;
-    if(ang[4]==180.0)                  lr[8] = -1.0;
+    if(TMath::AreEqualAbs(ang[4],90.0,epsil) ||TMath::AreEqualAbs(ang[4],270.,epsil)) lr[8] =  0.0;
+    if(TMath::AreEqualAbs(ang[4],0.,epsil))                  lr[8] = +1.0;
+    if(TMath::AreEqualAbs(ang[4],180.0,epsil))                  lr[8] = -1.0;
     // Normalize these elements and fill matrix fm.
     for(i=0;i<3;i++){// reuse si.
        si = 0.0;
@@ -320,7 +332,16 @@ void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
                                    Int_t idt,const Int_t id[3],
-                                   const Double_t tran[3]){
+                                   const Double_t tran[3]):
+TObject(),            // Base class
+fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
+fid(),       // layer, ladder, detector numbers.
+frot(),      //! vector of rotations about x,y,z [radians].
+ftran(),     // Translation vector of module x,y,z.
+fCylR(0.0),  //! R Translation in Cylinderical coordinates
+fCylPhi(0.0),//! Phi Translation vector in Cylindrical coord.
+fm(),        // Rotation matrix based on frot.
+fPath(){     // Path in geometry to this module
     // This is a constructor for the AliITSgeomMatrix class. The matrix 
     // is defined by the 6 GEANT 3.21 rotation angles [degrees], and 
     // the translation vector tran [cm]. In addition the layer, ladder, 
@@ -343,20 +364,27 @@ AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
     //    Double_t tran[3]  The translation vector
     Int_t i;
 
-    fDetectorIndex = idt; // a value never defined.
     for(i=0;i<3;i++){
        fid[i]   = id[i];
        ftran[i] = tran[i];
     }// end for i
     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
-    if(fCylPhi<0.0) fCylPhi += TMath::Pi();
+    if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
     this->MatrixFromSixAngles(rotd);
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::AngleFromMatrix(){
     // Computes the angles from the rotation matrix up to a phase of 
-    // 180 degrees.
+    // 180 degrees. The matrix used in AliITSgeomMatrix::MatrixFromAngle()
+    // and  its inverse AliITSgeomMatrix::AngleFromMatrix() are defined in 
+    // the following ways, R = Rz*Ry*Rx (M=R*L+T) where
+    //     1   0   0       Cy  0 +Sy       Cz -Sz  0
+    // Rx= 0   Cx -Sx  Ry=  0  1   0   Rz=+Sz  Cz  0
+    //     0  +Sx  Cx     -Sy  0  Cy        0   0  1
+    // The choice of the since of S, comes from the choice between 
+    // the rotation of the object or the coordinate system (view). I think
+    // that this choice is the first, the rotation of the object.
     // Inputs:
     //   none
     // Outputs:
@@ -367,8 +395,8 @@ void AliITSgeomMatrix::AngleFromMatrix(){
     // get angles from matrix up to a phase of 180 degrees.
 
     rx = TMath::ATan2(fm[2][1],fm[2][2]);if(rx<0.0) rx += 2.0*TMath::Pi();
-    ry = TMath::ASin(fm[0][2]);          if(ry<0.0) ry += 2.0*TMath::Pi();
-    rz = TMath::ATan2(fm[1][1],fm[0][0]);if(rz<0.0) rz += 2.0*TMath::Pi();
+    ry = TMath::ASin(-fm[0][2]);         if(ry<0.0) ry += 2.0*TMath::Pi();
+    rz = TMath::ATan2(fm[1][0],fm[0][0]);if(rz<0.0) rz += 2.0*TMath::Pi();
     frot[0] = rx;
     frot[1] = ry;
     frot[2] = rz;
@@ -377,28 +405,71 @@ void AliITSgeomMatrix::AngleFromMatrix(){
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::MatrixFromAngle(){
     // Computes the Rotation matrix from the angles [radians] kept in this
-    // class.
+    // class. The matrix used in AliITSgeomMatrix::MatrixFromAngle() and 
+    // its inverse AliITSgeomMatrix::AngleFromMatrix() are defined in 
+    // the following ways, R = Rz*Ry*Rx (M=R*L+T) where
+    //     1   0   0       Cy  0 +Sy       Cz -Sz  0
+    // Rx= 0   Cx -Sx  Ry=  0  1   0   Rz=+Sz  Cz  0
+    //     0  +Sx  Cx     -Sy  0  Cy        0   0  1
+    // The choice of the since of S, comes from the choice between 
+    // the rotation of the object or the coordinate system (view). I think
+    // that this choice is the first, the rotation of the object.
     // Inputs:
     //   none
     // Outputs:
     //   none
     // Return:
     //   none
-   Double_t sx,sy,sz,cx,cy,cz;
+    Double_t sx,sy,sz,cx,cy,cz;
 
-   sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
-   sy = TMath::Sin(frot[1]); cy = TMath::Cos(frot[1]);
-   sz = TMath::Sin(frot[2]); cz = TMath::Cos(frot[2]);
-   fm[0][0] =  cz*cy;             // fr[0]
-   fm[0][1] = -cz*sy*sx - sz*cx;  // fr[1]
-   fm[0][2] = -cz*sy*cx + sz*sx;  // fr[2]
-   fm[1][0] =  sz*cy;             // fr[3]
-   fm[1][1] = -sz*sy*sx + cz*cx;  // fr[4]
-   fm[1][2] = -sz*sy*cx - cz*sx;  // fr[5]
-   fm[2][0] =  sy;                // fr[6]
-   fm[2][1] =  cy*sx;             // fr[7]
-   fm[2][2] =  cy*cx;             // fr[8]
+    sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
+    sy = TMath::Sin(frot[1]); cy = TMath::Cos(frot[1]);
+    sz = TMath::Sin(frot[2]); cz = TMath::Cos(frot[2]);
+    fm[0][0] = +cz*cy;             // fr[0]
+    fm[0][1] = +cz*sy*sx - sz*cx;  // fr[1]
+    fm[0][2] = +cz*sy*cx + sz*sx;  // fr[2]
+    fm[1][0] = +sz*cy;             // fr[3]
+    fm[1][1] = +sz*sy*sx + cz*cx;  // fr[4]
+    fm[1][2] = +sz*sy*cx - cz*sx;  // fr[5]
+    fm[2][0] = -sy;                // fr[6]
+    fm[2][1] = +cy*sx;             // fr[7]
+    fm[2][2] = +cy*cx;             // fr[8]
+}
+//----------------------------------------------------------------------
+void AliITSgeomMatrix::SetEulerAnglesChi(const Double_t ang[3]){
+    // Computes the Rotation matrix from the Euler angles [radians], 
+    // Chi-convention, kept in this class. The matrix used in 
+    // AliITSgeomMatrix::SetEulerAnglesChi and 
+    // its inverse AliITSgeomMatrix::GetEulerAnglesChi() are defined in 
+    // the following ways, R = Rb*Rc*Rd (M=R*L+T) where
+    //     C2 +S2  0       1  0    0       C0 +S0  0
+    // Rb=-S2  C2  0  Rc=  0  C1 +S1   Rd=-S0  C0  0
+    //     0   0   1       0 -S1  C1       0   0   1
+    // This form is taken from Wolfram Research's Geometry>
+    // Transformations>Rotations web page (also should be
+    // found in their book).
+    // Inputs:
+    //   Double_t ang[3] The three Euler Angles Phi, Theta, Psi
+    // Outputs:
+    //   none
+    // Return:
+    //   none
+    Double_t s0,s1,s2,c0,c1,c2;
 
+    s0 = TMath::Sin(ang[0]); c0 = TMath::Cos(ang[0]);
+    s1 = TMath::Sin(ang[1]); c1 = TMath::Cos(ang[1]);
+    s2 = TMath::Sin(ang[2]); c2 = TMath::Cos(ang[2]);
+    fm[0][0] = +c2*c0-c1*s0*s2;  // fr[0]
+    fm[0][1] = +c2*s0+c1*c0*s2;  // fr[1]
+    fm[0][2] = +s2*s1;           // fr[2]
+    fm[1][0] = -s2*c0-c1*s0*c2;  // fr[3]
+    fm[1][1] = -s2*s0+c1*c0*c2;  // fr[4]
+    fm[1][2] = +c2*s1;           // fr[5]
+    fm[2][0] = s1*s0;            // fr[6]
+    fm[2][1] = -s1*c0;           // fr[7]
+    fm[2][2] = +c1;              // fr[8]
+    AngleFromMatrix();
+    return ;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
@@ -411,16 +482,16 @@ void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
     //                  detector coordiante system
     // Return:
     //   none
-       Int_t    i,j;
-       Double_t g[3];
+    Int_t    i,j;
+    Double_t g[3];
 
-       for(i=0;i<3;i++) g[i] = g0[i] - ftran[i];
-       for(i=0;i<3;i++){
-               l[i] = 0.0;
-               for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
-               // g = R l + translation
-       } // end for i
-       return;
+    for(i=0;i<3;i++) g[i] = g0[i] - ftran[i];
+    for(i=0;i<3;i++){
+        l[i] = 0.0;
+        for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
+        // g = R l + translation
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
@@ -433,15 +504,15 @@ void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
     //                   Global coordinate system
     // Return:
     //   none.
-       Int_t    i,j;
+    Int_t    i,j;
 
-       for(i=0;i<3;i++){
-               g[i] = 0.0;
-               for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
-               g[i] += ftran[i];
-               // g = R^t l + translation
-       } // end for i
-       return;
+    for(i=0;i<3;i++){
+        g[i] = 0.0;
+        for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
+        g[i] += ftran[i];
+        // g = R^t l + translation
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]) const{
@@ -456,14 +527,14 @@ void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]) const{
     //                 local coordinate system
     // Return:
     //   none.
-       Int_t    i,j;
+    Int_t    i,j;
 
-       for(i=0;i<3;i++){
-               l[i] = 0.0;
-               for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
-               // g = R l
-       } // end for i
-       return;
+    for(i=0;i<3;i++){
+        l[i] = 0.0;
+        for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
+        // g = R l
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]) const {
@@ -478,14 +549,14 @@ void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]) const {
     //                 coordinate system
     // Return:
     //   none.
-       Int_t    i,j;
+    Int_t    i,j;
 
-       for(i=0;i<3;i++){
-               g[i] = 0.0;
-               for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
-               // g = R^t l
-       } // end for i
-       return;
+    for(i=0;i<3;i++){
+        g[i] = 0.0;
+        for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
+        // g = R^t l
+    } // end for i
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLPositionError(const Double_t g[3][3],
@@ -502,15 +573,15 @@ void AliITSgeomMatrix::GtoLPositionError(const Double_t g[3][3],
     //                    local coordinate system
     // Return:
     //   none.
-       Int_t    i,j,k,m;
+    Int_t    i,j,k,m;
 
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           l[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               l[i][m] += fm[j][i]*g[j][k]*fm[k][m];
-       } // end for i,m
-           // g = R^t l R
-       return;
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        l[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            l[i][m] += fm[j][i]*g[j][k]*fm[k][m];
+    } // end for i,m
+    // g = R^t l R
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGPositionError(const Double_t l[3][3],
@@ -526,15 +597,15 @@ void AliITSgeomMatrix::LtoGPositionError(const Double_t l[3][3],
     //                    coordinate system
     // Return:
     //   none.
-       Int_t    i,j,k,m;
+    Int_t    i,j,k,m;
 
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           g[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               g[i][m] += fm[i][j]*l[j][k]*fm[m][k];
-       } // end for i,m
-           // g = R l R^t
-       return;
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        g[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            g[i][m] += fm[i][j]*l[j][k]*fm[m][k];
+    } // end for i,m
+    // g = R l R^t
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g[3],
@@ -705,22 +776,22 @@ void AliITSgeomMatrix::GtoLPositionErrorTracking(const Double_t g[3][3],
     //   Double_t l[3][3] the error matrix represented in the detector 
     //                    local coordinate system
     // Return:
-       Int_t    i,j,k,m;
-       Double_t rt[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.}};
+    Int_t    i,j,k,m;
+    Double_t rt[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.}};
 
-       if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a0[i][j]*fm[j][k];
-       else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a1[i][j]*fm[j][k];
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           l[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               l[i][m] += rt[j][i]*g[j][k]*rt[k][m];
-       } // end for i,m
-           // g = R^t l R
-       return;
+    if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a0[i][j]*fm[j][k];
+    else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a1[i][j]*fm[j][k];
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        l[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            l[i][m] += rt[j][i]*g[j][k]*rt[k][m];
+    } // end for i,m
+    // g = R^t l R
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::LtoGPositionErrorTracking(const Double_t l[3][3],
@@ -744,22 +815,22 @@ void AliITSgeomMatrix::LtoGPositionErrorTracking(const Double_t l[3][3],
     //                    coordinate system
     // Return:
     //   none.
-       Int_t    i,j,k,m;
-       Double_t rt[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.}};
+    Int_t    i,j,k,m;
+    Double_t rt[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.}};
 
-       if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a0[i][j]*fm[j][k];
-       else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
-           rt[i][k] = a1[i][j]*fm[j][k];
-       for(i=0;i<3;i++)for(m=0;m<3;m++){
-           g[i][m] = 0.0;
-           for(j=0;j<3;j++)for(k=0;k<3;k++)
-               g[i][m] += rt[i][j]*l[j][k]*rt[m][k];
-       } // end for i,m
-           // g = R l R^t
-       return;
+    if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a0[i][j]*fm[j][k];
+    else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
+        rt[i][k] = a1[i][j]*fm[j][k];
+    for(i=0;i<3;i++)for(m=0;m<3;m++){
+        g[i][m] = 0.0;
+        for(j=0;j<3;j++)for(k=0;k<3;k++)
+            g[i][m] += rt[i][j]*l[j][k]*rt[m][k];
+    } // end for i,m
+    // g = R l R^t
+    return;
 }
 //----------------------------------------------------------------------
 void AliITSgeomMatrix::PrintTitles(ostream *os) const {
@@ -799,7 +870,7 @@ void AliITSgeomMatrix::PrintComment(ostream *os) const {
     return;
 }
 //----------------------------------------------------------------------
-void AliITSgeomMatrix::Print(ostream *os){
+void AliITSgeomMatrix::Print(ostream *os)const{
     // Standard output format for this class.
     // Inputs:
     //    ostream *os   The output stream to print the class data on
@@ -845,19 +916,26 @@ void AliITSgeomMatrix::Read(istream *is){
     // Return:
     //    none.
     Int_t i,j;
-
+    const Int_t kMxVal=10000;
     *is >> fDetectorIndex;
     for(i=0;i<3;i++) *is >> fid[i];
 //    for(i=0;i<3;i++) *is >> frot[i]; // Redundant with fm[][].
     for(i=0;i<3;i++) *is >> ftran[i];
     for(i=0;i<3;i++)for(j=0;j<3;j++)  *is >> fm[i][j];
-    *is >> j; // string length
-    fPath.Resize(j);
-    for(i=0;i<j;i++) {*is >> fPath[i];}
+    while(is->peek()==' ')is->get(); // skip white spaces
+    if(isprint(is->peek())){ // old format did not have path.
+       *is >> j; // string length
+       if(j>kMxVal || j<0){
+         AliError(Form("j> %d",kMxVal));
+         return;
+       }
+       fPath.Resize(j);
+       for(i=0;i<j;i++) {*is >> fPath[i];}
+    } // end if
     AngleFromMatrix(); // compute angles frot[].
     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
-    if(fCylPhi<0.0) fCylPhi += TMath::Pi();
+    if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
     return;
 }
 //______________________________________________________________________
@@ -875,7 +953,7 @@ void AliITSgeomMatrix::Streamer(TBuffer &R__b){
         fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
         fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
         this->AngleFromMatrix();
-        if(fCylPhi<0.0) fCylPhi += TMath::Pi();
+        if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
     } else {
         AliITSgeomMatrix::Class()->WriteBuffer(R__b, this);
     } // end if
@@ -892,10 +970,10 @@ void AliITSgeomMatrix::SetTranslation(const Double_t tran[3]){
     for(Int_t i=0;i<3;i++) ftran[i] = tran[i];
     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
-    if(fCylPhi<0.0) fCylPhi += TMath::Pi();
+    if(fCylPhi<0.0) fCylPhi += 2.*TMath::Pi();
 }
 //----------------------------------------------------------------------
-TPolyLine3D* AliITSgeomMatrix::CreateLocalAxis(){
+TPolyLine3D* AliITSgeomMatrix::CreateLocalAxis() const {
     // This class is used as part of the documentation of this class
     // Inputs:
     //   none.
@@ -920,7 +998,7 @@ TPolyLine3D* AliITSgeomMatrix::CreateLocalAxis(){
     return new TPolyLine3D(5,gf);
 }
 //----------------------------------------------------------------------
-TPolyLine3D* AliITSgeomMatrix::CreateLocalAxisTracking(){
+TPolyLine3D* AliITSgeomMatrix::CreateLocalAxisTracking() const {
     // This class is used as part of the documentation of this class
     // Inputs:
     //   none.
@@ -947,7 +1025,7 @@ TPolyLine3D* AliITSgeomMatrix::CreateLocalAxisTracking(){
 //----------------------------------------------------------------------
 TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
                                     const Char_t *nodeTitle,TNode *mother,
-                                    TShape *shape,Bool_t axis){
+                                    TShape *shape,Bool_t axis) const {
     // Creates a node inside of the node mother out of the shape shape
     // in the position, with respect to mother, indecated by "this". If axis
     // is ture, it will insert an axis within this node/shape.
@@ -974,49 +1052,55 @@ TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
     title = nodeTitle;
     //
     mother->cd();
-    TNode *node1 = new TNode(name.Data(),title.Data(),shape,trans[0],trans[1],trans[2],rot);
+    TNode *node1 = new TNode(name.Data(),title.Data(),shape,
+                             trans[0],trans[1],trans[2],rot);
     if(axis){
         Int_t i,j;
-        const Float_t scale=0.5,lw=0.2;
-        Float_t xchar[13][2]={{0.5*lw,1.},{0.,0.5*lw},{0.5-0.5*lw,0.5},
-                              {0.,0.5*lw},{0.5*lw,0.},{0.5,0.5-0.5*lw},
-                              {1-0.5*lw,0.},{1.,0.5*lw},{0.5+0.5*lw,0.5},
-                              {1.,1.-0.5*lw},{1.-0.5*lw,1.},{0.5,0.5+0.5*lw},
-                              {0.5*lw,1.}};
-        Float_t ychar[10][2]={{.5-0.5*lw,0.},{.5+0.5*lw,0.},{.5+0.5*lw,0.5-0.5*lw},
-                              {1.,1.-0.5*lw},{1.-0.5*lw,1.},{0.5+0.5*lw,0.5},
-                              {0.5*lw,1.}   ,{0.,1-0.5*lw} ,{0.5-0.5*lw,0.5},
-                              {.5-0.5*lw,0.}};
-        Float_t zchar[11][2]={{0.,1.},{0,1.-lw},{1.-lw,1.-lw},{0.,lw}   ,{0.,0.},
-                              {1.,0.},{1.,lw}  ,{lw,lw}      ,{1.,1.-lw},{1.,1.},
-                              {0.,1.}};
+        const Float_t kScale=0.5,kLw=0.2;
+        Float_t xchar[13][2]={
+            {0.5*kLw,1.},{0.,0.5*kLw},{0.5-0.5*kLw,0.5},
+            {0.,0.5*kLw},{0.5*kLw,0.},{0.5,0.5-0.5*kLw},
+            {1-0.5*kLw,0.},{1.,0.5*kLw},{0.5+0.5*kLw,0.5},
+            {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5,0.5+0.5*kLw},
+            {0.5*kLw,1.}};
+        Float_t ychar[10][2]={
+            {.5-0.5*kLw,0.},{.5+0.5*kLw,0.},{.5+0.5*kLw,0.5-0.5*kLw},
+            {1.,1.-0.5*kLw},{1.-0.5*kLw,1.},{0.5+0.5*kLw,0.5},
+            {0.5*kLw,1.}   ,{0.,1-0.5*kLw} ,{0.5-0.5*kLw,0.5},
+            {.5-0.5*kLw,0.}};
+        Float_t zchar[11][2]={
+            {0.,1.},{0,1.-kLw},{1.-kLw,1.-kLw},{0.,kLw}   ,{0.,0.},
+            {1.,0.},{1.,kLw}  ,{kLw,kLw}      ,{1.,1.-kLw},{1.,1.},
+            {0.,1.}};
         for(i=0;i<13;i++)for(j=0;j<2;j++){
-            if(i<13) xchar[i][j] = scale*xchar[i][j];
-            if(i<10) ychar[i][j] = scale*ychar[i][j];
-            if(i<11) zchar[i][j] = scale*zchar[i][j];
+            if(i<13) xchar[i][j] = kScale*xchar[i][j];
+            if(i<10) ychar[i][j] = kScale*ychar[i][j];
+            if(i<11) zchar[i][j] = kScale*zchar[i][j];
         } // end for i,j
         TXTRU *axisxl = new TXTRU("x","x","text",12,2);
         for(i=0;i<12;i++) axisxl->DefineVertex(i,xchar[i][0],xchar[i][1]);
-        axisxl->DefineSection(0,-0.5*lw);axisxl->DefineSection(1,0.5*lw);
+        axisxl->DefineSection(0,-0.5*kLw);axisxl->DefineSection(1,0.5*kLw);
         TXTRU *axisyl = new TXTRU("y","y","text",9,2);
         for(i=0;i<9;i++) axisyl->DefineVertex(i,ychar[i][0],ychar[i][1]);
-        axisyl->DefineSection(0,-0.5*lw);axisyl->DefineSection(1,0.5*lw);
+        axisyl->DefineSection(0,-0.5*kLw);axisyl->DefineSection(1,0.5*kLw);
         TXTRU *axiszl = new TXTRU("z","z","text",10,2);
         for(i=0;i<10;i++) axiszl->DefineVertex(i,zchar[i][0],zchar[i][1]);
-        axiszl->DefineSection(0,-0.5*lw);axiszl->DefineSection(1,0.5*lw);
-        Float_t lxy[13][2]={{-0.5*lw,-0.5*lw},{0.8,-0.5*lw},{0.8,-0.1},{1.0,0.0},
-                            {0.8,0.1},{0.8,0.5*lw},{0.5*lw,0.5*lw},{0.5*lw,0.8},
-                            {0.1,0.8},{0.0,1.0},{-0.1,0.8},{-0.5*lw,0.8},
-                            {-0.5*lw,-0.5*lw}};
+        axiszl->DefineSection(0,-0.5*kLw);axiszl->DefineSection(1,0.5*kLw);
+        Float_t lxy[13][2]={
+            {-0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
+            {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},{0.5*kLw,0.8},
+            {0.1,0.8},{0.0,1.0},{-0.1,0.8},{-0.5*kLw,0.8},
+            {-0.5*kLw,-0.5*kLw}};
         TXTRU *axisxy = new TXTRU("axisxy","axisxy","text",13,2);
         for(i=0;i<13;i++) axisxy->DefineVertex(i,lxy[i][0],lxy[i][1]);
-        axisxy->DefineSection(0,-0.5*lw);axisxy->DefineSection(1,0.5*lw);
-        Float_t lz[8][2]={{0.5*lw,-0.5*lw},{0.8,-0.5*lw},{0.8,-0.1},{1.0,0.0},
-                           {0.8,0.1},{0.8,0.5*lw},{0.5*lw,0.5*lw},
-                           {0.5*lw,-0.5*lw}};
+        axisxy->DefineSection(0,-0.5*kLw);axisxy->DefineSection(1,0.5*kLw);
+        Float_t lz[8][2]={
+            {0.5*kLw,-0.5*kLw},{0.8,-0.5*kLw},{0.8,-0.1},{1.0,0.0},
+            {0.8,0.1},{0.8,0.5*kLw},{0.5*kLw,0.5*kLw},
+            {0.5*kLw,-0.5*kLw}};
         TXTRU *axisz = new TXTRU("axisz","axisz","text",8,2);
         for(i=0;i<8;i++) axisz->DefineVertex(i,lz[i][0],lz[i][1]);
-        axisz->DefineSection(0,-0.5*lw);axisz->DefineSection(1,0.5*lw);
+        axisz->DefineSection(0,-0.5*kLw);axisz->DefineSection(1,0.5*kLw);
         //TRotMatrix *xaxis90= new TRotMatrix("xaixis90","",90.0, 0.0, 0.0);
         TRotMatrix *yaxis90= new TRotMatrix("yaixis90","", 0.0,90.0, 0.0);
         TRotMatrix *zaxis90= new TRotMatrix("zaixis90","", 0.0, 0.0,90.0);
@@ -1025,7 +1109,8 @@ TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
         title = name.Append("axisxy");
         TNode *nodeaxy = new TNode(title.Data(),title.Data(),axisxy);
         title = name.Append("axisz");
-        TNode *nodeaz = new TNode(title.Data(),title.Data(),axisz,0.,0.,0.,yaxis90);
+        TNode *nodeaz = new TNode(title.Data(),title.Data(),axisz,
+                                  0.,0.,0.,yaxis90);
         TNode *textboxX0 = new TNode("textboxX0","textboxX0",axisxl,
                                     lxy[3][0],lxy[3][1],0.0);
         TNode *textboxX1 = new TNode("textboxX1","textboxX1",axisxl,
@@ -1060,7 +1145,7 @@ TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
     return node1;
 }
 //----------------------------------------------------------------------
-void AliITSgeomMatrix::MakeFigures(){
+void AliITSgeomMatrix::MakeFigures() const {
     // make figures to help document this class
     // Inputs:
     //   none.
@@ -1068,14 +1153,20 @@ void AliITSgeomMatrix::MakeFigures(){
     //   none.
     // Return:
     //   none.
-    const Double_t dx0=550.,dy0=550.,dz0=550.; // cm
-    const Double_t dx=1.0,dy=0.300,dz=3.0,rmax=0.1; // cm
+    const Double_t kDx0=550.,kDy0=550.,kDz0=550.; // cm
+    const Double_t kDx=1.0,kDy=0.300,kDz=3.0,kRmax=0.1; // cm
     Float_t l[5][3]={{1.0,0.0,0.0},{0.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,0.0},
                       {0.0,0.0,1.0}};
     TCanvas *c = new TCanvas(kFALSE);// create a batch mode canvas.
+#if ROOT_VERSION_CODE>= 331523
+    Double_t rmin[]={-1,-1,-1};
+    Double_t rmax[]={ 1, 1, 1};
+    TView *view = new TView3D(1,rmin,rmax);
+#else
     TView   *view = new TView(1); // Create Cartesian coordiante view
-    TBRIK   *mother  = new TBRIK("Mother","Mother","void",dx0,dy0,dz0);
-    TBRIK   *det  = new TBRIK("Detector","","Si",dx,dy,dz);
+#endif
+    TBRIK   *mother  = new TBRIK("Mother","Mother","void",kDx0,kDy0,kDz0);
+    TBRIK   *det  = new TBRIK("Detector","","Si",kDx,kDy,kDz);
     TPolyLine3D *axis = new TPolyLine3D(5,&(l[0][0]));
     TPCON *arrow      = new TPCON("arrow","","air",0.0,360.,2);
     TRotMatrix *xarrow= new TRotMatrix("xarrow","",90.,0.0,0.0);
@@ -1091,16 +1182,18 @@ void AliITSgeomMatrix::MakeFigures(){
     arrow->SetLineStyle(det->GetLineStyle());
     arrow->SetFillColor(1); // black
     arrow->SetFillStyle(4100); // window is 100% opaque
-    arrow->DefineSection(0,0.0,0.0,rmax);
-    arrow->DefineSection(1,2.*rmax,0.0,0.0);
-    view->SetRange(-dx0,-dy0,-dz0,dx0,dy0,dz0);
+    arrow->DefineSection(0,0.0,0.0,kRmax);
+    arrow->DefineSection(1,2.*kRmax,0.0,0.0);
+    view->SetRange(-kDx0,-kDy0,-kDz0,kDx0,kDy0,kDz0);
     //
     TNode *node0 = new TNode("NODE0","NODE0",mother);
     node0->cd();
     TNode *node1 = new TNode("NODE1","NODE1",det);
     node1->cd();
-    TNode *nodex = new TNode("NODEx","NODEx",arrow,l[0][0],l[0][1],l[0][2],xarrow);
-    TNode *nodey = new TNode("NODEy","NODEy",arrow,l[2][0],l[2][1],l[2][2],yarrow);
+    TNode *nodex = new TNode("NODEx","NODEx",arrow,
+                             l[0][0],l[0][1],l[0][2],xarrow);
+    TNode *nodey = new TNode("NODEy","NODEy",arrow,
+                             l[2][0],l[2][1],l[2][2],yarrow);
     TNode *nodez = new TNode("NODEz","NODEz",arrow,l[4][0],l[4][1],l[4][2]);
     //
     axis->Draw();