342991acd3684d5e3f24b6396731900a7ca48e46
[u/mrichter/AliRoot.git] / ITS / AliITShit.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Log$
18 Revision 1.3.4.2  2000/03/04 23:43:57  nilsen
19 Fixed up the comments/documentation.
20
21 Revision 1.3.4.1  2000/01/12 19:03:32  nilsen
22 This is the version of the files after the merging done in December 1999.
23 See the ReadMe110100.txt file for details
24
25 Revision 1.3  1999/09/29 09:24:20  fca
26 Introduction of the Copyright and cvs Log
27
28 */
29
30
31 #include <TMath.h>
32 #include <TRandom.h>
33 #include <TVector.h>
34 #include <TGeometry.h>
35 #include <TNode.h>
36 #include <TTUBE.h>
37
38 #include "AliRun.h"
39 #include "AliITSgeom.h"
40 #include "AliITS.h"
41 #include "AliITShit.h"
42
43
44 ClassImp(AliITShit)
45 ////////////////////////////////////////////////////////////////////////
46 // Version: 0
47 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
48 //
49 // Version: 1
50 // Modified and documented by Bjorn S. Nilsen
51 // July 11 1999
52 //
53 // AliITShit is the hit class for the ITS. Hits are the information
54 // that comes from a Monte Carlo at each step as a particle mass through
55 // sensitive detector elements as particles are transported through a
56 // detector.
57 //
58 //Begin_Html
59 /*
60 <img src="picts/ITS/AliITShit_Class_Diagram.gif">
61 </pre>
62 <br clear=left>
63 <font size=+2 color=red>
64 <p>This show the relasionships between the ITS hit class and the rest of Aliroot.
65 </font>
66 <pre>
67 */
68 //End_Html
69 ////////////////////////////////////////////////////////////////////////
70 // Inline Member functions:
71 //
72 // AliITShit()
73 //     The default creator of the AliITShit class.
74 //
75 // ~AliITShit()
76 //     The default destructor of the AliITShit class.
77 //
78 // int GetTrack()
79 //     See AliHit for a full description. Returns the track number fTrack
80 // for this hit.
81 //
82 // SetTrack(int track)
83 //     See AliHit for a full description. Sets the track number fTrack
84 // for this hit.
85 //
86 // Int_t GetTrackStatus()
87 //     Returns the value of the track status flag fStatus. This flag
88 // indicates the track status at the time of creating this hit. It is
89 // made up of the following 8 status bits from highest order to lowest
90 // order bits
91 // 0           :  IsTrackAlive():    IsTrackStop():IsTrackDisappeared():
92 // IsTrackOut():IsTrackExiting():IsTrackEntering():IsTrackInside()     .
93 // See AliMC for a description of these functions. If the function is
94 // true then the bit is set to one, otherwise it is zero.
95 //
96 // Bool_t StatusInside()
97 //     Returns kTRUE if the particle producing this hit is still inside
98 // the present volume. Returns kFalse if this particle will be in another
99 // volume. {bit IsTrackInside is set or not}
100 //
101 // Bool_t StatusEntering()
102 //     Returns kTRUE if the particle producing this hit is has just enterd
103 // the present volume. Returns kFalse otherwise.  {bit IsTrackEntering is
104 // set or not}
105 //
106 // Bool_t StatusExiting()
107 //     Returns kTRUE if the particle producing this hit is will exit
108 // the present volume. Returns kFalse otherwise. {bit IsTrackExiting is set
109 // or not}
110 //
111 // Bool_t StatusOut()
112 //     Returns kTRUE if the particle producing this hit is goint exit the
113 // simulation. Returns kFalse otherwise. {bit IsTrackOut is set or not}
114 //
115 // Bool_t StatusDisappeared()
116 //     Returns kTRUE if the particle producing this hit is going to "disappear"
117 // for example it has interacted producing some other particles. Returns
118 //  kFalse otherwise. {bit IsTrackOut is set or not}
119 //
120 // Bool_t StatusStop()
121 //     Returns kTRUE if the particle producing this hit is has dropped below
122 // its energy cut off producing some other particles. Returns kFalse otherwise.
123 // {bit IsTrackOut is set or not}
124 //
125 // Bool_t StatuAlives()
126 //     Returns kTRUE if the particle producing this hit is going to continue
127 // to be transported. Returns kFalse otherwise. {bit IsTrackOut is set or not}
128 //
129 // Int_t GetLayer()
130 //     Returns the layer number, fLayer, for this hit.
131 //
132 // Int_t GetLadder()
133 //     Returns the ladder number, fLadder, for this hit.
134 //
135 // Int_t GetDetector()
136 //     Returns the detector number, fDet, for this hit.
137 //
138 // GetDetectorID(Int_t &layer, Int_t &ladder, Int_t &detector)
139 //     Returns the layer, ladder, and detector numbers, fLayer fLadder fDet,
140 // in one call.
141 //
142 // Float_t GetIonization()
143 //     Returns the energy lost, fDestep, by the particle creating this hit,
144 // in the units defined by the Monte Carlo.
145 //
146 // GetPositionG(Float_t &x, Float_t &y, Float_t &z)
147 //     Returns the global position, fX fY fZ, of this hit, in the units
148 // define by the Monte Carlo.
149 //
150 // GetPositionG(Double_t &x, Double_t &y, Double_t &z)
151 //     Returns the global position, fX fY fZ, of this hit, in the units
152 // define by the Monte Carlo.
153 //
154 // GetPositionG(Float_t &x, Float_t &y, Float_t &z, Float_t &tof)
155 //     Returns the global position and time of flight, fX fY fZ fTof, of
156 // this hit, in the units define by the Monte Carlo.
157 //
158 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
159 //     Returns the global position and time of flight, fX fY fZ fTof, of
160 // this hit, in the units define by the Monte Carlo.
161 //
162 // GetPositionL(Double_t &x,Double_t &y,Double_t &z)
163 //     Returns the local position, fX fY fZ, of this hit in the coordiante
164 // of this module, in the units define by the Monte Carlo.
165 //
166 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
167 //     Returns the local position and time of flight, fX fY fZ fTof, of
168 // this hit in the coordinates of this module, in the units define by the
169 //  Monte Carlo.
170 //
171 // Float_t GetXG()
172 //     Returns the global x position in the units defined by the Monte Carlo.
173 //
174 // Float_t GetYG()
175 //     Returns the global y position in the units defined by the Monte Carlo.
176 //
177 // Float_t GetYG()
178 //     Returns the global z position in the units defined by the Monte Carlo.
179 //
180 // Float_t GetTOF()
181 //     Returns the time of flight, fTof, of this hit, in the units defined
182 // by the Monte Carlo.
183 //
184 // GetMomentumG(Float_t &px, Float_t &py, Float_t &pz)
185 //     Returns the global momentum, fPx fPy fPz, of the particle that made
186 // this hit, in the units define by the Monte Carlo.
187 //
188 // GetMomentumG(Double_t &px,Double_t &py,Double_t &pz)
189 //     Returns the global momentum, fPx fPy fPz, of the particle that made
190 // this hit, in the units define by the Monte Carlo.
191 //
192 // GetMomentumL(Double_t &px,Double_t &py,Double_t &pz)
193 //     Returns the momentum, fPx fPy fPz in coordinate appropreate for this
194 // specific module, in the units define by the Monte Carlo.
195 //
196 // Float_t GetPXG()
197 //     Returns the global X momentum in the units defined by the Monte Carlo.
198 //
199 // Float_t GetPYG()
200 //     Returns the global Y momentum in the units defined by the Monte Carlo.
201 //
202 // Float_t GetPZG()
203 //     Returns the global Z momentum in the units defined by the Monte Carlo.
204 //
205 ////////////////////////////////////////////////////////////////////////
206 //_____________________________________________________________________________
207 AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
208     AliHit(shunt, track){
209 ////////////////////////////////////////////////////////////////////////
210 // Create ITS hit
211 //     The creator of the AliITShit class. The variables shunt and
212 // track are passed to the creator of the AliHit class. See the AliHit
213 // class for a full description. the integer array *vol contains, in order,
214 // fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
215 // The array *hits contains, in order, fX = hits[0], fY = hits[1],
216 // fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
217 // fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
218 ////////////////////////////////////////////////////////////////////////
219   fLayer      = vol[0];   // Layer number
220   fLadder     = vol[2];   // Ladder number
221   fDet        = vol[1];   // Detector number
222   fStatus     = vol[3];   // Track status flags
223   fX          = hits[0];  // Track X position
224   fY          = hits[1];  // Track Y position
225   fZ          = hits[2];  // Track Z position
226   fPx         = hits[3];  // Track X Momentum
227   fPy         = hits[4];  // Track Y Momentum
228   fPz         = hits[5];  // Track Z Momentum
229   fDestep     = hits[6];  // Track dE/dx for this step
230   fTof        = hits[7];  // Track Time of Flight for this step
231 }
232 //______________________________________________________________________
233 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
234 ////////////////////////////////////////////////////////////////////////
235 //     Returns the position of this hit in the local coordinates of this
236 // module, and in the units of the Monte Carlo.
237 ////////////////////////////////////////////////////////////////////////
238     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
239     Float_t g[3],l[3];
240
241     g[0] = fX;
242     g[1] = fY;
243     g[2] = fZ;
244     gm->GtoL(fLayer,fLadder,fDet,g,l);
245     x = l[0];
246     y = l[1];
247     z = l[2];
248     return;
249 }
250 //______________________________________________________________________
251 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
252 ////////////////////////////////////////////////////////////////////////
253 //     Returns the position and time of flight of this hit in the local
254 // coordinates of this module, and in the units of the Monte Carlo.
255 ////////////////////////////////////////////////////////////////////////
256     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
257     Float_t g[3],l[3];
258
259     g[0] = fX;
260     g[1] = fY;
261     g[2] = fZ;
262     gm->GtoL(fLayer,fLadder,fDet,g,l);
263     x = l[0];
264     y = l[1];
265     z = l[2];
266     tof = fTof;
267     return;
268 }
269 //______________________________________________________________________
270 Float_t AliITShit::GetXL(){
271 ////////////////////////////////////////////////////////////////////////
272 //     Returns the x position of this hit in the local coordinates of this
273 // module, and in the units of the Monte Carlo.
274 ////////////////////////////////////////////////////////////////////////
275     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
276     Float_t g[3],l[3];
277
278     g[0] = fX;
279     g[1] = fY;
280     g[2] = fZ;
281     gm->GtoL(fLayer,fLadder,fDet,g,l);
282     return l[0];
283 }
284 //______________________________________________________________________
285 Float_t AliITShit::GetYL(){
286 ////////////////////////////////////////////////////////////////////////
287 //     Returns the y position of this hit in the local coordinates of this
288 // module, and in the units of the Monte Carlo.
289 ////////////////////////////////////////////////////////////////////////
290     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
291     Float_t g[3],l[3];
292
293     g[0] = fX;
294     g[1] = fY;
295     g[2] = fZ;
296     gm->GtoL(fLayer,fLadder,fDet,g,l);
297     return l[1];
298 }
299 //______________________________________________________________________
300 Float_t AliITShit::GetZL(){
301 ////////////////////////////////////////////////////////////////////////
302 //     Returns the z position of this hit in the local coordinates of this
303 // module, and in the units of the Monte Carlo.
304 ////////////////////////////////////////////////////////////////////////
305     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
306     Float_t g[3],l[3];
307
308     g[0] = fX;
309     g[1] = fY;
310     g[2] = fZ;
311     gm->GtoL(fLayer,fLadder,fDet,g,l);
312     return l[2];
313 }
314 //______________________________________________________________________
315 void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
316 ////////////////////////////////////////////////////////////////////////
317 //     Returns the momentum of this hit in the local coordinates of this
318 // module, and in the units of the Monte Carlo.
319 ////////////////////////////////////////////////////////////////////////
320     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
321     Float_t g[3],l[3];
322
323     g[0] = fPx;
324     g[1] = fPy;
325     g[2] = fPz;
326     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
327     px = l[0];
328     py = l[1];
329     pz = l[2];
330     return;
331 }
332 //______________________________________________________________________
333 Float_t AliITShit::GetPXL(){
334 ////////////////////////////////////////////////////////////////////////
335 //     Returns the X momentum of this hit in the local coordinates of this
336 // module, and in the units of the Monte Carlo.
337 ////////////////////////////////////////////////////////////////////////
338     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
339     Float_t g[3],l[3];
340
341     g[0] = fPx;
342     g[1] = fPy;
343     g[2] = fPz;
344     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
345     return l[0];
346 }
347 //______________________________________________________________________
348 Float_t AliITShit::GetPYL(){
349 ////////////////////////////////////////////////////////////////////////
350 //     Returns the Y momentum of this hit in the local coordinates of this
351 // module, and in the units of the Monte Carlo.
352 ////////////////////////////////////////////////////////////////////////
353     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
354     Float_t g[3],l[3];
355
356     g[0] = fPx;
357     g[1] = fPy;
358     g[2] = fPz;
359     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
360     return l[1];
361 }
362 //______________________________________________________________________
363 Float_t AliITShit::GetPZL(){
364 ////////////////////////////////////////////////////////////////////////
365 //     Returns the Z momentum of this hit in the local coordinates of this
366 // module, and in the units of the Monte Carlo.
367 ////////////////////////////////////////////////////////////////////////
368     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
369     Float_t g[3],l[3];
370
371     g[0] = fPx;
372     g[1] = fPy;
373     g[2] = fPz;
374     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
375     return l[2];
376 }
377 //___________________________________________________________________________;
378 Int_t AliITShit::GetModule(){
379 ////////////////////////////////////////////////////////////////////////
380 //     Returns the module index number of the module where this hit was in.
381 ////////////////////////////////////////////////////////////////////////
382     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
383
384     return gm->GetModuleIndex(fLayer,fLadder,fDet);
385 }
386 //______________________________________________________________________
387 TParticle * AliITShit::GetParticle(){
388 ////////////////////////////////////////////////////////////////////////
389 //     Returns the pointer to the TParticle for the particle that created
390 // this hit. From the TParticle all kinds of information about this 
391 // particle can be found. See the TParticle class.
392 ////////////////////////////////////////////////////////////////////////
393     TClonesArray *parts = gAlice->Particles();
394     return ((TParticle*)parts->UncheckedAt(this->GetTrack()));
395 }
396 //___________________________________________________________________________
397 void AliITShit::Streamer(TBuffer &R__b){
398 ////////////////////////////////////////////////////////////////////////
399 //     The streamer function for this AliITShit class. This has been set
400 // up so that future changes to this class can be easly incorporated.
401 ////////////////////////////////////////////////////////////////////////
402    if (R__b.IsReading()) {
403       Version_t R__v = R__b.ReadVersion(); 
404       if (R__v==1) {
405           AliHit::Streamer(R__b);
406           R__b >> fStatus;
407           R__b >> fLayer;
408           R__b >> fLadder;
409           R__b >> fDet;
410           R__b >> fPx;
411           R__b >> fPy;
412           R__b >> fPz;
413           R__b >> fDestep;
414           R__b >> fTof;
415       }else{ // for futrue changes to this class.
416       } // end if R__v==1
417    } else {
418       R__b.WriteVersion(AliITShit::IsA());
419       AliHit::Streamer(R__b);
420       R__b << fStatus;
421       R__b << fLayer;
422       R__b << fLadder;
423       R__b << fDet;
424       R__b << fPx;
425       R__b << fPy;
426       R__b << fPz;
427       R__b << fDestep;
428       R__b << fTof;
429    } // end if R__b.IsReading()
430 }