Correct syntax accepted by g++ but not standard for static members, remove minor...
[u/mrichter/AliRoot.git] / ITS / AliITSmoduleSSD.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.2  1999/09/29 09:24:20  fca
19 Introduction of the Copyright and cvs Log
20
21 */
22
23
24 #include "AliITSmoduleSSD.h"
25
26     //Technical parameters of detector
27 const Float_t   AliITSmoduleSSD::kStereo = 0.0175;  //Stereo Angle 17.5 mrad
28 const Float_t   AliITSmoduleSSD::kTan = 0.0175;  
29 const Int_t     AliITSmoduleSSD::kNStrips = 768;    //Number of strips on each side
30 const Float_t   AliITSmoduleSSD::kPitch = 0.095;    //Distance strip - strip (mm)
31 const Float_t   AliITSmoduleSSD::kX = 72.96;        //X size (mm)
32 const Float_t   AliITSmoduleSSD::kY = 0.3;          //Y size (mm)
33 const Float_t   AliITSmoduleSSD::kZ = 40;           //Thickness (mm)
34     
35     // <------------------------------
36   
37     //______________________________________________________________
38     //  
39     // Parameters for simulation
40     //______________________________________________________________
41       
42 const Float_t   AliITSmoduleSSD::kSigmaP = 0.003;     //Gaussian sigm
43 const Float_t   AliITSmoduleSSD::kSigmaN = 0.002;
44 const Int_t     AliITSmoduleSSD::kSteps  = 10;        //Number of steps 
45 const Int_t     AliITSmoduleSSD::kTresholdP = 1500;    
46 const Int_t     AliITSmoduleSSD::kTresholdN = 2500; 
47    
48
49
50 ClassImp(AliITSmoduleSSD)
51
52 //____________________________________________________________________
53 //
54 //  Constructor
55 //____________________________________________________________________
56 //                                     
57
58
59 AliITSmoduleSSD::AliITSmoduleSSD() {
60     
61
62     //Invalid Strips parameters
63     
64     fInvalidP = new TArrayS(0);
65     fInvalidN = new TArrayS(0);
66     
67     fNInvalidP = 0;
68     fNInvalidN = 0;
69     
70     
71     //DCS parameters
72     
73     fGainP = 83;
74     fGainN = 83;   
75     fSNRatioP = 600;
76     fSNRatioP = 500;
77     
78     fCouplingPR = 0.021;
79     fCouplingPL = 0.026;
80     fCouplingNR = 0.013;
81     fCouplingNL = 0.010;
82
83 }
84
85 AliITSmoduleSSD::AliITSmoduleSSD(Int_t index) {
86                                 
87     fIndex = index;     
88     
89     //Invalid Strips parameters
90     
91     fInvalidP = new TArrayS(0);
92     fInvalidN = new TArrayS(0);
93     
94     fNInvalidP = 0;
95     fNInvalidN = 0;
96     
97     
98     //DCS parameters
99     
100     fGainP = 83;
101     fGainN = 83;   
102     fSNRatioP = 600;
103     fSNRatioP = 500;
104     
105     fCouplingPR = 0.021;
106     fCouplingPL = 0.026;
107     fCouplingNR = 0.013;
108     fCouplingNL = 0.010;        
109 }
110
111 AliITSmoduleSSD::~AliITSmoduleSSD() {
112    
113     if (!fInvalidP) delete fInvalidP;
114     if (!fInvalidN) delete fInvalidN;                           
115 }
116
117
118 //____________________________________________________________________
119 //
120 //  Inalid strips menagement
121 //____________________________________________________________________
122 //                           
123
124
125
126 void AliITSmoduleSSD::SetInvalidP(Int_t strip, Bool_t b) {
127     
128     Bool_t already = kFALSE;
129     Int_t i;
130     
131     for (i=0; i<fNInvalidP; i++) {
132         if ((*fInvalidP)[i] == strip) {
133            already = kTRUE;
134            break;
135         }
136     }
137     
138     if (!already && b) {
139        (*fInvalidP)[fNInvalidP++] = strip;
140     } 
141 }
142
143 void AliITSmoduleSSD::SetInvalidMC(Float_t m, Float_t s) {
144
145     fNInvalid = m;
146     fISigma = s;
147     SetInvalidMC();
148 }
149
150 void AliITSmoduleSSD::SetInvalidMC() {
151
152     Int_t m = (Int_t)gRandom->Gaus(fNInvalid, fISigma);
153     
154     for(int i=0; i<m; i++) {
155        SetInvalidP((Int_t)(gRandom->Rndm()*kNStrips), kTRUE);
156     }
157     
158 }
159
160 Bool_t AliITSmoduleSSD::IsValidP(Int_t n) {
161     
162     for(Int_t i=0; i<fNInvalidP; i++) 
163        if ((*fInvalidP)[i] == n) return kFALSE;
164     return kTRUE;    
165 }
166
167 Bool_t AliITSmoduleSSD::IsValidN(Int_t n) {
168     
169     for(Int_t i=0; i<fNInvalidN; i++) 
170        if ((*fInvalidN)[i] == n) return kFALSE;
171     return kTRUE;    
172 }
173
174
175 //____________________________________________________________________
176 //
177 //  Add digit
178 //____________________________________________________________________
179 // 
180
181 /*********************************************************************
182
183 * AddDigits 
184 * sets paramerers: layer, ladder detector
185 * scan tracks wich produced this digit
186 * creates new SSD DIGTS
187 * call ITS to add digit to its Array
188 * set index frm ITS in its own array
189 *
190 * S.Radomski 17.09.1999
191 *
192 *********************************************************************/
193
194 void AliITSmoduleSSD::AddDigit(Int_t strNo, Int_t s, Bool_t p) {
195  
196     Int_t tracks[3];
197     Int_t digits[4];
198     AliITSdigit *t = (AliITSdigit*) (new AliITSdigitSSD(tracks, digits, 
199                                                         strNo, s, p));
200     
201     fIdigits->AddAt(((AliITS *)fITS)->AddDigit(t), fNdigits++);
202 }
203
204
205 //____________________________________________________________________
206 //
207 //  Hits to digits
208 //____________________________________________________________________
209 //                          
210
211
212
213 void AliITSmoduleSSD::HitToDigit() {
214
215     Int_t i;                           //for iteration
216     fP = new TArrayI(768);
217     fN = new TArrayI(768); 
218     
219     fPtrack1 = new TArrayI(768);
220     fPtrack2 = new TArrayI(768);
221     fPtrack3 = new TArrayI(768);
222     
223     fNtrack1 = new TArrayI(768);
224     fNtrack2 = new TArrayI(768);
225     fNtrack3 = new TArrayI(768);
226     
227     for(i=0; i<kNStrips; i++) {
228        (*fN)[i] = 0;
229        (*fP)[i] = 0;
230     } // end for i
231      
232     for(i=0; i<fNhitsM; i++) HitToDigit(i);
233
234     ApplyCoupling();    
235     ApplyNoise();
236         
237     for(i=0; i<fNInvalidP; i++) (*fP)[(*fInvalidP)[i]] = -20;
238     for(i=0; i<fNInvalidN; i++) (*fN)[(*fInvalidN)[i]] = -20;
239     
240     for(i=0; i<kNStrips; i++) 
241        if ((*fP)[i]>kTresholdP) AddDigit(i+1, (*fP)[i], kTRUE);
242     
243     for(i=0; i<kNStrips; i++)
244        if ((*fN)[i]>kTresholdN) AddDigit(i+1, (*fN)[i], kFALSE);
245        
246     delete fN;
247     delete fP;
248     
249     delete fPtrack1;
250     delete fPtrack2;
251     delete fPtrack3;
252     
253     delete fPtrack1;
254     delete fPtrack2;
255     delete fPtrack3;
256  
257 }
258
259
260
261 void AliITSmoduleSSD::HitToDigit(Int_t hitNo) {
262     
263     Int_t stripP, stripN, i;
264     Float_t dsP, dsN;
265     Float_t sP, sN;
266     Float_t EP, EN;
267     AliITShit *hit = (AliITShit*)((*fHitsM)[hitNo]);
268     Float_t dZ = kZ/kSteps*1000, l;
269
270     if(hit->GetIonization()==0.0) return;
271
272     Float_t x =  hit->GetXG();
273     Float_t y =  hit->GetYG();
274
275     Float_t dx = 0.0; //TMath::Tan(hit->fTheta)*kZ/kSteps;
276     Float_t dy = 0.0; //TMath::Tan(hit->fPhi)*kZ/kSteps;
277     l = sqrt(dZ*dZ + dx*dx *1000000);
278     
279     x -= (kSteps/2 -1) * dx;
280     y -= (kSteps/2 -1) * dy;
281     
282     for (i=1; i<kSteps; i++) {
283     
284         stripP = GetStripP(x, y);
285         dsP = Get2StripP(x, y);
286         
287         stripN = GetStripN(x, y);
288         dsN = Get2StripN(x, y);
289         
290         EP = gRandom->Landau(fGainP*l, l*10);
291         EN = gRandom->Landau(fGainN*l, l*10);
292         
293         sP = kSigmaP * sqrt(i);
294         sN = kSigmaN * sqrt(kSteps-i);
295
296         sP = (i<3 && dsP>0.3 && dsP<0.7)? 0.02 : sP;
297         sN = (i>7 && dsN>0.3 && dsN<0.7)? 0.02 : sN;         
298
299         sP = (i==3 && dsP>0.4 && dsP<0.6)? 0.015 : sP;
300         sN = (i==7 && dsN>0.4 && dsN<0.6)? 0.015 : sN;        
301         
302         
303         (*fP)[stripP-1]+=(Int_t)(EP*(F(-0.5-dsP,sP)-F(-1.5-dsP,sP)));  
304         (*fP)[stripP]  +=(Int_t)(EP*(F(0.5-dsP,sP)-F(-0.5-dsP,sP)));
305         (*fP)[stripP+1]+=(Int_t)(EP*(F(1.5-dsP,sP)-F(0.5-dsP,sP)));
306         (*fP)[stripP+2]+=(Int_t)(EP*(F(2.5-dsP,sP)-F(1.5-dsP,sP))); 
307         
308         (*fN)[stripN-1]+=(Int_t)(EN*(F(-0.5-dsN,sN)-F(-1.5-dsN,sN)));
309         (*fN)[stripN]  +=(Int_t)(EN*(F(0.5-dsN,sN)-F(-0.5-dsN,sN)));
310         (*fN)[stripN+1]+=(Int_t)(EN*(F(1.5-dsN,sN)-F(0.5-dsN,sN)));
311         (*fN)[stripN+2]+=(Int_t)(EN*(F(2.5-dsN,sN)-F(1.5-dsN,sN))); 
312         
313         x += dx; 
314         y += dy; 
315     }
316 }
317
318
319 //____________________________________________________________________
320 //
321 //  Private Methods for Simulation
322 //____________________________________________________________________
323 //                           
324
325
326
327 void AliITSmoduleSSD::ApplyNoise() {
328     
329     for(Int_t i = 0; i<kNStrips; i++) {
330         (*fP)[i] += (Int_t)gRandom->Gaus(0,fSNRatioP);
331         (*fN)[i] += (Int_t)gRandom->Gaus(0,fSNRatioN);
332     }
333 }
334
335 void AliITSmoduleSSD::ApplyCoupling() {
336     
337     for(Int_t i = 1; i<kNStrips-1; i++) {
338         (*fP)[i] += (Int_t)((*fP)[i-1]*fCouplingPL + (*fP)[i+1]*fCouplingPR);
339         (*fN)[i] += (Int_t)((*fN)[i-1]*fCouplingNL + (*fN)[i+1]*fCouplingNR);
340     }
341 }
342
343
344 //____________________________________________________________________
345 //
346 //  Private methods for geometry
347 //____________________________________________________________________
348 //                           
349
350
351
352 Int_t AliITSmoduleSSD::GetStripP(Float_t x, Float_t y) {
353     
354     Float_t  X = x - y*kTan;
355     Int_t strip = (Int_t)(X/kPitch);
356     strip = (strip<0)? -1: strip;
357     strip = (strip>kNStrips)? -1: strip;
358     return strip;
359 }
360
361 Int_t AliITSmoduleSSD::GetStripN(Float_t x, Float_t y) {
362     
363     Float_t  X = x - kTan*(kY - y);
364     Int_t strip = (Int_t)(X/kPitch);
365     strip = (strip<0)? -1: strip;
366     strip = (strip>kNStrips)? -1: strip;
367     return strip;
368
369 }
370
371 Float_t AliITSmoduleSSD::Get2StripP(Float_t x, Float_t y) {
372     
373     Int_t n = GetStripP(x,y);
374     return (x - y*kTan) / kPitch - n;
375 }
376
377 Float_t AliITSmoduleSSD::Get2StripN(Float_t x, Float_t y) {
378     
379     Int_t n = GetStripN(x,y);
380     return (x - kTan*(kY - y)) / kPitch - n;
381 }
382
383
384 Bool_t AliITSmoduleSSD::GetCrossing (Float_t &P, Float_t &N) {   
385
386     P *= kPitch;
387     N *= kPitch; 
388     
389     P = (kY * kTan + N + P)/2.0;         // x coordinate
390     N = kY - (P-N)/kTan;                 // y coordinate
391     
392     if (N<0 || N>kY) return kFALSE;
393     if (P<0 || P>kX) return kFALSE;
394     return kTRUE;   
395 }
396
397 //____________________________________________________________________
398
399
400