MUON/AliMUONSegmentationV0.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 #include <TArc.h>
  19 #include <TMath.h>
  20
  21 #include "AliMUONSegmentationV0.h"
  22 #include "AliMUONChamber.h"
  23 #include "AliRun.h"
  24 #include "AliMUON.h"
  25 #include "AliLog.h"
  26
  27 ClassImp(AliMUONSegmentationV0)
  28
  29 AliMUONSegmentationV0::AliMUONSegmentationV0()
  30   : AliSegmentation()
  31 {
  32   fCorr=0;
  33   fChamber=0;
  34 }
  35
  36 AliMUONSegmentationV0::AliMUONSegmentationV0(const AliMUONSegmentationV0& segmentation)
  37   : AliSegmentation(segmentation)
  38 {
  39 // Protected copy constructor
  40
  41   AliFatal("Not implemented.");
  42 }
  43
  44
  45 /*
  46 // Commented out - not used
  47
  48 void AliMUONSegmentationV0::Init(Int_t  chamber)
  49 {
  50 //  Initialises member data of the segmentation from geometry data
  51 //  owned by Chamber
  52 //
  53
  54     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
  55     fChamber=&(pMUON->Chamber(chamber));
  56
  57 //  Initialise maximum number of pads in x ans y
  58     fNpx=(Int_t) (fChamber->ROuter()/fDpx+1);
  59     fNpy=(Int_t) (fChamber->ROuter()/fDpy+1);
  60 //  Initialize inner and outer radius of the sensitive region
  61     fRmin=fChamber->RInner();
  62     fRmax=fChamber->ROuter();
  63     fCorr=0;
  64     fZ=fChamber->Z();
  65     fId=chamber;
  66 }
  67 */
  68
  69 Float_t AliMUONSegmentationV0::GetAnod(Float_t xhit) const
  70 {
  71 // Returns for a hit position xhit the position of the nearest anode wire
  72     Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
  73     return fWireD*wire;
  74 }
  75 //____________________________________________________________________________
  76 void   AliMUONSegmentationV0::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t *Nparallel, Int_t *Offset)
  77 {
  78   *Nparallel=1;
  79   *Offset=0;
  80 }
  81
  82
  83 //____________________________________________________________________________
  84 void   AliMUONSegmentationV0::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
  85 {
  86   GetPadI(x, y, ix, iy);
  87 }
  88 //____________________________________________________________________________
  89 void   AliMUONSegmentationV0::SetCorrFunc(Int_t /*dum*/, TF1* func)
  90 {
  91   fCorr=func;
  92 }
  93 //____________________________________________________________________________
  94 Int_t   AliMUONSegmentationV0::Sector(Int_t /*ix*/, Int_t /*iy*/)
  95 {
  96   return 1;
  97 }
  98 //____________________________________________________________________________
  99 Int_t   AliMUONSegmentationV0::Sector(Float_t /*x*/, Float_t /*y*/)
 100 {
 101   return 1;
 102 }
 103 //____________________________________________________________________________
 104 void AliMUONSegmentationV0::SetPadSize(Float_t p1, Float_t p2)
 105 {
 106 //  Sets the padsize
 107 //
 108     fDpx=p1;
 109     fDpy=p2;
 110 }
 111
 112 void AliMUONSegmentationV0::
 113     GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
 114 {
 115 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 116 //
 117     ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx)-1;
 118     iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy)-1;
 119     if (iy >  fNpy) iy= fNpy;
 120     if (iy < -fNpy) iy=-fNpy;
 121     if (ix >  fNpx) ix= fNpx;
 122     if (ix < -fNpx) ix=-fNpx;
 123 }
 124
 125 void AliMUONSegmentationV0::
 126 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
 127 {
 128 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
 129 //
 130 // Comments and Critics:
 131
 132 //  The Pad(0,0) does not exist, this causes in the present version errors
 133 //  during iteration when used with hits close to zero.
 134 //  Since we have frame crosses at  x=0 or y=0 this does not cause any problems
 135 //  Nevertheless, should be corrected in the  next version !!
 136 //  The name fRmin is misleading although we use this version with
 137 //  a circular chamber geometry.
 138
 139     x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)+fDpx/2.;
 140     y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)+fDpy/2.;
 141 }
 142 //______________________________________________________________________
 143 void AliMUONSegmentationV0::SetHit(Float_t xhit, Float_t yhit)
 144 {
 145     //
 146     // Sets virtual hit position, needed for evaluating pad response
 147     // outside the tracking program
 148     fXhit=xhit;
 149     fYhit=yhit;
 150 }
 151 //_______________________________________________________________________
 152 void     AliMUONSegmentationV0::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
 153 {
 154   SetHit(xhit, yhit);
 155 }
 156 //_______________________________________________________________________
 157
 158
 159 void AliMUONSegmentationV0::
 160 SetPad(Int_t ix, Int_t iy)
 161 {
 162     //
 163     // Sets virtual pad coordinates, needed for evaluating pad response
 164     // outside the tracking program
 165     GetPadC(ix,iy,fX,fY);
 166 }
 167 //____________________________________________________________________________________
 168 void AliMUONSegmentationV0::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
 169 {
 170 // Initialises iteration over pads for charge distribution algorithm
 171 //
 172     //
 173     // Find the wire position (center of charge distribution)
 174     Float_t x0a=GetAnod(xhit);
 175     fXhit=x0a;
 176     fYhit=yhit;
 177     //
 178     // and take fNsigma*sigma around this center
 179     Float_t x01=x0a  - dx;
 180     Float_t x02=x0a  + dx;
 181     Float_t y01=yhit - dy;
 182     Float_t y02=yhit + dy;
 183     //
 184     // find the pads over which the charge distributes
 185     GetPadI(x01,y01,fIxmin,fIymin);
 186     GetPadI(x02,y02,fIxmax,fIymax);
 187     //
 188     // Set current pad to lower left corner
 189     fIx=fIxmin;
 190     fIy=fIymin;
 191     GetPadC(fIx,fIy,fX,fY);
 192 }
 193 //________________________________________________________________________
 194 void AliMUONSegmentationV0::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
 195         {FirstPad(xhit, yhit, dx, dy);}
 196
 197
 198 void AliMUONSegmentationV0::NextPad()
 199 {
 200   // Stepper for the iteration over pads
 201   //
 202   // Comments and Critics:
 203   // Boundary crossing at x=0 or y=0 not correctly handled !
 204   // Step to next pad in the integration region
 205     if (fIx != fIxmax) {
 206         if (fIx==-1) fIx++;
 207         fIx++;
 208     } else if (fIy != fIymax) {
 209         fIx=fIxmin;
 210         if (fIy==-1) fIy++;
 211         fIy++;
 212     } else {
 213         printf("\n Error: Stepping outside integration region\n ");
 214     }
 215     GetPadC(fIx,fIy,fX,fY);
 216 }
 217
 218 Int_t AliMUONSegmentationV0::MorePads()
 219 {
 220 // Stopping condition for the iterator over pads
 221 //
 222 // Are there more pads in the integration region ?
 223
 224     if (fIx == fIxmax && fIy == fIymax) {
 225         return 0;
 226     } else {
 227         return 1;
 228
 229     }
 230 }
 231
 232 void AliMUONSegmentationV0::SigGenInit(Float_t x,Float_t y,Float_t /*z*/)
 233 {
 234 //
 235 //  Initialises pad and wire position during stepping
 236     fXt =x;
 237     fYt =y;
 238     GetPadI(x,y,fIxt,fIyt);
 239     fIwt= (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
 240 }
 241
 242 Int_t AliMUONSegmentationV0::SigGenCond(Float_t x,Float_t y,Float_t /*z*/)
 243 {
 244 //  Signal generation condition during stepping
 245 //  0: don't generate signal
 246 //  1: generate signal
 247 //  Comments and critics:
 248
 249 //  Crossing of pad boundary and mid plane between neighbouring wires is checked.
 250 //  To correctly simulate the dependence of the spatial resolution on the angle
 251 //  of incidence signal must be generated for constant steps on
 252 //  the projection of the trajectory along the anode wire.
 253
 254 //
 255 //  Signal will be generated if particle crosses pad boundary or
 256 //  boundary between two wires.
 257     Int_t ixt, iyt;
 258     GetPadI(x,y,ixt,iyt);
 259     Int_t iwt=(x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1;
 260     if ((ixt != fIxt) || (iyt !=fIyt) || (iwt != fIwt)) {
 261         return 1;
 262     } else {
 263         return 0;
 264     }
 265 }
 266 void AliMUONSegmentationV0::
 267 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
 268 {
 269 //  Returns integration limits for current pad
 270 //
 271     x1=fXhit-fX-fDpx/2.;
 272     x2=x1+fDpx;
 273     y1=fYhit-fY-fDpy/2.;
 274     y2=y1+fDpy;
 275 }
 276
 277 void AliMUONSegmentationV0::
 278 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
 279 {
 280 // Returns list of next neighbours for given Pad (iX, iY)
 281 //
 282 // Comments and critics
 283 //     "Diagonal" neighbours are not passed
 284 //      Is this ok when we search for local maxima ??
 285 //      No test whether neighbours have valid indices id performed
 286     *Nlist=4;
 287     Xlist[0]=Xlist[1]=iX;
 288     Xlist[2]=iX-1;
 289     Xlist[3]=iX+1;
 290     Ylist[0]=iY-1;
 291     Ylist[1]=iY+1;
 292     Ylist[2]=Ylist[3]=iY;
 293 }
 294
 295 Float_t AliMUONSegmentationV0::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y
 296                                                   , Int_t * /*dummy*/)
 297 {
 298 // Returns the square of the distance between 1 pad
 299 // labelled by its Channel numbers and a coordinate
 300
 301   Float_t x,y;
 302   GetPadC(iX,iY,x,y);
 303   return (x-X)*(x-X) + (y-Y)*(y-Y);
 304 }
 305
 306
 307 void  AliMUONSegmentationV0::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
 308 {
 309 // Returns test point on the pad plane.
 310 // Used during determination of the segmoid correction of the COG-method
 311     n=1;
 312     x[0]=(fRmax+fRmin)/2/TMath::Sqrt(2.);
 313     y[0]=x[0];
 314 }
 315
 316 /*
 317 // Commented out - not used
 318
 319 void AliMUONSegmentationV0::Draw(const char *)
 320 {
 321 // Draws the segmentation zones
 322 //
 323     TArc *circle;
 324     Float_t scale=0.95/fRmax/2.;
 325
 326
 327     circle = new TArc(0.5,0.5,fRmax*scale,0.,360.);
 328     circle->SetFillColor(2);
 329     circle->Draw();
 330
 331     circle = new TArc(0.5,0.5,fRmin*scale,0.,360.);
 332     circle->SetFillColor(1);
 333     circle->Draw();
 334 }
 335 */
 336
 337 AliMUONSegmentationV0&
 338 AliMUONSegmentationV0::operator =(const AliMUONSegmentationV0 & rhs)
 339 {
 340 // Protected assignement operator
 341
 342   if (this == &rhs) return *this;
 343
 344   AliFatal("Not implemented.");
 345
 346   return *this;
 347 }