- Welding section on absorber side (LHCVC2C_001)
[u/mrichter/AliRoot.git] / MUON / AliMUONSegmentationSlatModule.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$ */
17
18 /////////////////////////////////////////////////////
19 //  Segmentation classes for slat modules          //
20 //  to be used with AluMUONSegmentationSlat        //
21 /////////////////////////////////////////////////////
22
23
24 #include "AliMUONSegmentationSlatModule.h"
25 #include "AliRun.h"
26 #include "AliMUON.h"
27 #include <TMath.h>
28 #include <Riostream.h>
29
30 #include "AliMUONSegmentationV01.h"
31
32 //___________________________________________
33 ClassImp(AliMUONSegmentationSlatModule)
34
35 AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule()  
36   : AliMUONSegmentationV0()
37 {
38 // Default constructor
39     fNDiv = 0;      
40     fDpxD = 0;  
41 }
42
43 AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule(Int_t nsec) 
44   : AliMUONSegmentationV0()
45 {
46 // Non default constructor
47     fNsec = nsec;
48     fNDiv = new TArrayI(fNsec);      
49     fDpxD = new TArrayF(fNsec);      
50     (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;     
51     (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;     
52 }
53
54 //----------------------------------------------------------------------
55 AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule(
56                                   const AliMUONSegmentationSlatModule& rhs)
57   :  AliMUONSegmentationV0(rhs) 
58 {
59 // Protected copy constructor
60
61   Fatal("AliMUONSegmentationSlatModule", "Not implemented.");
62 }
63
64
65 AliMUONSegmentationSlatModule::~AliMUONSegmentationSlatModule() 
66 {
67 // Destructor
68     if (fNDiv) delete fNDiv;
69     if (fDpxD) delete fDpxD;
70 }
71
72 //----------------------------------------------------------------------
73 AliMUONSegmentationSlatModule& 
74 AliMUONSegmentationSlatModule::operator=(        
75                                  const AliMUONSegmentationSlatModule& rhs)
76 {
77 // Protected assignement operator
78
79   if (this == &rhs) return *this;
80
81   Fatal("operator=", "Not implemented.");
82     
83   return *this;  
84 }    
85           
86 void AliMUONSegmentationSlatModule::SetPcbBoards(Int_t n[4])
87 {
88 //
89 // Set Pcb Board segmentation zones
90     for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
91 }
92
93
94 void AliMUONSegmentationSlatModule::SetPadDivision(Int_t ndiv[4])
95 {
96 //
97 // Defines the pad size perp. to the anode wire (y) for different sectors. 
98 // Pad sizes are defined as integral fractions ndiv of a basis pad size
99 // fDpx
100 // 
101     for (Int_t i=0; i<4; i++) {
102         (*fNDiv)[i]=ndiv[i];
103     }
104     ndiv[0]=ndiv[1];
105 }
106
107 Float_t AliMUONSegmentationSlatModule::Dpx(Int_t isec) const
108 {
109 // Return x-strip width
110     return (*fDpxD)[isec];
111
112
113
114 Float_t AliMUONSegmentationSlatModule::Dpy(Int_t /*isec*/) const
115 {
116 // Return y-strip width
117
118     return fDpy;
119 }
120
121
122 void AliMUONSegmentationSlatModule::
123 GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy) 
124 {
125 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
126 //
127     iy = Int_t(y/fDpy)+1;
128     if (iy >  fNpy) iy= fNpy;
129 //
130 //  Find sector isec
131     
132     Int_t isec=-1;
133     for (Int_t i=fNsec-1; i > 0; i--) {
134         if (x >= fCx[i-1]) {
135             isec=i;
136             if (fCx[isec] == fCx[isec-1]  && isec > 1) isec--;
137             break;
138         }
139     }
140
141     if (isec>0) {
142         ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
143             +fNpxS[isec-1]+1;
144     } else if (isec == 0) {
145         ix= Int_t(x/(*fDpxD)[isec])+1;
146     } else {
147         ix=0;
148         iy=0;
149     }
150 }
151
152 void AliMUONSegmentationSlatModule::
153 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y) 
154 {
155 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
156 //
157     y = Float_t(iy*fDpy)-fDpy/2.;
158 //
159 //  Find sector isec
160     Int_t isec=AliMUONSegmentationSlatModule::Sector(ix,iy);
161     if (isec == -1) printf("\n PadC %d %d %d  %d \n ", isec, fId, ix, iy);
162 //
163     if (isec>0) {
164         x = fCx[isec-1]+(ix-fNpxS[isec-1])*(*fDpxD)[isec];
165         x = x-(*fDpxD)[isec]/2;
166     } else {
167         x=y=0;
168     }
169 }
170 //-------------------------------------------------------------------------
171 void AliMUONSegmentationSlatModule::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
172 {
173   GetPadI(x, y, ix, iy);
174 }
175 //-------------------------------------------------------------------------
176 void AliMUONSegmentationSlatModule::
177 SetPad(Int_t ix, Int_t iy)
178 {
179     //
180     // Sets virtual pad coordinates, needed for evaluating pad response 
181     // outside the tracking program 
182     GetPadC(ix,iy,fX,fY);
183     fSector=Sector(ix,iy);
184 }
185
186 void AliMUONSegmentationSlatModule::
187 SetHit(Float_t x, Float_t y)
188 {
189 // Set current hit 
190 //
191     fXhit = x;
192     fYhit = y;
193     
194     if (x < 0) fXhit = 0;
195     if (y < 0) fYhit = 0;
196     
197     if (x >= fCx[fNsec-1]) fXhit = fCx[fNsec-1];
198     if (y >= fDyPCB)       fYhit = fDyPCB;
199
200     
201 }
202 //----------------------------------------------------------
203 void AliMUONSegmentationSlatModule::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
204 {
205   SetHit(xhit, yhit);
206 }
207 //----------------------------------------------------------
208 void AliMUONSegmentationSlatModule::
209 FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
210 {
211 // Initialises iteration over pads for charge distribution algorithm
212 //
213     //
214     // Find the wire position (center of charge distribution)
215     Float_t x0a=GetAnod(xhit);
216     fXhit=x0a;
217     fYhit=yhit;
218     //
219     // and take fNsigma*sigma around this center
220     Float_t x01=x0a  - dx;
221     Float_t x02=x0a  + dx;
222     Float_t y01=yhit - dy;
223     Float_t y02=yhit + dy;
224     if (x01 < 0) x01 = 0;
225     if (y01 < 0) y01 = 0;
226
227     if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1];
228
229     
230
231     Int_t isec=-1;
232     for (Int_t i=fNsec-1; i > 0; i--) {
233         if (x02 >= fCx[i-1]) {
234             isec=i;
235             if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
236             break;
237         }
238     }
239     y02 += Dpy(isec);
240     if (y02 >= fDyPCB) y02 = fDyPCB;
241    
242     //
243     // find the pads over which the charge distributes
244     GetPadI(x01,y01,fIxmin,fIymin);
245     GetPadI(x02,y02,fIxmax,fIymax);
246     
247     if (fIxmax > fNpx) fIxmax=fNpx;
248     if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];    
249
250     fXmin=x01;
251     fXmax=x02;    
252     fYmin=y01;
253     fYmax=y02;    
254   
255     // 
256     // Set current pad to lower left corner
257     if (fIxmax < fIxmin) fIxmax=fIxmin;
258     if (fIymax < fIymin) fIymax=fIymin;    
259     fIx=fIxmin;
260     fIy=fIymin;
261     
262     GetPadC(fIx,fIy,fX,fY);
263     fSector=Sector(fIx,fIy);
264 /*
265     printf("\n \n First Pad: %d %d %f %f %d %d %d %f" , 
266            fIxmin, fIxmax, fXmin, fXmax, fNpx, fId, isec, Dpy(isec));    
267     printf("\n \n First Pad: %d %d %f %f %d %d %d %f",
268            fIymin, fIymax, fYmin, fYmax,  fNpyS[isec], fId, isec, Dpy(isec));
269 */
270 }
271 //----------------------------------------------------------------------
272 void AliMUONSegmentationSlatModule::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
273 {
274   FirstPad(xhit, yhit, dx, dy);
275 }
276 //----------------------------------------------------------------------
277 void AliMUONSegmentationSlatModule::NextPad()
278 {
279 // Stepper for the iteration over pads
280 //
281 // Step to next pad in the integration region
282 //  step from left to right    
283     if (fIx != fIxmax) {
284         fIx++;
285         GetPadC(fIx,fIy,fX,fY);
286         fSector=Sector(fIx,fIy);
287 //  step up 
288     } else if (fIy != fIymax) {
289         fIx=fIxmin;
290         fIy++;
291         GetPadC(fIx,fIy,fX,fY);
292         fSector=Sector(fIx,fIy);
293
294     } else {
295         fIx=-1;
296         fIy=-1;
297     }
298 //    printf("\n Next Pad %d %d %f %f %d %d %d %d %d ", 
299 }
300
301
302 Int_t AliMUONSegmentationSlatModule::MorePads()
303 {
304 // Stopping condition for the iterator over pads
305 //
306 // Are there more pads in the integration region
307     
308     return  (fIx != -1  || fIy != -1);
309 }
310
311
312 Int_t AliMUONSegmentationSlatModule::Sector(Int_t ix, Int_t iy) 
313 {
314 //
315 // Determine segmentation zone from pad coordinates
316 //
317     Int_t isec=-1;
318     for (Int_t i=0; i < fNsec; i++) {
319         if (ix <= fNpxS[i]) {
320             isec=i;
321             break;
322         }
323     }
324     if (isec == -1) printf("\n Sector: Attention isec ! %d %d %d %d \n",
325                            fId, ix, iy,fNpxS[3]);
326
327     return isec;
328
329 }
330
331 void AliMUONSegmentationSlatModule::
332 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2) 
333 {
334 //  Returns integration limits for current pad
335 //
336
337     x1=fXhit-fX-Dpx(fSector)/2.;
338     x2=x1+Dpx(fSector);
339     y1=fYhit-fY-Dpy(fSector)/2.;
340     y2=y1+Dpy(fSector);    
341 //    printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
342
343 }
344
345 void AliMUONSegmentationSlatModule::
346 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]) 
347 {
348 // Returns list of next neighbours for given Pad (iX, iY)
349 //
350 //
351     Int_t i=0;
352 //    
353 //  step right
354     if (iX+1 <= fNpx) {
355         Xlist[i]=iX+1;
356         Ylist[i++]=iY;
357     }
358 //
359 //  step left    
360     if (iX-1 > 0) {
361         Xlist[i]=iX-1;
362         Ylist[i++]=iY;
363     }
364
365 //    
366 //  step up
367     if (iY+1 <= fNpy) {
368         Xlist[i]=iX;
369         Ylist[i++]=iY+1;
370     }
371 //
372 //  step down    
373     if (iY-1 > 0) {
374         Xlist[i]=iX;
375         Ylist[i++]=iY-1;
376     }
377
378     *Nlist=i;
379 }
380
381
382 void AliMUONSegmentationSlatModule::Init(Int_t chamber)
383 {
384 //
385 //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
386 //  These arrays help in converting from real to pad co-ordinates and
387 //  vice versa
388 //   
389 //  Segmentation is defined by rectangular modules approximating
390 //  concentric circles as shown below
391 //
392 //  PCB module size in cm
393   // printf("\n Initialise Segmentation SlatModule \n");
394
395     fDxPCB=40;
396     fDyPCB=40;
397 //
398 // number of pad rows per PCB
399 //    
400     Int_t nPyPCB=Int_t(fDyPCB/fDpy);
401 //
402 // maximum number of pad rows    
403     fNpy=nPyPCB;
404 //
405 //  Calculate padsize along x
406     (*fDpxD)[fNsec-1]=fDpx;
407     if (fNsec > 1) {
408         for (Int_t i=fNsec-2; i>=0; i--){
409             (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
410         }
411     }
412 //
413 // fill the arrays defining the pad segmentation boundaries
414 //
415 //  
416 //  Loop over sectors (isec=0 is the dead space surounding the beam pipe)
417     for (Int_t isec=0; isec<4; isec++) {
418         if (isec==0) {
419             fNpxS[0] = 0;
420             fNpyS[0] = 0;
421             fCx[0]   = 0;
422         } else {
423             fNpxS[isec]=fNpxS[isec-1] + fPcbBoards[isec]*Int_t(fDxPCB/(*fDpxD)[isec]);
424             fNpyS[isec]=fNpy;
425             fCx[isec]=fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
426         }
427     } // sectors
428 // maximum number of pad rows    
429     fNpy=nPyPCB;
430     fNpx=fNpxS[3];
431 //
432     fId = chamber;
433 }
434
435
436
437
438
439
440
441
442
443
444
445