1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 //*********************************************************
19 // Segmentation classe for trigger chambers.
20 // The present version is a bit messy because, although the
21 // x,y positions are local, most of the methods use global
22 // strip numbering. The conversion is made via GetPadLoc2Glo.
23 // To be improved in the future.
24 //*********************************************************
28 #include "AliMUONTriggerSegmentation.h"
31 //___________________________________________
32 ClassImp(AliMUONTriggerSegmentation)
34 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation()
35 : AliMUONVGeometryDESegmentation(),
57 // add to St345SlatSegmentation
62 // add to St345SlatSegmentation
63 for (Int_t i=0; i<7; i++) {
74 //___________________________________________
75 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(Bool_t bending)
76 : AliMUONVGeometryDESegmentation(),
94 // add to St345SlatSegmentation
99 // Non default constructor
100 fNsec = 7; // 4 sector densities at most per slat
101 fNDiv = new TArrayI(fNsec);
102 fDpxD = new TArrayF(fNsec);
103 fDpyD = new TArrayF(fNsec);
104 (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;
105 (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;
106 (*fDpyD)[0]=(*fDpyD)[1]=(*fDpyD)[2]=(*fDpyD)[3]=0;
107 // add to St345SlatSegmentation
108 for (Int_t i=0; i<7; i++) {
118 //----------------------------------------------------------------------
119 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(const AliMUONTriggerSegmentation& rhs) : AliMUONVGeometryDESegmentation(rhs)
121 AliFatal("Not implemented.");
123 //----------------------------------------------------------------------
124 AliMUONTriggerSegmentation::~AliMUONTriggerSegmentation()
127 if (fNDiv) delete fNDiv;
128 if (fDpxD) delete fDpxD;
129 if (fDpyD) delete fDpyD;
131 //----------------------------------------------------------------------
132 AliMUONTriggerSegmentation& AliMUONTriggerSegmentation::operator=(const AliMUONTriggerSegmentation& rhs)
134 // Protected assignement operator
135 if (this == &rhs) return *this;
136 AliFatal("Not implemented.");
139 //----------------------------------------------------------------------
140 Int_t AliMUONTriggerSegmentation::ModuleColNum(Int_t ixGlo)
142 // returns column number (from 0 to 6) in which the (global) module
143 // ixGlo is sitting (could return 7 if ixGlow=isec)
144 return TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10-1;
146 //----------------------------------------------------------------------
147 Bool_t AliMUONTriggerSegmentation::HasPad(Int_t ix, Int_t iy)
149 // check if steping outside the limits (iy=1,2... iyGlo=0,1...)
150 Bool_t hasPad = true;
153 GetPadLoc2Glo(ix, iy, ixGlo, iyGlo);
154 if (iyGlo>=fNstrip[ModuleColNum(ixGlo)]) hasPad = false;
157 //____________________________________________________________________________
158 Float_t AliMUONTriggerSegmentation::Dpx(Int_t isec) const
160 // return x-strip width in sector isec
161 Float_t size = (isec<8) ? fStripXsize[isec-1] : fStripXsize[isec-2]/2.;
164 //____________________________________________________________________________
165 Float_t AliMUONTriggerSegmentation::Dpy(Int_t isec) const
167 // return y-strip width in sector isec
168 Float_t size = (isec<8) ? fStripYsize[isec-1] : fStripYsize[isec-2];
171 //----------------------------------------------------------------------------
172 void AliMUONTriggerSegmentation::GetPadLoc2Glo(Int_t ixLoc, Int_t iyLoc,
173 Int_t &ixGlo, Int_t &iyGlo)
175 // converts ixLoc & iyLoc into ixGlo & iyGLo (module,strip number)
176 ixGlo = 0; // see AliMUONTriggerConstants::fgkModuleI
177 iyGlo = 0; // from 0 to (fNtrip-1) in module
179 ixGlo = 10*fLineNumber + ixLoc;
181 } else if (!fBending) {
182 Int_t iCountStrip = 0;
183 for (Int_t iModule=0; iModule<fNsec; iModule++) {
184 for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) {
185 if ((ixLoc-1)==iCountStrip) {
186 ixGlo = 10*fLineNumber + iModule + 1;
193 // printf(" in GetPadLoc2Glo ixLoc iyLoc ixGlo iyGlo %i %i %i %i \n",ixLoc,iyLoc,ixGlo,iyGlo);
196 //----------------------------------------------------------------------------
197 void AliMUONTriggerSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
201 GetPadLoc2Glo(ix, iy, ixGlo, iyGlo);
205 // Returns real coordinates (x,y) for given pad coordinates (ix,iy)
208 Int_t iModule = ModuleColNum(ixGlo); // find column number (0-6)
211 x = fStripXsize[iModule]/ 2.;
213 x = fModuleXmax[iModule-1] + fStripXsize[iModule]/2.;
215 y = fModuleYmin[iModule] +
216 iyGlo*fStripYsize[iModule] + fStripYsize[iModule]/2.;
217 } else if (!fBending) {
218 if (ModuleColNum(ixGlo)==6 && iyGlo>7) {
219 x = fModuleXmin[iModule] + 8*fStripXsize[iModule] +
220 (iyGlo-8)*fStripXsize[iModule]/2. + fStripXsize[iModule]/4.;
222 x = fModuleXmin[iModule] +
223 iyGlo*fStripXsize[iModule] + fStripXsize[iModule]/2.;
225 y = fModuleYmin[iModule] + fStripYsize[iModule] / 2.;
227 x = x - fRpcHalfXsize;
228 y = y - fRpcHalfYsize;
230 // printf(" in GetPadC iModule ixloc iyloc ix iy x y %i %i %i %i %i %f %f \n",iModule,ixLoc,iyLoc,ix,iy,x,y);
233 //_____________________________________________________________________________
234 void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
236 // Returns pad coordinates (ix,iy) for given real coordinates (x,y)
238 x = x + fRpcHalfXsize;
239 y = y + fRpcHalfYsize;
240 // find module number
242 for (Int_t iModule=0; iModule<fNsec; iModule++) { // modules
243 if ( x > fModuleXmin[iModule] && x < fModuleXmax[iModule] ) {
244 ix = 10*fLineNumber + iModule;
251 Float_t yMax = fModuleYmin[modNum];
253 Float_t xMax = fModuleXmin[modNum];
255 for (Int_t iStrip=0; iStrip<fNstrip[modNum]; iStrip++) {
258 yMax = yMin + fStripYsize[modNum];
259 if (y > yMin && y < yMax) iy = iStrip;
260 } else if (!fBending) {
262 xMax = xMin + fStripXsize[modNum];
263 if (x > xMin && x < xMax) iy = iStrip;
267 // printf("in GetPadI ix iy x y %i %i %f %f \n",ix,iy,x,y);
269 //-------------------------------------------------------------------------
270 void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
272 GetPadI(x, y, ix, iy);
274 //____________________________________________________________________________
275 void AliMUONTriggerSegmentation::SetPadSize(Float_t p1, Float_t p2)
281 //-------------------------------------------------------------------------
282 void AliMUONTriggerSegmentation::SetLineNumber(Int_t iLineNumber){
283 fLineNumber = iLineNumber;
285 //-------------------------------------------------------------------------
286 void AliMUONTriggerSegmentation::SetPad(Int_t ix, Int_t iy)
289 // Sets virtual pad coordinates, needed for evaluating pad response
290 // outside the tracking program
291 GetPadC(ix,iy,fX,fY);
292 fSector=Sector(ix,iy);
294 //---------------------------------------------------------------------------
295 void AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y)
302 //----------------------------------------------------------------------------
303 void AliMUONTriggerSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
308 //--------------------------------------------------------------------------
309 Int_t AliMUONTriggerSegmentation::Sector(Int_t ix, Int_t iy)
311 // determine segmentation zone from pad coordinates (from 1 to 8)
314 GetPadLoc2Glo(ix, iy, ixGlo, iyGlo);
315 if (!fBending && ModuleColNum(ixGlo)==6 && iyGlo>7) {
316 return 8; // sector 8: diff. strip width within same module
318 return ModuleColNum(ixGlo)+1;
322 //-----------------------------------------------------------------------------
323 void AliMUONTriggerSegmentation::
324 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
327 // need to return (only) x4 = dist. betwwen the hit and the closest border of
330 Float_t xstrip,ystrip;
331 GetPadI(fXhit,fYhit,ix,iy);
332 GetPadC(ix,iy,xstrip,ystrip);
333 x1=fYhit; // hit y position
334 x2=ystrip; // y coordinate of the main strip
335 x3=fY; // current strip real y coordinate
337 // find the position of the 2 borders of the current strip
338 Float_t ymin = ystrip - fStripXsize[ModuleColNum(ixGlo)
340 fYofxsmin[ModuleNumber(fIx)][fIy];
341 Float_t ymax = fYofxsmax[ModuleNumber(fIx)][fIy];
343 // dist. between the hit and the closest border of the current strip
344 x4 = (TMath::Abs(ymax-x1) > TMath::Abs(ymin-x1)) ?
345 TMath::Abs(ymin-x1):TMath::Abs(ymax-x1);
347 // Returns integration limits for current pad
349 x1=fXhit-fX-Dpx(fSector)/2.;
351 y1=fYhit-fY-Dpy(fSector)/2.;
353 // printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
357 //-----------------------------------------------------------------------------
358 void AliMUONTriggerSegmentation::
359 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
361 // Returns list of next neighbours for given Pad (iX, iY)
373 Int_t sector = Sector(iX,iY);
375 if (iY+1 <= fNpyS[sector]) {
387 //--------------------------------------------------------------------------
388 void AliMUONTriggerSegmentation::Init(Int_t detectionElementId,
390 Float_t stripYsize[7],
391 Float_t stripXsize[7],
394 // printf(" fBending: %d \n",fBending);
397 if (fBending) nStripMax = nStrip[0];
399 for (Int_t i=0; i<7; i++) {
400 fNstrip[i]=nStrip[i];
401 fStripYsize[i]=stripYsize[i];
402 fStripXsize[i]=stripXsize[i];
405 // take care of offset in Y in chamber 5, first module
406 fModuleYmin[0] = offset;
409 Int_t npad = 0; // number of pad in x and y
410 for (Int_t iModule=0; iModule<fNsec; iModule++) { // modules
411 fModuleXmin[iModule] = tmp;
412 npad = npad + fNstrip[iModule];
414 fModuleXmax[iModule] =
415 fModuleXmin[iModule] + fStripXsize[iModule];
416 } else if (!fBending) {
418 fModuleXmax[iModule] =
419 fModuleXmin[iModule] +
420 fStripXsize[iModule]*fNstrip[iModule];
421 } else if (iModule==6) {
422 fModuleXmax[iModule] =
423 fModuleXmin[iModule] +
424 (fStripXsize[iModule]*fNstrip[iModule]/2) +
425 (fStripXsize[iModule]/2.*fNstrip[iModule]/2);
428 tmp = fModuleXmax[iModule];
430 // calculate nStripMax in x & y
432 if (fNstrip[iModule] > nStripMax) nStripMax = fNstrip[iModule];
433 } else if (!fBending) {
434 for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) nStripMax++;
438 // associate nStripMax
439 fNpx = (fBending) ? fNsec : nStripMax;
440 fNpy = (fBending) ? nStripMax : 1;
442 // calculate half size in x & y (to shift local coordinate ref. system)
446 for (Int_t iModule=0; iModule<fNsec; iModule++)
447 fRpcHalfXsize = fRpcHalfXsize + fStripXsize[iModule];
448 fRpcHalfYsize = fNstrip[1] * fStripYsize[1];
449 } else if (!fBending) {
450 fRpcHalfXsize = fModuleXmax[6];
451 fRpcHalfYsize = fStripYsize[1];
453 fRpcHalfXsize = fRpcHalfXsize / 2.;
454 fRpcHalfYsize = fRpcHalfYsize / 2.;
457 printf(" fNpx fNpy fRpcHalfXsize fRpcHalfYsize = %i %i %f %f \n",
458 fNpx,fNpy,fRpcHalfXsize,fRpcHalfYsize);
460 for (Int_t iModule=0; iModule<fNsec; iModule++) {
461 printf(" iModule fModuleXmin fModuleXmax fModuleYmin fStripXsize fStripYsize %i %f %f %f %f %f\n",
462 iModule,fModuleXmin[iModule],fModuleXmax[iModule],
463 fModuleYmin[iModule],
464 fStripXsize[iModule],fStripYsize[iModule]);
467 for (Int_t iModule=0; iModule<fNsec; iModule++) {
468 printf(" iModule fNstrip fStripXsize fStripYsize %i %i %f %f \n",
469 iModule,fNstrip[iModule],
470 fStripXsize[iModule],fStripYsize[iModule]);
476 // printf("npad = %i",npad);
478 fId = detectionElementId;