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