ITS/AliITSgeomMatrix.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.10  2001/08/24 21:06:37  nilsen
  19 Added more documentation, fixed up some coding violations, and some
  20 forward declorations.
  21
  22 Revision 1.9  2001/03/23 15:21:56  nilsen
  23 Added Cylinderical Coordinates for use with Tracking. Fixed a but in the
  24 Streamer, It was not setting a value for frot[3] as it should when reading.
  25
  26 Revision 1.8  2001/02/09 00:00:57  nilsen
  27 Fixed compatibility problem with HP unix {ios::fmtflags -> Int_t}. Fixed
  28 bugs in iostream based streamers used to read and write .det files. Fixed
  29 some detector sizes. Fixed bugs in some default-special constructors.
  30
  31 Revision 1.7  2001/02/03 00:00:30  nilsen
  32 New version of AliITSgeom and related files. Now uses automatic streamers,
  33 set up for new formatted .det file which includes detector information.
  34 Additional smaller modifications are still to come.
  35
  36 Revision 1.5  2000/10/02 16:32:35  barbera
  37 Forward declaration added
  38
  39 Revision 1.1.2.6  2000/10/02 15:52:05  barbera
  40 Forward declaration added
  41
  42 Revision 1.4  2000/09/07 17:30:45  nilsen
  43 fixed a bug in SixAnglesFromMatrix.
  44
  45 Revision 1.3  2000/09/05 14:25:50  nilsen
  46 Made fixes for HP compiler. All function parameter default values placed
  47 in .h file. Fixed the usual problem with HP comilers and the "for(Int_t i..."
  48 business. Replaced casting (Double_t [3][3]) to (Double_t (*)[3]) for HP.
  49 Lastly removed all "const" before function parameters which were 2 dim. arrays,
  50 because on HP root generates some strange code (?). Thanks Peter for the
  51 changes.
  52
  53 Revision 1.2  2000/08/29 20:16:50  nilsen
  54 New class for ITS coordiante transformations used by AliITSgeom nearly
  55 exclusively.
  56
  57 Revision 1.1.2.1  2000/06/04 16:32:31  Nilsen
  58 A new class to hold the matrix information needed by AliITSgeom.
  59
  60 */
  61
  62 ////////////////////////////////////////////////////////////////////////
  63 // This is the implementation file for AliITSgeomMatrix class. It
  64 // contains the routines to manipulate, setup, and queary the geometry
  65 // of a given ITS module. An ITS module may be one of at least three
  66 // ITS detector technologies, Silicon Pixel, Drift, or Strip Detectors,
  67 // and variations of these in size and/or layout. These routines let
  68 // one go between ALICE global coordiantes (cm) to a given modules
  69 // specific local coordinates (cm).
  70 ////////////////////////////////////////////////////////////////////////
  71
  72 #include <iostream.h>
  73 #include <iomanip.h>
  74 #include <TMath.h>
  75 #include <TBuffer.h>
  76 #include <TClass.h>
  77
  78 #include "AliITSgeomMatrix.h"
  79
  80 ClassImp(AliITSgeomMatrix)
  81 //----------------------------------------------------------------------
  82 AliITSgeomMatrix::AliITSgeomMatrix(){
  83 ////////////////////////////////////////////////////////////////////////
  84 // The Default constructor for the AliITSgeomMatrix class. By Default
  85 // the angles of rotations are set to zero, meaning that the rotation
  86 // matrix is the unit matrix. The translation vector is also set to zero
  87 // as are the module id number. The detector type is set to -1 (an undefined
  88 // value). The full rotation matrix is kept so that the evaluation
  89 // of a coordinate transformation can be done quickly and with a minimum
  90 // of CPU overhead. The basic coordinate systems are the ALICE global
  91 // coordinate system and the detector local coordinate system. In general
  92 // this structure is not limited to just those two coordinate systems.
  93 //Begin_Html
  94 /*
  95 <img src="picts/ITS/AliISgeomMatrix_L1.gif">
  96 */
  97 //End_Html
  98 ////////////////////////////////////////////////////////////////////////
  99     Int_t i,j;
 100
 101     fDetectorIndex = -1; // a value never defined.
 102     for(i=0;i<3;i++){
 103         fid[i] = 0;
 104         frot[i] = ftran[i] = 0.0;
 105         for(j=0;j<3;j++) fm[i][j] = 0.0;
 106         fCylR = fCylPhi = 0.0;
 107     }// end for i
 108     fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
 109 }
 110 //----------------------------------------------------------------------
 111 AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse){
 112 ////////////////////////////////////////////////////////////////////////
 113 // The standard copy constructor. This make a full / proper copy of
 114 // this class.
 115 ////////////////////////////////////////////////////////////////////////
 116         Int_t i,j;
 117
 118         this->fDetectorIndex = sourse.fDetectorIndex;
 119         for(i=0;i<3;i++){
 120                 this->fid[i]     = sourse.fid[i];
 121                 this->frot[i]    = sourse.frot[i];
 122                 this->ftran[i]   = sourse.ftran[i];
 123                 this->fCylR      = sourse.fCylR;
 124                 this->fCylPhi    = sourse.fCylPhi;
 125                 for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
 126         }// end for i
 127 }
 128 //----------------------------------------------------------------------
 129 void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
 130 ////////////////////////////////////////////////////////////////////////
 131 // The standard = operator. This make a full / proper copy of
 132 // this class.
 133 ////////////////////////////////////////////////////////////////////////
 134         Int_t i,j;
 135
 136         this->fDetectorIndex = sourse.fDetectorIndex;
 137         for(i=0;i<3;i++){
 138                 this->fid[i]     = sourse.fid[i];
 139                 this->frot[i]    = sourse.frot[i];
 140                 this->ftran[i]   = sourse.ftran[i];
 141                 this->fCylR      = sourse.fCylR;
 142                 this->fCylPhi    = sourse.fCylPhi;
 143                 for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
 144         }// end for i
 145 }
 146 //----------------------------------------------------------------------
 147 AliITSgeomMatrix::AliITSgeomMatrix(const Int_t idt,const Int_t id[3],
 148                    const Double_t rot[3],const Double_t tran[3]){
 149 ////////////////////////////////////////////////////////////////////////
 150 // This is a constructor for the AliITSgeomMatrix class. The matrix is
 151 // defined by 3 standard rotation angles [radians], and the translation
 152 // vector tran [cm]. In addition the layer, ladder, and detector number
 153 // for this particular module and the type of module must be given.
 154 // The full rotation matrix is kept so that the evaluation
 155 // of a coordinate transformation can be done quickly and with a minimum
 156 // of CPU overhead. The basic coordinate systems are the ALICE global
 157 // coordinate system and the detector local coordinate system. In general
 158 // this structure is not limited to just those two coordinate systems.
 159 //Begin_Html
 160 /*
 161 <img src="picts/ITS/AliISgeomMatrix_L1.gif">
 162 */
 163 //End_Html
 164 ////////////////////////////////////////////////////////////////////////
 165     Int_t i;
 166
 167     fDetectorIndex = idt; // a value never defined.
 168     for(i=0;i<3;i++){
 169         fid[i]   = id[i];
 170         frot[i]  = rot[i];
 171         ftran[i] = tran[i];
 172     }// end for i
 173     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
 174     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
 175     if(fCylPhi<0.0) fCylPhi += TMath::Pi();
 176     this->MatrixFromAngle();
 177 }
 178 //----------------------------------------------------------------------
 179 AliITSgeomMatrix::AliITSgeomMatrix(const Int_t idt, const Int_t id[3],
 180                                    Double_t matrix[3][3],
 181                                    const Double_t tran[3]){
 182 ////////////////////////////////////////////////////////////////////////
 183 // This is a constructor for the AliITSgeomMatrix class. The rotation matrix
 184 // is given as one of the inputs, and the translation vector tran [cm]. In
 185 // addition the layer, ladder, and detector number for this particular
 186 // module and the type of module must be given. The full rotation matrix
 187 // is kept so that the evaluation of a coordinate transformation can be
 188 // done quickly and with a minimum of CPU overhead. The basic coordinate
 189 // systems are the ALICE global coordinate system and the detector local
 190 // coordinate system. In general this structure is not limited to just
 191 // those two coordinate systems.
 192 //Begin_Html
 193 /*
 194 <img src="picts/ITS/AliISgeomMatrix_L1.gif">
 195 */
 196 //End_Html
 197 ////////////////////////////////////////////////////////////////////////
 198     Int_t i,j;
 199
 200     fDetectorIndex = idt; // a value never defined.
 201     for(i=0;i<3;i++){
 202         fid[i]   = id[i];
 203         ftran[i] = tran[i];
 204         for(j=0;j<3;j++) fm[i][j] = matrix[i][j];
 205     }// end for i
 206     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
 207     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
 208     if(fCylPhi<0.0) fCylPhi += TMath::Pi();
 209     this->AngleFromMatrix();
 210 }
 211 //----------------------------------------------------------------------
 212 void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang){
 213 ////////////////////////////////////////////////////////////////////////
 214 // This function returns the 6 GEANT 3.21 rotation angles [degrees] in
 215 // the array ang which must be at least [6] long.
 216 ////////////////////////////////////////////////////////////////////////
 217     Double_t si,c=180./TMath::Pi();
 218
 219     ang[1] = TMath::ATan2(fm[0][1],fm[0][0]);
 220     if(TMath::Cos(ang[1])!=0.0) si = fm[0][0]/TMath::Cos(ang[1]);
 221     else si = fm[0][1]/TMath::Sin(ang[1]);
 222     ang[0] = TMath::ATan2(si,fm[0][2]);
 223
 224     ang[3] = TMath::ATan2(fm[1][1],fm[1][0]);
 225     if(TMath::Cos(ang[3])!=0.0) si = fm[1][0]/TMath::Cos(ang[3]);
 226     else si = fm[1][1]/TMath::Sin(ang[3]);
 227     ang[2] = TMath::ATan2(si,fm[1][2]);
 228
 229     ang[5] = TMath::ATan2(fm[2][1],fm[2][0]);
 230     if(TMath::Cos(ang[5])!=0.0) si = fm[2][0]/TMath::Cos(ang[5]);
 231     else si = fm[2][1]/TMath::Sin(ang[5]);
 232     ang[4] = TMath::ATan2(si,fm[2][2]);
 233
 234     for(Int_t i=0;i<6;i++) {ang[i] *= c; if(ang[i]<0.0) ang[i] += 360.;}
 235 }
 236 //----------------------------------------------------------------------
 237 void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
 238 ////////////////////////////////////////////////////////////////////////
 239 // Given the 6 GEANT 3.21 rotation angles [degree], this will compute and
 240 // set the rotations matrix and 3 standard rotation angles [radians].
 241 // These angles and rotation matrix are overwrite the existing values in
 242 // this class.
 243 ////////////////////////////////////////////////////////////////////////
 244     Int_t    i,j;
 245     Double_t si,lr[9],c=TMath::Pi()/180.;
 246
 247     si    = TMath::Sin(c*ang[0]);
 248     if(ang[0]== 90.0)                 si = +1.0;
 249     if(ang[0]==270.0)                 si = -1.0;
 250     if(ang[0]==  0.0||ang[0]==180.) si =  0.0;
 251     lr[0] = si * TMath::Cos(c*ang[1]);
 252     lr[1] = si * TMath::Sin(c*ang[1]);
 253     lr[2] = TMath::Cos(c*ang[0]);
 254     if(ang[0]== 90.0||ang[0]==270.) lr[2] =  0.0;
 255     if(ang[0]== 0.0)                  lr[2] = +1.0;
 256     if(ang[0]==180.0)                 lr[2] = -1.0;
 257 //
 258     si    =  TMath::Sin(c*ang[2]);
 259     if(ang[2]== 90.0)                 si = +1.0;
 260     if(ang[2]==270.0)                 si = -1.0;
 261     if(ang[2]==  0.0||ang[2]==180.) si =  0.0;
 262     lr[3] = si * TMath::Cos(c*ang[3]);
 263     lr[4] = si * TMath::Sin(c*ang[3]);
 264     lr[5] = TMath::Cos(c*ang[2]);
 265     if(ang[2]== 90.0||ang[2]==270.) lr[5] =  0.0;
 266     if(ang[2]==  0.0)                 lr[5] = +1.0;
 267     if(ang[2]==180.0)                 lr[5] = -1.0;
 268 //
 269     si    = TMath::Sin(c*ang[4]);
 270     if(ang[4]== 90.0)                 si = +1.0;
 271     if(ang[4]==270.0)                 si = -1.0;
 272     if(ang[4]==  0.0||ang[4]==180.) si =  0.0;
 273     lr[6] = si * TMath::Cos(c*ang[5]);
 274     lr[7] = si * TMath::Sin(c*ang[5]);
 275     lr[8] = TMath::Cos(c*ang[4]);
 276     if(ang[4]== 90.0||ang[4]==270.0) lr[8] =  0.0;
 277     if(ang[4]==  0.0)                  lr[8] = +1.0;
 278     if(ang[4]==180.0)                  lr[8] = -1.0;
 279     // Normalize these elements and fill matrix fm.
 280     for(i=0;i<3;i++){// reuse si.
 281         si = 0.0;
 282         for(j=0;j<3;j++) si += lr[3*i+j]*lr[3*i+j];
 283         si = TMath::Sqrt(1./si);
 284         for(j=0;j<3;j++) fm[i][j] = si*lr[3*i+j];
 285     } // end for i
 286     this->AngleFromMatrix();
 287 }
 288 //----------------------------------------------------------------------
 289 AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
 290                                    const Int_t idt,const Int_t id[3],
 291                                    const Double_t tran[3]){
 292 ////////////////////////////////////////////////////////////////////////
 293 // This is a constructor for the AliITSgeomMatrix class. The matrix is
 294 // defined by the 6 GEANT 3.21 rotation angles [degrees], and the translation
 295 // vector tran [cm]. In addition the layer, ladder, and detector number
 296 // for this particular module and the type of module must be given.
 297 // The full rotation matrix is kept so that the evaluation
 298 // of a coordinate transformation can be done quickly and with a minimum
 299 // of CPU overhead. The basic coordinate systems are the ALICE global
 300 // coordinate system and the detector local coordinate system. In general
 301 // this structure is not limited to just those two coordinate systems.
 302 //Begin_Html
 303 /*
 304 <img src="picts/ITS/AliISgeomMatrix_L1.gif">
 305 */
 306 //End_Html
 307 ////////////////////////////////////////////////////////////////////////
 308     Int_t i;
 309
 310     fDetectorIndex = idt; // a value never defined.
 311     for(i=0;i<3;i++){
 312         fid[i]   = id[i];
 313         ftran[i] = tran[i];
 314     }// end for i
 315     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
 316     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
 317     if(fCylPhi<0.0) fCylPhi += TMath::Pi();
 318     this->MatrixFromSixAngles(rotd);
 319 }
 320 //----------------------------------------------------------------------
 321 void AliITSgeomMatrix::AngleFromMatrix(){
 322 ////////////////////////////////////////////////////////////////////////
 323 // Computes the angles from the rotation matrix up to a phase of 180 degrees.
 324 ////////////////////////////////////////////////////////////////////////
 325     Double_t rx,ry,rz;
 326     // get angles from matrix up to a phase of 180 degrees.
 327
 328     rx = TMath::ATan2(fm[2][1],fm[2][2]);if(rx<0.0) rx += 2.0*TMath::Pi();
 329     ry = TMath::ASin(fm[0][2]);          if(ry<0.0) ry += 2.0*TMath::Pi();
 330     rz = TMath::ATan2(fm[1][1],fm[0][0]);if(rz<0.0) rz += 2.0*TMath::Pi();
 331     frot[0] = rx;
 332     frot[1] = ry;
 333     frot[2] = rz;
 334     return;
 335 }
 336 //----------------------------------------------------------------------
 337 void AliITSgeomMatrix::MatrixFromAngle(){
 338 ////////////////////////////////////////////////////////////////////////
 339 // Computes the Rotation matrix from the angles [radians] kept in this
 340 // class.
 341 ////////////////////////////////////////////////////////////////////////
 342    Double_t sx,sy,sz,cx,cy,cz;
 343
 344    sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
 345    sy = TMath::Sin(frot[1]); cy = TMath::Cos(frot[1]);
 346    sz = TMath::Sin(frot[2]); cz = TMath::Cos(frot[2]);
 347    fm[0][0] =  cz*cy;             // fr[0]
 348    fm[0][1] = -cz*sy*sx - sz*cx;  // fr[1]
 349    fm[0][2] = -cz*sy*cx + sz*sx;  // fr[2]
 350    fm[1][0] =  sz*cy;             // fr[3]
 351    fm[1][1] = -sz*sy*sx + cz*cx;  // fr[4]
 352    fm[1][2] = -sz*sy*cx - cz*sx;  // fr[5]
 353    fm[2][0] =  sy;                // fr[6]
 354    fm[2][1] =  cy*sx;             // fr[7]
 355    fm[2][2] =  cy*cx;             // fr[8]
 356
 357 }
 358 //----------------------------------------------------------------------
 359 void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]){
 360 ////////////////////////////////////////////////////////////////////////
 361 // Returns the local coordinates given the global coordinates [cm].
 362 ////////////////////////////////////////////////////////////////////////
 363         Int_t    i,j;
 364         Double_t g[3];
 365
 366         for(i=0;i<3;i++) g[i] = g0[i] - ftran[i];
 367         for(i=0;i<3;i++){
 368                 l[i] = 0.0;
 369                 for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
 370                 // g = R l + translation
 371         } // end for i
 372         return;
 373 }
 374 //----------------------------------------------------------------------
 375 void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]){
 376 ////////////////////////////////////////////////////////////////////////
 377 // Returns the global coordinates given the local coordinates [cm].
 378 ////////////////////////////////////////////////////////////////////////
 379         Int_t    i,j;
 380
 381         for(i=0;i<3;i++){
 382                 g[i] = 0.0;
 383                 for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
 384                 g[i] += ftran[i];
 385                 // g = R^t l + translation
 386         } // end for i
 387         return;
 388 }
 389 //----------------------------------------------------------------------
 390 void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]){
 391 ////////////////////////////////////////////////////////////////////////
 392 // Returns the local coordinates of the momentum given the global
 393 // coordinates of the momentum. It transforms just like GtoLPosition
 394 // except that the translation vector is zero.
 395 ////////////////////////////////////////////////////////////////////////
 396         Int_t    i,j;
 397
 398         for(i=0;i<3;i++){
 399                 l[i] = 0.0;
 400                 for(j=0;j<3;j++) l[i] += fm[i][j]*g[j];
 401                 // g = R l
 402         } // end for i
 403         return;
 404 }
 405 //----------------------------------------------------------------------
 406 void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]){
 407 ////////////////////////////////////////////////////////////////////////
 408 // Returns the Global coordinates of the momentum given the local
 409 // coordinates of the momentum. It transforms just like LtoGPosition
 410 // except that the translation vector is zero.
 411 ////////////////////////////////////////////////////////////////////////
 412         Int_t    i,j;
 413
 414         for(i=0;i<3;i++){
 415                 g[i] = 0.0;
 416                 for(j=0;j<3;j++) g[i] += fm[j][i]*l[j];
 417                 // g = R^t l
 418         } // end for i
 419         return;
 420 }
 421 //----------------------------------------------------------------------
 422 void AliITSgeomMatrix::GtoLPositionError(      Double_t g[3][3],
 423                                                Double_t l[3][3]){
 424 ////////////////////////////////////////////////////////////////////////
 425 // Given an Uncertainty matrix in Global coordinates it is rotated so that
 426 // its representation in local coordinates can be returned. There is no
 427 // effect due to the translation vector or its uncertainty.
 428 ////////////////////////////////////////////////////////////////////////
 429         Int_t    i,j,k,m;
 430
 431         for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
 432                 l[i][m] = fm[j][i]*g[j][k]*fm[k][m];
 433                 // g = R^t l R
 434         return;
 435 }
 436 //----------------------------------------------------------------------
 437 void AliITSgeomMatrix::LtoGPositionError(      Double_t l[3][3],
 438                                                Double_t g[3][3]){
 439 ////////////////////////////////////////////////////////////////////////
 440 // Given an Uncertainty matrix in Local coordinates it is rotated so that
 441 // its representation in global coordinates can be returned. There is no
 442 // effect due to the translation vector or its uncertainty.
 443 ////////////////////////////////////////////////////////////////////////
 444         Int_t    i,j,k,m;
 445
 446         for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
 447                 g[i][m] = fm[i][j]*l[j][k]*fm[m][k];
 448                 // g = R l R^t
 449         return;
 450 }
 451 //----------------------------------------------------------------------
 452 void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g0[3],
 453                                             Double_t l[3]){
 454 ////////////////////////////////////////////////////////////////////////
 455 // A slightly different coordinate system is used when tracking.
 456 // This coordinate system is only relevant when the geometry represents
 457 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
 458 // alone but X -> -Y and Y -> X such that X always points out of the
 459 // ITS Cylinder for every layer including layer 1 (where the detector
 460 // are mounted upside down).
 461 //Begin_Html
 462 /*
 463 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
 464  */
 465 //End_Html
 466 ////////////////////////////////////////////////////////////////////////
 467     Double_t l0[3];
 468
 469     this->GtoLPosition(g0,l0);
 470     if(fid[0]==1){ // for layer 1 the detector are flipped upside down
 471                    // with respect to the others.
 472         l[0] = +l0[1];
 473         l[1] = -l0[0];
 474         l[2] = +l0[2];
 475     }else{
 476         l[0] = -l0[1];
 477         l[1] = +l0[0];
 478         l[2] = +l0[2];
 479     } // end if
 480     return;
 481 }
 482 //----------------------------------------------------------------------
 483 void AliITSgeomMatrix::LtoGPositionTracking(const Double_t l[3],
 484                                             Double_t g[3]){
 485 ////////////////////////////////////////////////////////////////////////
 486 // A slightly different coordinate system is used when tracking.
 487 // This coordinate system is only relevant when the geometry represents
 488 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
 489 // alone but X -> -Y and Y -> X such that X always points out of the
 490 // ITS Cylinder for every layer including layer 1 (where the detector
 491 // are mounted upside down).
 492 //Begin_Html
 493 /*
 494 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
 495  */
 496 //End_Html
 497 ////////////////////////////////////////////////////////////////////////
 498     Double_t l0[3];
 499
 500     if(fid[0]==1){ // for layer 1 the detector are flipped upside down
 501                    // with respect to the others.
 502         l0[0] = -l[1];
 503         l0[1] = +l[0];
 504         l0[2] = +l[2];
 505     }else{
 506         l0[0] = +l[1];
 507         l0[1] = -l[0];
 508         l0[2] = +l[2];
 509     } // end if
 510     this->LtoGPosition(l0,g);
 511     return;
 512 }
 513 //----------------------------------------------------------------------
 514 void AliITSgeomMatrix::GtoLMomentumTracking(const Double_t g[3],
 515                                             Double_t l[3]){
 516 ////////////////////////////////////////////////////////////////////////
 517 // A slightly different coordinate system is used when tracking.
 518 // This coordinate system is only relevant when the geometry represents
 519 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
 520 // alone but X -> -Y and Y -> X such that X always points out of the
 521 // ITS Cylinder for every layer including layer 1 (where the detector
 522 // are mounted upside down).
 523 //Begin_Html
 524 /*
 525 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
 526  */
 527 //End_Html
 528 ////////////////////////////////////////////////////////////////////////
 529     Double_t l0[3];
 530
 531     this->GtoLMomentum(g,l0);
 532     if(fid[0]==1){ // for layer 1 the detector are flipped upside down
 533                    // with respect to the others.
 534         l[0] = +l0[1];
 535         l[1] = -l0[0];
 536         l[2] = +l0[2];
 537     }else{
 538         l[0] = -l0[1];
 539         l[1] = +l0[0];
 540         l[2] = +l0[2];
 541     } // end if
 542     return;
 543         return;
 544 }
 545 //----------------------------------------------------------------------
 546 void AliITSgeomMatrix::LtoGMomentumTracking(const Double_t l[3],
 547                                             Double_t g[3]){
 548 ////////////////////////////////////////////////////////////////////////
 549 // A slightly different coordinate system is used when tracking.
 550 // This coordinate system is only relevant when the geometry represents
 551 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
 552 // alone but X -> -Y and Y -> X such that X always points out of the
 553 // ITS Cylinder for every layer including layer 1 (where the detector
 554 // are mounted upside down).
 555 //Begin_Html
 556 /*
 557 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
 558  */
 559 //End_Html
 560 ////////////////////////////////////////////////////////////////////////
 561     Double_t l0[3];
 562
 563     if(fid[0]==1){ // for layer 1 the detector are flipped upside down
 564                    // with respect to the others.
 565         l0[0] = -l[1];
 566         l0[1] = +l[0];
 567         l0[2] = +l[2];
 568     }else{
 569         l0[0] = +l[1];
 570         l0[1] = -l[0];
 571         l0[2] = +l[2];
 572     } // end if
 573     this->LtoGMomentum(l0,g);
 574         return;
 575 }
 576 //----------------------------------------------------------------------
 577 void AliITSgeomMatrix::GtoLPositionErrorTracking(     Double_t g[3][3],
 578                                                  Double_t l[3][3]){
 579 ////////////////////////////////////////////////////////////////////////
 580 // A slightly different coordinate system is used when tracking.
 581 // This coordinate system is only relevant when the geometry represents
 582 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
 583 // alone but X -> -Y and Y -> X such that X always points out of the
 584 // ITS Cylinder for every layer including layer 1 (where the detector
 585 // are mounted upside down).
 586 //Begin_Html
 587 /*
 588 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
 589  */
 590 //End_Html
 591 ////////////////////////////////////////////////////////////////////////
 592         Int_t    i,j,k,m;
 593         Double_t rt[3][3];
 594         Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
 595         Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
 596
 597         if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
 598             rt[i][k] = a0[i][j]*fm[j][k];
 599         else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
 600             rt[i][k] = a1[i][j]*fm[j][k];
 601         for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
 602                 l[i][m] = rt[j][i]*g[j][k]*rt[k][m];
 603                 // g = R^t l R
 604         return;
 605 }
 606 //----------------------------------------------------------------------
 607 void AliITSgeomMatrix::LtoGPositionErrorTracking( Double_t l[3][3],
 608                                                  Double_t g[3][3]){
 609 ////////////////////////////////////////////////////////////////////////
 610 // A slightly different coordinate system is used when tracking.
 611 // This coordinate system is only relevant when the geometry represents
 612 // the cylindrical ALICE ITS geometry. For tracking the Z axis is left
 613 // alone but X -> -Y and Y -> X such that X always points out of the
 614 // ITS Cylinder for every layer including layer 1 (where the detector
 615 // are mounted upside down).
 616 //Begin_Html
 617 /*
 618 <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
 619  */
 620 //End_Html
 621 ////////////////////////////////////////////////////////////////////////
 622         Int_t    i,j,k,m;
 623         Double_t rt[3][3];
 624         Double_t a0[3][3] = {{0.,+1.,0.},{-1.,0.,0.},{0.,0.,+1.}};
 625         Double_t a1[3][3] = {{0.,-1.,0.},{+1.,0.,0.},{0.,0.,+1.}};
 626
 627         if(fid[0]==1) for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
 628             rt[i][k] = a0[i][j]*fm[j][k];
 629         else for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)
 630             rt[i][k] = a1[i][j]*fm[j][k];
 631         for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
 632                 g[i][m] = rt[i][j]*l[j][k]*rt[m][k];
 633                 // g = R l R^t
 634         return;
 635 }
 636 //----------------------------------------------------------------------
 637 void AliITSgeomMatrix::PrintTitles(ostream *os){
 638 ////////////////////////////////////////////////////////////////////////
 639 // Standard output format for this class but it includes variable
 640 // names and formatting that makes it easer to read.
 641 ////////////////////////////////////////////////////////////////////////
 642     Int_t i,j;
 643
 644     *os << "fDetectorIndex=" << fDetectorIndex << " fid[3]={";
 645     for(i=0;i<3;i++) *os << fid[i]   << " ";
 646     *os << "} frot[3]={";
 647     for(i=0;i<3;i++) *os << frot[i]  << " ";
 648     *os << "} ftran[3]={";
 649     for(i=0;i<3;i++) *os << ftran[i] << " ";
 650     *os << "} fm[3][3]={";
 651     for(i=0;i<3;i++){for(j=0;j<3;j++){  *os << fm[i][j] << " ";} *os <<"}{";}
 652     *os << "}" << endl;
 653     return;
 654 }
 655 //----------------------------------------------------------------------
 656 void AliITSgeomMatrix::PrintComment(ostream *os){
 657 ////////////////////////////////////////////////////////////////////////
 658 //  output format used by Print..
 659 ////////////////////////////////////////////////////////////////////////
 660     *os << "fDetectorIndex fid[0] fid[1] fid[2] ftran[0] ftran[1] ftran[2] ";
 661     *os << "fm[0][0]  fm[0][1]  fm[0][2]  fm[1][0]  fm[1][1]  fm[1][2]  ";
 662     *os << "fm[2][0]  fm[2][1]  fm[2][2] ";
 663     return;
 664 }
 665 //----------------------------------------------------------------------
 666 void AliITSgeomMatrix::Print(ostream *os){
 667 ////////////////////////////////////////////////////////////////////////
 668 // Standard output format for this class.
 669 ////////////////////////////////////////////////////////////////////////
 670     Int_t i,j;
 671     Int_t fmt;
 672
 673     fmt = os->setf(ios::scientific);  // set scientific floating point output
 674     *os << fDetectorIndex << " ";
 675     for(i=0;i<3;i++) *os << fid[i]   << " ";
 676 //    for(i=0;i<3;i++) *os << frot[i]  << " ";  // Redundant with fm[][].
 677     for(i=0;i<3;i++) *os << setprecision(16) << ftran[i] << " ";
 678     for(i=0;i<3;i++)for(j=0;j<3;j++)  *os << setprecision(16) <<
 679                                           fm[i][j] << " ";
 680     *os << endl;
 681     os->flags(fmt); // reset back to old formating.
 682     return;
 683 }
 684 //----------------------------------------------------------------------
 685 void AliITSgeomMatrix::Read(istream *is){
 686 ////////////////////////////////////////////////////////////////////////
 687 // Standard input format for this class.
 688 ////////////////////////////////////////////////////////////////////////
 689     Int_t i,j;
 690
 691     *is >> fDetectorIndex;
 692     for(i=0;i<3;i++) *is >> fid[i];
 693 //    for(i=0;i<3;i++) *is >> frot[i]; // Redundant with fm[][].
 694     for(i=0;i<3;i++) *is >> ftran[i];
 695     for(i=0;i<3;i++)for(j=0;j<3;j++)  *is >> fm[i][j];
 696     AngleFromMatrix(); // compute angles frot[].
 697     fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
 698     fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
 699     if(fCylPhi<0.0) fCylPhi += TMath::Pi();
 700     return;
 701 }
 702 //______________________________________________________________________
 703 void AliITSgeomMatrix::Streamer(TBuffer &R__b){
 704    // Stream an object of class AliITSgeomMatrix.
 705
 706    if (R__b.IsReading()) {
 707       AliITSgeomMatrix::Class()->ReadBuffer(R__b, this);
 708       fCylR   = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
 709       fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
 710       this->AngleFromMatrix();
 711     if(fCylPhi<0.0) fCylPhi += TMath::Pi();
 712    } else {
 713       AliITSgeomMatrix::Class()->WriteBuffer(R__b, this);
 714    }
 715 }
 716 //----------------------------------------------------------------------
 717 ostream &operator<<(ostream &os,AliITSgeomMatrix &p){
 718 ////////////////////////////////////////////////////////////////////////
 719 // Standard output streaming function.
 720 ////////////////////////////////////////////////////////////////////////
 721
 722     p.Print(&os);
 723     return os;
 724 }
 725 //----------------------------------------------------------------------
 726 istream &operator>>(istream &is,AliITSgeomMatrix &r){
 727 ////////////////////////////////////////////////////////////////////////
 728 // Standard input streaming function.
 729 ////////////////////////////////////////////////////////////////////////
 730
 731     r.Read(&is);
 732     return is;
 733 }
 734 //----------------------------------------------------------------------