Update from ITS-working to Head. Included many changes in improvements to the
[u/mrichter/AliRoot.git] / ITS / AliITSgeom.h
CommitLineData
58005f18 1#ifndef ITSGEOM_H
2#define ITSGEOM_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/////////////////////////////////////////////////////////////////////////
20#include <fstream.h>
21#include "TObjArray.h"
22#include "AliITSgeomSPD.h"
23#include "AliITSgeomSDD.h"
24#include "AliITSgeomSSD.h"
25
26////////////////////////////////////////////////////////////////////////
27// The structure ITS_geom:
28// The structure ITS_geom has been defined to hold all of the
29// information necessary to do the coordinate transformations for one
30// detector between the ALICE Cartesian global and the detector local
31// coordinate systems. The rotations are implemented in the following
32// order, Rz*Ry*Rx*(Vglobal-Vtrans)=Vlocal (in matrix notation).
33// In addition it contains an index to the TObjArray containing all of
34// the information about the shape of the active detector volume, and
35// any other useful detector parameters. See the definition of *fShape
36// below and the classes AliITSgeomSPD, AliITSgeomSDD, and AliITSgeomSSD
37// for a full description. This structure is not available outside of
38// these routines.
39//
40// Int_t fShapeIndex
41// The index to the array of detector shape information. In this way
42// only an index is needed to be stored and not all of the shape
43// information. This saves much space since most, if not all, of the
44// detectors of a give type have the same shape information and are only
45// placed in a different spot in the ALICE/ITS detector.
46//
47// Float_t fx0,fy0,fz0
48// The Cartesian translation vector used to define part of the
49// coordinate transformation. The units of the translation are kept
50// in the Monte Carlo distance units, usually cm.
51//
52// Float_t frx,fry,frz
53// The three rotation angles that define the rotation matrix. The
54// angles are, frx the rotation about the x axis. fry the rotation about
55// the "new" or "rotated" y axis. frz the rotation about the "new" or
56// "rotated" z axis. These angles, although redundant with the rotation
57// matrix fr, are kept for speed. This allows for their retrieval without
58// having to compute them each and every time. The angles are kept in
59// radians
60//
61// Float_t fr[9]
62// The 3x3 rotation matrix defined by the angles frx, fry, and frz,
63// for the Global to Local transformation is
64// |fr[0] fr[1] fr[2]| | cos(frz) sin(frz) 0| | cos(fry) 0 sin(fry)|
65// fr=|fr[3] fr[4] fr[4]|=|-sin(frz) cos(frz) 0|*| 0 1 0 |
66// |fr[6] fr[7] fr[8]| | 0 0 1| |-sin(fry) 0 cos(fry)|
67//
68// |1 0 0 |
69// *|0 cos(frx) sin(frx)|
70// |0 -sin(frx) cos(frx)|
71//
72// Even though this information is redundant with the three rotation
73// angles, because this transformation matrix can be used so much it is
74// kept to speed things up a lot. The coordinate system used is Cartesian.
75////////////////////////////////////////////////////////////////////////
76
77struct ITS_geom {
78 Int_t fShapeIndex; // Shape index for this volume
79 Float_t fx0,fy0,fz0; // Translation vector
80 Float_t frx,fry,frz; // Rotation about axis, angle radians
81 Float_t fr[9]; // the rotation matrix
82};
83
84//_______________________________________________________________________
85
86class AliITSgeom : public TObject {
87////////////////////////////////////////////////////////////////////////
88//
89// version: 0
90// Written by Bjorn S. Nilsen
91//
92// Data Members:
93//
94// Int_t fNlayers
95// The number of ITS layers for this geometry. By default this
96// is 6, but can be modified by the creator function if there are
97// more layers defined.
98//
99// Int_t *fNlad
100// A pointer to an array fNlayers long containing the number of
101// ladders for each layer. This array is typically created and filled
102// by the AliITSgeom creator function.
103//
104// Int_t *fNdet
105// A pointer to an array fNlayers long containing the number of
106// active detector volumes for each ladder. This array is typically
107// created and filled by the AliITSgeom creator function.
108//
109// ITS_geom **fg
110// A pointer to an array of pointers pointing to the ITS_geom
111// structure containing the coordinate transformation information.
112// The ITS_geom structure corresponding to layer=lay, ladder=lad,
113// and detector=det is gotten by fg[lay-1][(fNlad[lay-1]*(lad-1)+det-1)].
114// In this way a lot of space is saved over trying to keep a three
115// dimensional array fNlayersXmax(fNlad)Xmax(fNdet), since the number
116// of detectors typically increases with layer number.
117//
118// TObjArray *fShape
119// A pointer to an array of TObjects containing the detailed shape
120// information for each type of detector used in the ITS. For example
121// I have created AliITSgeomSPD, AliITSgeomSDD, and AliITSgeomSSD as
122// example structures, derived from TObjects, to hold the detector
123// information. I would recommend that one element in each of these
124// structures, that which describes the shape of the active volume,
125// be one of the ROOT classes derived from TShape. In this way it would
126// be easy to have the display program display the correct active
127// ITS volumes. See the example classes AliITSgeomSPD, AliITSgeomSDD,
128// and AliITSgeomSSD for a more detailed example.
129//
130// Member Functions:
131//
132// AliITSgeom()
133// The default constructor for the AliITSgeom class. It, by default,
134// sets fNlayers to zero and zeros all pointers.
135//
136// AliITSgeom(const char *filename)
137// The constructor for the AliITSgeom class. All of the data to fill
138// this structure is read in from the file given my the input filename.
139//
140// AliITSgeom(AliITSgeom &source)
141// The copy constructor for the AliITSgeom class. It calls the
142// = operator function. See the = operator function for more details.
143//
144// void operator=(AliITSgeom &source)
145// The = operator function for the AliITSgeom class. It makes an
146// independent copy of the class in such a way that any changes made
147// to the copied class will not affect the source class in any way.
148// This is required for many ITS alignment studies where the copied
149// class is then modified by introducing some misalignment.
150//
151// ~AliITSgeom()
152// The destructor for the AliITSgeom class. If the arrays fNlad,
153// fNdet, or fg have had memory allocated to them, there pointer values
154// are non zero, then this memory space is freed and they are set
155// to zero. In addition, fNlayers is set to zero. The destruction of
156// TObjArray fShape is, by default, handled by the TObjArray destructor.
157//
158// Int_t GetNdetectors(Int_t layer)
159// This function returns the number of detectors/ladder for a give
160// layer. In particular it returns fNdet[layer-1].
161//
162// Int_t GetNladders(Int_t layer)
163// This function returns the number of ladders for a give layer. In
164// particular it returns fNlad[layer-1].
165//
166// Int_t GetNlayers()
167// This function returns the number of layers defined in the ITS
168// geometry. In particular it returns fNlayers.
169//
170// GetAngles(Int_t layer,Int_t ladder,Int_t detector,
171// Float_t &rx, Float_t &ry, Float_t &rz)
172// This function returns the rotation angles for a give detector on
173// a give ladder in a give layer in the three floating point variables
174// provided. rx = frx, fy = fry, rz = frz. The angles are in radians
175//
176// GetTrans(Int_t layer,Int_t ladder,Int_t detector,
177// Float_t &x, Float_t &y, Float_t &z)
178// This function returns the Cartesian translation for a give
179// detector on a give ladder in a give layer in the three floating
180// point variables provided. x = fx0, y = fy0, z = fz0. The units are
181// those of the Monte Carlo, generally cm.
182//
183// SetByAngles(Int_t layer,Int_t ladder,Int_t detector,
184// Float_t &rx, Float_t &ry, Float_t &rz)
185// This function computes a new rotation matrix based on the angles
186// rx, ry, and rz (in radians) for a give detector on the give ladder
187// in the give layer. A new
188// fg[layer-1][(fNlad[layer-1]*(ladder-1)+detector-1)].fr[] array is
189// computed.
190//
191// SetTrans(Int_t layer,Int_t ladder,Int_t detector,
192// Float_t x, Float_t y, Float_t z)
193// This function sets a new translation vector, given by the three
194// variables x, y, and z, for the Cartesian coordinate transformation
195// for the detector defined by layer, ladder and detector.
196//
197// GetRotMatrix(Int_t layer, Int_t ladder, Int_t detector, Float_t *mat)
198// Returns, in the Float_t array pointed to by mat, the full rotation
199// matrix for the give detector defined by layer, ladder, and detector.
200// It returns all nine elements of fr in the ITS_geom structure. See the
201// description of the ITS_geom structure for further details of this
202// rotation matrix.
203//
204// GtoL(Int_t layer, Int_t ladder, Int_t detector,
205// const Float_t *g, Float_t *l)
206// The function that does the global ALICE Cartesian coordinate
207// to local active volume detector Cartesian coordinate transformation.
208// The local detector coordinate system is determined by the layer,
209// ladder, and detector numbers. The global coordinates are entered by
210// the three element Float_t array g and the local coordinate values
211// are returned by the three element Float_t array l. The order of the
212// three elements are g[0]=x, g[1]=y, and g[2]=z, similarly for l.
213//
214// GtoL(const Int_t *Id, const Float_t *g, Float_t *l)
215// The function that does the global ALICE Cartesian coordinate
216// to local active volume detector Cartesian coordinate transformation.
217// The local detector coordinate system is determined by the three
218// element array Id containing as it's three elements Id[0]=layer,
219// Id[1]=ladder, and Id[2]=detector numbers. The global coordinates
220// are entered by the three element Float_t array g and the local
221// coordinate values are returned by the three element Float_t array l.
222// The order of the three elements are g[0]=x, g[1]=y, and g[2]=z,
223// similarly for l.
224//
225// LtoG(Int_t layer, Int_t ladder, Int_t detector,
226// const Float_t *l, Float_t *g)
227// The function that does the local active volume detector Cartesian
228// coordinate to global ALICE Cartesian coordinate transformation.
229// The local detector coordinate system is determined by the layer,
230// ladder, and detector numbers. The local coordinates are entered by
231// the three element Float_t array l and the global coordinate values
232// are returned by the three element Float_t array g. The order of the
233// three elements are l[0]=x, l[1]=y, and l[2]=z, similarly for g.
234//
235// LtoG(const Int_t *Id, const Float_t *l, Float_t *g)
236// The function that does the local active volume detector Cartesian
237// coordinate to global ALICE Cartesian coordinate transformation.
238// The local detector coordinate system is determined by the three
239// element array Id containing as it's three elements Id[0]=layer,
240// Id[1]=ladder, and Id[2]=detector numbers. The local coordinates
241// are entered by the three element Float_t array l and the global
242// coordinate values are returned by the three element Float_t array g.
243// The order of the three elements are l[0]=x, l[1]=y, and l[2]=z,
244// similarly for g.
245//
246// Int_t IsVersion()
247// This function returns the version number of this AliITSgeom
248// class.
249//
250// AddShape(TObject *shape)
251// This function adds one more shape element to the TObjArray
252// fShape. It is primarily used in the constructor functions of the
253// AliITSgeom class. The pointer *shape can be the pointer to any
254// class that is derived from TObject (this is true for nearly every
255// ROOT class). This does not appear to be working properly at this time.
256//
257// PrintComparison(FILE *fp, AliITSgeom *other)
258// This function was primarily created for diagnostic reasons. It
259// print to a file pointed to by the file pointer fp the difference
260// between two AliITSgeom classes. The format of the file is basicly,
261// define d? to be the difference between the same element of the two
262// classes. For example dfrx = this->fg[i][j].frx - other->fg[i][j].frx.
263// if(at least one of dfx0, dfy0, dfz0,dfrx,dfry,dfrz are non zero) then print
264// layer ladder detector dfx0 dfy0 dfz0 dfrx dfry dfrz
265// if(at least one of the 9 elements of dfr[] are non zero) then print
266// layer ladder detector dfr[0] dfr[1] dfr[2]
267// dfr[3] dfr[4] dfr[5]
268// dfr[6] dfr[7] dfr[8]
269// Only non zero values are printed to save space. The differences are
270// typical written to a file because there are usually a lot of numbers
271// printed out and it is usually easier to read them in some nice editor
272// rather than zooming quickly past you on a screen. fprintf is used to
273// do the printing. The fShapeIndex difference is not printed at this time.
274//
275// PrintData(FILE *fp, Int_t layer, Int_t ladder, Int_t detector)
276// This function prints out the coordinate transformations for
277// the particular detector defined by layer, ladder, and detector
278// to the file pointed to by the File pointer fp. fprinf statements
279// are used to print out the numbers. The format is
280// layer ladder detector Trans= fx0 fy0 fz0 rot= frx fry frz Shape=fShapeIndex
281// dfr= fr[0] fr[1] fr[2]
282// dfr= fr[3] fr[4] fr[5]
283// dfr= fr[6] fr[7] fr[8]
284// By indicating which detector, some control over the information
285// is given to the user. The output it written to the file pointed
286// to by the file pointer fp. This can be set to stdout if you want.
287//
288// Streamer(TBuffer &R__b)
289// The default Streamer function "written by ROOT" doesn't write out
290// the arrays referenced by pointers. Therefore, a specific Streamer function
291// has to be written. This function should not be modified but instead added
292// on to so that older versions can still be read. The proper handling of
293// the version dependent streamer function hasn't been written do to the lack
294// of finding an example at the time of writting.
295//
296//----------------------------------------------------------------------
297//
298// The following member functions are defined to modify an existing
299// AliITSgeom data structure. They were developed for the use in doing
300// alignment studies of the ITS.
301//
302// GlobalChange(Float_t *dtranslation, Float_t *drotation)
303// This function performs a Cartesian translation and rotation of
304// the full ITS from its default position by an amount determined by
305// the three element arrays dtranslation and drotation. If every element
306// of dtranslation and drotation are zero then there is no change made
307// the geometry. The change is global in that the exact same translation
308// and rotation is done to every detector element in the exact same way.
309// The units of the translation are those of the Monte Carlo, usually cm,
310// and those of the rotation are in radians. The elements of dtranslation
311// are dtranslation[0] = x, dtranslation[1] = y, and dtranslation[2] = z.
312// The elements of drotation are drotation[0] = rx, drotation[1] = ry, and
313// drotation[2] = rz. A change in x will move the hole ITS in the ALICE
314// global x direction, the same for a change in y. A change in z will
315// result in a translation of the ITS as a hole up or down the beam line.
316// A change in the angles will result in the inclination of the ITS with
317// respect to the beam line, except for an effective rotation about the
318// beam axis which will just rotate the ITS as a hole about the beam axis.
319//
320// GlobalCylindericalChange(Float_t *dtranslation, Float_t *drotation)
321// This function performs a cylindrical translation and rotation of
322// each ITS element by a fixed about in radius, rphi, and z from its
323// default position by an amount determined by the three element arrays
324// dtranslation and drotation. If every element of dtranslation and
325// drotation are zero then there is no change made the geometry. The
326// change is global in that the exact same distance change in translation
327// and rotation is done to every detector element in the exact same way.
328// The units of the translation are those of the Monte Carlo, usually cm,
329// and those of the rotation are in radians. The elements of dtranslation
330// are dtranslation[0] = r, dtranslation[1] = rphi, and dtranslation[2] = z.
331// The elements of drotation are drotation[0] = rx, drotation[1] = ry, and
332// drotation[2] = rz. A change in r will results in the increase of the
333// radius of each layer by the same about. A change in rphi will results in
334// the rotation of each layer by a different angle but by the same
335// circumferential distance. A change in z will result in a translation
336// of the ITS as a hole up or down the beam line. A change in the angles
337// will result in the inclination of the ITS with respect to the beam
338// line, except for an effective rotation about the beam axis which will
339// just rotate the ITS as a hole about the beam axis.
340//
341// RandomChange(Float_t *stranslation, Float_t *srotation)
342// This function performs a Gaussian random displacement and/or
343// rotation about the present global position of each active
344// volume/detector of the ITS. The sigma of the random displacement
345// is determined by the three element array stranslation, for the
346// x y and z translations, and the three element array srotation,
347// for the three rotation about the axis x y and z.
348//
349// RandomCylindericalChange(Float_t *stranslation, Float_t *srotation)
350// This function performs a Gaussian random displacement and/or
351// rotation about the present global position of each active
352// volume/detector of the ITS. The sigma of the random displacement
353// is determined by the three element array stranslation, for the
354// r rphi and z translations, and the three element array srotation,
355// for the three rotation about the axis x y and z. This random change
356// in detector position allow for the simulation of a random uncertainty
357// in the detector positions of the ITS.
358////////////////////////////////////////////////////////////////////////
359 private:
360 Int_t fNlayers; // The number of layers.
361 Int_t *fNlad; // Array of the number of ladders/layer(layer)
362 Int_t *fNdet; // Array of the number of detectors/ladder(layer)
363 ITS_geom **fg; // Structure of translation and rotation.
364 TObjArray *fShape; // Array of shapes and detector information.
365
366 public:
367 AliITSgeom(); // Default constructor
368 AliITSgeom(const char *filename); // Constructor
369 AliITSgeom(AliITSgeom &source); // Copy constructor
370 void operator=(AliITSgeom &source);// = operator
371 virtual ~AliITSgeom(); // Default destructor
372 // this is a dummy routine for now.
593d2ea1 373 Int_t GetNdetectors(Int_t layer) const {return fNdet[layer-1];}
374 Int_t GetNladders(Int_t layer) const {return fNlad[layer-1];}
375 Int_t GetNlayers() const {return fNlayers;}
376 void GetAngles(Int_t lay,Int_t lad,Int_t det,
377 Float_t &rx,Float_t &ry,Float_t &rz)const {
58005f18 378 rx = fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].frx;
379 ry = fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fry;
380 rz = fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].frz;}
593d2ea1 381 void GetTrans(Int_t lay,Int_t lad,Int_t det,
382 Float_t &x,Float_t &y,Float_t &z)const {
58005f18 383 x = fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0;
384 y = fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0;
385 z = fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0;}
386 void SetByAngles(Int_t lay,Int_t lad,Int_t det,
387 Float_t rx,Float_t ry,Float_t rz);
593d2ea1 388 void SetTrans(Int_t lay,Int_t lad,Int_t det,
58005f18 389 Float_t x,Float_t y,Float_t z){
390 fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0 = x;
391 fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0 = y;
392 fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0 = z;}
393 void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Float_t *mat);
394 void GtoL(Int_t lay,Int_t lad,Int_t det,const Float_t *g,Float_t *l);
395 void GtoL(const Int_t *id,const Float_t *g,Float_t *l);
396 void GtoL(const Int_t index,const Float_t *g,Float_t *l);
397 void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,const Float_t *g,Float_t *l);
398 void LtoG(Int_t lay,Int_t lad,Int_t det,const Float_t *l,Float_t *g);
399 void LtoG(const Int_t *id,const Float_t *l,Float_t *g);
400 void LtoG(const Int_t index,const Float_t *l,Float_t *g);
401 void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,const Float_t *l,Float_t *g);
402 Int_t GetModuleIndex(Int_t lay,Int_t lad,Int_t det);
593d2ea1 403 void GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det);
58005f18 404 void GlobalChange(Float_t *tran,Float_t *rot);
405 void GlobalCylindericalChange(Float_t *tran,Float_t *rot);
406 void RandomChange(Float_t *stran,Float_t *srot);
407 void RandomCylindericalChange(Float_t *stran,Float_t *srot);
408 void PrintComparison(FILE *fp,AliITSgeom *other);
409 void PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det);
410 ofstream &PrintGeom(ofstream &out);
411 ifstream &ReadGeom(ifstream &in);
412 virtual Int_t IsVersion() const {return 0;}
593d2ea1 413 void AddShape(TObject *shp){fShape->AddLast(shp);}
414 virtual TObject *GetShape(Int_t lay,Int_t lad,Int_t det)
415 const {return fShape->At(fg[lay-1][fNdet[lay-1]*(lad-1)+det-1].fShapeIndex);}
58005f18 416
417 ClassDef(AliITSgeom,1)
418};
419
420#endif