MUON/AliMUONSegmentationTriggerX.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 /*
  17 $Log$
  18 Revision 1.5  2000/07/03 11:54:57  morsch
  19 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  20 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  21
  22 Revision 1.4  2000/06/29 12:34:09  morsch
  23 AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
  24 it usable with any other geometry class. The link to the object to which it belongs is
  25 established via an index. This assumes that there exists a global geometry manager
  26 from which the pointer to the parent object can be obtained (in our case gAlice).
  27
  28 Revision 1.3  2000/06/26 10:01:26  pcrochet
  29 global variables removed
  30
  31 Revision 1.2  2000/06/15 07:58:48  morsch
  32 Code from MUON-dev joined
  33
  34 Revision 1.1.2.1  2000/06/09 21:51:03  morsch
  35 Code from AliMUONSegResTrigger.cxx
  36
  37 */
  38
  39
  40
  41 /*
  42 Old Log:
  43 Revision 1.1.2.4  2000/04/26 12:33:25  morsch
  44 Minor changes in some methods (CP)
  45
  46 Revision 1.1.2.3  2000/03/20 18:14:16  morsch
  47 Missing sector added.
  48
  49 Revision 1.1.2.2  2000/02/20 07:50:49  morsch
  50 Bugs in Dpx, Dpy and ISector methods corrected (P.C.)
  51
  52 Revision 1.1.2.1  2000/02/17 14:33:49  morsch
  53 Draft version from P. Crochet
  54
  55 */
  56
  57 #include "AliMUONSegmentationTriggerX.h"
  58 #include "AliMUONTriggerConstants.h"
  59 #include "TMath.h"
  60 #include "TRandom.h"
  61 #include "TArc.h"
  62 #include "AliMUONChamber.h"
  63 #include <iostream.h>
  64 ClassImp(AliMUONSegmentationTriggerX)
  65
  66 //------------------------------------------------------------------
  67 void AliMUONSegmentationTriggerX::Init(Int_t chamber)
  68 {
  69 // intialize X segmentation
  70   cout << "Initialize Trigger Chamber Geometry X " << "\n";
  71   AliMUONSegmentationTrigger::Init(chamber);
  72
  73 // calculate x & y position of X strips
  74   Int_t nModule=AliMUONTriggerConstants::Nmodule();
  75   for (Int_t imodule=0; imodule<nModule; imodule++) {
  76     Float_t width=StripSizeX(AliMUONTriggerConstants::ModuleId(imodule));
  77     Int_t nStrip=AliMUONTriggerConstants::NstripX(imodule);
  78     for (Int_t istrip=0; istrip<nStrip; istrip++){
  79       fXofxsmin[imodule][istrip] = AliMUONTriggerConstants::XcMin(imodule)*fZscale;
  80       fXofxsmax[imodule][istrip] = AliMUONTriggerConstants::XcMax(imodule)*fZscale;
  81
  82       fYofxsmin[imodule][istrip] = (fYcmin[imodule]+width*(istrip))*fZscale;
  83       fYofxsmax[imodule][istrip] = (fYcmin[imodule]+width*(istrip+1))*fZscale;
  84     }
  85   }
  86 }
  87
  88 //------------------------------------------------------------------
  89 void AliMUONSegmentationTriggerX::GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy){
  90 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
  91 //  x,y = real coordinates; ix = module number , iy = strip number
  92   ix = 0;
  93   iy = 0;
  94   Int_t nModule=AliMUONTriggerConstants::Nmodule();
  95   for (Int_t imodule=0; imodule<nModule; imodule++) {
  96       Int_t nStrip=AliMUONTriggerConstants::NstripX(imodule);
  97       for (Int_t istrip=0; istrip<nStrip; istrip++){
  98           if (x>fXofxsmin[imodule][istrip]&&x<fXofxsmax[imodule][istrip]&&
  99               y>fYofxsmin[imodule][istrip]&&y<fYofxsmax[imodule][istrip]){
 100               ix = AliMUONTriggerConstants::ModuleId(imodule);
 101               iy = istrip;
 102           }
 103       }
 104   }
 105 }
 106
 107 //------------------------------------------------------------------
 108 void AliMUONSegmentationTriggerX::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y){
 109 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
 110 //  ix = module number , iy = strip number;  x,y = center of strip
 111   x = 0.;
 112   y = 0.;
 113   Int_t nModule=AliMUONTriggerConstants::Nmodule();
 114
 115   for (Int_t imodule=0; imodule<nModule; imodule++) {
 116     if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
 117       x=fXofxsmin[imodule][iy]+(fXofxsmax[imodule][iy]-fXofxsmin[imodule][iy])/2.;
 118       y=fYofxsmin[imodule][iy]+(fYofxsmax[imodule][iy]-fYofxsmin[imodule][iy])/2.;
 119     }
 120   }
 121 }
 122
 123 //------------------------------------------------------------------
 124 void AliMUONSegmentationTriggerX::SetPadSize(Float_t p1, Float_t p2)
 125 {
 126 //  Sets the padsize
 127 //
 128   fDpx=p1;
 129   fDpy=p2;
 130 }
 131
 132 //------------------------------------------------------------------
 133 void AliMUONSegmentationTriggerX::
 134 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[2], Int_t Ylist[2]){
 135 // Returns list of next neighbours for given Pad (ix, iy)
 136
 137   Int_t absiX=TMath::Abs(iX);
 138   *Nlist = 0;
 139
 140   if (absiX!=0) {
 141     Int_t numModule=ModuleNumber(absiX);
 142
 143     if (iY<AliMUONTriggerConstants::NstripX(numModule)-1) { // strip up in same module
 144       *Nlist=1;
 145       Xlist[0]=absiX;
 146       Ylist[0]=iY+1;
 147     }
 148
 149     if (iY>0) {                               // strip down in same module
 150       *Nlist=*Nlist+1;
 151       Xlist[*Nlist-1]=absiX;
 152       Ylist[*Nlist-1]=iY-1;
 153     }
 154
 155     if (iX<0) {                               // left side of chamber
 156       for (Int_t i=0; i<*Nlist; i++) {Xlist[i]=-Xlist[i];}
 157     }
 158   }
 159 }
 160
 161 //------------------------------------------------------------------
 162 void AliMUONSegmentationTriggerX::SetPad(Int_t ix, Int_t iy)
 163 {
 164   // Sets virtual pad coordinates, needed for evaluating pad response
 165   // outside the tracking program
 166   GetPadC(ix,iy,fX,fY);
 167   GetPadI(fX,fY,fIx,fIy);
 168   fSector=Sector(ix,iy);
 169 }
 170
 171 //------------------------------------------------------------------
 172 Int_t AliMUONSegmentationTriggerX::ISector()
 173 { return fSector;}
 174
 175 //------------------------------------------------------------------
 176 Int_t AliMUONSegmentationTriggerX::Ix()
 177 { return fIx;}
 178
 179 //------------------------------------------------------------------
 180 Int_t AliMUONSegmentationTriggerX::Iy()
 181 { return fIy;}
 182
 183 //------------------------------------------------------------------
 184 Float_t AliMUONSegmentationTriggerX::Dpx(Int_t isec)
 185 {
 186 // returns x size of x strips for sector isec
 187
 188   if (isec==1) {
 189     return 17.0*fZscale;
 190   } else if (isec==2) {
 191     return 34.0*fZscale;
 192   } else if (isec==3) {
 193     return 34.0*fZscale;
 194   } else if (isec==4) {
 195     return 34.0*fZscale;
 196   } else if (isec==5) {
 197     return 34.0*fZscale;
 198   } else if (isec==6) {
 199     return 68.0*fZscale;
 200   } else {
 201     return 0.;
 202   }
 203 }
 204
 205 //------------------------------------------------------------------
 206 Float_t AliMUONSegmentationTriggerX::Dpy(Int_t isec)
 207 {
 208 // returns y size of x strips for sector isec
 209
 210   if (isec==1) {
 211     return 1.0625*fZscale;
 212   } else if (isec==2) {
 213     return 1.0625*fZscale;
 214   } else if (isec==3) {
 215     return 1.0625*fZscale;
 216   } else if (isec==4) {
 217     return 2.125*fZscale;
 218   } else if (isec==5) {
 219     return 4.25*fZscale;
 220   } else if (isec==6) {
 221     return 4.25*fZscale;
 222   } else {
 223     return 0.;
 224   }
 225 }
 226
 227 //------------------------------------------------------------------
 228 void AliMUONSegmentationTriggerX::SetHit(Float_t xhit, Float_t yhit)
 229 {
 230 // set hit during disIntegration
 231 AliMUONSegmentationTrigger::SetHit(xhit,yhit);
 232 }
 233
 234 //------------------------------------------------------------------
 235 Int_t AliMUONSegmentationTriggerX::Sector(Int_t ix, Int_t iy)
 236 {
 237 // Returns sector number for given module
 238 //
 239
 240   Int_t absix=TMath::Abs(ix);
 241   Int_t iwidth=Int_t(StripSizeX(absix));
 242
 243   if (absix==52) {
 244     return 1;
 245   } else if (absix==41||absix==61) {
 246     return 2;
 247   } else if (iwidth==1) {
 248     return 3;
 249   } else if (iwidth==2) {
 250     return 4;
 251   } else if ((absix>=11&&absix<17)||(absix>=91&&absix<97)) {
 252     return 5;
 253   } else if (iwidth==4) {
 254     return 6;
 255   } else {
 256     return 0;
 257   }
 258 }
 259
 260 //------------------------------------------------------------------
 261 void AliMUONSegmentationTriggerX::
 262 IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& width)
 263 {
 264 // returns quantities needed to evaluate neighbour strip response
 265
 266   Int_t ix,iy;
 267   Float_t xstrip,ystrip;
 268   GetPadI(fXhit,fYhit,ix,iy);
 269   GetPadC(ix,iy,xstrip,ystrip);
 270   x1=fYhit;        // hit y position
 271   x2=ystrip;       // y coordinate of the main strip
 272   x3=fY;           // current strip real y coordinate
 273   width=StripSizeX(ix);   // width of the main strip
 274 }
 275
 276
 277
 278
 279
 280
 281
 282