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