MUON/AliMUONTriggerSegmentation.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 #include <TArrayI.h>
  20 #include <TArrayF.h>
  21 #include "AliMUONTriggerSegmentation.h"
  22 #include "AliLog.h"
  23
  24 //___________________________________________
  25 ClassImp(AliMUONTriggerSegmentation)
  26
  27 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation()
  28   : AliMUONVGeometryDESegmentation(),
  29     fBending(0),
  30     fId(0)
  31 {
  32   // default constructor
  33 }
  34 //___________________________________________
  35 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(Bool_t bending)
  36   : AliMUONVGeometryDESegmentation(),
  37     fBending(!bending),
  38     fId(0)
  39 //      fDpx(0),
  40 //      fDpy(0),
  41 //      fNpx(999999),
  42 //      fNpy(999999),
  43 //      fXhit(0.),
  44 //      fYhit(0.),
  45 //      fIx(0),
  46 //      fIy(0),
  47 //      fX(0.),
  48 //      fY(0.),
  49 //      fIxmin(0),
  50 //      fIxmax(0),
  51 //      fIymin(0),
  52 //      fIymax(0)
  53 {
  54   // Non default constructor
  55   fNsec = 7;  // 4 sector densities at most per slat
  56 /*  fNDiv = new TArrayI(fNsec);
  57   fDpxD = new TArrayF(fNsec);
  58   fDpyD = new TArrayF(fNsec);
  59   (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;
  60   (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;
  61   (*fDpyD)[0]=(*fDpyD)[1]=(*fDpyD)[2]=(*fDpyD)[3]=0;
  62 */
  63 }
  64 //----------------------------------------------------------------------
  65 AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(const AliMUONTriggerSegmentation& rhs) : AliMUONVGeometryDESegmentation(rhs)
  66 {
  67   AliFatal("Not implemented.");
  68 }
  69 //----------------------------------------------------------------------
  70 AliMUONTriggerSegmentation::~AliMUONTriggerSegmentation()
  71 {
  72   // Destructor
  73 /*  if (fNDiv) delete fNDiv;
  74   if (fDpxD) delete fDpxD;
  75   if (fDpyD) delete fDpyD;
  76 */
  77 }
  78 //----------------------------------------------------------------------
  79 AliMUONTriggerSegmentation& AliMUONTriggerSegmentation::operator=(const AliMUONTriggerSegmentation& rhs)
  80 {
  81   // Protected assignement operator
  82   if (this == &rhs) return *this;
  83   AliFatal("Not implemented.");
  84   return *this;
  85 }
  86 //____________________________________________________________________________
  87 Float_t AliMUONTriggerSegmentation::Dpx(Int_t isec) const
  88 {
  89     // Return x-strip width
  90     Int_t iModule = TMath::Abs(isec)-Int_t(TMath::Abs(isec)/10)*10 - 1;
  91     return fStripXsize[iModule];
  92 }
  93 //____________________________________________________________________________
  94 Float_t AliMUONTriggerSegmentation::Dpy(Int_t  isec) const
  95 {
  96 // Return x-strip width
  97     Int_t iModule = TMath::Abs(isec)-Int_t(TMath::Abs(isec)/10)*10 - 1;
  98     return fStripYsize[iModule];
  99 }
 100 //----------------------------------------------------------------------------
 101 void AliMUONTriggerSegmentation::GetPadLoc2Glo(Int_t ixLoc, Int_t iyLoc,
 102                                                Int_t &ixGlo, Int_t &iyGlo)
 103 {
 104     ixGlo = 0;
 105     iyGlo = 0;
 106     if (fBending) {
 107         ixGlo = (10 * fLineNumber) + ixLoc;
 108         iyGlo = iyLoc - 1;
 109     } else if (!fBending) {
 110         Int_t iCountStrip = 0;
 111         for (Int_t iModule=0; iModule<7; iModule++) {
 112             for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) {
 113                 if ((ixLoc-1)==iCountStrip) {
 114                     ixGlo = (10 * fLineNumber) + iModule + 1;
 115                     iyGlo = iStrip;
 116                 }
 117                 iCountStrip++;
 118             }
 119         }
 120     }
 121 //    printf(" in GetPadLoc2Glo ixLoc iyLoc ixGlo iyGlo %i %i %i %i \n",ixLoc,iyLoc,ixGlo,iyGlo);
 122
 123 }
 124 //----------------------------------------------------------------------------
 125 void AliMUONTriggerSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
 126 {
 127     Int_t ixLoc = ix;
 128     Int_t iyLoc = iy;
 129     Int_t ixGlo = 0;
 130     Int_t iyGlo = 0;
 131     GetPadLoc2Glo(ixLoc, iyLoc, ixGlo, iyGlo);
 132     ix = ixGlo;
 133     iy = iyGlo;
 134
 135     // Returns real coordinates (x,y) for given pad coordinates (ix,iy)
 136     x = 0.;
 137     y = 0.;
 138 // find module number
 139     Int_t iModule = TMath::Abs(ix)-Int_t(TMath::Abs(ix)/10)*10 - 1;
 140     if (fBending) {
 141         if (iModule==0) {
 142             x = (fModuleXmax[iModule] - fModuleXmin[iModule]) / 2.;
 143         } else {
 144         x = fModuleXmax[iModule-1] +
 145             (fModuleXmax[iModule] - fModuleXmin[iModule]) / 2.;
 146         }
 147         y = (iy * fStripYsize[iModule]) + fStripYsize[iModule]/2;
 148     } else if (!fBending) {
 149         x = fModuleXmin[iModule] +
 150             (iy * fStripXsize[iModule]) + fStripXsize[iModule]/2;
 151         y = fStripYsize[iModule] / 2;
 152     }
 153     x = x - fRpcHalfXsize;
 154     y = y - fRpcHalfYsize;
 155
 156 //    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);
 157 }
 158
 159 //_____________________________________________________________________________
 160 void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
 161 {
 162 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 163
 164     x = x + fRpcHalfXsize;
 165     y = y + fRpcHalfYsize;
 166 // find module number
 167     Int_t modNum=0;
 168     for (Int_t iModule=0; iModule<7; iModule++) { // modules
 169         if ( x > fModuleXmin[iModule] && x < fModuleXmax[iModule] ) {
 170             ix = (10 * fLineNumber) + iModule;
 171             modNum = iModule;
 172         }
 173     }
 174
 175 // find strip number
 176     Float_t yMin = 0.;
 177     Float_t yMax = fModuleYmin[modNum];
 178     Float_t xMin = 0.;
 179     Float_t xMax = fModuleXmin[modNum];
 180     if (ix!=0) {
 181         for (Int_t iStrip=0; iStrip<fNstrip[modNum]; iStrip++) {
 182             if (fBending) {
 183                 yMin = yMax;
 184                 yMax = yMin + fStripYsize[modNum];
 185                 if (y > yMin && y < yMax) iy = iStrip;
 186             } else {
 187                 xMin = xMax;
 188                 xMax = xMin + fStripXsize[modNum];
 189                 if (x > xMin && x < xMax) iy = iStrip;
 190             }
 191         } // loop on strips
 192     } // if ix!=0
 193 //    printf("in GetPadI ix iy x y %i %i %f %f \n",ix,iy,x,y);
 194 }
 195 //-------------------------------------------------------------------------
 196 void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
 197 {
 198   GetPadI(x, y, ix, iy);
 199 }
 200 //____________________________________________________________________________
 201 void AliMUONTriggerSegmentation::SetPadSize(Float_t p1, Float_t p2)
 202 {
 203   //  Sets the padsize
 204   fDpx=p1;
 205   fDpy=p2;
 206 }
 207 //-------------------------------------------------------------------------
 208 void AliMUONTriggerSegmentation::SetLineNumber(Int_t iLineNumber){
 209     fLineNumber = iLineNumber;
 210 }
 211 //-------------------------------------------------------------------------
 212 void AliMUONTriggerSegmentation::SetNstrip(Int_t nStrip[7]){
 213     for (Int_t i=0; i<7; i++) fNstrip[i]=nStrip[i];
 214 }
 215 //-------------------------------------------------------------------------
 216 void AliMUONTriggerSegmentation::SetStripYsize(Float_t stripYsize[7]){
 217     for (Int_t i=0; i<7; i++) fStripYsize[i]=stripYsize[i];
 218 }
 219 //-------------------------------------------------------------------------
 220 void AliMUONTriggerSegmentation::SetStripXsize(Float_t stripXsize[7]){
 221     for (Int_t i=0; i<7; i++) fStripXsize[i]=stripXsize[i];
 222 }
 223 //-------------------------------------------------------------------------
 224 void AliMUONTriggerSegmentation::SetPad(Int_t ix, Int_t iy)
 225 {
 226   //
 227   // Sets virtual pad coordinates, needed for evaluating pad response
 228   // outside the tracking program
 229   GetPadC(ix,iy,fX,fY);
 230   fSector=Sector(ix,iy);
 231 }
 232 //---------------------------------------------------------------------------
 233 void AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y)
 234 {
 235   // Set current hit
 236   //
 237   fXhit = x;
 238   fYhit = y;
 239
 240 }
 241 //----------------------------------------------------------------------------
 242 void AliMUONTriggerSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
 243 {
 244   SetHit(xhit, yhit);
 245 }
 246
 247 //--------------------------------------------------------------------------
 248 Int_t AliMUONTriggerSegmentation::Sector(Int_t ix, Int_t /*iy*/)
 249 {
 250   // Determine segmentation zone from pad coordinates
 251   return ix;
 252 }
 253 //-----------------------------------------------------------------------------
 254 void AliMUONTriggerSegmentation::
 255 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
 256 {
 257   //  Returns integration limits for current pad
 258   //
 259   x1=fXhit-fX-Dpx(fSector)/2.;
 260   x2=x1+Dpx(fSector);
 261   y1=fYhit-fY-Dpy(fSector)/2.;
 262   y2=y1+Dpy(fSector);
 263   //    printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
 264
 265 }
 266 //-----------------------------------------------------------------------------
 267 void AliMUONTriggerSegmentation::
 268 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
 269 {
 270   // Returns list of next neighbours for given Pad (iX, iY)
 271   Int_t i=0;
 272   //  step right
 273   if (iX+1 <= fNpx) {
 274     Xlist[i]=iX+1;
 275     Ylist[i++]=iY;
 276   }
 277   //  step left
 278   if (iX-1 > 0) {
 279     Xlist[i]=iX-1;
 280     Ylist[i++]=iY;
 281   }
 282   Int_t sector = Sector(iX,iY);
 283   //  step up
 284   if (iY+1 <= fNpyS[sector]) {
 285     Xlist[i]=iX;
 286     Ylist[i++]=iY+1;
 287   }
 288   //  step down
 289   if (iY-1 > 0) {
 290     Xlist[i]=iX;
 291     Ylist[i++]=iY-1;
 292   }
 293   *Nlist=i;
 294 }
 295
 296 //--------------------------------------------------------------------------
 297 void AliMUONTriggerSegmentation::Init(Int_t detectionElementId,
 298                                       Int_t iLineNumber,
 299                                       Int_t nStrip[7],
 300                                       Float_t stripYsize[7],
 301                                       Float_t stripXsize[7],
 302                                       Float_t offset)
 303 {
 304 //  printf(" fBending: %d \n",fBending);
 305 // WARNING: pay attention to the fucking length of the chamber
 306 // i.e. in the last module the y strip width varies within the module
 307 // (thank you General Tecnica!)
 308
 309   fLineNumber = iLineNumber;
 310   Int_t nStripMax = 0;
 311   if (fBending) nStripMax = nStrip[0];
 312
 313   for (Int_t i=0; i<7; i++) {
 314       fNstrip[i]=nStrip[i];
 315       fStripYsize[i]=stripYsize[i];
 316       fStripXsize[i]=stripXsize[i];
 317   }
 318
 319   Float_t tmp = 0.;
 320   Int_t npad = 0;  // number of pad in x and y
 321   for (Int_t iModule=0; iModule<7; iModule++) { // modules
 322       fModuleXmin[iModule] = tmp;
 323       npad = npad + fNstrip[iModule];
 324       if (fBending) {
 325           fModuleXmax[iModule] =
 326               fModuleXmin[iModule] + fStripXsize[iModule];
 327       } else if (!fBending) {
 328           if (iModule<6) {
 329               fModuleXmax[iModule] =
 330                   fModuleXmin[iModule] + fStripXsize[iModule]*fNstrip[iModule];
 331           } else if (iModule==6) {
 332               fModuleXmax[iModule] =
 333                   fModuleXmin[iModule] +
 334                   (fStripXsize[iModule]*fNstrip[iModule]/2) +
 335                   (fStripXsize[iModule]/2.*fNstrip[iModule]/2);
 336           }
 337       }
 338       tmp = fModuleXmax[iModule];
 339
 340 // calculate nStripMax in x & y
 341       if (fBending) {
 342           if (fNstrip[iModule] > nStripMax) nStripMax = fNstrip[iModule];
 343       } else if (!fBending) {
 344           for (Int_t iStrip=0; iStrip<fNstrip[iModule]; iStrip++) nStripMax++;
 345       }
 346   } // loop on modules
 347
 348 // take care of offset in Y in chamber 5, first module
 349   fModuleYmin[0] = offset;
 350
 351 // associate nStripMax
 352   if (fBending) {
 353       fNpx = 7;
 354       fNpy = nStripMax;
 355   } else if (!fBending) {
 356       fNpx = nStripMax;
 357       fNpy = 1;
 358   }
 359
 360 // calculate half size in x & y
 361   fRpcHalfXsize = 0;
 362   fRpcHalfYsize = 0;
 363   if (fBending) {
 364       for (Int_t iModule=0; iModule<7; iModule++)
 365           fRpcHalfXsize = fRpcHalfXsize + fStripXsize[iModule];
 366       fRpcHalfYsize = fNstrip[1] * fStripYsize[1];
 367   } else if (!fBending) {
 368       fRpcHalfXsize = fModuleXmax[6];
 369       fRpcHalfYsize = fStripYsize[1];
 370   }
 371   fRpcHalfXsize = fRpcHalfXsize / 2.;
 372   fRpcHalfYsize = fRpcHalfYsize / 2.;
 373
 374 /*
 375   printf(" fNpx fNpy fRpcHalfXsize fRpcHalfYsize = %i %i %f %f \n",
 376          fNpx,fNpy,fRpcHalfXsize,fRpcHalfYsize);
 377
 378   for (Int_t iModule=0; iModule<7; iModule++) {
 379       printf(" iModule fModuleXmin fModuleXmax fStripXsize fStripYsize %i %f %f %f %f\n",
 380              iModule,fModuleXmin[iModule],fModuleXmax[iModule],
 381              fStripXsize[iModule],fStripYsize[iModule]);
 382              }
 383 */
 384 //  printf("npad = %i",npad);
 385
 386   fId = detectionElementId;
 387 }
 388
 389
 390
 391
 392
 393
 394