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