Protection against missing timestamps
[u/mrichter/AliRoot.git] / ITS / AliITSmodule.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 /* $Id$ */
17
18 #include <TArrayI.h>
19
20 #include <stdlib.h>
21
22 #include "AliRun.h"
23 #include "AliITS.h"
24 #include "AliITShit.h"
25 #include "AliITSmodule.h"
26 #include "AliITSgeomTGeo.h"
27
28 ClassImp(AliITSmodule)
29
30 //_______________________________________________________________________
31 //
32 // Impementation of class AliITSmodule
33 //
34 // created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski 
35 //             R. Barbers, B. Batyunia, B. S. Nilsen
36 // ver 1.0     CERN 16.09.1999
37 //_______________________________________________________________________
38 //________________________________________________________________________
39 // 
40 // Constructors and deconstructor
41 //________________________________________________________________________
42 //
43 AliITSmodule::AliITSmodule():
44 fITS(0),
45 fIndex(0),
46 fHitsM(0),
47 fTrackIndex(0),
48 fHitIndex(0) {
49     // constructor
50
51 }
52 //_________________________________________________________________________
53 AliITSmodule::AliITSmodule(Int_t index):
54 fITS(0),
55 fIndex(index),
56 fHitsM(0),
57 fTrackIndex(0),
58 fHitIndex(0) {
59   // constructor
60
61     fHitsM      = new TObjArray();
62     fTrackIndex = new TArrayI(16);
63     fHitIndex   = new TArrayI(16);
64     fITS        = (AliITS*)(gAlice->GetDetector("ITS"));
65 }
66 //__________________________________________________________________________
67 AliITSmodule::~AliITSmodule() {
68     // The destructor for AliITSmodule. Before destoring AliITSmodule
69     // we must first destroy all of it's members.
70
71     if(fHitsM){
72       fHitsM->Delete();
73       delete fHitsM;
74       fHitsM = 0;
75     } // end if
76     delete fTrackIndex;
77     delete fHitIndex;
78     fITS = 0; // We don't delete this pointer since it is just a copy.
79 }
80 //____________________________________________________________________________
81 AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source),
82 fITS(source.fITS),
83 fIndex(source.fIndex),
84 fHitsM(source.fHitsM),
85 fTrackIndex(source.fTrackIndex),
86 fHitIndex(source.fHitIndex){
87 ////////////////////////////////////////////////////////////////////////
88 //     Copy Constructor 
89 ////////////////////////////////////////////////////////////////////////
90
91 }
92 //_____________________________________________________________________________
93 AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
94 ////////////////////////////////////////////////////////////////////////
95 //    Assignment operator 
96 ////////////////////////////////////////////////////////////////////////
97   this->~AliITSmodule();
98   new(this) AliITSmodule(source);
99   return *this;
100 }
101 //_________________________________________________________________________
102 // 
103 // Hits management
104 //__________________________________________________________________________
105 Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
106 // Hits management
107
108   //printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
109     fHitsM->AddLast(new AliITShit(*hit));
110     Int_t fNhitsM = fHitsM->GetEntriesFast();
111     if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
112       fTrackIndex->Set(fNhitsM+64);
113     } // end if
114     if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
115       fHitIndex->Set(fNhitsM+64);
116     } // end if
117     (*fTrackIndex)[fNhitsM-1] = t;
118     (*fHitIndex)[fNhitsM-1]   = h;
119     return fNhitsM;
120 }
121 //___________________________________________________________________________
122 Double_t AliITSmodule::PathLength(const AliITShit *itsHit1,
123                                   const AliITShit *itsHit2) {
124   // path lenght
125    Float_t  x1g,y1g,z1g;   
126    Float_t  x2g,y2g,z2g;
127    Double_t s;
128
129    itsHit1->GetPositionG(x1g,y1g,z1g);
130    itsHit2->GetPositionG(x2g,y2g,z2g);
131
132    s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
133                     ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
134                     ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
135    return s;
136 }
137 //___________________________________________________________________________
138 void AliITSmodule::PathLength(Float_t x,Float_t y,Float_t z,
139                               Int_t status,Int_t &nseg,
140                               Float_t &x1,Float_t &y1,Float_t &z1,
141                               Float_t &dx1,Float_t &dy1,Float_t &dz1,
142                               Int_t &flag) const{
143   // path length
144     static Float_t x0,y0,z0;
145
146     if ((status&0x0002)!=0){ // entering
147         x0 = x;
148         y0 = y;
149         z0 = z;
150         nseg = 0;
151         flag = 1;
152     }else{
153         x1 = x0;
154         y1 = y0;
155         z1 = z0;
156         dx1 = x-x1;
157         dy1 = y-y1;
158         dz1 = z-z1;
159         nseg++;
160         if ((status&0x0004)!=0) flag = 0; //exiting
161         if ((status&0x0001)!=0) flag = 2; // inside
162         else flag = 2; //inside ?
163         x0 = x;
164         y0 = y;
165         z0 = z;
166     } // end if
167 }
168 //___________________________________________________________________________
169 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
170                                   Double_t &c,Double_t &d,
171                                   Double_t &e,Double_t &f,Double_t &de){
172   // line segment
173     AliITShit *h1;
174     Double_t t;
175
176     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
177
178     h1 = (AliITShit *) (fHitsM->At(hitindex));
179     if(h1->StatusEntering()){ // if track entering volume, get index for next
180                               // step
181         return kFALSE;
182     } // end if StatusEntering()
183     // else stepping
184     de = h1->GetIonization();
185     h1->GetPositionL0(a,c,e,t);
186     h1->GetPositionL(b,d,f);
187     b = b - a;
188     d = d - c;
189     f = f - e;
190     return kTRUE;
191 }
192 //___________________________________________________________________________
193 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
194                                   Double_t &c,Double_t &d,
195                                   Double_t &e,Double_t &f,Double_t &de){
196   // line segment
197     AliITShit *h1;
198     Double_t t;
199
200     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
201
202     h1 = (AliITShit *) (fHitsM->At(hitindex));
203     if(h1->StatusEntering()){ // if track entering volume, get index for next
204                               // step
205         return kFALSE;
206     } // end if StatusEntering()
207     // else stepping
208     de = h1->GetIonization();
209     h1->GetPositionG0(a,c,e,t);
210     h1->GetPositionG(b,d,f);
211     b = b - a;
212     d = d - c;
213     f = f - e;
214     return kTRUE;
215 }
216 //___________________________________________________________________________
217 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
218                                   Double_t &c,Double_t &d,
219                                   Double_t &e,Double_t &f,
220                                   Double_t &de,Int_t &track){
221   // line segmente
222     AliITShit *h1;
223     Double_t t;
224
225     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
226
227     h1 = (AliITShit *) (fHitsM->At(hitindex));
228     if(h1->StatusEntering()){ // if track entering volume, get index for next
229                               // step
230         track = h1->GetTrack();
231         return kFALSE;
232     } // end if StatusEntering()
233     // else stepping
234     de = h1->GetIonization();
235     h1->GetPositionL0(a,c,e,t);
236     h1->GetPositionL(b,d,f);
237     b = b - a;
238     d = d - c;
239     f = f - e;
240     track = h1->GetTrack();
241     return kTRUE;
242 }
243 //___________________________________________________________________________
244 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
245                                   Double_t &c,Double_t &d,
246                                   Double_t &e,Double_t &f,
247                                   Double_t &de,Int_t &track){
248   // line segment
249     AliITShit *h1;
250     Double_t t;
251
252     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
253
254     h1 = (AliITShit *) (fHitsM->At(hitindex));
255     if(h1->StatusEntering()){ // if track entering volume, get index for next
256                               // step
257         track = h1->GetTrack();
258         return kFALSE;
259     } // end if StatusEntering()
260     // else stepping
261     de = h1->GetIonization();
262     h1->GetPositionG0(a,c,e,t);
263     h1->GetPositionG(b,d,f);
264     b = b - a;
265     d = d - c;
266     f = f - e;
267     track = h1->GetTrack();
268     return kTRUE;
269 }
270 //______________________________________________________________________
271 Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
272                                 Float_t &x,Float_t &y,Float_t &z){
273     // Computes the mean hit location for a set of hits that make up a track
274     // passing through a volume. Returns kFALSE untill the the track leaves
275     // the volume.
276     // median hit
277    Float_t x1l=0.,y1l=0.,z1l=0.;
278    Float_t x2l=0.,y2l=0.,z2l=0.;
279    Float_t xMl,yMl=0,zMl;
280    Double_t l[3], g[3];
281
282    h1->GetPositionG(x1l,y1l,z1l);
283    h2->GetPositionG(x2l,y2l,z2l);
284
285    if((y2l*y1l)<0.) {
286      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
287      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
288    } else {
289      xMl = 0.5*(x1l+x2l);
290      zMl = 0.5*(z1l+z2l);
291    }
292
293    l[0] = xMl;
294    l[1] = yMl;
295    l[2] = zMl;
296    AliITSgeomTGeo::LocalToGlobal(h1->GetModule(),l,g);
297    x = g[0];
298    y = g[1];
299    z = g[2];
300    return kTRUE;
301 }
302 //___________________________________________________________________________
303 void AliITSmodule::MedianHitG(Int_t index,
304                               Float_t hitx1,Float_t hity1,Float_t hitz1,
305                               Float_t hitx2,Float_t hity2,Float_t hitz2,
306                               Float_t &xMg, Float_t &yMg, Float_t &zMg){
307   // median hit
308    Float_t x1l,y1l,z1l;
309    Float_t x2l,y2l,z2l;
310    Float_t xMl,yMl=0,zMl;
311    Double_t l[3], g[3];
312
313    g[0] = hitx1;
314    g[1] = hity1;
315    g[2] = hitz1;
316    AliITSgeomTGeo::GlobalToLocal(index,g,l);
317    x1l = l[0];
318    y1l = l[1];
319    z1l = l[2];
320
321    g[0] = hitx2;
322    g[1] = hity2;
323    g[2] = hitz2;
324    AliITSgeomTGeo::GlobalToLocal(index,g,l);
325    x2l = l[0];
326    y2l = l[1];
327    z2l = l[2];
328
329    if((y2l*y1l)<0.) {
330      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
331      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
332    } else {
333      xMl = 0.5*(x1l+x2l);
334      zMl = 0.5*(z1l+z2l);
335    }
336
337    l[0] = xMl;
338    l[1] = yMl;
339    l[2] = zMl;
340    AliITSgeomTGeo::LocalToGlobal(index,l,g);
341    xMg = g[0];
342    yMg = g[1];
343    zMg = g[2];
344 }
345 //___________________________________________________________________________
346 Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1, 
347                              AliITShit *itsHit2, 
348                              Float_t &xMl, Float_t &yMl, Float_t &zMl) const{
349   // median hit
350    Float_t x1l,y1l,z1l;
351    Float_t x2l,y2l,z2l;
352
353    itsHit1->GetPositionL(x1l,y1l,z1l);
354    itsHit2->GetPositionL(x2l,y2l,z2l);
355
356    yMl = 0.0;
357    if((y2l*y1l)<0.) {
358      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
359      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;       
360    } else {
361      xMl = 0.5*(x1l+x2l);
362      zMl = 0.5*(z1l+z2l);
363    }
364    return kTRUE;
365 }
366 //___________________________________________________________________________
367 void AliITSmodule::MedianHit(Int_t index,
368                              Float_t xg,Float_t yg,Float_t zg,
369                              Int_t status,
370                              Float_t &xMg,Float_t &yMg,Float_t &zMg,
371                              Int_t &flag){
372   // median hit
373    static Float_t x1,y1,z1;
374
375    if ((status&0x0002)!=0){ // entering
376        x1 = xg;
377        y1 = yg;
378        z1 = zg;
379        flag = 1;
380    } else if ((status&0x0004)!=0){ // exiting
381        MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
382        flag = 0;
383    } // end if
384    else  flag = 1;
385 }
386 //___________________________________________________________________________
387 void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
388   // get ID
389   AliITSgeomTGeo::GetModuleId(fIndex,lay,lad,det);
390   return ;
391 }
392