X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSgeomMatrix.cxx;h=99cb5436cd9c957c9fbb731d12462fba13e6c3f7;hb=81842c1640a56ed6be5ead79dfb0245de1f45904;hp=cda85004d6c615f1756c76e8bd87e0be3c3b3660;hpb=9f69211c632a0768950149c010b5340af74aa8a4;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSgeomMatrix.cxx b/ITS/AliITSgeomMatrix.cxx index cda85004d6c..99cb5436cd9 100644 --- a/ITS/AliITSgeomMatrix.cxx +++ b/ITS/AliITSgeomMatrix.cxx @@ -13,8 +13,9 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -/* $Id$ */ - +/* +$Id$ +*/ //////////////////////////////////////////////////////////////////////// // This is the implementation file for AliITSgeomMatrix class. It // contains the routines to manipulate, setup, and queary the geometry @@ -26,31 +27,56 @@ //////////////////////////////////////////////////////////////////////// #include +#include #include #include -#include +#include +#if ROOT_VERSION_CODE>= 331523 +#include +#else +#include +#endif +#include +#include +#include +#include +#include #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 -/* - -*/ -//End_Html -//////////////////////////////////////////////////////////////////////// +AliITSgeomMatrix::AliITSgeomMatrix(): +TObject(), +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 + /* + + */ + //End_Html + // Inputs: + // none. + // Outputs: + // none. + // Return: + // A default constructes AliITSgeomMatrix class. Int_t i,j; fDetectorIndex = -1; // a value never defined. @@ -62,65 +88,96 @@ AliITSgeomMatrix::AliITSgeomMatrix(){ }// end for i fm[0][0] = fm[1][1] = fm[2][2] = 1.0; } + //---------------------------------------------------------------------- -AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) : - TObject(sourse){ -//////////////////////////////////////////////////////////////////////// -// The standard Copy constructor. This make a full / proper copy of -// this class. -//////////////////////////////////////////////////////////////////////// +AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &source) : +TObject(source), +fDetectorIndex(source.fDetectorIndex), +fCylR(source.fCylR), +fCylPhi(source.fCylPhi), +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]; - this->fCylR = sourse.fCylR; - this->fCylPhi = sourse.fCylPhi; - for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j]; + 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]; - this->fCylR = sourse.fCylR; - this->fCylPhi = sourse.fCylPhi; - for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j]; - }// end for i + this->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]; + } + this->fPath = source.fPath; + return *this; } + //---------------------------------------------------------------------- AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3], - const Double_t rot[3],const Double_t tran[3]){ -//////////////////////////////////////////////////////////////////////// -// 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 -/* - -*/ -//End_Html -//////////////////////////////////////////////////////////////////////// + const Double_t rot[3],const Double_t tran[3]): +TObject(), +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 + /* + + */ + //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]; @@ -134,26 +191,42 @@ AliITSgeomMatrix::AliITSgeomMatrix(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 -/* - -*/ -//End_Html -//////////////////////////////////////////////////////////////////////// + const Double_t tran[3]): +TObject(), +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 + /* + + */ + //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]; @@ -165,11 +238,15 @@ AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt, const Int_t id[3], 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(); ang[1] = TMath::ATan2(fm[0][1],fm[0][0]); @@ -191,12 +268,16 @@ void AliITSgeomMatrix::SixAnglesFromMatrix(Double_t *ang){ } //---------------------------------------------------------------------- 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.; @@ -244,26 +325,34 @@ void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){ //---------------------------------------------------------------------- AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/, Int_t idt,const Int_t id[3], - const Double_t tran[3]){ -//////////////////////////////////////////////////////////////////////// -// 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 -/* - -*/ -//End_Html -//////////////////////////////////////////////////////////////////////// + const Double_t tran[3]): +TObject(), +fDetectorIndex(idt), +fCylR(0.), +fCylPhi(0.), +fPath(){ + // 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 + /* + + */ + //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]; @@ -273,49 +362,83 @@ AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/, if(fCylPhi<0.0) fCylPhi += 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; return; } + //---------------------------------------------------------------------- void AliITSgeomMatrix::MatrixFromAngle(){ -//////////////////////////////////////////////////////////////////////// -// Computes the Rotation matrix from the angles [radians] kept in this -// class. -//////////////////////////////////////////////////////////////////////// + // 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] + 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::GtoLPosition(const Double_t g0[3],Double_t l[3]){ -//////////////////////////////////////////////////////////////////////// -// Returns the local coordinates given the global coordinates [cm]. -//////////////////////////////////////////////////////////////////////// +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]; @@ -328,10 +451,16 @@ void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]){ return; } //---------------------------------------------------------------------- -void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]){ -//////////////////////////////////////////////////////////////////////// -// Returns the global coordinates given the local coordinates [cm]. -//////////////////////////////////////////////////////////////////////// +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++){ @@ -343,12 +472,18 @@ void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]){ 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. -//////////////////////////////////////////////////////////////////////// +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++){ @@ -359,12 +494,18 @@ void AliITSgeomMatrix::GtoLMomentum(const Double_t g[3],Double_t l[3]){ 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. -//////////////////////////////////////////////////////////////////////// +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++){ @@ -375,13 +516,20 @@ void AliITSgeomMatrix::LtoGMomentum(const Double_t l[3],Double_t g[3]){ 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. -//////////////////////////////////////////////////////////////////////// +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(m=0;m<3;m++){ @@ -393,13 +541,19 @@ void AliITSgeomMatrix::GtoLPositionError( Double_t g[3][3], 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. -//////////////////////////////////////////////////////////////////////// +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(m=0;m<3;m++){ @@ -411,24 +565,30 @@ void AliITSgeomMatrix::LtoGPositionError( Double_t l[3][3], 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 -/* - - */ -//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 + /* + + */ + //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]; @@ -443,20 +603,26 @@ void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g0[3], } //---------------------------------------------------------------------- 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 -/* - - */ -//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 + /* + + */ + //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 @@ -474,20 +640,26 @@ void AliITSgeomMatrix::LtoGPositionTracking(const Double_t l[3], } //---------------------------------------------------------------------- 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 -/* - - */ -//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 + /* + + */ + //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); @@ -505,20 +677,26 @@ void AliITSgeomMatrix::GtoLMomentumTracking(const Double_t g[3], } //---------------------------------------------------------------------- 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 -/* - - */ -//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 + /* + + */ + //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 @@ -535,21 +713,26 @@ void AliITSgeomMatrix::LtoGMomentumTracking(const Double_t l[3], 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 -/* - - */ -//End_Html -//////////////////////////////////////////////////////////////////////// +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 + /* + + */ + //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.}}; @@ -568,21 +751,27 @@ void AliITSgeomMatrix::GtoLPositionErrorTracking( Double_t g[3][3], 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 -/* - - */ -//End_Html -//////////////////////////////////////////////////////////////////////// +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 + /* + + */ + //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.}}; @@ -601,11 +790,15 @@ void AliITSgeomMatrix::LtoGPositionErrorTracking( Double_t l[3][3], 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]={"; @@ -620,20 +813,28 @@ void AliITSgeomMatrix::PrintTitles(ostream *os){ return; } //---------------------------------------------------------------------- -void AliITSgeomMatrix::PrintComment(ostream *os){ -//////////////////////////////////////////////////////////////////////// -// output format used by Print.. -//////////////////////////////////////////////////////////////////////// +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){ -//////////////////////////////////////////////////////////////////////// -// Standard output format for this class. -//////////////////////////////////////////////////////////////////////// +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 @@ -656,15 +857,21 @@ void AliITSgeomMatrix::Print(ostream *os){ 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;iflags(fmt); // reset back to old formating. return; } //---------------------------------------------------------------------- void AliITSgeomMatrix::Read(istream *is){ -//////////////////////////////////////////////////////////////////////// -// Standard input format for this class. -//////////////////////////////////////////////////////////////////////// + // Standard input format for this class. + // Inputs: + // istream *is The input stream to read on + // Outputs: + // none. + // Return: + // none. Int_t i,j; *is >> fDetectorIndex; @@ -672,6 +879,12 @@ void AliITSgeomMatrix::Read(istream *is){ // 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 + fPath.Resize(j); + for(i=0;i> 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]); @@ -681,31 +894,287 @@ void AliITSgeomMatrix::Read(istream *is){ //______________________________________________________________________ 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 (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 += 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 += TMath::Pi(); - } else { - AliITSgeomMatrix::Class()->WriteBuffer(R__b, this); - } +} +//---------------------------------------------------------------------- +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); 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); return is;