* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-////////////////////////////////////////////////////////////////////////
-// This is the implementation file for AliITSgeomMatrix class. It
-// contains the routines to manipulate, setup, and queary the geometry
-// of a given ITS module. An ITS module may be one of at least three
-// ITS detector technologies, Silicon Pixel, Drift, or Strip Detectors,
-// and variations of these in size and/or layout. These routines let
-// one go between ALICE global coordiantes (cm) to a given modules
-// specific local coordinates (cm).
-////////////////////////////////////////////////////////////////////////
+/*
+$Id$
+*/
+/*
+ This is the implementation file for AliITSgeomMatrix class. It
+ contains the routines to manipulate, setup, and queary the geometry
+ of a given ITS module. An ITS module may be one of at least three
+ ITS detector technologies, Silicon Pixel, Drift, or Strip Detectors,
+ and variations of these in size and/or layout. These routines let
+ one go between ALICE global coordiantes (cm) to a given modules
+ specific local coordinates (cm).
+*/
#include <Riostream.h>
#include <TMath.h>
#include <TBuffer.h>
#include <TClass.h>
+#include <TCanvas.h>
+#include <TView.h>
+#include <TPolyLine3D.h>
+//#include <TPolyLineShape.h>
+#include <TNode.h>
+#include <TPCON.h>
+#include <TBRIK.h>
+#include <TXTRU.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(),
+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.
//----------------------------------------------------------------------
AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) :
TObject(sourse){
-////////////////////////////////////////////////////////////////////////
-// The standard Copy constructor. 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 constructes AliITSgeomMatrix class.
Int_t i,j;
this->fDetectorIndex = sourse.fDetectorIndex;
this->fCylPhi = sourse.fCylPhi;
for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
}// end for i
+ this->fPath = sourse.fPath;
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
-////////////////////////////////////////////////////////////////////////
-// The standard = operator. This make a full / proper copy of
-// this class.
-////////////////////////////////////////////////////////////////////////
+ // 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.
Int_t i,j;
this->fDetectorIndex = sourse.fDetectorIndex;
this->fCylPhi = sourse.fCylPhi;
for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
}// end for i
+ this->fPath = sourse.fPath;
}
//----------------------------------------------------------------------
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
-/*
-<img src="picts/ITS/AliISgeomMatrix_L1.gif">
-*/
-//End_Html
-////////////////////////////////////////////////////////////////////////
+ const Double_t rot[3],const Double_t tran[3]):
+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 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.
//----------------------------------------------------------------------
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
-////////////////////////////////////////////////////////////////////////
+ const Double_t tran[3]):
+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
+ // 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.
}
//----------------------------------------------------------------------
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.
-////////////////////////////////////////////////////////////////////////
+ // 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]);
}
//----------------------------------------------------------------------
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.;
//----------------------------------------------------------------------
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
-/*
-<img src="picts/ITS/AliISgeomMatrix_L1.gif">
-*/
-//End_Html
-////////////////////////////////////////////////////////////////////////
+ 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/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.
}
//----------------------------------------------------------------------
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.
+ // Inputs:
+ // none
+ // Outputs:
+ // none
+ // Return:
+ // none
Double_t rx,ry,rz;
// get angles from matrix up to a phase of 180 degrees.
}
//----------------------------------------------------------------------
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.
+ // Inputs:
+ // none
+ // Outputs:
+ // none
+ // Return:
+ // none
Double_t sx,sy,sz,cx,cy,cz;
sx = TMath::Sin(frot[0]); cx = TMath::Cos(frot[0]);
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::GtoLPosition(const Double_t g0[3],Double_t l[3]) const {
-////////////////////////////////////////////////////////////////////////
-// Returns the local coordinates given the global coordinates [cm].
-////////////////////////////////////////////////////////////////////////
+ // 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];
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::LtoGPosition(const Double_t l[3],Double_t g[3]) const {
-////////////////////////////////////////////////////////////////////////
-// Returns the global coordinates given the local coordinates [cm].
-////////////////////////////////////////////////////////////////////////
+ // 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++){
}
//----------------------------------------------------------------------
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.
-////////////////////////////////////////////////////////////////////////
+ // 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++){
}
//----------------------------------------------------------------------
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.
-////////////////////////////////////////////////////////////////////////
+ // 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++){
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::GtoLPositionError( 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.
-////////////////////////////////////////////////////////////////////////
+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++){
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::LtoGPositionError( Double_t l[3][3],
+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.
-////////////////////////////////////////////////////////////////////////
+ // 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++){
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::GtoLPositionTracking(const Double_t g0[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
-////////////////////////////////////////////////////////////////////////
+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]) 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
-////////////////////////////////////////////////////////////////////////
+ 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]) 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
-////////////////////////////////////////////////////////////////////////
+ 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);
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::LtoGMomentumTracking(const Double_t l[3],
- 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
-////////////////////////////////////////////////////////////////////////
+ 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]) 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
-////////////////////////////////////////////////////////////////////////
+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.}};
return;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::LtoGPositionErrorTracking( 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_T1.gif">
- */
-//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
+ /*
+ <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.}};
}
//----------------------------------------------------------------------
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.
-////////////////////////////////////////////////////////////////////////
+ // 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]={";
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::PrintComment(ostream *os) const {
-////////////////////////////////////////////////////////////////////////
-// output format used by Print..
-////////////////////////////////////////////////////////////////////////
+ // 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] ";
}
//----------------------------------------------------------------------
void AliITSgeomMatrix::Print(ostream *os){
-////////////////////////////////////////////////////////////////////////
-// Standard output format for this class.
-////////////////////////////////////////////////////////////////////////
+ // 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
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.
-////////////////////////////////////////////////////////////////////////
+ // 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;
// for(i=0;i<3;i++) *is >> frot[i]; // Redundant with fm[][].
for(i=0;i<3;i++) *is >> ftran[i];
for(i=0;i<3;i++)for(j=0;j<3;j++) *is >> fm[i][j];
+ *is >> j; // string length
+ fPath.Resize(j);
+ for(i=0;i<j;i++) {*is >> fPath[i];}
AngleFromMatrix(); // compute angles frot[].
fCylR = TMath::Sqrt(ftran[0]*ftran[0]+ftran[1]*ftran[1]);
fCylPhi = TMath::ATan2(ftran[1],ftran[0]);
//______________________________________________________________________
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 += TMath::Pi();
- } else {
- AliITSgeomMatrix::Class()->WriteBuffer(R__b, this);
- }
+ 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.
- 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();
+ // 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();
+}
+//----------------------------------------------------------------------
+TPolyLine3D* AliITSgeomMatrix::CreateLocalAxis(){
+ // 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(){
+ // 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){
+ // 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 scale=0.5,lw=0.2;
+ Float_t xchar[13][2]={{0.5*lw,1.},{0.,0.5*lw},{0.5-0.5*lw,0.5},
+ {0.,0.5*lw},{0.5*lw,0.},{0.5,0.5-0.5*lw},
+ {1-0.5*lw,0.},{1.,0.5*lw},{0.5+0.5*lw,0.5},
+ {1.,1.-0.5*lw},{1.-0.5*lw,1.},{0.5,0.5+0.5*lw},
+ {0.5*lw,1.}};
+ Float_t ychar[10][2]={{.5-0.5*lw,0.},{.5+0.5*lw,0.},{.5+0.5*lw,0.5-0.5*lw},
+ {1.,1.-0.5*lw},{1.-0.5*lw,1.},{0.5+0.5*lw,0.5},
+ {0.5*lw,1.} ,{0.,1-0.5*lw} ,{0.5-0.5*lw,0.5},
+ {.5-0.5*lw,0.}};
+ Float_t zchar[11][2]={{0.,1.},{0,1.-lw},{1.-lw,1.-lw},{0.,lw} ,{0.,0.},
+ {1.,0.},{1.,lw} ,{lw,lw} ,{1.,1.-lw},{1.,1.},
+ {0.,1.}};
+ for(i=0;i<13;i++)for(j=0;j<2;j++){
+ if(i<13) xchar[i][j] = scale*xchar[i][j];
+ if(i<10) ychar[i][j] = scale*ychar[i][j];
+ if(i<11) zchar[i][j] = scale*zchar[i][j];
+ } // end for i,j
+ TXTRU *axisxl = new TXTRU("x","x","text",12,2);
+ for(i=0;i<12;i++) axisxl->DefineVertex(i,xchar[i][0],xchar[i][1]);
+ axisxl->DefineSection(0,-0.5*lw);axisxl->DefineSection(1,0.5*lw);
+ TXTRU *axisyl = new TXTRU("y","y","text",9,2);
+ for(i=0;i<9;i++) axisyl->DefineVertex(i,ychar[i][0],ychar[i][1]);
+ axisyl->DefineSection(0,-0.5*lw);axisyl->DefineSection(1,0.5*lw);
+ TXTRU *axiszl = new TXTRU("z","z","text",10,2);
+ for(i=0;i<10;i++) axiszl->DefineVertex(i,zchar[i][0],zchar[i][1]);
+ axiszl->DefineSection(0,-0.5*lw);axiszl->DefineSection(1,0.5*lw);
+ Float_t lxy[13][2]={{-0.5*lw,-0.5*lw},{0.8,-0.5*lw},{0.8,-0.1},{1.0,0.0},
+ {0.8,0.1},{0.8,0.5*lw},{0.5*lw,0.5*lw},{0.5*lw,0.8},
+ {0.1,0.8},{0.0,1.0},{-0.1,0.8},{-0.5*lw,0.8},
+ {-0.5*lw,-0.5*lw}};
+ TXTRU *axisxy = new TXTRU("axisxy","axisxy","text",13,2);
+ for(i=0;i<13;i++) axisxy->DefineVertex(i,lxy[i][0],lxy[i][1]);
+ axisxy->DefineSection(0,-0.5*lw);axisxy->DefineSection(1,0.5*lw);
+ Float_t lz[8][2]={{0.5*lw,-0.5*lw},{0.8,-0.5*lw},{0.8,-0.1},{1.0,0.0},
+ {0.8,0.1},{0.8,0.5*lw},{0.5*lw,0.5*lw},
+ {0.5*lw,-0.5*lw}};
+ TXTRU *axisz = new TXTRU("axisz","axisz","text",8,2);
+ for(i=0;i<8;i++) axisz->DefineVertex(i,lz[i][0],lz[i][1]);
+ axisz->DefineSection(0,-0.5*lw);axisz->DefineSection(1,0.5*lw);
+ //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(){
+ // make figures to help document this class
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ const Double_t dx0=550.,dy0=550.,dz0=550.; // cm
+ const Double_t dx=1.0,dy=0.300,dz=3.0,rmax=0.1; // cm
+ 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.
+ TView *view = new TView(1); // Create Cartesian coordiante view
+ TBRIK *mother = new TBRIK("Mother","Mother","void",dx0,dy0,dz0);
+ TBRIK *det = new TBRIK("Detector","","Si",dx,dy,dz);
+ 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,rmax);
+ arrow->DefineSection(1,2.*rmax,0.0,0.0);
+ view->SetRange(-dx0,-dy0,-dz0,dx0,dy0,dz0);
+ //
+ 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;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff