Corrected by F. Carminati for v3.04
[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 /*
17 $Log$
18 Revision 1.8  2000/10/02 16:32:57  barbera
19 Forward declarations added and formatting
20
21 Revision 1.3.4.8  2000/10/02 15:55:26  barbera
22 Forward declarations added and formatting
23
24 Revision 1.7  2000/09/22 12:36:38  nilsen
25 Minor changes to improve compilation and create less NOISE.
26
27 Revision 1.6  2000/07/10 16:07:18  fca
28 Release version of ITS code
29
30 Revision 1.3.4.2  2000/03/02 21:42:29  nilsen 
31 Linked AliDetector::fDigit to AliITSmodule::fDigitsM and AliITS::fITSRecPoints
32 to AliITSmodule::fRecPointsM. Renamed AliITSmodule::fPointsM to fRecPointsM.
33 Removed the deletion of fDigitsM from the distructor since it is only a copy
34 of what is in AliDetector. Fixed a bug in the functions LineSegmentL and
35 LineSegmentG. Added two new versions of LineSegmentL and LineSegmentG to
36 additionaly return track number from the hit. Removed FastPoint function,
37 haven't found anywere it was used, also it had very many problems, should
38 just call FastPointSPD... .
39
40 Revision 1.3.4.1  2000/01/12 19:03:32  nilsen
41 This is the version of the files after the merging done in December 1999.
42 See the ReadMe110100.txt file for details
43
44 Revision 1.3  1999/10/04 15:20:12  fca
45 Correct syntax accepted by g++ but not standard for static members, remove minor warnings
46
47 Revision 1.2  1999/09/29 09:24:20  fca
48 Introduction of the Copyright and cvs Log
49
50 */
51
52 #include <TArrayI.h>
53
54 #include <stdlib.h>
55
56 #include "AliRun.h"
57 #include "AliITS.h"
58 #include "AliITShit.h"
59 #include "AliITSmodule.h"
60 #include "AliITSgeom.h"
61
62 ClassImp(AliITSmodule)
63
64 //_______________________________________________________________________
65 //
66 // Impementation of class AliITSmodule
67 //
68 // created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski 
69 //             R. Barbers, B. Batyunia, B. S. Nilsen
70 // ver 1.0     CERN 16.09.1999
71 //_______________________________________________________________________
72 //________________________________________________________________________
73 // 
74 // Constructors and deconstructor
75 //________________________________________________________________________
76 //
77 AliITSmodule::AliITSmodule() {
78   // constructor
79     fIndex       = 0;
80     fHitsM       = 0;
81     fTrackIndex  = 0;
82     fHitIndex    = 0;
83     fITS         = 0;
84
85 }
86 //_________________________________________________________________________
87 AliITSmodule::AliITSmodule(Int_t index) {
88   // constructor
89
90     fIndex      = index;
91     fHitsM      = new TObjArray();
92     fTrackIndex = new TArrayI(16);
93     fHitIndex   = new TArrayI(16);
94     fITS        = (AliITS*)(gAlice->GetDetector("ITS"));
95 }
96 //__________________________________________________________________________
97 AliITSmodule::~AliITSmodule() {
98     // The destructor for AliITSmodule. Before destoring AliITSmodule
99     // we must first destroy all of it's members.
100
101     fIndex   = 0;
102     if(fHitsM){
103         for(Int_t i=0;i<fHitsM->GetEntriesFast();i++) 
104             delete ((AliITShit *)(fHitsM->At(i)));
105         // must delete each object in the TObjArray.
106         delete fHitsM;
107     } // end if
108     delete fTrackIndex;
109     delete fHitIndex;
110     fITS = 0; // We don't delete this pointer since it is just a copy.
111 }
112 //____________________________________________________________________________
113 AliITSmodule::AliITSmodule(const AliITSmodule &source){
114 ////////////////////////////////////////////////////////////////////////
115 //     Copy Constructor 
116 ////////////////////////////////////////////////////////////////////////
117   printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
118   exit(1);
119 }
120
121 //_____________________________________________________________________________
122 AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
123 ////////////////////////////////////////////////////////////////////////
124 //    Assignment operator 
125 ////////////////////////////////////////////////////////////////////////
126   printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
127   exit(1);
128   return *this; // fake return neded on Sun
129
130
131 //_________________________________________________________________________
132 // 
133 // Hits management
134 //__________________________________________________________________________
135 Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
136 // Hits management
137
138   //printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
139     fHitsM->AddLast(new AliITShit(*hit));
140     Int_t fNhitsM = fHitsM->GetEntriesFast();
141     if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
142         TArrayI *p = new TArrayI(fNhitsM+64);
143         for(Int_t i=0;i<fTrackIndex->GetSize();i++) 
144             (*p)[i] = fTrackIndex->At(i);
145         delete fTrackIndex;
146         fTrackIndex = p;
147     } // end if
148     if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
149         TArrayI *p = new TArrayI(fNhitsM+64);
150         for(Int_t i=0;i<fHitIndex->GetSize();i++) 
151             (*p)[i] = fHitIndex->At(i);
152         delete fHitIndex;
153         fHitIndex = p;
154     } // end if
155     (*fTrackIndex)[fNhitsM-1] = t;
156     (*fHitIndex)[fNhitsM-1]   = h;
157     return fNhitsM;
158 }
159
160 //___________________________________________________________________________
161 void AliITSmodule::MedianHitG(Int_t index,
162                               Float_t hitx1,Float_t hity1,Float_t hitz1,
163                               Float_t hitx2,Float_t hity2,Float_t hitz2,
164                               Float_t &xMg, Float_t &yMg, Float_t &zMg){
165   // median hit
166    AliITSgeom *gm = fITS->GetITSgeom();
167    Float_t x1l,y1l,z1l;
168    Float_t x2l,y2l,z2l;
169    Float_t xMl,yMl=0,zMl;
170    Float_t l[3], g[3];
171
172    g[0] = hitx1;
173    g[1] = hity1;
174    g[2] = hitz1;
175    gm->GtoL(index,g,l);
176    x1l = l[0];
177    y1l = l[1];
178    z1l = l[2];
179
180    g[0] = hitx2;
181    g[1] = hity2;
182    g[2] = hitz2;
183    gm->GtoL(index,g,l);
184    x2l = l[0];
185    y2l = l[1];
186    z2l = l[2];
187
188    xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
189    zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
190
191    l[0] = xMl;
192    l[1] = yMl;
193    l[2] = zMl;
194    gm->LtoG(index,l,g);
195    xMg = g[0];
196    yMg = g[1];
197    zMg = g[2];
198 }
199 //___________________________________________________________________________
200 Double_t AliITSmodule::PathLength(Int_t index,AliITShit *itsHit1,
201                                   AliITShit *itsHit2){
202   // path lenght
203    Float_t  x1g,y1g,z1g;   
204    Float_t  x2g,y2g,z2g;
205    Double_t s;
206
207    itsHit1->GetPositionG(x1g,y1g,z1g);
208    itsHit2->GetPositionG(x2g,y2g,z2g);
209
210    s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
211                     ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
212                     ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
213    return s;
214 }
215 //___________________________________________________________________________
216 void AliITSmodule::PathLength(Int_t index,
217                               Float_t x,Float_t y,Float_t z,
218                               Int_t status,Int_t &nseg,
219                               Float_t &x1,Float_t &y1,Float_t &z1,
220                               Float_t &dx1,Float_t &dy1,Float_t &dz1,
221                               Int_t &flag){
222   // path length
223     static Float_t x0,y0,z0;
224
225     if (status == 66){ // entering
226         x0 = x;
227         y0 = y;
228         z0 = z;
229         nseg = 0;
230         flag = 1;
231     }else{
232         x1 = x0;
233         y1 = y0;
234         z1 = z0;
235         dx1 = x-x1;
236         dy1 = y-y1;
237         dz1 = z-z1;
238         nseg++;
239         if (status == 68) flag = 0; //exiting
240         else flag = 2; //inside
241         x0 = x;
242         y0 = y;
243         z0 = z;
244     } // end if
245 }
246 //___________________________________________________________________________
247 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
248                                   Double_t &c,Double_t &d,
249                                   Double_t &e,Double_t &f,Double_t &de){
250   // line segment
251     static Int_t hitindex0;
252     AliITShit *h0,*h1;
253
254     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
255
256     h1 = (AliITShit *) (fHitsM->At(hitindex));
257     if(h1->StatusEntering()){ // if track entering volume, get index for next
258                               // step
259         hitindex0 = hitindex;
260         return kFALSE;
261     } // end if StatusEntering()
262     // else stepping
263     h0 = (AliITShit *) (fHitsM->At(hitindex0));
264     de = h1->GetIonization();
265     h0->GetPositionL(a,c,e);
266     h1->GetPositionL(b,d,f);
267     b = b - a;
268     d = d - c;
269     f = f - e;
270     hitindex0 = hitindex;
271     return kTRUE;
272 }
273 //___________________________________________________________________________
274 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
275                                   Double_t &c,Double_t &d,
276                                   Double_t &e,Double_t &f,Double_t &de){
277   // line segment
278     static Int_t hitindex0;
279     AliITShit *h0,*h1;
280
281     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
282
283     h1 = (AliITShit *) (fHitsM->At(hitindex));
284     if(h1->StatusEntering()){ // if track entering volume, get index for next
285                               // step
286         hitindex0 = hitindex;
287         return kFALSE;
288     } // end if StatusEntering()
289     // else stepping
290     h0 = (AliITShit *) (fHitsM->At(hitindex0));
291     de = h1->GetIonization();
292     h0->GetPositionG(a,c,e);
293     h1->GetPositionG(b,d,f);
294     b = b - a;
295     d = d - c;
296     f = f - e;
297     hitindex0 = hitindex;
298     return kTRUE;
299 }
300 //___________________________________________________________________________
301 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
302                                   Double_t &c,Double_t &d,
303                                   Double_t &e,Double_t &f,
304                                   Double_t &de,Int_t &track){
305   // line segmente
306     static Int_t hitindex0;
307     AliITShit *h0,*h1;
308
309     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
310
311     h1 = (AliITShit *) (fHitsM->At(hitindex));
312     if(h1->StatusEntering()){ // if track entering volume, get index for next
313                               // step
314         hitindex0 = hitindex;
315         track = h1->GetTrack();
316         return kFALSE;
317     } // end if StatusEntering()
318     // else stepping
319     h0 = (AliITShit *) (fHitsM->At(hitindex0));
320     de = h1->GetIonization();
321     h0->GetPositionL(a,c,e);
322     h1->GetPositionL(b,d,f);
323     b = b - a;
324     d = d - c;
325     f = f - e;
326     hitindex0 = hitindex;
327     track = h1->GetTrack();
328     return kTRUE;
329 }
330 //___________________________________________________________________________
331 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
332                                   Double_t &c,Double_t &d,
333                                   Double_t &e,Double_t &f,
334                                   Double_t &de,Int_t &track){
335   // line segment
336     static Int_t hitindex0;
337     AliITShit *h0,*h1;
338
339     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
340
341     h1 = (AliITShit *) (fHitsM->At(hitindex));
342     if(h1->StatusEntering()){ // if track entering volume, get index for next
343                               // step
344         hitindex0 = hitindex;
345         track = h1->GetTrack();
346         return kFALSE;
347     } // end if StatusEntering()
348     // else stepping
349     h0 = (AliITShit *) (fHitsM->At(hitindex0));
350     de = h1->GetIonization();
351     h0->GetPositionG(a,c,e);
352     h1->GetPositionG(b,d,f);
353     b = b - a;
354     d = d - c;
355     f = f - e;
356     hitindex0 = hitindex;
357     track = h1->GetTrack();
358     return kTRUE;
359 }
360 //___________________________________________________________________________
361 void AliITSmodule::MedianHitL(Int_t index, 
362                              AliITShit *itsHit1, 
363                              AliITShit *itsHit2, 
364                              Float_t &xMl, Float_t &yMl, Float_t &zMl){
365   // median hit
366    Float_t x1l,y1l,z1l;
367    Float_t x2l,y2l,z2l;
368
369    itsHit1->GetPositionL(x1l,y1l,z1l);
370    itsHit2->GetPositionL(x2l,y2l,z2l);
371
372    xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
373    yMl = 0.0;
374    zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;         
375 }
376 //___________________________________________________________________________
377 void AliITSmodule::MedianHit(Int_t index,
378                              Float_t xg,Float_t yg,Float_t zg,
379                              Int_t status,
380                              Float_t &xMg,Float_t &yMg,Float_t &zMg,
381                              Int_t &flag){
382   // median hit
383    static Float_t x1,y1,z1;
384
385    if (status == 66){ // entering
386        x1 = xg;
387        y1 = yg;
388        z1 = zg;
389        flag = 1;
390    } // end if
391    if (status == 68){ // exiting
392        MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
393        flag = 0;
394    } // end if
395    if ((status != 66) && (status != 68)) flag = 1;
396 }
397 //___________________________________________________________________________
398 void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
399   // get ID
400         fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
401         return ;
402 }
403