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 **************************************************************************/
21 #include "AliMUONTriggerSegmentation.h"
24 //___________________________________________
25 ClassImp(AliMUONTriggerSegmentation)
27 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation()
28 : AliMUONVGeometryDESegmentation(),
50 // add to St345SlatSegmentation
55 // add to St345SlatSegmentation
56 for (Int_t i=0; i<7; i++) {
67 //___________________________________________
68 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(Bool_t bending)
69 : AliMUONVGeometryDESegmentation(),
87 // add to St345SlatSegmentation
92 // Non default constructor
93 fNsec = 4; // 4 sector densities at most per slat
94 fNDiv = new TArrayI(fNsec);
95 fDpxD = new TArrayF(fNsec);
96 fDpyD = new TArrayF(fNsec);
97 (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;
98 (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;
99 (*fDpyD)[0]=(*fDpyD)[1]=(*fDpyD)[2]=(*fDpyD)[3]=0;
100 // add to St345SlatSegmentation
101 for (Int_t i=0; i<7; i++) {
111 //----------------------------------------------------------------------
112 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(const AliMUONTriggerSegmentation& rhs) : AliMUONVGeometryDESegmentation(rhs)
114 AliFatal("Not implemented.");
116 //----------------------------------------------------------------------
117 AliMUONTriggerSegmentation::~AliMUONTriggerSegmentation()
120 if (fNDiv) delete fNDiv;
121 if (fDpxD) delete fDpxD;
122 if (fDpyD) delete fDpyD;
124 //----------------------------------------------------------------------
125 AliMUONTriggerSegmentation& AliMUONTriggerSegmentation::operator=(const AliMUONTriggerSegmentation& rhs)
127 // Protected assignement operator
128 if (this == &rhs) return *this;
129 AliFatal("Not implemented.");
132 //----------------------------------------------------------------------
133 Bool_t AliMUONTriggerSegmentation::HasPad(Int_t ix, Int_t iy)
135 // check if steping outside the limits
141 GetPadLoc2Glo(ixLoc, iyLoc, ixGlo, iyGlo);
142 Int_t iModule = TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10 - 1;
143 if ((iy-1)>=fNstrip[iModule]) hasPad = false;
146 //____________________________________________________________________________
147 Float_t AliMUONTriggerSegmentation::Dpx(Int_t isec) const
149 // Return x-strip width
151 Int_t iModule = TMath::Abs(isec)-Int_t(TMath::Abs(isec)/10)*10 - 1;
152 // printf ("iModule = %i\n",iModule);
155 size = fStripXsize[iModule];
156 } else if (iModule==7) {
157 size = fStripXsize[iModule-1]/2;
161 //____________________________________________________________________________
162 Float_t AliMUONTriggerSegmentation::Dpy(Int_t isec) const
164 // Return y-strip width
166 Int_t iModule = TMath::Abs(isec)-Int_t(TMath::Abs(isec)/10)*10 - 1;
168 size = fStripYsize[iModule];
169 } else if (iModule==7) {
170 size = fStripYsize[iModule-1];
174 //----------------------------------------------------------------------------
175 void AliMUONTriggerSegmentation::GetPadLoc2Glo(Int_t ixLoc, Int_t iyLoc,
176 Int_t &ixGlo, Int_t &iyGlo)
178 // converts ixLoc & iyLoc into ixGlo & iyGLo (module,strip number)
182 ixGlo = (10 * fLineNumber) + ixLoc;
184 } else if (!fBending) {
185 Int_t iCountStrip = 0;
186 for (Int_t iModule=0; iModule<7; iModule++) {
187 for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) {
188 if ((ixLoc-1)==iCountStrip) {
189 ixGlo = (10 * fLineNumber) + iModule + 1;
196 // printf(" in GetPadLoc2Glo ixLoc iyLoc ixGlo iyGlo %i %i %i %i \n",ixLoc,iyLoc,ixGlo,iyGlo);
199 //----------------------------------------------------------------------------
200 void AliMUONTriggerSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
206 GetPadLoc2Glo(ixLoc, iyLoc, ixGlo, iyGlo);
210 // Returns real coordinates (x,y) for given pad coordinates (ix,iy)
213 // find module number
214 Int_t iModule = TMath::Abs(ix)-Int_t(TMath::Abs(ix)/10)*10 - 1;
217 x = (fModuleXmax[iModule] - fModuleXmin[iModule]) / 2.;
219 x = fModuleXmax[iModule-1] +
220 (fModuleXmax[iModule] - fModuleXmin[iModule]) / 2.;
222 y = fModuleYmin[iModule] +
223 (iy * fStripYsize[iModule]) + fStripYsize[iModule]/2.;
224 } else if (!fBending) {
225 if (TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10==7 && iyGlo>7) {
226 x = fModuleXmin[iModule] + 7 * fStripXsize[iModule] +
227 ( (iy -8)* fStripXsize[iModule]/2.) + fStripXsize[iModule]/4.;
228 y = fModuleYmin[iModule] + fStripYsize[iModule] / 2.;
230 x = fModuleXmin[iModule] +
231 (iy * fStripXsize[iModule]) + fStripXsize[iModule]/2.;
232 y = fModuleYmin[iModule] + fStripYsize[iModule] / 2.;
235 x = x - fRpcHalfXsize;
236 y = y - fRpcHalfYsize;
238 // 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);
241 //_____________________________________________________________________________
242 void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
244 // Returns pad coordinates (ix,iy) for given real coordinates (x,y)
246 x = x + fRpcHalfXsize;
247 y = y + fRpcHalfYsize;
248 // find module number
250 for (Int_t iModule=0; iModule<7; iModule++) { // modules
251 if ( x > fModuleXmin[iModule] && x < fModuleXmax[iModule] ) {
252 ix = (10 * fLineNumber) + iModule;
259 Float_t yMax = fModuleYmin[modNum];
261 Float_t xMax = fModuleXmin[modNum];
263 for (Int_t iStrip=0; iStrip<fNstrip[modNum]; iStrip++) {
266 yMax = yMin + fStripYsize[modNum];
267 if (y > yMin && y < yMax) iy = iStrip;
270 xMax = xMin + fStripXsize[modNum];
271 if (x > xMin && x < xMax) iy = iStrip;
275 // printf("in GetPadI ix iy x y %i %i %f %f \n",ix,iy,x,y);
277 //-------------------------------------------------------------------------
278 void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
280 GetPadI(x, y, ix, iy);
282 //____________________________________________________________________________
283 void AliMUONTriggerSegmentation::SetPadSize(Float_t p1, Float_t p2)
289 //-------------------------------------------------------------------------
290 void AliMUONTriggerSegmentation::SetLineNumber(Int_t iLineNumber){
291 fLineNumber = iLineNumber;
293 //-------------------------------------------------------------------------
294 void AliMUONTriggerSegmentation::SetNstrip(Int_t nStrip[7]){
295 for (Int_t i=0; i<7; i++) fNstrip[i]=nStrip[i];
297 //-------------------------------------------------------------------------
298 void AliMUONTriggerSegmentation::SetStripYsize(Float_t stripYsize[7]){
299 for (Int_t i=0; i<7; i++) fStripYsize[i]=stripYsize[i];
301 //-------------------------------------------------------------------------
302 void AliMUONTriggerSegmentation::SetStripXsize(Float_t stripXsize[7]){
303 for (Int_t i=0; i<7; i++) fStripXsize[i]=stripXsize[i];
305 //-------------------------------------------------------------------------
306 void AliMUONTriggerSegmentation::SetPad(Int_t ix, Int_t iy)
309 // Sets virtual pad coordinates, needed for evaluating pad response
310 // outside the tracking program
311 GetPadC(ix,iy,fX,fY);
312 fSector=Sector(ix,iy);
314 //---------------------------------------------------------------------------
315 void AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y)
322 //----------------------------------------------------------------------------
323 void AliMUONTriggerSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
328 //--------------------------------------------------------------------------
329 Int_t AliMUONTriggerSegmentation::Sector(Int_t ix, Int_t iy)
331 // Determine segmentation zone from pad coordinates
336 GetPadLoc2Glo(ixLoc, iyLoc, ixGlo, iyGlo);
338 TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10==7 && iyGlo>7) {
339 return ixGlo + 1; // different strip width within same module
345 //-----------------------------------------------------------------------------
346 void AliMUONTriggerSegmentation::
347 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
349 // Returns integration limits for current pad
351 x1=fXhit-fX-Dpx(fSector)/2.;
353 y1=fYhit-fY-Dpy(fSector)/2.;
355 // printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
358 //-----------------------------------------------------------------------------
359 void AliMUONTriggerSegmentation::
360 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
362 // Returns list of next neighbours for given Pad (iX, iY)
374 Int_t sector = Sector(iX,iY);
376 if (iY+1 <= fNpyS[sector]) {
388 //--------------------------------------------------------------------------
389 void AliMUONTriggerSegmentation::Init(Int_t detectionElementId,
391 Float_t stripYsize[7],
392 Float_t stripXsize[7],
395 // printf(" fBending: %d \n",fBending);
398 if (fBending) nStripMax = nStrip[0];
400 for (Int_t i=0; i<7; i++) {
401 fNstrip[i]=nStrip[i];
402 fStripYsize[i]=stripYsize[i];
403 fStripXsize[i]=stripXsize[i];
406 // take care of offset in Y in chamber 5, first module
407 fModuleYmin[0] = offset;
410 Int_t npad = 0; // number of pad in x and y
411 for (Int_t iModule=0; iModule<7; iModule++) { // modules
412 fModuleXmin[iModule] = tmp;
413 npad = npad + fNstrip[iModule];
415 fModuleXmax[iModule] =
416 fModuleXmin[iModule] + fStripXsize[iModule];
417 } else if (!fBending) {
419 fModuleXmax[iModule] =
420 fModuleXmin[iModule] + 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++;
439 // associate nStripMax
443 } else if (!fBending) {
448 // calculate half size in x & y (to shift the local coordinate ref. system)
452 for (Int_t iModule=0; iModule<7; iModule++)
453 fRpcHalfXsize = fRpcHalfXsize + fStripXsize[iModule];
454 fRpcHalfYsize = fNstrip[1] * fStripYsize[1];
455 } else if (!fBending) {
456 fRpcHalfXsize = fModuleXmax[6];
457 fRpcHalfYsize = fStripYsize[1];
459 fRpcHalfXsize = fRpcHalfXsize / 2.;
460 fRpcHalfYsize = fRpcHalfYsize / 2.;
463 printf(" fNpx fNpy fRpcHalfXsize fRpcHalfYsize = %i %i %f %f \n",
464 fNpx,fNpy,fRpcHalfXsize,fRpcHalfYsize);
468 for (Int_t iModule=0; iModule<7; iModule++) {
469 printf(" iModule fModuleXmin fModuleXmax fModuleYmin fStripXsize fStripYsize %i %f %f %f %f %f\n",
470 iModule,fModuleXmin[iModule],fModuleXmax[iModule],
471 fModuleYmin[iModule],
472 fStripXsize[iModule],fStripYsize[iModule]);
475 for (Int_t iModule=0; iModule<7; iModule++) {
476 printf(" iModule fNstrip fStripXsize fStripYsize %i %i %f %f \n",
477 iModule,fNstrip[iModule],
478 fStripXsize[iModule],fStripYsize[iModule]);
484 // printf("npad = %i",npad);
486 fId = detectionElementId;