* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.2 2000/08/29 20:16:50 nilsen
-New class for ITS coordiante transformations used by AliITSgeom nearly
-exclusively.
-
-Revision 1.1.2.1 2000/06/04 16:32:31 Nilsen
-A new class to hold the matrix information needed by AliITSgeom.
-
+/*
+$Id$
*/
-#include <iostream.h>
+////////////////////////////////////////////////////////////////////////
+// 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 <TCanvas.h>
+#if ROOT_VERSION_CODE>= 331523
+#include <TView3D.h>
+#else
+#include <TView.h>
+#endif
+#include <TPolyLine3D.h>
+#include <TNode.h>
+#include <TPCON.h>
+#include <TBRIK.h>
+#include <TXTRU.h>
+#include "AliLog.h"
#include "AliITSgeomMatrix.h"
ClassImp(AliITSgeomMatrix)
//----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(){
-////////////////////////////////////////////////////////////////////////
-// The Default constructor for the AliITSgeomMatrix class. By Default
-// the angles of rotations are set to zero, meaning that the rotation
-// matrix is the unit matrix. The translation vector is also set to zero
-// as are the module id number. The detector type is set to -1 (an undefined
-// value). The full rotation matrix is kept so that the evaluation
-// of a coordinate transformation can be done quickly and with a minimum
-// of CPU overhead. The basic coordinate systems are the ALICE global
-// coordinate system and the detector local coordinate system. In general
-// this structure is not limited to just those two coordinate systems.
-//Begin_Html
-/*
-<img src="picts/ITS/AliISgeomMatrix_L1.gif">
-*/
-//End_Html
-////////////////////////////////////////////////////////////////////////
+AliITSgeomMatrix::AliITSgeomMatrix():
+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].
+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
+ // The Default constructor for the AliITSgeomMatrix class. By Default
+ // the angles of rotations are set to zero, meaning that the rotation
+ // matrix is the unit matrix. The translation vector is also set to
+ // zero as are the module id number. The detector type is set to -1
+ // (an undefined value). The full rotation matrix is kept so that
+ // the evaluation of a coordinate transformation can be done
+ // quickly and with a minimum of CPU overhead. The basic coordinate
+ // systems are the ALICE global coordinate system and the detector
+ // local coordinate system. In general this structure is not limited
+ // to just those two coordinate systems.
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // A default constructes AliITSgeomMatrix class.
Int_t i,j;
fDetectorIndex = -1; // a value never defined.
}// end for i
fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
}
+
//----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse){
-////////////////////////////////////////////////////////////////////////
-// The standard copy constructor. This make a full / proper copy of
-// this class.
-////////////////////////////////////////////////////////////////////////
- Int_t i,j;
+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:
+ // AliITSgeomMatrix &source The source of this copy
+ // Outputs:
+ // none.
+ // Return:
+ // A copy constructes 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];
- for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
- }// end for i
+ 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){
-////////////////////////////////////////////////////////////////////////
-// The standard = operator. This make a full / proper copy of
-// this class.
-////////////////////////////////////////////////////////////////////////
- Int_t i,j;
+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
+ // this class.
+ // Inputs:
+ // AliITSgeomMatrix &source The source of this copy
+ // Outputs:
+ // none.
+ // Return:
+ // A copy of the source AliITSgeomMatrix class.
+
+ if(this == &source)return *this;
+ 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];
- for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
- }// end for i
+ 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(const Int_t idt,const Int_t id[3],
- const Double_t rot[3],const Double_t tran[3]){
-////////////////////////////////////////////////////////////////////////
-// This is a constructor for the AliITSgeomMatrix class. The matrix is
-// defined by 3 standard rotation angles [radians], and the translation
-// vector tran [cm]. In addition the layer, ladder, and detector number
-// for this particular module and the type of module must be given.
-// The full rotation matrix is kept so that the evaluation
-// of a coordinate transformation can be done quickly and with a minimum
-// of CPU overhead. The basic coordinate systems are the ALICE global
-// coordinate system and the detector local coordinate system. In general
-// this structure is not limited to just those two coordinate systems.
-//Begin_Html
-/*
-<img src="picts/ITS/AliISgeomMatrix_L1.gif">
-*/
-//End_Html
-////////////////////////////////////////////////////////////////////////
- Int_t i;
+AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
+ const Double_t rot[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 moduel
+ // This is a constructor for the AliITSgeomMatrix class. The matrix is
+ // defined by 3 standard rotation angles [radians], and the translation
+ // vector tran [cm]. In addition the layer, ladder, and detector number
+ // for this particular module and the type of module must be given.
+ // The full rotation matrix is kept so that the evaluation
+ // of a coordinate transformation can be done quickly and with a minimum
+ // of CPU overhead. The basic coordinate systems are the ALICE global
+ // coordinate system and the detector local coordinate system. In general
+ // this structure is not limited to just those two coordinate systems.
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Int_t idt The detector index value
+ // Int_t id[3] The layer, ladder, and detector numbers
+ // Double_t rot[3] The 3 Cartician rotaion angles [radians]
+ // Double_t tran[3] The 3 Cartician translation distnaces
+ // Outputs:
+ // none.
+ // Return:
+ // 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];
- ftran[i] = tran[i];
- }// end for i
- this->MatrixFromAngle();
+ for(i=0;i<3;i++){
+ fid[i] = id[i];
+ frot[i] = rot[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 += 2.*TMath::Pi();
+ this->MatrixFromAngle();
}
//----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(const Int_t idt, const Int_t id[3],
+AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt, const Int_t id[3],
Double_t matrix[3][3],
- const Double_t tran[3]){
-////////////////////////////////////////////////////////////////////////
-// This is a constructor for the AliITSgeomMatrix class. The rotation matrix
-// is given as one of the inputs, and the translation vector tran [cm]. In
-// addition the layer, ladder, and detector number for this particular
-// module and the type of module must be given. The full rotation matrix
-// is kept so that the evaluation of a coordinate transformation can be
-// done quickly and with a minimum of CPU overhead. The basic coordinate
-// systems are the ALICE global coordinate system and the detector local
-// coordinate system. In general this structure is not limited to just
-// those two coordinate systems.
-//Begin_Html
-/*
-<img src="picts/ITS/AliISgeomMatrix_L1.gif">
-*/
-//End_Html
-////////////////////////////////////////////////////////////////////////
- Int_t i,j;
+ 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
+ // rotation matrix is given as one of the inputs, and the
+ // translation vector tran [cm]. In addition the layer, ladder,
+ // and detector number for this particular module and the type of
+ // module must be given. The full rotation matrix is kept so that
+ // the evaluation of a coordinate transformation can be done quickly
+ // and with a minimum of CPU overhead. The basic coordinate systems
+ // are the ALICE global coordinate system and the detector local
+ // coordinate system. In general this structure is not limited to just
+ // those two coordinate systems.
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Int_t idt The detector index value
+ // Int_t id[3] The layer, ladder, and detector numbers
+ // Double_t rot[3][3] The 3x3 Cartician rotaion matrix
+ // Double_t tran[3] The 3 Cartician translation distnaces
+ // Outputs:
+ // none.
+ // Return:
+ // 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];
- for(j=0;j<3;j++) fm[i][j] = matrix[i][j];
- }// end for i
- this->AngleFromMatrix();
+ for(i=0;i<3;i++){
+ fid[i] = id[i];
+ ftran[i] = tran[i];
+ for(j=0;j<3;j++) fm[i][j] = matrix[i][j];
+ }// 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 += 2.*TMath::Pi();
+ this->AngleFromMatrix();
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang){
-////////////////////////////////////////////////////////////////////////
-// This function returns the 6 GEANT 3.21 rotation angles [degrees] in
-// the array ang which must be at least [6] long.
-////////////////////////////////////////////////////////////////////////
+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:
+ // none.
+ // Outputs:
+ // Double_t ang[6] The 6 Geant3.21 rotation angles. [degrees]
+ // 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[4] = TMath::ATan2(si,fm[1][2]);
+ ang[2] = TMath::ATan2(si,fm[1][2]);
- ang[6] = TMath::ATan2(fm[2][1],fm[2][0]);
- if(TMath::Cos(ang[6])!=0.0) si = fm[2][0]/TMath::Cos(ang[6]);
- else si = fm[2][1]/TMath::Sin(ang[6]);
- ang[5] = TMath::ATan2(si,fm[2][2]);
+ ang[5] = TMath::ATan2(fm[2][1],fm[2][0]);
+ 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]);
for(Int_t i=0;i<6;i++) {ang[i] *= c; if(ang[i]<0.0) ang[i] += 360.;}
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
-////////////////////////////////////////////////////////////////////////
-// Given the 6 GEANT 3.21 rotation angles [degree], this will compute and
-// set the rotations matrix and 3 standard rotation angles [radians].
-// These angles and rotation matrix are overwrite the existing values in
-// this class.
-////////////////////////////////////////////////////////////////////////
+ // Given the 6 GEANT 3.21 rotation angles [degree], this will compute and
+ // set the rotations matrix and 3 standard rotation angles [radians].
+ // These angles and rotation matrix are overwrite the existing values in
+ // this class.
+ // Inputs:
+ // Double_t ang[6] The 6 Geant3.21 rotation angles. [degrees]
+ // Outputs:
+ // none.
+ // Return:
+ // 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;
}
//----------------------------------------------------------------------
AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
- const Int_t idt,const Int_t id[3],
- const Double_t tran[3]){
-////////////////////////////////////////////////////////////////////////
-// 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, and detector number
-// for this particular module and the type of module must be given.
-// The full rotation matrix is kept so that the evaluation
-// of a coordinate transformation can be done quickly and with a minimum
-// of CPU overhead. The basic coordinate systems are the ALICE global
-// coordinate system and the detector local coordinate system. In general
-// this structure is not limited to just those two coordinate systems.
-//Begin_Html
-/*
-<img src="picts/ITS/AliISgeomMatrix_L1.gif">
-*/
-//End_Html
-////////////////////////////////////////////////////////////////////////
+ Int_t idt,const Int_t id[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,
+ // and detector number for this particular module and the type of
+ // module must be given. The full rotation matrix is kept so that
+ // the evaluation of a coordinate transformation can be done
+ // quickly and with a minimum of CPU overhead. The basic coordinate
+ // systems are the ALICE global coordinate system and the detector
+ // local coordinate system. In general this structure is not limited
+ // to just those two coordinate systems.
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_L1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t rotd[6] The 6 Geant 3.21 rotation angles [degrees]
+ // Int_t idt The module Id number
+ // Int_t id[3] The layer, ladder and detector number
+ // 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 += 2.*TMath::Pi();
this->MatrixFromSixAngles(rotd);
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::AngleFromMatrix(){
-////////////////////////////////////////////////////////////////////////
-// Computes the angles from the rotation matrix up to a phase of 180 degrees.
-////////////////////////////////////////////////////////////////////////
+ // Computes the angles from the rotation matrix up to a phase of
+ // 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:
+ // none
+ // Return:
+ // none
Double_t rx,ry,rz;
// 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;
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::MatrixFromAngle(){
-////////////////////////////////////////////////////////////////////////
-// Computes the Rotation matrix from the angles [radians] kept in this
-// class.
-////////////////////////////////////////////////////////////////////////
- Double_t sx,sy,sz,cx,cy,cz;
+ // Computes the Rotation matrix from the angles [radians] kept in this
+ // 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;
- 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]){
-////////////////////////////////////////////////////////////////////////
-// Returns the local coordinates given the global coordinates [cm].
-////////////////////////////////////////////////////////////////////////
- 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;
+void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
+ // Returns the local coordinates given the global coordinates [cm].
+ // Inputs:
+ // Double_t g[3] The position represented in the ALICE
+ // global coordinate system
+ // Outputs:
+ // Double_t l[3] The poistion represented in the local
+ // detector coordiante system
+ // Return:
+ // none
+ 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;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]){
-////////////////////////////////////////////////////////////////////////
-// Returns the global coordinates given the local coordinates [cm].
-////////////////////////////////////////////////////////////////////////
- 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;
+void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
+ // Returns the global coordinates given the local coordinates [cm].
+ // Inputs:
+ // Double_t l[3] The poistion represented in the detector
+ // local coordinate system
+ // Outputs:
+ // Double_t g[3] The poistion represented in the ALICE
+ // Global coordinate system
+ // Return:
+ // none.
+ 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;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]){
-////////////////////////////////////////////////////////////////////////
-// Returns the local coordinates of the momentum given the global
-// coordinates of the momentum. It transforms just like GtoLPosition
-// except that the translation vector is zero.
-////////////////////////////////////////////////////////////////////////
- Int_t i,j;
+void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]) const{
+ // Returns the local coordinates of the momentum given the global
+ // coordinates of the momentum. It transforms just like GtoLPosition
+ // except that the translation vector is zero.
+ // Inputs:
+ // Double_t g[3] The momentum represented in the ALICE global
+ // coordinate system
+ // Outputs:
+ // Double_t l[3] the momentum represented in the detector
+ // local coordinate system
+ // Return:
+ // none.
+ 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]){
-////////////////////////////////////////////////////////////////////////
-// Returns the Global coordinates of the momentum given the local
-// coordinates of the momentum. It transforms just like LtoGPosition
-// except that the translation vector is zero.
-////////////////////////////////////////////////////////////////////////
- Int_t i,j;
+void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]) const {
+ // Returns the Global coordinates of the momentum given the local
+ // coordinates of the momentum. It transforms just like LtoGPosition
+ // except that the translation vector is zero.
+ // Inputs:
+ // Double_t l[3] the momentum represented in the detector
+ // local coordinate system
+ // Outputs:
+ // Double_t g[3] The momentum represented in the ALICE global
+ // coordinate system
+ // Return:
+ // none.
+ 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(Double_t g[3][3],
- Double_t l[3][3]){
-////////////////////////////////////////////////////////////////////////
-// Given an Uncertainty matrix in Global coordinates it is rotated so that
-// its representation in local coordinates can be returned. There is no
-// effect due to the translation vector or its uncertainty.
-////////////////////////////////////////////////////////////////////////
- Int_t i,j,k,m;
+void AliITSgeomMatrix::GtoLPositionError(const Double_t g[3][3],
+ Double_t l[3][3]) const {
+ // Given an Uncertainty matrix in Global coordinates it is
+ // rotated so that its representation in local coordinates can
+ // be returned. There is no effect due to the translation vector
+ // or its uncertainty.
+ // Inputs:
+ // Double_t g[3][3] The error matrix represented in the ALICE global
+ // coordinate system
+ // Outputs:
+ // Double_t l[3][3] the error matrix represented in the detector
+ // local coordinate system
+ // Return:
+ // none.
+ Int_t i,j,k,m;
- for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
- l[i][m] = fm[j][i]*g[j][k]*fm[k][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(Double_t l[3][3],
- Double_t g[3][3]){
-////////////////////////////////////////////////////////////////////////
-// Given an Uncertainty matrix in Local coordinates it is rotated so that
-// its representation in global coordinates can be returned. There is no
-// effect due to the translation vector or its uncertainty.
-////////////////////////////////////////////////////////////////////////
- Int_t i,j,k,m;
+void AliITSgeomMatrix::LtoGPositionError(const Double_t l[3][3],
+ Double_t g[3][3]) const {
+ // Given an Uncertainty matrix in Local coordinates it is rotated so that
+ // its representation in global coordinates can be returned. There is no
+ // effect due to the translation vector or its uncertainty.
+ // Inputs:
+ // Double_t l[3][3] the error matrix represented in the detector
+ // local coordinate system
+ // Outputs:
+ // Double_t g[3][3] The error matrix represented in the ALICE global
+ // coordinate system
+ // Return:
+ // none.
+ Int_t i,j,k,m;
- for(i=0;i<3;i++)for(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
- g[i][m] = fm[i][j]*l[j][k]*fm[m][k];
- // 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 g0[3],
- Double_t l[3]){
-////////////////////////////////////////////////////////////////////////
-// 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 detector
-// are mounted upside down).
-//Begin_Html
-/*
-<img src="picts/ITS/AliITSgeomMatrix_T1.gif">
- */
-//End_Html
-////////////////////////////////////////////////////////////////////////
+void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g[3],
+ Double_t l[3]) const {
+ // 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 detector
+ // are mounted upside down).
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t g[3] The position represented in the ALICE
+ // global coordinate system
+ // Outputs:
+ // Double_t l[3] The poistion represented in the local
+ // detector coordiante system
+ // Return:
+ // none
Double_t l0[3];
- this->GtoLPosition(g0,l0);
+ this->GtoLPosition(g,l0);
if(fid[0]==1){ // for layer 1 the detector are flipped upside down
// with respect to the others.
l[0] = +l0[1];
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::LtoGPositionTracking(const Double_t l[3],
- Double_t g[3]){
-////////////////////////////////////////////////////////////////////////
-// 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 detector
-// are mounted upside down).
-//Begin_Html
-/*
-<img src="picts/ITS/AliITSgeomMatrix_T1.gif">
- */
-//End_Html
-////////////////////////////////////////////////////////////////////////
+ Double_t g[3]) const {
+ // 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 detector
+ // are mounted upside down).
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t l[3] The poistion represented in the detector
+ // local coordinate system
+ // Outputs:
+ // Double_t g[3] The poistion represented in the ALICE
+ // Global coordinate system
+ // Return:
+ // none.
Double_t l0[3];
if(fid[0]==1){ // for layer 1 the detector are flipped upside down
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::GtoLMomentumTracking(const Double_t g[3],
- Double_t l[3]){
-////////////////////////////////////////////////////////////////////////
-// 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 detector
-// are mounted upside down).
-//Begin_Html
-/*
-<img src="picts/ITS/AliITSgeomMatrix_T1.gif">
- */
-//End_Html
-////////////////////////////////////////////////////////////////////////
+ Double_t l[3]) const {
+ // 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 detector
+ // are mounted upside down).
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t g[3] The momentum represented in the ALICE global
+ // coordinate system
+ // Outputs:
+ // Double_t l[3] the momentum represented in the detector
+ // local coordinate system
+ // Return:
+ // none.
Double_t l0[3];
this->GtoLMomentum(g,l0);
l[2] = +l0[2];
} // end if
return;
- return;
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::LtoGMomentumTracking(const Double_t l[3],
- Double_t g[3]){
-////////////////////////////////////////////////////////////////////////
-// 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 detector
-// are mounted upside down).
-//Begin_Html
-/*
-<img src="picts/ITS/AliITSgeomMatrix_T1.gif">
- */
-//End_Html
-////////////////////////////////////////////////////////////////////////
+ Double_t g[3]) const {
+ // 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 detector
+ // are mounted upside down).
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_T1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t l[3] the momentum represented in the detector
+ // local coordinate system
+ // Outputs:
+ // Double_t g[3] The momentum represented in the ALICE global
+ // coordinate system
+ // Return:
+ // none.
Double_t l0[3];
if(fid[0]==1){ // for layer 1 the detector are flipped upside down
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::GtoLPositionErrorTracking(Double_t g[3][3],
- Double_t l[3][3]){
-////////////////////////////////////////////////////////////////////////
-// 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 detector
-// are mounted upside down).
-//Begin_Html
-/*
-<img src="picts/ITS/AliITSgeomMatrix_T1.gif">
- */
-//End_Html
-////////////////////////////////////////////////////////////////////////
- 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(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
- l[i][m] = Rt[j][i]*g[j][k]*Rt[k][m];
- // g = R^t l R
- return;
+void AliITSgeomMatrix::GtoLPositionErrorTracking(const Double_t g[3][3],
+ Double_t l[3][3]) const {
+ // 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 detector
+ // are mounted upside down).
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_TE1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t g[3][3] The error matrix represented in the ALICE global
+ // coordinate system
+ // Outputs:
+ // 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.}};
+
+ 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(Double_t l[3][3],
- Double_t g[3][3]){
-////////////////////////////////////////////////////////////////////////
-// 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 detector
-// are mounted upside down).
-//Begin_Html
-/*
-<img src="picts/ITS/AliITSgeomMatrix_T1.gif">
- */
-//End_Html
-////////////////////////////////////////////////////////////////////////
- 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(j=0;j<3;j++)for(k=0;k<3;k++)for(m=0;m<3;m++)
- g[i][m] = Rt[i][j]*l[j][k]*Rt[m][k];
- // g = R l R^t
- return;
+void AliITSgeomMatrix::LtoGPositionErrorTracking(const Double_t l[3][3],
+ Double_t g[3][3]) const {
+ // 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 detector
+ // are mounted upside down).
+ //Begin_Html
+ /*
+ <img src="picts/ITS/AliITSgeomMatrix_TE1.gif">
+ */
+ //End_Html
+ // Inputs:
+ // Double_t l[3][3] the error matrix represented in the detector
+ // local coordinate system
+ // Outputs:
+ // Double_t g[3][3] The error matrix represented in the ALICE global
+ // 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.}};
+
+ 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){
-////////////////////////////////////////////////////////////////////////
-// Standard output format for this class but it includes variable
-// names and formatting that makes it easer to read.
-////////////////////////////////////////////////////////////////////////
+void AliITSgeomMatrix::PrintTitles(ostream *os) const {
+ // Standard output format for this class but it includes variable
+ // names and formatting that makes it easer to read.
+ // Inputs:
+ // ostream *os The output stream to print the title on
+ // Outputs:
+ // none.
+ // Return:
+ // none.
Int_t i,j;
*os << "fDetectorIndex=" << fDetectorIndex << " fid[3]={";
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::print(ostream *os){
-////////////////////////////////////////////////////////////////////////
-// Standard output format for this class.
-////////////////////////////////////////////////////////////////////////
+void AliITSgeomMatrix::PrintComment(ostream *os) const {
+ // output format used by Print.
+ // Inputs:
+ // ostream *os The output stream to print the comments on
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ *os << "fDetectorIndex fid[0] fid[1] fid[2] ftran[0] ftran[1] ftran[2] ";
+ *os << "fm[0][0] fm[0][1] fm[0][2] fm[1][0] fm[1][1] fm[1][2] ";
+ *os << "fm[2][0] fm[2][1] fm[2][2] ";
+ return;
+}
+//----------------------------------------------------------------------
+void AliITSgeomMatrix::Print(ostream *os)const{
+ // Standard output format for this class.
+ // Inputs:
+ // ostream *os The output stream to print the class data on
+ // Outputs:
+ // none.
+ // Return:
+ // none.
Int_t i,j;
+#if defined __GNUC__
+#if __GNUC__ > 2
+ ios::fmtflags fmt;
+#else
+ Int_t fmt;
+#endif
+#else
+#if defined __ICC || defined __ECC || defined __xlC__
+ ios::fmtflags fmt;
+#else
+ Int_t fmt;
+#endif
+#endif
+ fmt = os->setf(ios::scientific); // set scientific floating point output
*os << fDetectorIndex << " ";
for(i=0;i<3;i++) *os << fid[i] << " ";
- for(i=0;i<3;i++) *os << frot[i] << " ";
- for(i=0;i<3;i++) *os << ftran[i] << " ";
- for(i=0;i<3;i++)for(j=0;j<3;j++) *os << fm[i][j] << " ";
+// for(i=0;i<3;i++) *os << frot[i] << " "; // Redundant with fm[][].
+ for(i=0;i<3;i++) *os << setprecision(16) << ftran[i] << " ";
+ for(i=0;i<3;i++)for(j=0;j<3;j++) *os << setprecision(16) <<
+ fm[i][j] << " ";
+ *os << fPath.Length()<< " ";
+ for(i=0;i<fPath.Length();i++) *os << fPath[i];
*os << endl;
+ os->flags(fmt); // reset back to old formating.
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::read(istream *is){
-////////////////////////////////////////////////////////////////////////
-// Standard input format for this class.
-////////////////////////////////////////////////////////////////////////
+void AliITSgeomMatrix::Read(istream *is){
+ // Standard input format for this class.
+ // Inputs:
+ // istream *is The input stream to read on
+ // Outputs:
+ // none.
+ // 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];
+// 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];
+ 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){
+ 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 += 2.*TMath::Pi();
return;
}
+//______________________________________________________________________
+void AliITSgeomMatrix::Streamer(TBuffer &R__b){
+ // Stream an object of class AliITSgeomMatrix.
+ // Inputs:
+ // TBuffer &R__b The output buffer to stream data on.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+
+ if (R__b.IsReading()) {
+ AliITSgeomMatrix::Class()->ReadBuffer(R__b, this);
+ 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 += 2.*TMath::Pi();
+ } else {
+ AliITSgeomMatrix::Class()->WriteBuffer(R__b, this);
+ } // end if
+}
+//______________________________________________________________________
+void AliITSgeomMatrix::SetTranslation(const Double_t tran[3]){
+ // Sets the translation vector and computes fCylR and fCylPhi.
+ // Inputs:
+ // Double_t trans[3] The translation vector to be used
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ 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 += 2.*TMath::Pi();
+}
+//----------------------------------------------------------------------
+TPolyLine3D* AliITSgeomMatrix::CreateLocalAxis() const {
+ // This class is used as part of the documentation of this class
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // A pointer to a new TPolyLine3D object showing the 3 line
+ // segments that make up the this local axis in the global
+ // reference system.
+ Float_t gf[15];
+ Double_t g[5][3];
+ Double_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}};
+ Int_t i;
+
+ for(i=0;i<5;i++) {
+ LtoGPosition(l[i],g[i]);
+ gf[3*i]=(Float_t)g[i][0];
+ gf[3*i+1]=(Float_t)g[i][1];
+ gf[3*i+2]=(Float_t)g[i][2];
+ } // end for i
+ return new TPolyLine3D(5,gf);
+}
+//----------------------------------------------------------------------
+TPolyLine3D* AliITSgeomMatrix::CreateLocalAxisTracking() const {
+ // This class is used as part of the documentation of this class
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // A pointer to a new TPolyLine3D object showing the 3 line
+ // segments that make up the this local axis in the global
+ // reference system.
+ Float_t gf[15];
+ Double_t g[5][3];
+ Double_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}};
+ Int_t i;
+
+ for(i=0;i<5;i++) {
+ LtoGPositionTracking(l[i],g[i]);
+ gf[3*i]=(Float_t)g[i][0];
+ gf[3*i+1]=(Float_t)g[i][1];
+ gf[3*i+2]=(Float_t)g[i][2];
+ } // end for i
+ return new TPolyLine3D(5,gf);
+}
+//----------------------------------------------------------------------
+TNode* AliITSgeomMatrix::CreateNode(const Char_t *nodeName,
+ const Char_t *nodeTitle,TNode *mother,
+ 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.
+ // Inputs:
+ // Char_t *nodeName This name of this node
+ // Char_t *nodeTitle This node title
+ // TNode *mother The node this node will be inside of/with respect to
+ // TShape *shape The shape of this node
+ // Bool_t axis If ture, a set of x,y,z axis will be included
+ // Outputs:
+ // none.
+ // Return:
+ // A pointer to "this" node.
+ Double_t trans[3],matrix[3][3],*matr;
+ TRotMatrix *rot = new TRotMatrix();
+ TString name,title;
+
+ matr = &(matrix[0][0]);
+ this->GetTranslation(trans);
+ this->GetMatrix(matrix);
+ rot->SetMatrix(matr);
+ //
+ name = nodeName;
+ title = nodeTitle;
+ //
+ mother->cd();
+ 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 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] = 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*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*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*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*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*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);
+ //
+ node1->cd();
+ 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 *textboxX0 = new TNode("textboxX0","textboxX0",axisxl,
+ lxy[3][0],lxy[3][1],0.0);
+ TNode *textboxX1 = new TNode("textboxX1","textboxX1",axisxl,
+ lxy[3][0],lxy[3][1],0.0,yaxis90);
+ TNode *textboxX2 = new TNode("textboxX2","textboxX2",axisxl,
+ lxy[3][0],lxy[3][1],0.0,zaxis90);
+ TNode *textboxY0 = new TNode("textboxY0","textboxY0",axisyl,
+ lxy[9][0],lxy[9][1],0.0);
+ TNode *textboxY1 = new TNode("textboxY1","textboxY1",axisyl,
+ lxy[9][0],lxy[9][1],0.0,yaxis90);
+ TNode *textboxY2 = new TNode("textboxY2","textboxY2",axisyl,
+ lxy[9][0],lxy[9][1],0.0,zaxis90);
+ TNode *textboxZ0 = new TNode("textboxZ0","textboxZ0",axiszl,
+ 0.0,0.0,lz[3][0]);
+ TNode *textboxZ1 = new TNode("textboxZ1","textboxZ1",axiszl,
+ 0.0,0.0,lz[3][0],yaxis90);
+ TNode *textboxZ2 = new TNode("textboxZ2","textboxZ2",axiszl,
+ 0.0,0.0,lz[3][0],zaxis90);
+ nodeaxy->Draw();
+ nodeaz->Draw();
+ textboxX0->Draw();
+ textboxX1->Draw();
+ textboxX2->Draw();
+ textboxY0->Draw();
+ textboxY1->Draw();
+ textboxY2->Draw();
+ textboxZ0->Draw();
+ textboxZ1->Draw();
+ textboxZ2->Draw();
+ } // end if
+ mother->cd();
+ return node1;
+}
+//----------------------------------------------------------------------
+void AliITSgeomMatrix::MakeFigures() const {
+ // make figures to help document this class
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ 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
+#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);
+ TRotMatrix *yarrow= new TRotMatrix("yarrow","",0.0,90.,0.0);
+
+ det->SetLineColor(0); // black
+ det->SetLineStyle(1); // solid line
+ det->SetLineWidth(2); // pixel units
+ det->SetFillColor(1); // black
+ det->SetFillStyle(4010); // window is 90% transparent
+ arrow->SetLineColor(det->GetLineColor());
+ arrow->SetLineWidth(det->GetLineWidth());
+ arrow->SetLineStyle(det->GetLineStyle());
+ arrow->SetFillColor(1); // black
+ arrow->SetFillStyle(4100); // window is 100% opaque
+ 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 *nodez = new TNode("NODEz","NODEz",arrow,l[4][0],l[4][1],l[4][2]);
+ //
+ axis->Draw();
+ nodex->Draw();
+ nodey->Draw();
+ nodez->Draw();
+
+ //
+ node0->cd();
+ node0->Draw();
+ c->Update();
+ c->SaveAs("AliITSgeomMatrix_L1.gif");
+}
//----------------------------------------------------------------------
ostream &operator<<(ostream &os,AliITSgeomMatrix &p){
-////////////////////////////////////////////////////////////////////////
-// Standard output streaming function.
-////////////////////////////////////////////////////////////////////////
+ // Standard output streaming function.
+ // Inputs:
+ // ostream &os The output stream to print the class data on
+ // AliITSgeomMatrix &p This class
+ // Outputs:
+ // none.
+ // Return:
+ // none.
- p.print(&os);
+ p.Print(&os);
return os;
}
//----------------------------------------------------------------------
istream &operator>>(istream &is,AliITSgeomMatrix &r){
-////////////////////////////////////////////////////////////////////////
-// Standard input streaming function.
-////////////////////////////////////////////////////////////////////////
+ // Standard input streaming function.
+ // Inputs:
+ // ostream &os The input stream to print the class data on
+ // AliITSgeomMatrix &p This class
+ // Outputs:
+ // none.
+ // Return:
+ // none.
- r.read(&is);
+ r.Read(&is);
return is;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::Streamer(TBuffer &R__b){
-////////////////////////////////////////////////////////////////////////
-// Stream an object of class AliITSgeomMatrix.
-////////////////////////////////////////////////////////////////////////
-
- UInt_t R__s, R__c;
- if (R__b.IsReading()) {
- Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
- if (R__v==1) {
- R__b >> fDetectorIndex;
- R__b.ReadStaticArray(fid);
- R__b.ReadStaticArray(frot);
- R__b.ReadStaticArray(ftran);
- R__b.ReadStaticArray((double*)fm);
- R__b.CheckByteCount(R__s, R__c, AliITSgeomMatrix::IsA());
- } // end if R__v
- } else { // R__b.IsWriting()
- R__c = R__b.WriteVersion(AliITSgeomMatrix::IsA(), kTRUE);
- R__b << fDetectorIndex;
- R__b.WriteArray(fid, 3);
- R__b.WriteArray(frot, 3);
- R__b.WriteArray(ftran, 3);
- R__b.WriteArray((double*)fm, 9);
- R__b.SetByteCount(R__c, kTRUE);
- } // end if R__b.IsReading()||IsWriting()
-}
-//______________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff