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