Added charge to the clusters tree
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUModule.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: AliITSUModule.cxx 53509 2011-12-10 18:55:52Z masera $ */
17
18 #include <TArrayI.h>
19
20 #include <stdlib.h>
21
22 #include "AliRun.h"
23 #include "AliITS.h"
24 #include "AliITSUModule.h"
25 #include "AliITSUGeomTGeo.h"
26 using namespace TMath;
27
28 ClassImp(AliITSUModule)
29
30 //_______________________________________________________________________
31 //
32 // Impementation of class AliITSUModule
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 AliITSUModule::AliITSUModule()
44 :  fHitsM(0)
45   ,fGeomTG(0)
46 {
47   // constructor
48 }
49
50 //_________________________________________________________________________
51 AliITSUModule::AliITSUModule(Int_t index, AliITSUGeomTGeo* tg)
52   :fHitsM(new TObjArray())
53   ,fGeomTG(tg)
54 {
55   // constructor
56   SetIndex(index);
57 }
58
59 //__________________________________________________________________________
60 AliITSUModule::~AliITSUModule() 
61 {
62   // The destructor for AliITSUModule. Before destoring AliITSUModule
63   // we must first destroy all of it's members.
64   if (fHitsM) fHitsM->Clear();
65   delete fHitsM;
66 }
67
68 //____________________________________________________________________________
69 AliITSUModule::AliITSUModule(const AliITSUModule &source)
70  :TObject(source)
71  ,fHitsM(source.fHitsM)
72  ,fGeomTG(source.fGeomTG)
73 {
74 //     Copy Constructor 
75 }
76
77 //_____________________________________________________________________________
78 AliITSUModule& AliITSUModule::operator=(const AliITSUModule &source)
79 {
80   //    Assignment operator 
81   if (this!=&source) {
82     this->~AliITSUModule();
83     new(this) AliITSUModule(source);
84   }
85   return *this;
86 }
87
88 //___________________________________________________________________________
89 Double_t AliITSUModule::PathLength(const AliITSUHit *itsHit1,const AliITSUHit *itsHit2) 
90 {
91   // path lenght
92   Float_t  x1g,y1g,z1g;   
93   Float_t  x2g,y2g,z2g;
94   Double_t s;
95   //
96   itsHit1->GetPositionG(x1g,y1g,z1g);
97   itsHit2->GetPositionG(x2g,y2g,z2g);
98   //
99   s = Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
100             ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
101             ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g)) );
102    return s;
103 }
104
105 //___________________________________________________________________________
106 void AliITSUModule::PathLength(Float_t x,Float_t y,Float_t z,Int_t status,Int_t &nseg,Float_t &x1,Float_t &y1,Float_t &z1,
107                               Float_t &dx1,Float_t &dy1,Float_t &dz1,Int_t &flag) const
108 {
109   // path length
110   static Float_t x0,y0,z0;
111   //
112   if ((status&0x0002)!=0){ // entering
113     x0 = x;
114     y0 = y;
115     z0 = z;
116     nseg = 0;
117     flag = 1;
118   }else{
119     x1 = x0;
120     y1 = y0;
121     z1 = z0;
122     dx1 = x-x1;
123     dy1 = y-y1;
124     dz1 = z-z1;
125     nseg++;
126     if ((status&0x0004)!=0) flag = 0; //exiting
127     if ((status&0x0001)!=0) flag = 2; // inside
128     else flag = 2; //inside ?
129     x0 = x;
130     y0 = y;
131     z0 = z;
132   } // end if
133 }
134
135 //___________________________________________________________________________
136 Bool_t AliITSUModule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
137                                   Double_t &e,Double_t &f,Double_t &de)
138 {
139   // line segment
140   AliITSUHit *h1;
141   Double_t t;
142   //  
143   if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
144   //
145   h1 = (AliITSUHit *) (fHitsM->At(hitindex));
146   if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
147   de = h1->GetIonization();
148   h1->GetPositionL0(a,c,e,t);
149   h1->GetPositionL(b,d,f);
150   b = b - a;
151   d = d - c;
152   f = f - e;
153   return kTRUE;
154 }
155
156 //___________________________________________________________________________
157 Bool_t AliITSUModule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
158                                   Double_t &e,Double_t &f,Double_t &de)
159 {
160   // line segment
161   AliITSUHit *h1;
162   Double_t t;
163   //
164   if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
165   h1 = (AliITSUHit *) (fHitsM->At(hitindex));
166   if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
167   de = h1->GetIonization();
168   h1->GetPositionG0(a,c,e,t);
169   h1->GetPositionG(b,d,f);
170   b = b - a;
171   d = d - c;
172   f = f - e;
173   return kTRUE;
174 }
175
176 //___________________________________________________________________________
177 Bool_t AliITSUModule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
178                                    Double_t &e,Double_t &f,Double_t &de,Double_t &tof, Int_t &track)
179 {
180   // line segmente
181   AliITSUHit *h1;
182   if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
183   //
184   h1 = (AliITSUHit *) (fHitsM->At(hitindex));
185   if(h1->StatusEntering()){ // if track entering volume, get index for next
186     // step
187     track = h1->GetTrack();
188     return kFALSE;
189   } // end if StatusEntering()
190     // else stepping
191   de = h1->GetIonization();
192   h1->GetPositionL0(a,c,e,tof);
193   h1->GetPositionL(b,d,f);
194   b = b - a;
195   d = d - c;
196   f = f - e;
197   track = h1->GetTrack();
198   return kTRUE;
199 }
200
201 //___________________________________________________________________________
202 Bool_t AliITSUModule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
203                                    Double_t &e,Double_t &f,Double_t &de,Double_t &tof, Int_t &track)
204 {
205   // line segment
206   AliITSUHit *h1;
207   if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
208   //
209   h1 = (AliITSUHit *) (fHitsM->At(hitindex));
210   if(h1->StatusEntering()){ // if track entering volume, get index for next
211     // step
212     track = h1->GetTrack();
213     return kFALSE;
214   } // end if StatusEntering()
215   de = h1->GetIonization();
216   h1->GetPositionG0(a,c,e,tof);
217   h1->GetPositionG(b,d,f);
218   b = b - a;
219   d = d - c;
220   f = f - e;
221   track = h1->GetTrack();
222   return kTRUE;
223 }
224
225 //______________________________________________________________________
226 Bool_t AliITSUModule::MedianHitG(AliITSUHit *h1,AliITSUHit *h2,Float_t &x,Float_t &y,Float_t &z)
227 {
228   // Computes the mean hit location for a set of hits that make up a track
229   // passing through a volume. Returns kFALSE untill the the track leaves
230   // the volume.
231   // median hit
232   Float_t x1l=0.,y1l=0.,z1l=0.;
233   Float_t x2l=0.,y2l=0.,z2l=0.;
234   Float_t xMl,yMl=0,zMl;
235   Double_t l[3], g[3];
236   
237   h1->GetPositionG(x1l,y1l,z1l);
238   h2->GetPositionG(x2l,y2l,z2l);
239   
240   if((y2l*y1l)<0.) {
241     xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
242     zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
243   } else {
244     xMl = 0.5*(x1l+x2l);
245     zMl = 0.5*(z1l+z2l);
246   }
247   
248   l[0] = xMl;
249   l[1] = yMl;
250   l[2] = zMl;
251   fGeomTG->LocalToGlobal(h1->GetModule(),l,g);
252   x = g[0];
253   y = g[1];
254   z = g[2];
255   return kTRUE;
256 }
257
258 //___________________________________________________________________________
259 void AliITSUModule::MedianHitG(Int_t index,Float_t hitx1,Float_t hity1,Float_t hitz1,Float_t hitx2,Float_t hity2,Float_t hitz2,
260                                  Float_t &xMg, Float_t &yMg, Float_t &zMg)
261 {
262   // median hit
263   Float_t x1l,y1l,z1l;
264   Float_t x2l,y2l,z2l;
265   Float_t xMl,yMl=0,zMl;
266   Double_t l[3], g[3];
267   
268   g[0] = hitx1;
269   g[1] = hity1;
270   g[2] = hitz1;
271   fGeomTG->GlobalToLocal(index,g,l);
272   x1l = l[0];
273   y1l = l[1];
274   z1l = l[2];
275   
276   g[0] = hitx2;
277   g[1] = hity2;
278   g[2] = hitz2;
279   fGeomTG->GlobalToLocal(index,g,l);
280   x2l = l[0];
281   y2l = l[1];
282   z2l = l[2];
283   
284   if((y2l*y1l)<0.) {
285     xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
286     zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
287   } else {
288     xMl = 0.5*(x1l+x2l);
289     zMl = 0.5*(z1l+z2l);
290   }
291   
292   l[0] = xMl;
293   l[1] = yMl;
294   l[2] = zMl;
295   fGeomTG->LocalToGlobal(index,l,g);
296   xMg = g[0];
297   yMg = g[1];
298   zMg = g[2];
299 }
300
301 //___________________________________________________________________________
302 Bool_t AliITSUModule::MedianHitL( AliITSUHit *itsHit1,AliITSUHit *itsHit2, Float_t &xMl, Float_t &yMl, Float_t &zMl) const
303 {
304   // median hit
305   Float_t x1l,y1l,z1l;
306   Float_t x2l,y2l,z2l;
307   
308   itsHit1->GetPositionL(x1l,y1l,z1l);
309   itsHit2->GetPositionL(x2l,y2l,z2l);
310   
311   yMl = 0.0;
312   if((y2l*y1l)<0.) {
313     xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
314     zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;        
315   } else {
316     xMl = 0.5*(x1l+x2l);
317     zMl = 0.5*(z1l+z2l);
318   }
319   return kTRUE;
320 }
321
322 //___________________________________________________________________________
323 void AliITSUModule::MedianHit(Int_t index,Float_t xg,Float_t yg,Float_t zg,Int_t status,
324                              Float_t &xMg,Float_t &yMg,Float_t &zMg,Int_t &flag)
325 {
326   // median hit
327   static Float_t x1,y1,z1;
328   //
329   if ((status&0x0002)!=0){ // entering
330     x1 = xg;
331     y1 = yg;
332     z1 = zg;
333     flag = 1;
334   } else if ((status&0x0004)!=0){ // exiting
335     MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
336     flag = 0;
337   } // end if
338   else  flag = 1;
339 }
340
341