Logging of Debug, Info and Error Messages follwing AliRoot Standard http://aliweb...
[u/mrichter/AliRoot.git] / MUON / AliMUONSegmentationV01.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 and Response classes version 01   //
20 /////////////////////////////////////////////////////
21
22 #include <TBox.h> 
23 #include <TTUBE.h>
24 #include <TBRIK.h>
25 #include <TNode.h>  
26 #include <TGeometry.h>  
27 #include <TF1.h> 
28 #include <TVector3.h> 
29 #include <TObjArray.h>
30
31 #include "AliMUONSegmentationV01.h"
32 #include "AliMUON.h"
33 #include "AliMUONChamber.h"
34 #include "AliRun.h"
35 #include "AliLog.h"
36
37
38
39 //___________________________________________
40 ClassImp(AliMUONSegmentationV01)
41
42 AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
43   : AliMUONSegmentationV0(segmentation)
44 {
45 // Protected copy constructor
46
47   AliFatal("Not implemented.");
48 }
49
50 AliMUONSegmentationV01::AliMUONSegmentationV01() 
51   : AliMUONSegmentationV0()
52 {
53 // Default constructor
54     fRSec = 0;
55     fNDiv = 0;      
56     fDpxD = 0;
57     fCorrA = 0;
58     fSector = -1;
59 }
60
61 AliMUONSegmentationV01::AliMUONSegmentationV01(Int_t nsec) 
62   : AliMUONSegmentationV0()
63 {
64 //  Non default constructor
65
66     fNsec = nsec;
67     fRSec = new TArrayF(fNsec);
68     fNDiv = new TArrayI(fNsec);      
69     fDpxD = new TArrayF(fNsec);      
70
71
72     (*fRSec)[0]=(*fRSec)[1]=(*fRSec)[2]=(*fRSec)[3]=0;     
73     (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;     
74     (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;     
75     fCorrA = new TObjArray(3);
76     fCorrA->AddAt(0,0);
77     fCorrA->AddAt(0,1);
78     fCorrA->AddAt(0,2);
79     fOffsetY=0;
80     fSector = -1;
81
82
83 AliMUONSegmentationV01::~AliMUONSegmentationV01() 
84 {
85 // Destructor
86     if (fRSec) delete fRSec;
87     if (fNDiv) delete fNDiv;
88     if (fDpxD) delete fDpxD;
89     if (fCorrA) {
90         fCorrA->Delete();
91         delete fCorrA;
92     }
93
94
95
96 Float_t AliMUONSegmentationV01::Dpx(Int_t isec) const
97 {
98 //
99 // Returns x-pad size for given sector isec
100    Float_t dpx = (*fDpxD)[isec];
101    return dpx;
102 }
103
104 Float_t AliMUONSegmentationV01::Dpy(Int_t /*isec*/) const
105 {
106 //
107 // Returns y-pad size for given sector isec
108    return fDpy;
109 }
110     
111 void   AliMUONSegmentationV01::SetSegRadii(Float_t  r[4])
112 {
113 //
114 // Set the radii of the segmentation zones 
115     for (Int_t i=0; i<4; i++) {
116         (*fRSec)[i]=r[i];
117     }
118 }
119
120
121 void AliMUONSegmentationV01::SetPadDivision(Int_t ndiv[4])
122 {
123 //
124 // Defines the pad size perp. to the anode wire (y) for different sectors. 
125 // Pad sizes are defined as integral fractions ndiv of a basis pad size
126 // fDpx
127 // 
128     for (Int_t i=0; i<4; i++) {
129         (*fNDiv)[i]=ndiv[i];
130     }
131     ndiv[0]=ndiv[1];
132 }
133
134
135 void AliMUONSegmentationV01::Init(Int_t chamber)
136 {
137 //
138 //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
139 //  These arrays help in converting from real to pad co-ordinates and
140 //  vice versa.
141 //  This version approximates concentric segmentation zones
142 //
143
144     Int_t isec;
145     //printf("\n Initialise Segmentation V01\n");
146
147
148     fNpy=Int_t((*fRSec)[fNsec-1]/fDpy)+1;
149
150     (*fDpxD)[fNsec-1]=fDpx;
151     if (fNsec > 1) {
152         for (Int_t i=fNsec-2; i>=0; i--){
153             (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
154         }
155     }
156 //
157 // fill the arrays defining the pad segmentation boundaries
158     Float_t ry;
159     Int_t   dnx;
160     Int_t   add;
161 //
162 //  loop over sections
163     for(isec=0; isec<fNsec; isec++) {
164 //  
165 //  loop over pads along the aode wires
166         for (Int_t iy=1; iy<=fNpy; iy++) {
167 //
168             Float_t x=iy*fDpy-fDpy/2;
169             if (x > (*fRSec)[isec]) {
170                 fNpxS[isec][iy]=0;
171                 fCx[isec][iy]=0;
172             } else {
173                 ry=TMath::Sqrt((*fRSec)[isec]*(*fRSec)[isec]-x*x);
174                 if (isec > 1) {
175                     dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
176                     if (isec < fNsec-1) {
177                         if (TMath::Odd((Long_t)dnx)) dnx++;             
178                     }
179                     fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
180                     fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
181                 } else if (isec == 1) {
182                     dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
183                     fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
184                     add=4 - (fNpxS[isec][iy])%4;
185                     if (add < 4) fNpxS[isec][iy]+=add; 
186                     dnx=fNpxS[isec][iy]-fNpxS[isec-1][iy];
187                     fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
188                 } else {
189                     dnx=Int_t(ry/(*fDpxD)[isec]);
190                     fNpxS[isec][iy]=dnx;
191                     fCx[isec][iy]=dnx*(*fDpxD)[isec];
192                 }
193             }
194         } // y-pad loop
195     } // sector loop
196
197 // reference to chamber
198     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
199     fChamber=&(pMUON->Chamber(chamber));
200     fRmin=fChamber->RInner();
201     fRmax=fChamber->ROuter();    
202     fCorr=0;
203     fZ = fChamber->Z();
204     fId=chamber;
205 }
206
207 //______________________________________________________________________
208 Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
209 {
210 // Returns sector number for given pad position
211 //
212     Int_t absix=TMath::Abs(ix);
213     Int_t absiy=TMath::Abs(iy);
214     Int_t isec=0;
215     for (Int_t i=0; i<fNsec; i++) {
216         if (absix<=fNpxS[i][absiy]){
217             isec=i;
218             break;
219         }
220     }
221     return isec;
222 }
223
224 //______________________________________________________________________
225 void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
226 {
227 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
228 //
229     iy = (y-fOffsetY >0)? 
230       Int_t((y-fOffsetY)/fDpy)+1 
231       : 
232       Int_t((y-fOffsetY)/fDpy)-1;
233   
234     if (iy >  fNpy) iy= fNpy;
235     if (iy < -fNpy) iy=-fNpy;
236 //
237 //  Find sector isec
238     Int_t isec=-1;
239     Float_t absx=TMath::Abs(x);
240     Int_t absiy=TMath::Abs(iy);
241     for (Int_t i=0; i < fNsec; i++) {
242         if (absx <= fCx[i][absiy]) {
243             isec=i;
244             break;
245         }
246     }
247     if (isec>0) {
248         ix= Int_t((absx-fCx[isec-1][absiy])/(*fDpxD)[isec])
249             +fNpxS[isec-1][absiy]+1;
250     } else if (isec == 0) {
251         ix= Int_t(absx/(*fDpxD)[isec])+1;
252     } else {
253         ix=fNpxS[fNsec-1][absiy]+1;     
254     }
255     ix = (x>0) ? ix:-ix;
256 }
257 //________________________________________________________________
258 void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy) 
259 {
260   GetPadI(x, y, ix, iy);
261 }
262 //________________________________________________________________
263
264 void AliMUONSegmentationV01::
265 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
266 {
267 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
268 //
269     y = (iy>0) ?
270       Float_t(iy*fDpy)-fDpy/2.+fOffsetY
271       :
272       Float_t(iy*fDpy)+fDpy/2.+fOffsetY; 
273
274 //
275 //  Find sector isec
276     Int_t isec=AliMUONSegmentationV01::Sector(ix,iy);
277 //
278     Int_t absix=TMath::Abs(ix);
279     Int_t absiy=TMath::Abs(iy);
280     if (isec) {
281         x=fCx[isec-1][absiy]+(absix-fNpxS[isec-1][absiy])*(*fDpxD)[isec];
282         x=(ix>0) ?  x-(*fDpxD)[isec]/2 : -x+(*fDpxD)[isec]/2;
283     } else {
284         x=y=0;
285     }
286
287 }
288 //________________________________________________________________
289
290 void AliMUONSegmentationV01::
291 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z)
292 {
293 //  Returns real coordinates (x,y,z) for given pad coordinates (ix,iy)
294 //
295   GetPadC(ix,iy,x,y); 
296     
297   // To be properly interfaced with chamber geometry (AliMUONSt1GeometryBuilderV2) ???
298   TVector3 scale[4];  
299   scale[0] = TVector3( 1,  1,  1);  // quadrant I
300   scale[1] = TVector3(-1,  1, -1);  // quadrant II
301   scale[2] = TVector3(-1, -1,  1);  // quadrant III
302   scale[3] = TVector3( 1, -1, -1);  // quadrant IV
303
304   Int_t iQuadrant;
305   
306   if (ix > 0) {
307     if (iy > 0) {
308       iQuadrant = 0;
309     } else {
310       iQuadrant = 3;
311     }
312   } else {
313     if (iy > 0) {
314       iQuadrant = 1;
315     } else {
316       iQuadrant = 2;
317     }
318   }      
319   if (TMath::Abs(fZ) <  600) {
320     z = fZ + scale[iQuadrant].Z()*6.5/2.; // Station 1
321   } else {
322     z = fZ;  // Station 2
323   }
324 }
325
326 void AliMUONSegmentationV01::
327 SetPad(Int_t ix, Int_t iy)
328 {
329     //
330     // Sets virtual pad coordinates, needed for evaluating pad response 
331     // outside the tracking program 
332     GetPadC(ix,iy,fX,fY);
333     fSector=Sector(ix,iy);
334 }
335
336 //______________________________________________________________________
337 void AliMUONSegmentationV01::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
338 {
339 // Initialises iteration over pads for charge distribution algorithm
340 //
341     //
342     // Find the wire position (center of charge distribution)
343     Float_t x0a=GetAnod(xhit);
344     fXhit=x0a;
345     fYhit=yhit;
346     
347     //
348     // and take fNsigma*sigma around this center
349     Float_t x01=x0a  - dx;
350     Float_t x02=x0a  + dx;
351     Float_t y01=yhit - dy;
352     Float_t y02=yhit + dy;
353     //
354     // find the pads over which the charge distributes
355
356     GetPadI(x01,y01,fIxmin,fIymin);
357     GetPadI(x02,y02,fIxmax,fIymax);
358     fXmin=x01;
359     fXmax=x02;
360     fYmin=y01;
361     fYmax=y02;
362     
363     // 
364     // Set current pad to lower left corner
365     if (fIxmax < fIxmin) fIxmax=fIxmin;
366     if (fIymax < fIymin) fIymax=fIymin;    
367     fIx=fIxmin;
368     fIy=fIymin;
369     GetPadC(fIx,fIy,fX,fY);
370
371     // added 
372     if (fSector == -1) {
373       fSector=Sector(fIx,fIy);
374     }
375 }
376
377
378 void AliMUONSegmentationV01::NextPad()
379 {
380 // Stepper for the iteration over pads
381 //
382 // Step to next pad in the integration region
383   // 
384   // Step to next pad in integration region
385     Float_t xc,yc;
386     Int_t   iyc;
387     
388 //  step from left to right    
389
390     if (fX < fXmax && fX != 0) {
391         if (fIx==-1) fIx++;
392         fIx++;
393 //  step up 
394     } else if (fIy != fIymax) {
395         if (fIy==-1) fIy++;
396         fIy++;
397 //      get y-position of next row (yc), xc not used here       
398         GetPadC(fIx,fIy,xc,yc);
399 //      get x-pad coordiante for first pad in row (fIx)
400         GetPadI(fXmin,yc,fIx,iyc);
401     } else {
402         fIx=-1;
403         fIy=-1;
404     }
405     GetPadC(fIx,fIy,fX,fY);
406     fSector=Sector(fIx,fIy);
407     if (MorePads() && 
408         (fSector ==-1 || fSector==0)) 
409         NextPad();
410 }
411
412 Int_t AliMUONSegmentationV01::MorePads()
413
414 {
415 // Stopping condition for the iterator over pads
416 //
417 // Are there more pads in the integration region
418     return  (fIx != -1  || fIy != -1);
419 /*
420     if ((fX >= fXmax  && fIy >= fIymax) || fY==0) {
421         return 0;
422     } else {
423         return 1;
424     }
425 */
426 }
427 //______________________________________________________________________
428 void AliMUONSegmentationV01::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
429 {
430   FirstPad(xhit, yhit, dx, dy);
431 }
432
433
434 void AliMUONSegmentationV01::
435 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
436 {
437 //  Returns integration limits for current pad
438 //
439     x1=fXhit-fX-Dpx(fSector)/2.;
440     x2=x1+Dpx(fSector);
441     y1=fYhit-fY-Dpy(fSector)/2.;
442     y2=y1+Dpy(fSector);    
443 }
444
445 void AliMUONSegmentationV01::
446 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
447 {
448 // Returns list of next neighbours for given Pad (iX, iY)
449 //
450     const Float_t kEpsilon=fDpy/1000;
451     
452     Float_t x,y;
453     Int_t   ixx, iyy, isec1;
454 //
455     Int_t   isec0=AliMUONSegmentationV01::Sector(iX,iY);
456     Int_t i=0;
457 //    
458 //  step right
459     Xlist[i]=iX+1;
460     if (Xlist[i]==0) Xlist[i]++;
461     Ylist[i++]=iY;
462 //
463 //  step left    
464     Xlist[i]=iX-1;
465     if (Xlist[i]==0) Xlist[i]--;
466     Ylist[i++]=iY;
467 //
468 //  step up 
469     AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
470     AliMUONSegmentationV01::GetPadI(x+kEpsilon,y+fDpy,ixx,iyy);
471     Xlist[i]=ixx;
472     Ylist[i++]=iyy;
473     isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
474     if (isec1==isec0) {
475 //
476 //  no sector boundary crossing
477 //      Xlist[i]=ixx+1;
478 //      Ylist[i++]=iY+1;
479         
480 //      Xlist[i]=ixx-1;
481 //      Ylist[i++]=iY+1;
482     } else if (isec1 < isec0) {
483 // finer segmentation
484 //      Xlist[i]=ixx+1;
485 //      Ylist[i++]=iY+1;
486         
487         Xlist[i]=ixx-1;
488         Ylist[i++]=iyy;
489         
490 //      Xlist[i]=ixx-2;
491 //      Ylist[i++]=iY+1;
492     } else {
493 // coarser segmenation  
494 /*
495         if (TMath::Odd(iX-fNpxS[isec1-1][iY+1])) {
496             Xlist[i]=ixx-1;
497             Ylist[i++]=iY+1;
498         } else {
499             Xlist[i]=ixx+1;
500             Ylist[i++]=iY+1;
501         }
502 */
503     }
504
505 //
506 // step down 
507     AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
508     AliMUONSegmentationV01::GetPadI(x+kEpsilon,y-fDpy,ixx,iyy);
509     Xlist[i]=ixx;
510     Ylist[i++]=iyy;
511     isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
512     if (isec1==isec0) {
513 //
514 //  no sector boundary crossing
515 /*
516     Xlist[i]=ixx+1;
517     Ylist[i++]=iY-1;
518         
519     Xlist[i]=ixx-1;
520     Ylist[i++]=iY-1;
521 */
522     } else if (isec1 < isec0) {
523 // finer segmentation
524 //      Xlist[i]=ixx+1;
525 //      Ylist[i++]=iY-1;
526         
527         Xlist[i]=ixx-1;
528         Ylist[i++]=iyy;
529         
530 //      Xlist[i]=ixx-2;
531 //      Ylist[i++]=iY-1;
532     } else {
533 // coarser segmentation 
534 /*
535         if (TMath::Odd(iX-fNpxS[isec1-1][iY-1])) {
536             Xlist[i]=ixx-1;
537             Ylist[i++]=iY-1;
538         } else {
539             Xlist[i]=ixx+1;
540             Ylist[i++]=iY-1;
541         }
542 */
543     }
544     *Nlist=i;
545 }
546
547 void AliMUONSegmentationV01::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
548 {
549 // Returns test point on the pad plane.
550 // Used during determination of the segmoid correction of the COG-method
551
552     n=3;
553     x[0]=((*fRSec)[0]+(*fRSec)[1])/2/TMath::Sqrt(2.);
554     y[0]=x[0];
555     x[1]=((*fRSec)[1]+(*fRSec)[2])/2/TMath::Sqrt(2.);
556     y[1]=x[1];
557     x[2]=((*fRSec)[2]+(*fRSec)[3])/2/TMath::Sqrt(2.);
558     y[2]=x[2];
559 }
560
561 void AliMUONSegmentationV01::Draw(const char* opt)
562 {
563  
564 // Draws the segmentation zones
565 //
566   if (!strcmp(opt,"eventdisplay")) { 
567     const int kColorMUON  = kBlue;
568
569     TRotMatrix* rot000 = new TRotMatrix("Rot000"," ", 90,  0, 90, 90, 0, 0);
570     TRotMatrix* rot090 = new TRotMatrix("Rot090"," ", 90, 90, 90,180, 0, 0);
571     TRotMatrix* rot180 = new TRotMatrix("Rot180"," ", 90,180, 90,270, 0, 0);
572     TRotMatrix* rot270 = new TRotMatrix("Rot270"," ", 90,270, 90,  0, 0, 0);
573
574     char nameChamber[9], nameSense[9], nameFrame[9], nameNode[9];
575     char nameSense1[9], nameSense2[9];    
576     TNode *node, *nodeF;
577  
578     sprintf(nameChamber,"C_MUON%d",fId+1);
579     sprintf(nameSense,"S_MUON%d",fId+1);
580     sprintf(nameSense1,"S1_MUON%d",fId+1);
581     sprintf(nameSense2,"S2_MUON%d",fId+1);
582     sprintf(nameFrame,"F_MUON%d",fId+1);        
583
584     TNode* top=gAlice->GetGeometry()->GetNode("alice");
585
586     Float_t rmin = (*fRSec)[0]-3;
587     Float_t rmax = (*fRSec)[3]+3;
588     new TTUBE(nameChamber,"Mother","void",rmin,rmax,0.25,1.);
589     rmin = (*fRSec)[0];
590     rmax = (*fRSec)[3];
591     new TTUBE(nameSense,"Sens. region","void",rmin,rmax,0.25, 1.);
592     Float_t dx=(rmax-rmin)/2;
593     Float_t dy=3.;
594     Float_t dz=0.25;
595     TBRIK* frMUON = new TBRIK(nameFrame,"Frame","void",dx,dy,dz);
596     top->cd();
597     sprintf(nameNode,"MUON%d",100+fId+1);
598     node = new TNode(nameNode,"ChamberNode",nameChamber,0,0,fChamber->Z(),"");
599     node->SetLineColor(kColorMUON);
600     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
601     (pMUON->Nodes())->Add(node);
602     node->cd();
603     sprintf(nameNode,"MUON%d",200+fId+1);
604     node = new TNode(nameNode,"Sens. Region Node",nameSense,0,0,0,"");
605     node->SetLineColor(kColorMUON);
606     node->cd();
607     Float_t dr=dx+rmin;
608     sprintf(nameNode,"MUON%d",300+fId+1);
609     nodeF = new TNode(nameNode,"Frame0",frMUON,dr, 0, 0,rot000,"");
610     nodeF->SetLineColor(kColorMUON);
611     node->cd();
612     sprintf(nameNode,"MUON%d",400+fId+1);
613     nodeF = new TNode(nameNode,"Frame1",frMUON,0 ,dr,0,rot090,"");
614     nodeF->SetLineColor(kColorMUON);
615     node->cd();
616     sprintf(nameNode,"MUON%d",500+fId+1);
617     nodeF = new TNode(nameNode,"Frame2",frMUON,-dr,0,0,rot180,"");
618     nodeF->SetLineColor(kColorMUON);
619     node  ->cd();
620     sprintf(nameNode,"MUON%d",600+fId+1);   
621     nodeF = new TNode(nameNode,"Frame3",frMUON,0,-dr,0,rot270,"");
622     nodeF->SetLineColor(kColorMUON);   
623   } else {
624     TBox *box;
625     
626     Float_t dx=0.95/fCx[3][1]/2;
627     Float_t dy=0.95/(Float_t(Npy()))/2;
628     Float_t x0,y0,x1,y1;
629     Float_t xc=0.5;
630     Float_t yc=0.5;
631     
632     for (Int_t iy=1; iy<Npy(); iy++) {
633       for (Int_t isec=0; isec<4; isec++) {
634         if (isec==0) {
635           x0=0;
636           x1=fCx[isec][iy]*dx;
637         } else {
638           x0=fCx[isec-1][iy]*dx;
639           x1=fCx[isec][iy]*dx;
640         }
641         y0=Float_t(iy-1)*dy;
642         y1=y0+dy;
643         box=new TBox(x0+xc,y0+yc,x1+xc,y1+yc);
644         box->SetFillColor(isec+1);
645         box->Draw();
646         
647         box=new TBox(-x1+xc,y0+yc,-x0+xc,y1+yc);
648         box->SetFillColor(isec+1);
649         box->Draw();
650         
651         box=new TBox(x0+xc,-y1+yc,x1+xc,-y0+yc);
652         box->SetFillColor(isec+1);
653         box->Draw();
654         
655         box=new TBox(-x1+xc,-y1+yc,-x0+xc,-y0+yc);
656         box->SetFillColor(isec+1);
657         box->Draw();
658       }
659     }
660   }
661 }
662 void AliMUONSegmentationV01::SetCorrFunc(Int_t isec, TF1* func)
663 {
664 // Set the correction function
665     fCorrA->AddAt(func,isec);
666 }
667
668 TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
669
670 // Get correction function
671   //PH    return (TF1*) (*fCorrA)[isec];
672     return (TF1*) fCorrA->At(isec);
673 }
674
675 AliMUONSegmentationV01& 
676 AliMUONSegmentationV01::operator =(const AliMUONSegmentationV01 & rhs)
677 {
678 // Protected assignement operator
679
680   if (this == &rhs) return *this;
681
682   AliFatal("Not implemented.");
683     
684   return *this;  
685 }
686