RICH/AliRICHSegmentationV1.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 "AliRICHSegmentationV1.h"
  19
  20 ClassImp(AliRICHSegmentationV1)
  21
  22 AliRICHSegmentationV1::AliRICHSegmentationV1()
  23 {
  24
  25 // Default constructor for AliRICHSegmantionV1 (with dead zones)
  26
  27    fNpx=144;      // number of pads along X direction
  28    fNpy=160;      // number of pads along Y direction
  29    fDeadZone=3.0; // space between CsI photocathods in cm
  30    fDpx=0.84;     // pad width in cm
  31    fDpy=0.80;     // pad heights in cm
  32    fWireD=0.84/2;
  33    fSector=-1;
  34    Init(0);       // ??? remove 0
  35 }
  36
  37 void AliRICHSegmentationV1::Init(Int_t /*id*/)
  38 {//Recalculates all the values after some of them have been changed
  39
  40    Float_t csi_length = fNpy*fDpy + fDeadZone;
  41    Float_t csi_width = fNpx*fDpx + 2*fDeadZone;
  42
  43    fPadPlane_Width = (csi_width - 2*fDeadZone)/3;
  44    fPadPlane_Length = (csi_length - fDeadZone)/2;
  45 }
  46
  47 // calculate sector from x-y coordinates
  48
  49 Int_t AliRICHSegmentationV1::Sector(Float_t x, Float_t y)
  50 {
  51
  52 // Calculate in which sector is the hit
  53
  54   fSector=-1;
  55
  56   //old numerical definition
  57
  58   /*if (x<-fDeadZone/2)
  59     {
  60       if (y>22.75)
  61         {
  62           if (y<63.1)
  63             fSector=0;
  64         }
  65       if (y<20.15)
  66         {
  67           if (y>(-20.15))
  68             fSector=2;
  69         }
  70       if (y<(-22.75))
  71         {
  72           if (y>(-63.1))
  73             fSector=4;
  74         }
  75     }
  76   else if (x>fDeadZone/2)
  77     {
  78       if (y>22.75)
  79         {
  80           if (y<63.1)
  81             fSector=1;
  82         }
  83       if (y<20.15)
  84         {
  85           if (y>(-20.15))
  86             fSector=3;
  87         }
  88       if (y<(-22.75))
  89         {
  90           if (y>(-63.1))
  91             fSector=5;
  92         }
  93     }*/
  94
  95   //Parametrized definition
  96
  97   if (y<-fDeadZone/2)
  98     {
  99       if (x> fPadPlane_Width/2 +fDeadZone)
 100         {
 101           if ( x<fPadPlane_Width/2 +fDeadZone + fPadPlane_Width)
 102             fSector=0;
 103         }
 104       if (x< fPadPlane_Width/2)
 105         {
 106           if (x> -( fPadPlane_Width/2))
 107             fSector=2;
 108         }
 109       if (x< -( fPadPlane_Width/2 +fDeadZone))
 110         {
 111           if (x> -( fPadPlane_Width/2 +fDeadZone +  fPadPlane_Width))
 112             fSector=4;
 113         }
 114     }
 115   else if (y>fDeadZone/2)
 116     {
 117       if (x> fPadPlane_Width/2 +fDeadZone)
 118         {
 119           if (x< fPadPlane_Width/2 +fDeadZone +  fPadPlane_Width)
 120             fSector=1;
 121         }
 122       if (x< fPadPlane_Width/2)
 123         {
 124           if (x> -( fPadPlane_Width/2))
 125             fSector=3;
 126         }
 127       if (x< -( fPadPlane_Width/2 +fDeadZone))
 128         {
 129           if (x> -( fPadPlane_Width/2 +fDeadZone +  fPadPlane_Width))
 130             fSector=5;
 131         }
 132     }
 133
 134
 135   //if (fSector==2)
 136     //printf("x:%f, y:%f, sector:%d\n",x,y,fSector);
 137
 138   return fSector;
 139 }
 140
 141
 142 void AliRICHSegmentationV1::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
 143 {
 144 //  returns pad coordinates (ix,iy) for given real coordinates (x,y)
 145 //
 146 // Please check origin of pad numbering !!!
 147
 148   Int_t sector=Sector(x,y);
 149
 150   //printf("Sector: %d\n",sector);
 151
 152   if (sector==0)
 153     {
 154       //ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx);
 155       //iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy);
 156       ix = Int_t ((x-fDeadZone)/fDpx);
 157       iy = Int_t ((y+fDeadZone/2)/fDpy)-1;
 158     }
 159   if (sector==1)
 160     {
 161       ix = Int_t ((x-fDeadZone)/fDpx);
 162       iy = Int_t ((y-fDeadZone/2)/fDpy);
 163     }
 164   if (sector==2)
 165     {
 166       ix = (x>=0)? ix = Int_t (x/fDpx) : ix = Int_t (x/fDpx)-1;
 167       iy = Int_t ((y+fDeadZone/2)/fDpy)-1;
 168     }
 169   if (sector==3)
 170     {
 171       ix = (x>=0)? ix = Int_t (x/fDpx) : ix = Int_t (x/fDpx)-1;
 172       iy = Int_t ((y-fDeadZone/2)/fDpy);
 173     }
 174   if (sector==4)
 175     {
 176       ix = Int_t ((x+fDeadZone)/fDpx)-1;
 177       iy = Int_t ((y+fDeadZone/2)/fDpy)-1;
 178     }
 179   if (sector==5)
 180     {
 181       ix = Int_t ((x+fDeadZone)/fDpx)-1;
 182       iy = Int_t ((y-fDeadZone/2)/fDpy);
 183     }
 184
 185
 186   //ix = Int_t (x/fDpx);
 187   //iy = Int_t (y/fDpy);
 188
 189   //ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx);
 190   //iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy);
 191
 192   if (sector==-1)
 193     {
 194       ix = fIxmax;
 195       iy = fIymax;
 196     }
 197
 198   if (iy >  fNpy) iy= fNpy;
 199   if (iy < -fNpy) iy=-fNpy;
 200   if (ix >  fNpx) ix= fNpx;
 201   if (ix < -fNpx) ix=-fNpx;
 202 }
 203
 204 void AliRICHSegmentationV1::
 205 GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
 206 {
 207 //  returns real coordinates (x,y) for given pad coordinates (ix,iy)
 208 //
 209
 210   //Int_t sector=Sector(ix*.8,iy*.84);
 211
 212   Int_t sector=-1;
 213
 214  // old numerical definition
 215
 216  /*if (ix<=0)
 217     {
 218       if (iy<=72)
 219         {
 220           if (iy>24)
 221             sector=0;
 222         }
 223       if (iy<=24)
 224         {
 225           if (iy>-24)
 226             sector=2;
 227         }
 228       if (iy<=-24)
 229         {
 230           if (iy>-72)
 231             sector=4;
 232         }
 233     }
 234   if (ix>0)
 235     {
 236       if (iy<=72)
 237         {
 238           if (iy>24)
 239             sector=1;
 240         }
 241       if (iy<=24)
 242         {
 243           if (iy>-24)
 244             sector=3;
 245         }
 246       if (iy<=-24)
 247         {
 248           if (iy>-72)
 249             sector=5;
 250         }
 251     }*/
 252
 253   //  parametrised definition
 254
 255   Float_t padplane_width = fNpx/3;
 256
 257   if (iy<0)
 258     {
 259       if (ix < fNpx/2)
 260         {
 261           if (ix >= padplane_width/2)
 262             sector=0;
 263         }
 264       if (ix< padplane_width/2)
 265         {
 266           if (ix >= -(padplane_width/2))
 267             sector=2;
 268         }
 269       if (ix >= -(fNpx/2))
 270         {
 271           if (ix < -(padplane_width/2))
 272             sector=4;
 273         }
 274     }
 275   if (iy>=0)
 276     {
 277       if (ix < fNpx/2)
 278         {
 279           if (ix >= padplane_width/2)
 280             sector=1;
 281         }
 282       if (ix< padplane_width/2)
 283         {
 284           if (ix >= -(padplane_width/2))
 285             sector=3;
 286         }
 287       if (ix >= -(fNpx/2))
 288         {
 289           if (ix < -(padplane_width/2))
 290             sector=5;
 291         }
 292     }
 293
 294   if (sector==0)
 295     {
 296       //x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)-fDpx/2.;
 297       //y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)-fDpy/2.;
 298       x = Float_t(ix)*fDpx+fDpx/2+fDeadZone;
 299       y = Float_t(iy)*fDpy+fDpy/2-fDeadZone/2;
 300     }
 301   if (sector==1)
 302     {
 303       x = Float_t(ix)*fDpx+fDpx/2+fDeadZone;
 304       y = Float_t(iy)*fDpy+fDpy/2+fDeadZone/2;
 305     }
 306   if (sector==2)
 307     {
 308       x = (ix>=0) ? x = Float_t(ix)*fDpx+fDpx/2 : x = Float_t(ix)*fDpx+fDpx/2;
 309       y = Float_t(iy)*fDpy+fDpy/2-fDeadZone/2;
 310     }
 311   if (sector==3)
 312     {
 313       x = (ix>=0) ? x = Float_t(ix)*fDpx+fDpx/2 : x = Float_t(ix)*fDpx+fDpx/2;
 314       y = Float_t(iy)*fDpy+fDpy/2+fDeadZone/2;
 315     }
 316   if (sector==4)
 317     {
 318       x = Float_t(ix)*fDpx+fDpx/2-fDeadZone;
 319       y = Float_t(iy)*fDpy+fDpy/2-fDeadZone/2;
 320     }
 321   if (sector==5)
 322     {
 323       x = Float_t(ix)*fDpx+fDpx/2-fDeadZone;
 324       y = Float_t(iy)*fDpy+fDpy/2+fDeadZone/2;
 325     }
 326
 327
 328   //if (sector==2)
 329     //printf("fSector:%d x:%f y:%f\n",fSector,x,y);
 330
 331 }
 332
 333 void AliRICHSegmentationV1::
 334 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
 335 {
 336
 337 // Calculates integration limits
 338
 339 /*
 340   x1=fXt-fX-fDpx/2.;
 341   x2=x1+fDpx;
 342   y1=fYt-fY-fDpy/2.;
 343   y2=y1+fDpy;
 344 */
 345   //Int_t sector=Sector(fX,fY);
 346
 347   //printf("Sector:%d\n",sector);
 348
 349   x1=fXhit-fX-fDpx/2.;
 350   x2=x1+fDpx;
 351   y1=fYhit-fY-fDpy/2.;
 352   y2=y1+fDpy;
 353 }
 354
 355
 356
 357
 358
 359