1 /////////////////////////////////////////////////////
2 // Segmentation and Response classes version 01 //
3 /////////////////////////////////////////////////////
9 #include "AliMUONv01.h"
14 //___________________________________________
15 ClassImp(AliMUONsegmentationV01)
17 AliMUONsegmentationV01::AliMUONsegmentationV01()
25 void AliMUONsegmentationV01::SetSegRadii(Float_t r[4])
27 for (Int_t i=0; i<4; i++) {
29 printf("\n R %d %f",i,fRSec[i]);
34 void AliMUONsegmentationV01::SetPadDivision(Int_t ndiv[4])
37 // Defines the pad size perp. to the anode wire (y) for different sectors.
39 for (Int_t i=0; i<4; i++) {
41 printf("\n Ndiv %d %d",i,fNDiv[i]);
47 void AliMUONsegmentationV01::Init(AliMUONchamber*)
50 // Fill the arrays fCx (x-contour) and fNpx (ix-contour) for each sector
51 // These arrays help in converting from real to pad co-ordinates and
55 printf("\n Initialise segmentation v01");
56 fNpy=Int_t(fRSec[fNsec-1]/fDpy)+1;
60 for (Int_t i=fNsec-2; i>=0; i--){
61 fDpxD[i]=fDpxD[fNsec-1]/fNDiv[i];
62 printf("\n dx %d %f",i,fDpxD[i]);
67 // fill the arrays defining the pad segmentation boundaries
72 for(isec=0; isec<fNsec; isec++) {
74 // loop over pads along the aode wires
75 for (Int_t iy=1; iy<=fNpy; iy++) {
77 Float_t x=iy*fDpy-fDpy/2;
78 if (x > fRSec[isec]) {
82 ry=TMath::Sqrt(fRSec[isec]*fRSec[isec]-x*x);
84 dnx= Int_t((ry-fCx[isec-1][iy])/fDpxD[isec]);
85 if (TMath::Odd(dnx)) dnx--;
86 fNpx[isec][iy]=fNpx[isec-1][iy]+dnx;
87 fCx[isec][iy]=fCx[isec-1][iy]+dnx*fDpxD[isec];
89 dnx=Int_t(ry/fDpxD[isec]);
91 if (TMath::Odd(dnx)) dnx--;
92 fCx[isec][iy]=dnx*fDpxD[isec];
100 for (Int_t iy=0; iy<fNpy; iy++) {
101 printf("\n iy %d",iy);
102 for(isec=0; isec<fNsec; isec++) {
106 printf("\n iy %d",iy);
107 for(isec=0; isec<fNsec; isec++) {
116 // for debugging only
117 for (Int_t ix=1; ix<100; ix++) {
118 for (Int_t iy=1; iy<100; iy++) {
119 GetPadCxy(ix,iy,x,y);
120 GetPadIxy(x,y,jx,jy);
121 if ((ix != jx) && (jx!=-1)) {
122 printf("\n %d %f %d %f", ix,x,iy,y);
123 printf("\n %d %f %d %f", jx,x,jy,y);
124 printf("\n \n **********");
130 Int_t AliMUONsegmentationV01::Sector(Int_t ix, Int_t iy)
132 Int_t absix=TMath::Abs(ix);
133 Int_t absiy=TMath::Abs(iy);
135 for (Int_t i=0; i<fNsec; i++) {
136 if (absix<=fNpx[i][absiy]){
145 Float_t AliMUONsegmentationV01::GetAnod(Float_t xhit)
148 // Finds anod-wire position closest to xhit
149 Float_t wire= (xhit<0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
150 // printf("getanod: %f %f %f ",xhit, wire, fWireD*wire);
154 void AliMUONsegmentationV01::
155 GetPadIxy(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
157 // returns pad coordinates (ix,iy) for given real coordinates (x,y)
159 iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy)-1;
160 if (iy > fNpy) iy= fNpy;
161 if (iy < -fNpy) iy=-fNpy;
165 Float_t absx=TMath::Abs(x);
166 Int_t absiy=TMath::Abs(iy);
167 for (Int_t i=0; isec < fNsec; i++) {
168 if (absx <= fCx[i][absiy]) {
174 ix= Int_t((absx-fCx[isec-1][absiy])/fDpxD[isec])
175 +fNpx[isec-1][absiy]+1;
176 } else if (isec == 0) {
177 ix= Int_t(absx/fDpxD[isec])+1;
179 ix=fNpx[fNsec-1][absiy]+1;
181 // printf("\n %d %d",isec,absiy);
186 void AliMUONsegmentationV01::
187 GetPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
189 // returns real coordinates (x,y) for given pad coordinates (ix,iy)
191 y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)+fDpy/2.;
194 Int_t isec=Sector(ix,iy);
196 Int_t absix=TMath::Abs(ix);
197 Int_t absiy=TMath::Abs(iy);
199 x=fCx[isec-1][absiy]+(absix-fNpx[isec-1][absiy])*fDpxD[isec];
200 x=(ix>0) ? x-fDpxD[isec]/2 : -x+fDpxD[isec]/2;
207 void AliMUONsegmentationV01::
208 GetSuperPadIxy(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
210 ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx)-1;
211 iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy)-1;
214 void AliMUONsegmentationV01::
215 GetSuperPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
217 x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)+fDpx/2.;
218 y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)+fDpy/2.;
221 void AliMUONsegmentationV01::SetPADSIZ(Float_t p1, Float_t p2)
227 void AliMUONsegmentationV01::
228 FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
231 // Find the wire position (center of charge distribution)
232 Float_t x0a=GetAnod(xhit);
234 // and take fNsigma*sigma around this center
235 Float_t x01=x0a - dx;
236 Float_t x02=x0a + dx;
237 Float_t y01=yhit - dy;
238 Float_t y02=yhit + dy;
240 // find the pads over which the charge distributes
241 GetPadIxy(x01,y01,fixmin,fiymin);
242 GetPadIxy(x02,y02,fixmax,fiymax);
246 // upper and lower limits should be checked
248 printf("\n FirstPad called");
249 printf("\n Hit Position %f %f",xhit,yhit);
250 printf("\n Closest wire %f", x0a);
251 printf("\n Integration limits: %i %i %i %i",fixmin,fixmax,fiymin,fiymax);
252 printf("\n Integration limits: %f %f %f %f \n",x01,x02,y01,y02);
255 // Set current pad to lower left corner
256 if (fixmax < fixmin) fixmax=fixmin;
257 if (fiymax < fiymin) fiymax=fiymin;
260 GetPadCxy(fix,fiy,fx,fy);
264 void AliMUONsegmentationV01::NextPad()
267 // Step to next pad in integration region
271 // step from left to right
272 if (fx < fxmax && fx != 0) {
275 } else if (fiy != fiymax) {
277 // get y-position of next row (yc), xc not used here
278 GetPadCxy(fix,fiy,xc,yc);
279 // get x-pad coordiante for 1 pad in row (fix)
280 GetPadIxy(fxmin,yc,fix,iyc);
282 printf("\n Error: Stepping outside integration region\n ");
284 GetPadCxy(fix,fiy,fx,fy);
285 fSector=Sector(fix,fiy);
286 // printf("\n this pad %f %f %d %d",fx,fy,fix,fiy);
290 Int_t AliMUONsegmentationV01::MorePads()
292 // Are there more pads in the integration region
294 if ((fx >= fxmax && fiy >= fiymax) || fy==0) {
301 void AliMUONsegmentationV01::SigGenInit(Float_t x,Float_t y,Float_t)
304 // Initialises pad and wire position during stepping
307 GetPadIxy(x,y,fixt,fiyt);
308 fiwt= (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
311 Int_t AliMUONsegmentationV01::SigGenCond(Float_t x,Float_t y,Float_t)
314 // Signal will be generated if particle crosses pad boundary or
315 // boundary between two wires.
317 GetPadIxy(x,y,ixt,iyt);
319 Int_t iwt=(x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1;
321 if ((ixt != fixt) || (iyt !=fiyt) || (iwt != fiwt)) {
328 void AliMUONsegmentationV01::
329 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
331 x1=fxt-fx-fDpxD[fSector]/2.;
332 x2=x1+fDpxD[fSector];
337 void AliMUONsegmentationV01::
338 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
340 const Float_t epsilon=fDpy/1000;
343 Int_t ixx, iyy, isec1;
345 Int_t isec0=Sector(iX,iY);
357 GetPadCxy(iX,iY,x,y);
358 GetPadIxy(x+epsilon,y+fDpy,ixx,iyy);
361 isec1=Sector(ixx,iyy);
364 // no sector boundary crossing
370 } else if (isec1 < isec0) {
371 // finer segmentation
381 // coarser segmenation
382 if (TMath::Odd(iX-fNpx[isec1-1][iY+1])) {
392 GetPadCxy(iX,iY,x,y);
393 GetPadIxy(x+epsilon,y-fDpy,ixx,iyy);
396 isec1=Sector(ixx,iyy);
399 // no sector boundary crossing
405 } else if (isec1 < isec0) {
406 // finer segmentation
416 // coarser segmenation
417 if (TMath::Odd(iX-fNpx[isec1-1][iY-1])) {
428 //___________________________________________
429 void AliMUONsegmentationV01::
430 FitXY(AliMUONRecCluster* Cluster,TClonesArray* MUONdigits)
431 // Default : Centre of gravity method
439 if (gAlice->TreeD()->GetReadEvent() != Cluster->GetCathod()+1)
440 // next line warns if in the future cathod 1 is not event 2 !
441 printf("ClusterFillXY : not reading the right cathod !\n");
442 for(Int_t clusDigit=Cluster->FirstDigitIndex();
443 clusDigit!=Cluster->InvalidDigitIndex();
444 clusDigit=Cluster->NextDigitIndex()) {
445 AliMUONdigit* pDigit=(AliMUONdigit*)MUONdigits->UncheckedAt(clusDigit);
446 GetPadCxy(pDigit->fPadX,pDigit->fPadY,xToAdd,yToAdd);
447 x+= xToAdd*pDigit->fSignal;
448 y+= yToAdd*pDigit->fSignal;
449 q+= (Float_t) pDigit->fSignal;