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