Correct formula for phi, in case of current local X <0, in GetLocalXat and GetPhiZat
[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 "AliITSgeom.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(Int_t index,AliITShit *itsHit1,
123                                   AliITShit *itsHit2) {
124   // path lenght
125    Float_t  x1g,y1g,z1g;   
126    Float_t  x2g,y2g,z2g;
127    Double_t s;
128
129    index = 0;
130    itsHit1->GetPositionG(x1g,y1g,z1g);
131    itsHit2->GetPositionG(x2g,y2g,z2g);
132
133    s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
134                     ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
135                     ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
136    return s;
137 }
138 //___________________________________________________________________________
139 void AliITSmodule::PathLength(Int_t index,
140                               Float_t x,Float_t y,Float_t z,
141                               Int_t status,Int_t &nseg,
142                               Float_t &x1,Float_t &y1,Float_t &z1,
143                               Float_t &dx1,Float_t &dy1,Float_t &dz1,
144                               Int_t &flag) const{
145   // path length
146     static Float_t x0,y0,z0;
147
148     index = 0;
149     if ((status&0x0002)!=0){ // entering
150         x0 = x;
151         y0 = y;
152         z0 = z;
153         nseg = 0;
154         flag = 1;
155     }else{
156         x1 = x0;
157         y1 = y0;
158         z1 = z0;
159         dx1 = x-x1;
160         dy1 = y-y1;
161         dz1 = z-z1;
162         nseg++;
163         if ((status&0x0004)!=0) flag = 0; //exiting
164         if ((status&0x0001)!=0) flag = 2; // inside
165         else flag = 2; //inside ?
166         x0 = x;
167         y0 = y;
168         z0 = z;
169     } // end if
170 }
171 //___________________________________________________________________________
172 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
173                                   Double_t &c,Double_t &d,
174                                   Double_t &e,Double_t &f,Double_t &de){
175   // line segment
176     AliITShit *h1;
177     Double_t t;
178
179     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
180
181     h1 = (AliITShit *) (fHitsM->At(hitindex));
182     if(h1->StatusEntering()){ // if track entering volume, get index for next
183                               // step
184         return kFALSE;
185     } // end if StatusEntering()
186     // else stepping
187     de = h1->GetIonization();
188     h1->GetPositionL0(a,c,e,t);
189     h1->GetPositionL(b,d,f);
190     b = b - a;
191     d = d - c;
192     f = f - e;
193     return kTRUE;
194 }
195 //___________________________________________________________________________
196 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
197                                   Double_t &c,Double_t &d,
198                                   Double_t &e,Double_t &f,Double_t &de){
199   // line segment
200     AliITShit *h1;
201     Double_t t;
202
203     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
204
205     h1 = (AliITShit *) (fHitsM->At(hitindex));
206     if(h1->StatusEntering()){ // if track entering volume, get index for next
207                               // step
208         return kFALSE;
209     } // end if StatusEntering()
210     // else stepping
211     de = h1->GetIonization();
212     h1->GetPositionG0(a,c,e,t);
213     h1->GetPositionG(b,d,f);
214     b = b - a;
215     d = d - c;
216     f = f - e;
217     return kTRUE;
218 }
219 //___________________________________________________________________________
220 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
221                                   Double_t &c,Double_t &d,
222                                   Double_t &e,Double_t &f,
223                                   Double_t &de,Int_t &track){
224   // line segmente
225     AliITShit *h1;
226     Double_t t;
227
228     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
229
230     h1 = (AliITShit *) (fHitsM->At(hitindex));
231     if(h1->StatusEntering()){ // if track entering volume, get index for next
232                               // step
233         track = h1->GetTrack();
234         return kFALSE;
235     } // end if StatusEntering()
236     // else stepping
237     de = h1->GetIonization();
238     h1->GetPositionL0(a,c,e,t);
239     h1->GetPositionL(b,d,f);
240     b = b - a;
241     d = d - c;
242     f = f - e;
243     track = h1->GetTrack();
244     return kTRUE;
245 }
246 //___________________________________________________________________________
247 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
248                                   Double_t &c,Double_t &d,
249                                   Double_t &e,Double_t &f,
250                                   Double_t &de,Int_t &track){
251   // line segment
252     AliITShit *h1;
253     Double_t t;
254
255     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
256
257     h1 = (AliITShit *) (fHitsM->At(hitindex));
258     if(h1->StatusEntering()){ // if track entering volume, get index for next
259                               // step
260         track = h1->GetTrack();
261         return kFALSE;
262     } // end if StatusEntering()
263     // else stepping
264     de = h1->GetIonization();
265     h1->GetPositionG0(a,c,e,t);
266     h1->GetPositionG(b,d,f);
267     b = b - a;
268     d = d - c;
269     f = f - e;
270     track = h1->GetTrack();
271     return kTRUE;
272 }
273 //______________________________________________________________________
274 Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
275                                 Float_t &x,Float_t &y,Float_t &z){
276     // Computes the mean hit location for a set of hits that make up a track
277     // passing through a volume. Returns kFALSE untill the the track leaves
278     // the volume.
279     // median hit
280    AliITSgeom *gm = fITS->GetITSgeom();
281    Float_t x1l=0.,y1l=0.,z1l=0.;
282    Float_t x2l=0.,y2l=0.,z2l=0.;
283    Float_t xMl,yMl=0,zMl;
284    Float_t l[3], g[3];
285
286    h1->GetPositionG(x1l,y1l,z1l);
287    h2->GetPositionG(x2l,y2l,z2l);
288
289    if((y2l*y1l)<0.) {
290      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
291      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
292    } else {
293      xMl = 0.5*(x1l+x2l);
294      zMl = 0.5*(z1l+z2l);
295    }
296
297    l[0] = xMl;
298    l[1] = yMl;
299    l[2] = zMl;
300    gm->LtoG(h1->GetModule(),l,g);
301    x = g[0];
302    y = g[1];
303    z = g[2];
304    return kTRUE;
305 }
306 //___________________________________________________________________________
307 void AliITSmodule::MedianHitG(Int_t index,
308                               Float_t hitx1,Float_t hity1,Float_t hitz1,
309                               Float_t hitx2,Float_t hity2,Float_t hitz2,
310                               Float_t &xMg, Float_t &yMg, Float_t &zMg){
311   // median hit
312    AliITSgeom *gm = fITS->GetITSgeom();
313    Float_t x1l,y1l,z1l;
314    Float_t x2l,y2l,z2l;
315    Float_t xMl,yMl=0,zMl;
316    Float_t l[3], g[3];
317
318    g[0] = hitx1;
319    g[1] = hity1;
320    g[2] = hitz1;
321    gm->GtoL(index,g,l);
322    x1l = l[0];
323    y1l = l[1];
324    z1l = l[2];
325
326    g[0] = hitx2;
327    g[1] = hity2;
328    g[2] = hitz2;
329    gm->GtoL(index,g,l);
330    x2l = l[0];
331    y2l = l[1];
332    z2l = l[2];
333
334    if((y2l*y1l)<0.) {
335      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
336      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
337    } else {
338      xMl = 0.5*(x1l+x2l);
339      zMl = 0.5*(z1l+z2l);
340    }
341
342    l[0] = xMl;
343    l[1] = yMl;
344    l[2] = zMl;
345    gm->LtoG(index,l,g);
346    xMg = g[0];
347    yMg = g[1];
348    zMg = g[2];
349 }
350 //___________________________________________________________________________
351 Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1, 
352                              AliITShit *itsHit2, 
353                              Float_t &xMl, Float_t &yMl, Float_t &zMl) const{
354   // median hit
355    Float_t x1l,y1l,z1l;
356    Float_t x2l,y2l,z2l;
357
358    itsHit1->GetPositionL(x1l,y1l,z1l);
359    itsHit2->GetPositionL(x2l,y2l,z2l);
360
361    yMl = 0.0;
362    if((y2l*y1l)<0.) {
363      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
364      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;       
365    } else {
366      xMl = 0.5*(x1l+x2l);
367      zMl = 0.5*(z1l+z2l);
368    }
369    return kTRUE;
370 }
371 //___________________________________________________________________________
372 void AliITSmodule::MedianHit(Int_t index,
373                              Float_t xg,Float_t yg,Float_t zg,
374                              Int_t status,
375                              Float_t &xMg,Float_t &yMg,Float_t &zMg,
376                              Int_t &flag){
377   // median hit
378    static Float_t x1,y1,z1;
379
380    if ((status&0x0002)!=0){ // entering
381        x1 = xg;
382        y1 = yg;
383        z1 = zg;
384        flag = 1;
385    } else if ((status&0x0004)!=0){ // exiting
386        MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
387        flag = 0;
388    } // end if
389    else  flag = 1;
390 }
391 //___________________________________________________________________________
392 void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
393   // get ID
394         fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
395         return ;
396 }
397