remove props
[u/mrichter/AliRoot.git] / ITS / AliITSgeom.h
CommitLineData
b79e4bc3 1#ifndef ALIITSGEOM_H
2#define ALIITSGEOM_H
3da30618 3/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * See cxx source for full Copyright notice */
5
6/* $Id$ */
7
58005f18 8/////////////////////////////////////////////////////////////////////////
9// ITS geometry manipulation routines.
10// Created April 15 1999.
11// version: 0.0.0
12// By: Bjorn S. Nilsen
13//
14// A package of geometry routines to do transformations between
15// local, detector active area, and ALICE global coordinate system in such
16// a way as to allow for detector alignment studies and the like. All of
17// the information needed to do the coordinate transformation are kept in
18// a specialized structure for ease of implementation.
19/////////////////////////////////////////////////////////////////////////
4ae5bbc4 20#include <Riostream.h>
85f1e34a 21#include <TObject.h>
e8189707 22#include <TObjArray.h>
23#include <TVector.h>
023ae34b 24#include <TString.h>
25#include <TArrayI.h>
3010c308 26#include <TMath.h>
012f0f4c 27//
269f57ed 28#include "AliITSgeomMatrix.h"
325d8c32 29#include "AliLog.h"
58005f18 30
22e9f252 31typedef enum {kND=-1,kSPD=0, kSDD=1, kSSD=2, kSSDp=3,kSDDp=4} AliITSDetector;
58005f18 32
33//_______________________________________________________________________
34
35class AliITSgeom : public TObject {
b79e4bc3 36
58005f18 37 public:
269f57ed 38 AliITSgeom(); // Default constructor
023ae34b 39 AliITSgeom(Int_t itype,Int_t nlayers,const Int_t *nlads,const Int_t *ndets,
40 Int_t nmods); // Constructor
e56160b8 41 AliITSgeom(const AliITSgeom &source); // Copy constructor
42 AliITSgeom& operator=(const AliITSgeom &source);// = operator
3f38f7af 43 virtual ~AliITSgeom(); // Default destructor
023ae34b 44 // Zero and reinitilizes this class.
45 void Init(Int_t itype,Int_t nlayers,const Int_t *nlads,
46 const Int_t *ndets,Int_t mods);
85f1e34a 47 // this function allocates a AliITSgeomMatrix for a particular module.
023ae34b 48 void CreateMatrix(Int_t mod,Int_t lay,Int_t lad,Int_t det,
49 AliITSDetector idet,const Double_t tran[3],
50 const Double_t rot[10]);
023ae34b 51 // Getters
269f57ed 52 Int_t GetTransformationType() const {return fTrans;}
023ae34b 53 //
85f1e34a 54 // returns kTRUE if the transformation defined by this class is
55 // for Global GEANT coordinate system to the local GEANT coordinate system
8253cd9a 56 // of the detector. These are the transformation used by GEANT.
269f57ed 57 Bool_t IsGeantToGeant() const {return (fTrans == 0);}
85f1e34a 58 // returns kTRUE if the transformation defined by this class is
59 // for Global GEANT coordinate system to the local "Tracking" coordinate
8253cd9a 60 // system of the detector. These are the transformation used by the
61 // Tracking code.
269f57ed 62 Bool_t IsGeantToTracking() const {return ((fTrans&&0xfffe)!= 0);}
85f1e34a 63 // returns kTRUE if the transformation defined by this class is
64 // for Global GEANT coordinate system to the local GEANT coordinate system
65 // of the detector but may have been displaced by some typically small
66 // amount. These are modified transformation similar to that used by GEANT.
269f57ed 67 Bool_t IsGeantToDisplaced() const {return ((fTrans&&0xfffd)!= 0);}
023ae34b 68 //
8253cd9a 69 // This function returns a pointer to the particular AliITSgeomMatrix
70 // class for a specific module index.
012f0f4c 71 AliITSgeomMatrix *GetGeomMatrix(Int_t index){if(index<fGm.GetSize()&&
72 index>=0)
73 return (AliITSgeomMatrix*)(fGm.At(index));else
74 Error("GetGeomMatrix","index=%d<0||>=GetSize()=%d",
75 index,fGm.GetSize());return 0;}
76 AliITSgeomMatrix *GetGeomMatrix(Int_t index)const{if(index<fGm.GetSize()
77 &&index>=0)
78 return (AliITSgeomMatrix*)(fGm.At(index));else
79 Error("GetGeomMatrix","index=%d<0||>=GetSize()=%d",
80 index,fGm.GetSize());return 0;}
023ae34b 81 // This function find and return the number of detector types only.
5cf690c1 82 Int_t GetNDetTypes()const{Int_t max;return GetNDetTypes(max);};
023ae34b 83 // This function find and return the number of detector types and the
84 // maximum det type value.
5cf690c1 85 Int_t GetNDetTypes(Int_t &max)const;
023ae34b 86 // This function finds and return the number of detector types and the
87 // and the number of each type in the TArrayI and their types.
5cf690c1 88 Int_t GetNDetTypes(TArrayI &maxs,AliITSDetector *types)const;
269f57ed 89 // This function returns the number of detectors/ladder for a give
90 // layer. In particular it returns fNdet[layer-1].
c183cf7d 91 Int_t GetNdetectors(Int_t lay) const {return fNdet[lay-1];}
269f57ed 92 // This function returns the number of ladders for a give layer. In
93 // particular it returns fNlad[layer-1].
7f6ab649 94 Int_t GetNladders(Int_t lay) const {return fNlad[lay-1];};
269f57ed 95 // This function returns the number of layers defined in the ITS
96 // geometry. In particular it returns fNlayers.
97 Int_t GetNlayers() const {return fNlayers;}
5cf690c1 98 Int_t GetModuleIndex(Int_t lay,Int_t lad,Int_t det)const;
269f57ed 99 // This function returns the module index number given the layer,
100 // ladder and detector numbers put into the array id[3].
5cf690c1 101 Int_t GetModuleIndex(const Int_t *id)const{
023ae34b 102 return GetModuleIndex(id[0],id[1],id[2]);}
5cf690c1 103 void GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det)const;
cd71de57 104 // Returns the detector type
5cf690c1 105 //Int_t GetModuleType(Int_t index)const{
106 // return GetGeomMatrix(index)->GetDetectorIndex();}
107 AliITSDetector GetModuleType(Int_t index)const{
108 return (AliITSDetector)(GetGeomMatrix(index)->GetDetectorIndex());}
3f38f7af 109 // Returns the detector type as a string
5cf690c1 110 const char * GetModuleTypeName(Int_t index)const{
023ae34b 111 return GetDetectorTypeName(GetModuleType(index));}
112 // Returns the detector type as a string
5cf690c1 113 const char * GetDetectorTypeName(Int_t index)const{switch(index) {
023ae34b 114 case kSPD : return "kSPD" ; case kSDD : return "kSDD" ;
115 case kSSD : return "kSSD" ; case kSSDp: return "kSSDp";
116 case kSDDp: return "kSDDp"; default : return "Undefined";};}
117 //
5cf690c1 118 Int_t GetStartDet(Int_t dtype )const;
119 Int_t GetLastDet(Int_t dtype)const;
269f57ed 120 // Returns the starting module index number for SPD detector,
121 // assuming the modules are placed in the "standard" cylindrical
122 // ITS structure.
5cf690c1 123 Int_t GetStartSPD()const{return GetStartDet(kSPD);}
269f57ed 124 // Returns the ending module index number for SPD detector,
125 // assuming the modules are placed in the "standard" cylindrical
126 // ITS structure.
5cf690c1 127 Int_t GetLastSPD()const{return GetLastDet(kSPD);}
269f57ed 128 // Returns the starting module index number for SDD detector,
129 // assuming the modules are placed in the "standard" cylindrical
130 // ITS structure.
5cf690c1 131 Int_t GetStartSDD()const{return GetStartDet(kSDD);}
269f57ed 132 // Returns the ending module index number for SDD detector,
133 // assuming the modules are placed in the "standard" cylindrical
134 // ITS structure.
5cf690c1 135 Int_t GetLastSDD()const{return GetLastDet(kSDD);}
269f57ed 136 // Returns the starting module index number for SSD detector,
137 // assuming the modules are placed in the "standard" cylindrical
138 // ITS structure.
5cf690c1 139 Int_t GetStartSSD()const{return GetStartDet(kSSD);}
269f57ed 140 // Returns the ending module index number for SSD detector,
141 // assuming the modules are placed in the "standard" cylindrical
142 // ITS structure.
5cf690c1 143 Int_t GetLastSSD()const{return GetLastDet(kSSD);}
269f57ed 144 // Returns the last module index number.
85f1e34a 145 Int_t GetIndexMax() const {return fNmodules;}
023ae34b 146 //
269f57ed 147 // This function returns the rotation angles for a give module
148 // in the Double point array ang[3]. The angles are in radians
5cf690c1 149 void GetAngles(Int_t index,Double_t *ang)const{
023ae34b 150 GetGeomMatrix(index)->GetAngles(ang);}
269f57ed 151 // This function returns the rotation angles for a give module
152 // in the three floating point variables provided. rx = frx,
153 // fy = fry, rz = frz. The angles are in radians
5cf690c1 154 void GetAngles(Int_t index,Float_t &rx,Float_t &ry,Float_t &rz)const{
023ae34b 155 Double_t a[3];GetAngles(index,a);rx = a[0];ry = a[1];rz = a[2];}
269f57ed 156 // This function returns the rotation angles for a give detector on
157 // a give ladder in a give layer in the three floating point variables
158 // provided. rx = frx, fy = fry, rz = frz. The angles are in radians
85f1e34a 159 void GetAngles(Int_t lay,Int_t lad,Int_t det,
5cf690c1 160 Float_t &rx,Float_t &ry,Float_t &rz)const{
023ae34b 161 GetAngles(GetModuleIndex(lay,lad,det),rx,ry,rz);}
162 //
269f57ed 163 // This function returns the 6 GEANT rotation angles for a give
164 // module in the double point array ang[3]. The angles are in degrees
5cf690c1 165 void GetGeantAngles(Int_t index,Double_t *ang)const{
8253cd9a 166 GetGeomMatrix(index)->SixAnglesFromMatrix(ang);}
023ae34b 167 //
269f57ed 168 // This function returns the Cartesian translation for a give
169 // module in the Double array t[3]. The units are
170 // those of the Monte Carlo, generally cm.
5cf690c1 171 void GetTrans(Int_t index,Double_t *t)const{
023ae34b 172 GetGeomMatrix(index)->GetTranslation(t);}
269f57ed 173 // This function returns the Cartesian translation for a give
174 // module index in the three floating point variables provided.
175 // x = fx0, y = fy0, z = fz0. The units are those of the Mont
176 // Carlo, generally cm.
5cf690c1 177 void GetTrans(Int_t index,Float_t &x,Float_t &y,Float_t &z)const{
023ae34b 178 Double_t t[3];GetTrans(index,t);x = t[0];y = t[1];z = t[2];}
269f57ed 179 // This function returns the Cartesian translation for a give
180 // detector on a give ladder in a give layer in the three floating
181 // point variables provided. x = fx0, y = fy0, z = fz0. The units are
182 // those of the Monte Carlo, generally cm.
85f1e34a 183 void GetTrans(Int_t lay,Int_t lad,Int_t det,
5cf690c1 184 Float_t &x,Float_t &y,Float_t &z)const{
023ae34b 185 GetTrans(GetModuleIndex(lay,lad,det),x,y,z);}
186 //
d8cc8493 187 // This function returns the Cartesian translation for a give
188 // module in the Double array t[3]. The units are
189 // those of the Monte Carlo, generally cm.
5cf690c1 190 void GetTransCyln(Int_t index,Double_t *t)const{
023ae34b 191 GetGeomMatrix(index)->GetTranslationCylinderical(t);}
d8cc8493 192 // This function returns the Cartesian translation for a give
193 // module index in the three floating point variables provided.
194 // x = fx0, y = fy0, z = fz0. The units are those of the Mont
195 // Carlo, generally cm.
5cf690c1 196 void GetTransCyln(Int_t index,Float_t &x,Float_t &y,Float_t &z)const{
023ae34b 197 Double_t t[3];GetTransCyln(index,t);x = t[0];y = t[1];z = t[2];}
d8cc8493 198 // This function returns the Cartesian translation for a give
199 // detector on a give ladder in a give layer in the three floating
200 // point variables provided. x = fx0, y = fy0, z = fz0. The units are
201 // those of the Monte Carlo, generally cm.
85f1e34a 202 void GetTransCyln(Int_t lay,Int_t lad,Int_t det,
5cf690c1 203 Float_t &x,Float_t &y,Float_t &z)const{
023ae34b 204 GetTransCyln(GetModuleIndex(lay,lad,det),x,y,z);}
205 //
269f57ed 206 // This function returns the Cartesian translation [cm] and the
207 // 6 GEANT rotation angles [degrees]for a given layer ladder and
208 // detector number, in the TVector x (at least 9 elements large).
023ae34b 209 // This function is required to be in-lined for speed.
5cf690c1 210 void GetCenterThetaPhi(Int_t lay,Int_t lad,Int_t det,TVector &x)const{
023ae34b 211 Double_t t[3],a[6];Int_t i=GetModuleIndex(lay,lad,det);GetTrans(i,t);
212 GetGeantAngles(i,a);x(0)=t[0];x(1)=t[1];x(2)=t[2];x(3)=a[0];x(4)=a[1];
213 x(5)=a[2];x(6)=a[3];x(7)=a[4];x(8)=a[5];}
214 //
269f57ed 215 // This function returns the rotation matrix in Double
216 // precision for a given module.
5cf690c1 217 void GetRotMatrix(Int_t index,Double_t mat[3][3])const{
023ae34b 218 GetGeomMatrix(index)->GetMatrix(mat);}
269f57ed 219 // This function returns the rotation matrix in a Double
220 // precision pointer for a given module. mat[i][j] => mat[3*i+j].
5cf690c1 221 void GetRotMatrix(Int_t index,Double_t *mat)const{
023ae34b 222 Double_t rot[3][3];GetRotMatrix(index,rot);
223 for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++) mat[3*i+j] = rot[i][j];}
269f57ed 224 // This function returns the rotation matrix in a floating
225 // precision pointer for a given layer ladder and detector module.
226 // mat[i][j] => mat[3*i+j].
5cf690c1 227 void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Float_t *mat)const{
023ae34b 228 GetRotMatrix(GetModuleIndex(lay,lad,det),mat);}
269f57ed 229 // This function returns the rotation matrix in a Double
230 // precision pointer for a given layer ladder and detector module.
231 // mat[i][j] => mat[3*i+j].
5cf690c1 232 void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Double_t *mat)const{
023ae34b 233 GetRotMatrix(GetModuleIndex(lay,lad,det),mat);}
269f57ed 234 // This function returns the rotation matrix in a floating
235 // precision pointer for a given module. mat[i][j] => mat[3*i+j].
5cf690c1 236 void GetRotMatrix(Int_t index,Float_t *mat)const{
8253cd9a 237 Double_t rot[3][3];
023ae34b 238 GetGeomMatrix(index)->GetMatrix(rot);
269f57ed 239 for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++) mat[3*i+j] = rot[i][j];}
fd9cde50 240 // This function sets the rotation matrix in a Double
241 // precision pointer for a given module. mat[i][j] => mat[3*i+j].
242 void SetRotMatrix(Int_t index,Double_t *mat){Double_t rot[3][3];
243 for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++) rot[i][j]=mat[3*i+j];
244 GetGeomMatrix(index)->SetMatrix(rot);}
012f0f4c 245 // Return the normal for a specific module
246 void GetGlobalNormal(Int_t index,Double_t n[3]){
247 GetGeomMatrix(index)->GetGlobalNormal(n[0],n[1],n[2]);}
023ae34b 248 //
023ae34b 249 //
250 // Setters
269f57ed 251 // Sets the rotation angles and matrix for a give module index
252 // via the double precision array a[3] [radians].
85f1e34a 253 void SetByAngles(Int_t index,const Double_t a[]){
023ae34b 254 GetGeomMatrix(index)->SetAngles(a);}
269f57ed 255 // Sets the rotation angles and matrix for a give module index
256 // via the 3 floating precision variables rx, ry, and rz [radians].
023ae34b 257 void SetByAngles(Int_t index,Float_t rx, Float_t ry, Float_t rz) {
258 Double_t a[3];a[0] = rx;a[1] = ry;a[2] = rz;
259 GetGeomMatrix(index)->SetAngles(a);}
269f57ed 260 // Sets the rotation angles and matrix for a give layer, ladder,
261 // and detector numbers via the 3 floating precision variables rx,
262 // ry, and rz [radians].
85f1e34a 263 void SetByAngles(Int_t lay,Int_t lad,Int_t det,
6ba216a4 264 Float_t rx, Float_t ry, Float_t rz) {
023ae34b 265 SetByAngles(GetModuleIndex(lay,lad,det),rx,ry,rz);}
266 //
269f57ed 267 // Sets the rotation angles and matrix for a give module index
268 // via the Double precision array a[6] [degree]. The angles are those
269 // defined by GEANT 3.12.
85f1e34a 270 void SetByGeantAngles(Int_t index,const Double_t *ang){
023ae34b 271 GetGeomMatrix(index)->MatrixFromSixAngles(ang);}
269f57ed 272 // Sets the rotation angles and matrix for a give layer, ladder
273 // and detector, in the array id[3] via the Double precision array
274 // a[6] [degree]. The angles are those defined by GEANT 3.12.
275 void SetByGeantAngles(const Int_t *id,const Double_t *ang){
023ae34b 276 SetByGeantAngles(GetModuleIndex(id),ang);}
269f57ed 277 // Sets the rotation angles and matrix for a give layer, ladder
278 // and detector, via the Double precision array a[6] [degree]. The
279 // angles are those defined by GEANT 3.12.
85f1e34a 280 void SetByGeantAngles(Int_t lay,Int_t lad,Int_t det,
023ae34b 281 const Double_t *ang){
282 SetByGeantAngles(GetModuleIndex(lay,lad,det),ang);}
283 //
269f57ed 284 // This function sets a new translation vector, given by the
285 // array x[3], for the Cartesian coordinate transformation
286 // for a give module index.
85f1e34a 287 void SetTrans(Int_t index,Double_t x[]){
023ae34b 288 GetGeomMatrix(index)->SetTranslation(x);}
269f57ed 289 // This function sets a new translation vector, given by the three
290 // variables x, y, and z, for the Cartesian coordinate transformation
291 // for the detector defined by layer, ladder and detector.
85f1e34a 292 void SetTrans(Int_t lay,Int_t lad,Int_t det,
269f57ed 293 Float_t x,Float_t y,Float_t z){Double_t t[3];
294 t[0] = x;t[1] = y;t[2] = z;
295 SetTrans(GetModuleIndex(lay,lad,det),t);}
023ae34b 296 //
023ae34b 297 // transformations
269f57ed 298 // Transforms from the ALICE Global coordinate system
299 // to the detector local coordinate system for the detector
300 // defined by the layer, ladder, and detector numbers. The
301 // global and local coordinate are given in two floating point
302 // arrays g[3], and l[3].
85f1e34a 303 void GtoL(Int_t lay,Int_t lad,Int_t det,
5cf690c1 304 const Float_t *g,Float_t *l)const{
023ae34b 305 GtoL(GetModuleIndex(lay,lad,det),g,l);}
269f57ed 306 // Transforms from the ALICE Global coordinate system
307 // to the detector local coordinate system for the detector
308 // defined by the id[0], id[1], and id[2] numbers. The
309 // global and local coordinate are given in two floating point
310 // arrays g[3], and l[3].
5cf690c1 311 void GtoL(const Int_t *id,const Float_t *g,Float_t *l)const{
023ae34b 312 GtoL(GetModuleIndex(id),g,l);}
269f57ed 313 // Transforms from the ALICE Global coordinate system
314 // to the detector local coordinate system for the detector
315 // module index number. The global and local coordinate are
316 // given in two floating point arrays g[3], and l[3].
5cf690c1 317 void GtoL(Int_t index,const Float_t *g,Float_t *l)const{
023ae34b 318 Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
319 GetGeomMatrix(index)->GtoLPosition(dg,dl);
320 for(i=0;i<3;i++) l[i] =dl[i];}
269f57ed 321 // Transforms from the ALICE Global coordinate system
322 // to the detector local coordinate system for the detector
323 // defined by the layer, ladder, and detector numbers. The
324 // global and local coordinate are given in two Double point
325 // arrays g[3], and l[3].
85f1e34a 326 void GtoL(Int_t lay,Int_t lad,Int_t det,
5cf690c1 327 const Double_t *g,Double_t *l)const{
023ae34b 328 GtoL(GetModuleIndex(lay,lad,det),g,l);}
269f57ed 329 // Transforms from the ALICE Global coordinate system
330 // to the detector local coordinate system for the detector
331 // defined by the id[0], id[1], and id[2] numbers. The
332 // global and local coordinate are given in two Double point
333 // arrays g[3], and l[3].
5cf690c1 334 void GtoL(const Int_t *id,const Double_t *g,Double_t *l)const{
023ae34b 335 GtoL(GetModuleIndex(id),g,l);}
269f57ed 336 // Transforms from the ALICE Global coordinate system
337 // to the detector local coordinate system for the detector
338 // module index number. The global and local coordinate are
339 // given in two Double point arrays g[3], and l[3].
5cf690c1 340 void GtoL(Int_t index,const Double_t g[3],Double_t l[3])const{
341 GetGeomMatrix(index)->GtoLPosition(g,l);}
023ae34b 342 //
269f57ed 343 // Transforms from the ALICE Global coordinate system
344 // to the detector local coordinate system (used for ITS tracking)
345 // for the detector module index number. The global and local
346 // coordinate are given in two Double point arrays g[3], and l[3].
5cf690c1 347 void GtoLtracking(Int_t index,const Double_t *g,Double_t *l)const{
023ae34b 348 if(IsGeantToTracking()) GtoL(index,g,l);
349 else GetGeomMatrix(index)->GtoLPositionTracking(g,l);}
269f57ed 350 // Transforms from the ALICE Global coordinate system
351 // to the detector local coordinate system (used for ITS tracking)
352 // for the detector id[3]. The global and local
353 // coordinate are given in two Double point arrays g[3], and l[3].
5cf690c1 354 void GtoLtracking(const Int_t *id,const Double_t *g,Double_t *l)const{
023ae34b 355 GtoLtracking(GetModuleIndex(id),g,l);}
269f57ed 356 // Transforms from the ALICE Global coordinate system
357 // to the detector local coordinate system (used for ITS tracking)
358 // for the detector layer ladder and detector numbers. The global
359 // and local coordinate are given in two Double point arrays g[3],
360 // and l[3].
85f1e34a 361 void GtoLtracking(Int_t lay,Int_t lad,Int_t det,
5cf690c1 362 const Double_t *g,Double_t *l)const{
023ae34b 363 GtoLtracking(GetModuleIndex(lay,lad,det),g,l);}
364 //
269f57ed 365 // Transforms of momentum types of quantities from the ALICE
366 // Global coordinate system to the detector local coordinate system
367 // for the detector layer ladder and detector numbers. The global
368 // and local coordinate are given in two float point arrays g[3],
369 // and l[3].
85f1e34a 370 void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
5cf690c1 371 const Float_t *g,Float_t *l)const{
023ae34b 372 GtoLMomentum(GetModuleIndex(lay,lad,det),g,l);}
269f57ed 373 // Transforms of momentum types of quantities from the ALICE
374 // Global coordinate system to the detector local coordinate system
375 // for the detector module index number. The global and local
376 // coordinate are given in two float point arrays g[3], and l[3].
5cf690c1 377 void GtoLMomentum(Int_t index,const Float_t *g,Float_t *l)const{
023ae34b 378 Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
379 GetGeomMatrix(index)->GtoLMomentum(dg,dl);
380 for(i=0;i<3;i++) l[i] =dl[i];}
269f57ed 381 // Transforms of momentum types of quantities from the ALICE
382 // Global coordinate system to the detector local coordinate system
383 // for the detector layer ladder and detector numbers. The global
384 // and local coordinate are given in two Double point arrays g[3],
385 // and l[3].
85f1e34a 386 void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
5cf690c1 387 const Double_t *g,Double_t *l)const{
023ae34b 388 GtoLMomentum(GetModuleIndex(lay,lad,det),g,l);}
269f57ed 389 // Transforms of momentum types of quantities from the ALICE
390 // Global coordinate system to the detector local coordinate system
391 // for the detector module index number. The global and local
392 // coordinate are given in two Double point arrays g[3], and l[3].
5cf690c1 393 void GtoLMomentum(Int_t index,const Double_t *g,Double_t *l)const{
023ae34b 394 Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
395 GetGeomMatrix(index)->GtoLMomentum(dg,dl);
396 for(i=0;i<3;i++) l[i] =dl[i];}
397 //
269f57ed 398 // Transforms of momentum types of quantities from the ALICE
399 // Global coordinate system to the detector local coordinate system
400 // (used for ITS tracking) for the detector module index number.
401 // The global and local coordinate are given in two Double point
402 // arrays g[3], and l[3].
5cf690c1 403 void GtoLMomentumTracking(Int_t index,const Double_t *g,Double_t *l)const{
023ae34b 404 if(IsGeantToTracking()) GtoLMomentum(index,g,l);
405 else GetGeomMatrix(index)->GtoLMomentumTracking(g,l);}
269f57ed 406 // Transforms of momentum types of quantities from the ALICE
407 // Global coordinate system to the detector local coordinate system
408 // (used for ITS tracking) for the detector id[3].
409 // The global and local coordinate are given in two Double point
410 // arrays g[3], and l[3].
5cf690c1 411 void GtoLMomentumTracking(const Int_t *id,
412 const Double_t *g,Double_t *l)const{
023ae34b 413 GtoLMomentumTracking(GetModuleIndex(id),g,l);}
269f57ed 414 // Transforms of momentum types of quantities from the ALICE
415 // Global coordinate system to the detector local coordinate system
416 // (used for ITS tracking) for the detector layer ladder and detector
417 // numbers. The global and local coordinate are given in two Double point
418 // arrays g[3], and l[3].
85f1e34a 419 void GtoLMomentumTracking(Int_t lay,Int_t lad,Int_t det,
5cf690c1 420 const Double_t *g,Double_t *l)const{
023ae34b 421 GtoLMomentumTracking(GetModuleIndex(lay,lad,det),g,l);}
422 //
269f57ed 423 // Transforms from the detector local coordinate system
424 // to the ALICE Global coordinate system for the detector
425 // defined by the layer, ladder, and detector numbers. The
426 // global and local coordinate are given in two floating point
427 // arrays g[3], and l[3].
85f1e34a 428 void LtoG(Int_t lay,Int_t lad,Int_t det,
5cf690c1 429 const Float_t *l,Float_t *g)const{
023ae34b 430 LtoG(GetModuleIndex(lay,lad,det),l,g);}
269f57ed 431 // Transforms from the detector local coordinate system
432 // to the ALICE Global coordinate system for the detector
433 // defined by the id[0], id[1], and id[2] numbers. The
434 // global and local coordinate are given in two floating point
435 // arrays g[3], and l[3].
5cf690c1 436 void LtoG(const Int_t *id,const Float_t *l,Float_t *g)const{
023ae34b 437 LtoG(GetModuleIndex(id),l,g);}
269f57ed 438 // Transforms from the detector local coordinate system
439 // to the ALICE Global coordinate system for the detector
440 // module index number. The global and local coordinate are
441 // given in two floating point arrays g[3], and l[3].
5cf690c1 442 void LtoG(Int_t index,const Float_t *l,Float_t *g)const{
023ae34b 443 Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
444 GetGeomMatrix(index)->LtoGPosition(dl,dg);
445 for(i=0;i<3;i++) g[i] =dg[i];}
269f57ed 446 // Transforms from the detector local coordinate system
447 // to the ALICE Global coordinate system for the detector
448 // defined by the layer, ladder, and detector numbers. The
449 // global and local coordinate are given in two Double point
450 // arrays g[3], and l[3].
85f1e34a 451 void LtoG(Int_t lay,Int_t lad,Int_t det,
5cf690c1 452 const Double_t *l,Double_t *g)const{
023ae34b 453 LtoG(GetModuleIndex(lay,lad,det),l,g);}
269f57ed 454 // Transforms from the detector local coordinate system
455 // to the ALICE Global coordinate system for the detector
456 // defined by the id[0], id[1], and id[2] numbers. The
457 // global and local coordinate are given in two Double point
458 // arrays g[3], and l[3].
5cf690c1 459 void LtoG(const Int_t *id,const Double_t *l,Double_t *g)const{
023ae34b 460 LtoG(GetModuleIndex(id),l,g);}
269f57ed 461 // Transforms from the detector local coordinate system
462 // to the ALICE Global coordinate system for the detector
463 // module index number. The global and local coordinate are
464 // given in two Double point arrays g[3], and l[3].
5cf690c1 465 void LtoG(Int_t index,const Double_t *l,Double_t *g)const{
466 GetGeomMatrix(index)->LtoGPosition(l,g);}
023ae34b 467 //
269f57ed 468 // Transforms from the detector local coordinate system (used
469 // for ITS tracking) to the ALICE Global coordinate system
470 // for the detector module index number. The global and local
471 // coordinate are given in two Double point arrays g[3], and l[3].
5cf690c1 472 void LtoGtracking(Int_t index,const Double_t *l,Double_t *g)const{
023ae34b 473 if(IsGeantToTracking()) LtoG(index,l,g);
474 else GetGeomMatrix(index)->LtoGPositionTracking(l,g);}
269f57ed 475 // Transforms from the detector local coordinate system (used
476 // for ITS tracking) to the ALICE Global coordinate system
477 // for the detector id[3]. The global and local
478 // coordinate are given in two Double point arrays g[3], and l[3].
5cf690c1 479 void LtoGtracking(const Int_t *id,const Double_t *l,Double_t *g)const{
023ae34b 480 LtoGtracking(GetModuleIndex(id),l,g);}
269f57ed 481 // Transforms from the detector local coordinate system (used
482 // for ITS tracking) to the detector local coordinate system
483 // for the detector layer ladder and detector numbers. The global
484 // and local coordinate are given in two Double point arrays g[3],
485 // and l[3].
85f1e34a 486 void LtoGtracking(Int_t lay,Int_t lad,Int_t det,
5cf690c1 487 const Double_t *l,Double_t *g)const{
023ae34b 488 LtoGtracking(GetModuleIndex(lay,lad,det),l,g);}
489 //
269f57ed 490 // Transforms of momentum types of quantities from the detector
491 // local coordinate system to the ALICE Global coordinate system
492 // for the detector layer ladder and detector numbers. The global
493 // and local coordinate are given in two float point arrays g[3],
494 // and l[3].
85f1e34a 495 void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
5cf690c1 496 const Float_t *l,Float_t *g)const{
023ae34b 497 LtoGMomentum(GetModuleIndex(lay,lad,det),l,g);}
269f57ed 498 // Transforms of momentum types of quantities from the detector
499 // local coordinate system to the ALICE Global coordinate system
500 // for the detector module index number. The global and local
501 // coordinate are given in two float point arrays g[3], and l[3].
5cf690c1 502 void LtoGMomentum(Int_t index,const Float_t *l,Float_t *g)const{
023ae34b 503 Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
504 GetGeomMatrix(index)->LtoGMomentum(dl,dg);
505 for(i=0;i<3;i++) g[i] =dg[i];}
269f57ed 506 // Transforms of momentum types of quantities from the detector
507 // local coordinate system to the ALICE Global coordinate system
508 // for the detector layer ladder and detector numbers. The global
509 // and local coordinate are given in two Double point arrays g[3],
510 // and l[3].
85f1e34a 511 void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
5cf690c1 512 const Double_t *l,Double_t *g)const{
023ae34b 513 LtoGMomentum(GetModuleIndex(lay,lad,det),l,g);}
269f57ed 514 // Transforms of momentum types of quantities from the detector
515 // local coordinate system to the ALICE Global coordinate system
516 // for the detector module index number. The global and local
517 // coordinate are given in two Double point arrays g[3], and l[3].
5cf690c1 518 void LtoGMomentum(Int_t index,const Double_t *l,Double_t *g)const{
023ae34b 519 GetGeomMatrix(index)->LtoGMomentum(l,g);}
520 //
269f57ed 521 // Transforms of momentum types of quantities from the detector
522 // local coordinate system (used for ITS tracking) to the detector
523 // system ALICE Global for the detector module index number.
524 // The global and local coordinate are given in two Double point
525 // arrays g[3], and l[3].
5cf690c1 526 void LtoGMomentumTracking(Int_t index,const Double_t *l,Double_t *g)const{
023ae34b 527 if(IsGeantToTracking()) LtoGMomentum(index,l,g);
528 else GetGeomMatrix(index)->LtoGMomentumTracking(l,g);}
269f57ed 529 // Transforms of momentum types of quantities from the detector
530 // local coordinate system (used for ITS tracking) to the ALICE
531 // Global coordinate system for the detector id[3].
532 // The global and local coordinate are given in two Double point
533 // arrays g[3], and l[3].
012f0f4c 534 void LtoGMomentumTracking(const Int_t *id,const Double_t *l,Double_t *g)
535 const{LtoGMomentumTracking(GetModuleIndex(id),l,g);}
269f57ed 536 // Transforms of momentum types of quantities from the detector
537 // local coordinate system (used for ITS tracking) to the ALICE
538 // Global coordinate system for the detector layer ladder and detector
539 // numbers. The global and local coordinate are given in two Double point
540 // arrays g[3], and l[3].
85f1e34a 541 void LtoGMomentumTracking(Int_t lay,Int_t lad,Int_t det,
5cf690c1 542 const Double_t *l,Double_t *g)const{
269f57ed 543 LtoGMomentumTracking(GetModuleIndex(lay,lad,det),l,g);}
023ae34b 544 //
269f57ed 545 // Transforms from one detector local coordinate system
546 // to another detector local coordinate system for the detector
547 // module index1 number to the detector module index2 number. The
548 // local coordinates are given in two Double point arrays l1[3],
549 // and l2[3].
5cf690c1 550 void LtoL(Int_t index1,Int_t index2,Double_t *l1,Double_t *l2)const{
023ae34b 551 Double_t g[3]; LtoG(index1,l1,g);GtoL(index2,g,l2);}
269f57ed 552 // Transforms from one detector local coordinate system
553 // to another detector local coordinate system for the detector
554 // id1[3] to the detector id2[3]. The local coordinates are given
555 // in two Double point arrays l1[3], and l2[3].
012f0f4c 556 void LtoL(const Int_t *id1,const Int_t *id2,Double_t *l1,Double_t *l2)
557 const{LtoL(GetModuleIndex(id1[0],id1[1],id1[2]),
269f57ed 558 GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
023ae34b 559 //
269f57ed 560 // Transforms from one detector local coordinate system (used for
561 // ITS tracking) to another detector local coordinate system (used
562 // for ITS tracking) for the detector module index1 number to the
563 // detector module index2 number. The local coordinates are given
564 // in two Double point arrays l1[3], and l2[3].
85f1e34a 565 void LtoLtracking(Int_t index1,Int_t index2,
5cf690c1 566 Double_t *l1,Double_t *l2)const{
023ae34b 567 Double_t g[3]; LtoGtracking(index1,l1,g);GtoLtracking(index2,g,l2);}
269f57ed 568 // Transforms from one detector local coordinate system (used for
569 // ITS tracking) to another detector local coordinate system (used
570 // for ITS tracking) for the detector id1[3] to the detector id2[3].
571 // The local coordinates are given in two Double point arrays l1[3],
572 // and l2[3].
573 void LtoLtracking(const Int_t *id1,const Int_t *id2,
5cf690c1 574 Double_t *l1,Double_t *l2)const{
023ae34b 575 LtoLtracking(GetModuleIndex(id1[0],id1[1],id1[2]),
576 GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
577 //
269f57ed 578 // Transforms of momentum types of quantities from one detector
579 // local coordinate system to another detector local coordinate
580 // system for the detector module index1 number to the detector
581 // module index2 number. The local coordinates are given in two
582 // Double point arrays l1[3], and l2[3].
85f1e34a 583 void LtoLMomentum(Int_t index1,Int_t index2,
5cf690c1 584 const Double_t *l1,Double_t *l2)const{
023ae34b 585 Double_t g[3]; LtoGMomentum(index1,l1,g);GtoLMomentum(index2,g,l2);}
269f57ed 586 // Transforms of momentum types of quantities from one detector
587 // local coordinate system to another detector local coordinate
588 // system for the detector id1[3] to the detector id2[3]. The local
589 // coordinates are given in two Double point arrays l1[3], and l2[3].
b79e4bc3 590 void LtoLMomentum(const Int_t *id1,const Int_t *id2,
5cf690c1 591 const Double_t *l1,Double_t *l2)const{
023ae34b 592 LtoLMomentum(GetModuleIndex(id1[0],id1[1],id1[2]),
593 GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
594 //
269f57ed 595 // Transforms of momentum types of quantities from one detector
596 // local coordinate system (used by ITS tracking) to another detector
597 // local coordinate system (used by ITS tracking) for the detector
598 // module index1 number to the detector module index2 number. The
599 // local coordinates are given in two Double point arrays l1[3],
600 // and l2[3].
85f1e34a 601 void LtoLMomentumTracking(Int_t index1,Int_t index2,
5cf690c1 602 Double_t *l1,Double_t *l2)const{
023ae34b 603 Double_t g[3]; LtoGMomentumTracking(index1,l1,g);
604 GtoLMomentumTracking(index2,g,l2);}
269f57ed 605 // Transforms of momentum types of quantities from one detector
606 // local coordinate system (used by ITS tracking) to another detector
607 // local coordinate system (used by ITS tracking) for the detector
608 // id1[3] to the detector id2[3]. The local coordinates are given in
609 // two Double point arrays l1[3], and l2[3].
610 void LtoLMomentumTracking(const Int_t *id1,const Int_t *id2,
5cf690c1 611 Double_t *l1,Double_t *l2)const{
023ae34b 612 LtoLMomentumTracking(GetModuleIndex(id1[0],id1[1],id1[2]),
269f57ed 613 GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
023ae34b 614 //
269f57ed 615 // Transforms a matrix, like an Uncertainty or Error matrix from
616 // the ALICE Global coordinate system to a detector local coordinate
617 // system. The specific detector is determined by the module index
618 // number.
5cf690c1 619 void GtoLErrorMatrix(Int_t index,const Double_t **g,Double_t **l)const{
012f0f4c 620 GetGeomMatrix(index)->GtoLPositionError(
621 (Double_t (*)[3])g,(Double_t (*)[3])l);}
023ae34b 622 //
269f57ed 623 // Transforms a matrix, like an Uncertainty or Error matrix from
624 // the ALICE Global coordinate system to a detector local coordinate
625 // system (used by ITS tracking). The specific detector is determined
626 // by the module index number.
85f1e34a 627 void GtoLErrorMatrixTracking(Int_t index,const Double_t **g,
5cf690c1 628 Double_t **l)const{
023ae34b 629 if(IsGeantToTracking()) GetGeomMatrix(index)->GtoLPositionError((
630 Double_t (*)[3])g,(Double_t (*)[3])l);
631 else GetGeomMatrix(index)->GtoLPositionErrorTracking(
632 (Double_t (*)[3])g,(Double_t (*)[3])l);}
633 //
269f57ed 634 // Transforms a matrix, like an Uncertainty or Error matrix from
635 // the detector local coordinate system to a ALICE Global coordinate
636 // system. The specific detector is determined by the module index
637 // number.
5cf690c1 638 void LtoGErrorMatrix(Int_t index,const Double_t **l,Double_t **g)const{
012f0f4c 639 GetGeomMatrix(index)->LtoGPositionError(
640 (Double_t (*)[3])l,(Double_t (*)[3])g);}
641 //
642 // Transforms a matrix, like an Uncertainty or Error matrix from
643 // the detector local coordinate system to a ALICE Global coordinate
644 // system. The specific detector is determined by the module index
645 // number.
646 void LtoGErrorMatrix(Int_t index,const Double_t l[3][3],Double_t g[3][3])
647 const{
648 GetGeomMatrix(index)->LtoGPositionError(
649 (Double_t (*)[3])l,(Double_t (*)[3])g);}
650
023ae34b 651 //
269f57ed 652 // Transforms a matrix, like an Uncertainty or Error matrix from
653 // the detector local coordinate system (used by ITS tracking) to a
654 // ALICE Global coordinate system. The specific detector is determined
655 // by the module index number.
85f1e34a 656 void LtoGErrorMatrixTracking(Int_t index,const Double_t **l,
5cf690c1 657 Double_t **g)const{
012f0f4c 658 if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError(
659 (Double_t (*)[3])g,(Double_t (*)[3])l);
660 else GetGeomMatrix(index)->LtoGPositionErrorTracking(
661 (Double_t (*)[3])l,(Double_t (*)[3])g);}
662 //
663 // Transforms a matrix, like an Uncertainty or Error matrix from
664 // the detector local coordinate system (used by ITS tracking) to a
665 // ALICE Global coordinate system. The specific detector is determined
666 // by the module index number.
667 void LtoGErrorMatrixTracking(Int_t index,const Double_t l[3][3],
668 Double_t g[3][3])const{
669 if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError(
670 (Double_t (*)[3])g,(Double_t (*)[3])l);
671 else GetGeomMatrix(index)->LtoGPositionErrorTracking(
672 (Double_t (*)[3])l,(Double_t (*)[3])g);}
023ae34b 673 //
269f57ed 674 // Transforms a matrix, like an Uncertainty or Error matrix from
675 // one detector local coordinate system to another detector local
676 // coordinate system. The specific detector is determined by the
677 // two module index number index1 and index2.
85f1e34a 678 void LtoLErrorMatrix(Int_t index1,Int_t index2,
5cf690c1 679 const Double_t **l1,Double_t **l2)const{
023ae34b 680 Double_t g[3][3];
681 LtoGErrorMatrix(index1,l1,(Double_t **)g);
682 GtoLErrorMatrix(index2,(const Double_t **)g,l2);}
683 //
269f57ed 684 // Transforms a matrix, like an Uncertainty or Error matrix from
685 // one detector local coordinate system (used by ITS tracking) to
686 // another detector local coordinate system (used by ITS tracking).
687 // The specific detector is determined by the two module index number
688 // index1 and index2.
85f1e34a 689 void LtoLErrorMatrixTraking(Int_t index1,Int_t index2,
5cf690c1 690 const Double_t **l1,Double_t **l2)const{
023ae34b 691 Double_t g[3][3];
692 LtoGErrorMatrixTracking(index1,l1,(Double_t **)g);
693 GtoLErrorMatrixTracking(index2,(const Double_t **)g,l2);}
694 // Find Specific Modules
85f1e34a 695 // Locate the nearest module to the point g, in ALICE global Cartesian
696 // coordinates [cm] in a give layer. If layer = 0 then it search in
697 // all layers.
5cf690c1 698 Int_t GetNearest(const Double_t g[3],Int_t lay=0)const;
85f1e34a 699 // Locates the nearest 27 modules, in nearest order, to the point g, in
700 // ALICE global Cartesian coordinates [cm] in a give layer. If layer = 0
701 // then it searches in all layers. (there are 27 elements in a 3x3x3
702 // cube.
5cf690c1 703 void GetNearest27(const Double_t g[3],Int_t n[27],Int_t lay=0)const;
269f57ed 704 // Returns the distance [cm] between the point g[3] and the center of
705 // the detector/module specified by the the module index number.
5cf690c1 706 Double_t Distance(Int_t index,const Double_t g[3])const{
023ae34b 707 return TMath::Sqrt(GetGeomMatrix(index)->Distance2(g));}
023ae34b 708 // Geometry manipulation
85f1e34a 709 // This function performs a Cartesian translation and rotation of
710 // the full ITS from its default position by an amount determined by
711 // the three element arrays tran and rot.
269f57ed 712 void GlobalChange(const Float_t *tran,const Float_t *rot);
85f1e34a 713 // This function performs a Cylindrical translation and rotation of
714 // the full ITS from its default position by an amount determined by
715 // the three element arrays tran and rot.
269f57ed 716 void GlobalCylindericalChange(const Float_t *tran,const Float_t *rot);
85f1e34a 717 // This function performs a Gaussian random displacement and/or
718 // rotation about the present global position of each active
719 // volume/detector of the ITS with variances given by stran and srot.
269f57ed 720 void RandomChange(const Float_t *stran,const Float_t *srot);
85f1e34a 721 // This function performs a Gaussian random displacement and/or
722 // rotation about the present global position of each active
723 // volume/detector of the ITS with variances given by stran and srot.
724 // But in Cylindrical coordinates.
269f57ed 725 void RandomCylindericalChange(const Float_t *stran,const Float_t *srot);
85f1e34a 726 // This function converts these transformations from Alice global and
727 // local to Tracking global and local.
012f0f4c 728 //
729 // This converts the geometry
730 void GeantToTracking(const AliITSgeom &source);
023ae34b 731 // Other routines.
85f1e34a 732 // This routine prints, to a file, the contents of this class.
5cf690c1 733 void PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det)const;
85f1e34a 734 // This function prints out this class in a single stream. This steam
735 // can be read by ReadGeom.
c0fc8108 736 // (Coverity warnings) void PrintGeom(ostream *out)const;
e8189707 737
00a7cc50 738 //Conversion from det. local coordinates to local ("V2") coordinates
739 //used for tracking
740
012f0f4c 741 void DetLToTrackingV2(Int_t md,Float_t xin,Float_t zin,
742 Float_t &yout, Float_t &zout);
00a7cc50 743
012f0f4c 744 void TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,
745 Float_t &xout,Float_t &zout);
4bfbde86 746
085bb6ed 747 private:
023ae34b 748 TString fVersion; // Transformation version.
8253cd9a 749 Int_t fTrans; // Flag to keep track of which transformation
750 Int_t fNmodules;// The total number of modules
751 Int_t fNlayers; // The number of layers.
023ae34b 752 TArrayI fNlad; // Array of the number of ladders/layer(layer)
753 TArrayI fNdet; // Array of the number of detector/ladder(layer)
754 TObjArray fGm; // Structure of translation. and rotation.
8253cd9a 755
325d8c32 756 ClassDef(AliITSgeom,4) // ITS geometry class
012f0f4c 757};
758// Input and output function for standard C++ input/output.
58005f18 759
760#endif