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 /* $Id$ */
  17
  18 #include <TMath.h>
  19 #include <TBRIK.h>
  20 #include <TNode.h>
  21 #include <TGeometry.h>
  22
  23 #include "AliMUON.h"
  24 #include "AliMUONSegmentationTriggerX.h"
  25 #include "AliMUONTriggerConstants.h"
  26 #include "AliMUONChamber.h"
  27 #include "AliRun.h"  // gAlice
  28 #include "AliLog.h"
  29
  30 ClassImp(AliMUONSegmentationTriggerX)
  31
  32 //------------------------------------------------------------------
  33 void AliMUONSegmentationTriggerX::Init(Int_t chamber)
  34 {
  35 // intialize X segmentation
  36   AliDebug(2,"Initialize Trigger Chamber Geometry X");
  37   AliMUONSegmentationTrigger::Init(chamber);
  38
  39 // calculate x & y position of X strips
  40   Int_t nModule=AliMUONTriggerConstants::Nmodule();
  41   for (Int_t imodule=0; imodule<nModule; imodule++) {
  42     Float_t width=StripSizeX(AliMUONTriggerConstants::ModuleId(imodule));
  43     Int_t nStrip=AliMUONTriggerConstants::NstripX(imodule);
  44     for (Int_t istrip=0; istrip<nStrip; istrip++){
  45       fXofxsmin[imodule][istrip] = AliMUONTriggerConstants::XcMin(imodule)*fZscale;
  46       fXofxsmax[imodule][istrip] = AliMUONTriggerConstants::XcMax(imodule)*fZscale;
  47
  48       fYofxsmin[imodule][istrip] = (fYcmin[imodule]+width*(istrip))*fZscale;
  49       fYofxsmax[imodule][istrip] = (fYcmin[imodule]+width*(istrip+1))*fZscale;
  50 /*
  51       if (TMath::Abs(AliMUONTriggerConstants::ModuleId(imodule))==11) {
  52           printf("module Id istrip fXofxsmin fXofxsmax fYofxsmin fYofxsmax %d %d %f %f %f %f \n",
  53                  AliMUONTriggerConstants::ModuleId(imodule),
  54                  istrip,
  55                  fXofxsmin[imodule][istrip],
  56                  fXofxsmax[imodule][istrip],
  57                  fYofxsmin[imodule][istrip],
  58                  fYofxsmax[imodule][istrip]);
  59       }
  60 */
  61     }
  62   }
  63 }
  64
  65 //------------------------------------------------------------------
  66 void AliMUONSegmentationTriggerX::GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy)
  67 {
  68 //  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
  69 //  x,y = real coordinates; ix = module number , iy = strip number
  70   ix = 0;
  71   iy = 0;
  72   Int_t nModule=AliMUONTriggerConstants::Nmodule();
  73   for (Int_t imodule=0; imodule<nModule; imodule++) {
  74       Int_t nStrip=AliMUONTriggerConstants::NstripX(imodule);
  75       for (Int_t istrip=0; istrip<nStrip; istrip++){
  76           if (x>fXofxsmin[imodule][istrip]&&x<fXofxsmax[imodule][istrip]&&
  77               y>fYofxsmin[imodule][istrip]&&y<fYofxsmax[imodule][istrip]){
  78               ix = AliMUONTriggerConstants::ModuleId(imodule);
  79               iy = istrip;
  80           }
  81       }
  82   }
  83 }
  84
  85 //------------------------------------------------------------------
  86 void AliMUONSegmentationTriggerX::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
  87 {
  88 //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
  89 //  ix = module number , iy = strip number;  x,y = center of strip
  90   x = 0.;
  91   y = 0.;
  92   Int_t nModule=AliMUONTriggerConstants::Nmodule();
  93
  94   for (Int_t imodule=0; imodule<nModule; imodule++) {
  95     if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
  96       x=fXofxsmin[imodule][iy]+(fXofxsmax[imodule][iy]-fXofxsmin[imodule][iy])/2.;
  97       y=fYofxsmin[imodule][iy]+(fYofxsmax[imodule][iy]-fYofxsmin[imodule][iy])/2.;
  98     }
  99   }
 100 }
 101
 102 //------------------------------------------------------------------
 103 void AliMUONSegmentationTriggerX::SetPadSize(Float_t p1, Float_t p2)
 104 {
 105 //  Sets the padsize
 106 //
 107   fDpx=p1;
 108   fDpy=p2;
 109 }
 110
 111 //------------------------------------------------------------------
 112 void AliMUONSegmentationTriggerX::
 113 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]){
 114 // Returns list of 10 next neighbours for given X strip (ix, iy)
 115 // neighbour number 4 in the list -
 116 // neighbour number 3 in the list  |
 117 // neighbour number 2 in the list  |_ Upper part
 118 // neighbour number 1 in the list  |
 119 // neighbour number 0 in the list -
 120 //      X strip (ix, iy)
 121 // neighbour number 5 in the list -
 122 // neighbour number 6 in the list  | _ Lower part
 123 // neighbour number 7 in the list  |
 124 // neighbour number 8 in the list  |
 125 // neighbour number 9 in the list -
 126
 127   Int_t absiX = TMath::Abs(iX);
 128   Int_t numModule = ModuleNumber(absiX);   // module number Id.
 129   Int_t nStrip = AliMUONTriggerConstants::NstripX(numModule); //numb of strips
 130   Int_t iCandidateUp, iCandidateDo;
 131   Int_t j;
 132
 133   *Nlist = 10;
 134   for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;
 135
 136   if (iY < nStrip) {
 137
 138     for (Int_t i=0; i<5; i++) {
 139       j = i + 5;
 140       iCandidateUp = iY + (i + 1);
 141       iCandidateDo = iY - (i + 1);
 142       if (iCandidateUp < nStrip) {
 143         Xlist[i] = iX;
 144         Ylist[i] = iCandidateUp;
 145       }
 146       if (iCandidateDo >= 0) {
 147         Xlist[j] = iX;
 148         Ylist[j] = iCandidateDo;
 149       }
 150     }
 151
 152   } // iY < nStrip
 153 }
 154
 155 //------------------------------------------------------------------
 156 void AliMUONSegmentationTriggerX::SetPad(Int_t ix, Int_t iy)
 157 {
 158   // Sets virtual pad coordinates, needed for evaluating pad response
 159   // outside the tracking program
 160   GetPadC(ix,iy,fX,fY);
 161   GetPadI(fX,fY,fIx,fIy);
 162   fSector=Sector(ix,iy);
 163 }
 164
 165 //------------------------------------------------------------------
 166 Int_t AliMUONSegmentationTriggerX::ISector()
 167 { return fSector;}
 168
 169 //------------------------------------------------------------------
 170 Int_t AliMUONSegmentationTriggerX::Ix()
 171 { return fIx;}
 172
 173 //------------------------------------------------------------------
 174
 175 Int_t AliMUONSegmentationTriggerX::Iy()
 176 { return fIy;}
 177
 178 //------------------------------------------------------------------
 179 Float_t AliMUONSegmentationTriggerX::Dpx(Int_t isec) const
 180 {
 181 // returns x size of x strips for sector isec
 182
 183   if (isec==1) {
 184     return AliMUONTriggerConstants::StripLength(0)*fZscale;
 185   } else if (isec==2) {
 186     return AliMUONTriggerConstants::StripLength(1)*fZscale;
 187   } else if (isec==3) {
 188     return AliMUONTriggerConstants::StripLength(1)*fZscale;
 189   } else if (isec==4) {
 190     return AliMUONTriggerConstants::StripLength(1)*fZscale;
 191   } else if (isec==5) {
 192     return AliMUONTriggerConstants::StripLength(1)*fZscale;
 193   } else if (isec==6) {
 194     return AliMUONTriggerConstants::StripLength(2)*fZscale;
 195   } else {
 196     return 0.;
 197   }
 198 }
 199
 200 //------------------------------------------------------------------
 201 Float_t AliMUONSegmentationTriggerX::Dpy(Int_t isec) const
 202 {
 203 // returns y size of x strips for sector isec
 204
 205   if (isec==1) {
 206     return AliMUONTriggerConstants::StripWidth(0)*fZscale;
 207   } else if (isec==2) {
 208     return AliMUONTriggerConstants::StripWidth(0)*fZscale;
 209   } else if (isec==3) {
 210     return AliMUONTriggerConstants::StripWidth(0)*fZscale;
 211   } else if (isec==4) {
 212     return AliMUONTriggerConstants::StripWidth(1)*fZscale;
 213   } else if (isec==5) {
 214     return AliMUONTriggerConstants::StripWidth(2)*fZscale;
 215   } else if (isec==6) {
 216     return AliMUONTriggerConstants::StripWidth(2)*fZscale;
 217   } else {
 218     return 0.;
 219   }
 220 }
 221
 222 //------------------------------------------------------------------
 223 void AliMUONSegmentationTriggerX::GetPadI(Float_t x, Float_t y, Float_t /*z*/, Int_t &ix, Int_t &iy)
 224 {
 225   GetPadI(x, y, ix, iy);
 226 }
 227
 228 //------------------------------------------------------------------
 229 void AliMUONSegmentationTriggerX::SetHit(Float_t xhit, Float_t yhit)
 230 {
 231 // set hit during disIntegration
 232 AliMUONSegmentationTrigger::SetHit(xhit,yhit);
 233 }
 234 //------------------------------------------------------------------
 235 void AliMUONSegmentationTriggerX::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
 236 {
 237   SetHit(xhit, yhit);
 238 }
 239
 240 //------------------------------------------------------------------
 241 Int_t AliMUONSegmentationTriggerX::Sector(Int_t ix, Int_t /*iy*/)
 242 {
 243 // Returns sector number for given module
 244 //
 245
 246   Int_t absix=TMath::Abs(ix);
 247   Int_t iwidth=Int_t(StripSizeX(absix));
 248
 249   if (absix==52) {
 250     return 1;
 251   } else if (absix==41||absix==61) {
 252     return 2;
 253   } else if (iwidth==1) {
 254     return 3;
 255   } else if (iwidth==2) {
 256     return 4;
 257   } else if ((absix>=11&&absix<17)||(absix>=91&&absix<97)) {
 258     return 5;
 259   } else if (iwidth==4) {
 260     return 6;
 261   } else {
 262     return 0;
 263   }
 264 }
 265
 266 //------------------------------------------------------------------
 267 void AliMUONSegmentationTriggerX::
 268 IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4)
 269 {
 270 // returns quantities needed to evaluate neighbour strip response
 271
 272   Int_t ix,iy;
 273   Float_t xstrip,ystrip;
 274   GetPadI(fXhit,fYhit,ix,iy);
 275   GetPadC(ix,iy,xstrip,ystrip);
 276   x1=fYhit;        // hit y position
 277   x2=ystrip;       // y coordinate of the main strip
 278   x3=fY;           // current strip real y coordinate
 279   //  width=StripSizeX(ix);   // width of the main strip
 280
 281   // find the position of the 2 borders of the current strip
 282   Float_t ymin = fYofxsmin[ModuleNumber(fIx)][fIy];
 283   Float_t ymax = fYofxsmax[ModuleNumber(fIx)][fIy];
 284
 285   // dist. between the hit and the closest border of the current strip
 286   x4 = (TMath::Abs(ymax-x1) > TMath::Abs(ymin-x1)) ?
 287     TMath::Abs(ymin-x1):TMath::Abs(ymax-x1);
 288
 289 }
 290
 291 //------------------------------------------------------------------
 292 void AliMUONSegmentationTriggerX::Draw(const char* opt)
 293 {
 294 // Draw method for event display
 295   if (!strcmp(opt,"eventdisplay")) {
 296
 297     TNode *node, *nodeS;
 298     char nameChamber[10], nameNode[11];
 299     char nameSense1[10], nameSense2[10], nameSense3[10], nameSense4[10];
 300
 301     TNode* top=gAlice->GetGeometry()->GetNode("alice");
 302     sprintf(nameChamber,"C_MUON%d",fId+1);
 303     new TBRIK(nameChamber,"Mother","void",340.,340.,0.25);
 304     top->cd();
 305     sprintf(nameNode,"MUON%d",100+fId+1);
 306     node = new TNode(nameNode,"Chambernode",nameChamber,0,0,fChamber->Z(),"");
 307     node->SetLineColor(kBlack);
 308     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 309     (pMUON->Nodes())->Add(node);
 310
 311     sprintf(nameSense1,"S1_MUON%d",fId+1);
 312     sprintf(nameSense2,"S2_MUON%d",fId+1);
 313     sprintf(nameSense3,"S3_MUON%d",fId+1);
 314     sprintf(nameSense4,"S4_MUON%d",fId+1);
 315
 316     for (Int_t imodule=0; imodule<AliMUONTriggerConstants::Nmodule(); imodule++) {
 317       Int_t idModule=AliMUONTriggerConstants::ModuleId(imodule);
 318
 319       if (TMath::Abs(idModule)!=51) {
 320
 321         Int_t nStripX=AliMUONTriggerConstants::NstripX(imodule);
 322         Float_t xmin=fXofxsmin[imodule][0];
 323         Float_t xmax=fXofxsmax[imodule][nStripX-1];
 324         Float_t ymin=fYofxsmin[imodule][0];
 325         Float_t ymax=fYofxsmax[imodule][nStripX-1];
 326         Float_t xpos=xmin+(xmax-xmin)/2.;
 327         Float_t ypos=ymin+(ymax-ymin)/2.;
 328         Float_t halfx=(xmax-xmin)/2.;
 329         Float_t halfy=(ymax-ymin)/2.;
 330
 331         if (idModule==11)
 332           new TBRIK(nameSense1,"Module","void",halfx,halfy,0.25);
 333         if (idModule==17)
 334           new TBRIK(nameSense2,"Module","void",halfx,halfy,0.25);
 335         if (idModule==41)
 336           new TBRIK(nameSense3,"Module","void",halfx,halfy,0.25);
 337         if (idModule==52)
 338           new TBRIK(nameSense4,"Module","void",halfx,halfy,0.25);
 339         node->cd();
 340         sprintf(nameNode,"S_MUON%d",1000*fId+1+imodule);
 341
 342         if (TMath::Abs(idModule)==41||TMath::Abs(idModule)==61) {
 343           nodeS = new TNode(nameNode,"Module",nameSense3,xpos,ypos,0,"");
 344         } else if (TMath::Abs(idModule)==52) {
 345           nodeS = new TNode(nameNode,"Module",nameSense4,xpos,ypos,0,"");
 346         } else if (TMath::Abs((idModule-Int_t(idModule/10)*10.))!=7) {
 347           nodeS = new TNode(nameNode,"Module",nameSense1,xpos,ypos,0,"");
 348         } else {
 349           //    } else if (TMath::Abs((idModule-Int_t(idModule/10)*10.))==7) {
 350           nodeS = new TNode(nameNode,"Module",nameSense2,xpos,ypos,0,"");
 351         }
 352         nodeS->SetLineColor(kBlue);
 353         node->cd();
 354       }
 355     }
 356   }
 357 }
 358
 359
 360
 361