EVE/Alieve/ITSModule.cxx

   1 #include "ITSModule.h"
   2
   3 #include <AliITSdigitSPD.h>
   4 #include <AliITSdigitSDD.h>
   5 #include <AliITSdigitSSD.h>
   6
   7 #include <TStyle.h>
   8
   9 using namespace Reve;
  10 using namespace Alieve;
  11
  12
  13 Bool_t       ITSModule::fgStaticInitDone = kFALSE;
  14
  15 FrameBox*    ITSModule::fgSPDFrameBox = 0;
  16 FrameBox*    ITSModule::fgSDDFrameBox = 0;
  17 FrameBox*    ITSModule::fgSSDFrameBox = 0;
  18
  19 RGBAPalette* ITSModule::fgSPDPalette  = 0;
  20 RGBAPalette* ITSModule::fgSDDPalette  = 0;
  21 RGBAPalette* ITSModule::fgSSDPalette  = 0;
  22
  23 //__________________________________________________________________________
  24 // ITSModule
  25 //
  26 //
  27
  28 ClassImp(ITSModule)
  29
  30 /**************************************************************************/
  31
  32 ITSModule::ITSModule(const Text_t* n, const Text_t* t) :
  33   QuadSet(n, t),
  34   fInfo(0),
  35   fID(-1), fDetID(-1),
  36   fLayer(-1), fLadder(-1), fDet(-1),
  37   fDx(0), fDz(0), fDy(0)
  38 {}
  39
  40 ITSModule::ITSModule(Int_t gid, ITSDigitsInfo* info) :
  41   QuadSet(Form("ITS module %d", gid)),
  42   fInfo  (0),
  43   fID(-1), fDetID(-1),
  44   fLayer(-1), fLadder(-1), fDet(-1),
  45   fDx(0), fDz(0), fDy(0)
  46 {
  47   SetDigitsInfo(info);
  48   SetID(gid);
  49 }
  50
  51 ITSModule::~ITSModule()
  52 {
  53   if(fInfo) fInfo->DecRefCount();
  54 }
  55
  56 /**************************************************************************/
  57
  58 void ITSModule::InitStatics(ITSDigitsInfo* info)
  59 {
  60   if (fgStaticInitDone) return;
  61   fgStaticInitDone = kTRUE;
  62
  63   {
  64     Float_t dx = info->fSegSPD->Dx()*0.00005;
  65     Float_t dz = 3.48;
  66
  67     fgSPDFrameBox = new FrameBox();
  68     fgSPDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
  69     fgSPDFrameBox->SetFrameColor((Color_t) 31);
  70     fgSPDPalette  = new RGBAPalette(0, 1);
  71   }
  72
  73   {
  74     Float_t dx = info->fSegSDD->Dx()*0.0001;
  75     Float_t dz = info->fSegSDD->Dz()*0.00005;
  76
  77     fgSDDFrameBox = new FrameBox();
  78     fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
  79     fgSDDFrameBox->SetFrameColor((Color_t) 32);
  80     fgSDDPalette  = new RGBAPalette(5, 80);
  81     fgSDDPalette->SetLimits(0, 512); // Set proper ADC range.
  82   }
  83
  84   {
  85     Float_t dx = info->fSegSSD->Dx()*0.00005;
  86     Float_t dz = info->fSegSSD->Dz()*0.00005;
  87
  88     fgSSDFrameBox = new FrameBox();
  89     fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
  90     fgSSDFrameBox->SetFrameColor((Color_t) 33);
  91     fgSSDPalette  = new RGBAPalette(2, 100);
  92     fgSSDPalette->SetLimits(0, 1024); // Set proper ADC range.
  93   }
  94
  95 }
  96
  97 /**************************************************************************/
  98
  99 void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
 100 {
 101   if (fInfo == info) return;
 102   if (fInfo) fInfo->DecRefCount();
 103   fInfo = info;
 104   if (fInfo) fInfo->IncRefCount();
 105 }
 106
 107 /**************************************************************************/
 108
 109 void ITSModule::SetID(Int_t gid)
 110 {
 111   static const Exc_t eH("ITSModule::SetID ");
 112
 113   if(fInfo == 0)
 114     throw(eH + "ITSDigitsInfo not set.");
 115
 116   if (gid < fInfo->fGeom->GetStartSPD() || gid > fInfo->fGeom->GetLastSSD())
 117     throw(eH + Form("%d is not valid. ID range from %d to %d", gid,
 118                      fInfo->fGeom->GetStartSPD(), fInfo->fGeom->GetLastSSD()));
 119
 120   fID = gid;
 121
 122   if (!fgStaticInitDone) InitStatics(fInfo);
 123
 124   fInfo->fGeom->GetModuleId(fID, fLayer, fLadder, fDet);
 125   TString strLadder = "Ladder";
 126   TString strSensor = "Sensor";
 127   TString symname;
 128   Int_t   id, nsector, nstave, nladder, rest;
 129
 130   if (fID <= fInfo->fGeom->GetLastSPD())
 131   {
 132     // SPD
 133
 134     SetFrame(fgSPDFrameBox);
 135     SetPalette(fgSPDPalette);
 136
 137     symname += strLadder;
 138     if (fID < 80)
 139     {
 140       nsector = fID/8;
 141       rest    = fID - 8*nsector;
 142       nstave  = 1;
 143     }
 144     else
 145     {
 146       id      = fID - 80;
 147       nsector = id/8;
 148       rest    = id - 8*nsector;
 149       nstave  = 1;
 150     }
 151     if (rest < 4) nstave = 0;
 152     rest    -= 4*nstave;
 153     symname += rest;
 154     SetName(symname);
 155     fDetID = 0;
 156     fDx = fInfo->fSegSPD->Dx()*0.00005;
 157     fDz = 3.48;
 158     fDy = fInfo->fSegSPD->Dy()*0.00005;
 159
 160   }
 161   else if (fID <= fInfo->fGeom->GetLastSDD())
 162   {
 163     // SDD
 164
 165     SetFrame(fgSDDFrameBox);
 166     SetPalette(fgSDDPalette);
 167
 168     symname += strSensor;
 169     if (fID < 324)
 170     {
 171       id      = fID - 240;
 172       nladder = id/6;
 173       rest    = id - 6*nladder;
 174     }
 175     else
 176     {
 177       id      = fID - 324;
 178       nladder = id/8;
 179       rest    = id - 8*nladder;
 180     }
 181     symname += rest;
 182     SetName(symname);
 183     fDetID = 1;
 184     fDx = fInfo->fSegSDD->Dx()*0.0001;
 185     fDz = fInfo->fSegSDD->Dz()*0.00005;
 186     fDy = fInfo->fSegSDD->Dy()*0.00005;
 187
 188   }
 189   else
 190   {
 191     // SSD
 192
 193     SetFrame(fgSSDFrameBox);
 194     SetPalette(fgSSDPalette);
 195
 196     symname += strSensor;
 197     if (fID < 1248)
 198     {
 199       id      = fID - 500;
 200       nladder = id/22;
 201       rest    = id - nladder*22;
 202     }
 203     else
 204     {
 205       id      = fID - 1248;
 206       nladder = id/25;
 207       rest    = id - nladder*25;
 208     }
 209     symname += rest;
 210     SetName(symname);
 211     fDetID = 2;
 212     fInfo->fSegSSD->SetLayer(fLayer);
 213     fDx = fInfo->fSegSSD->Dx()*0.00005;
 214     fDz = fInfo->fSegSSD->Dz()*0.00005;
 215     fDy = fInfo->fSegSSD->Dy()*0.00005;
 216
 217   }
 218
 219   LoadQuads();
 220   ComputeBBox();
 221   SetTrans();
 222 }
 223
 224 void ITSModule::LoadQuads()
 225 {
 226   // Here we still use 'z' for the name of axial coordinates.
 227   // The transforamtion matrix aplied rotates y -> z.
 228   // We need this as QuadSet offers optimized treatment for
 229   // quads in the x-y plane.
 230
 231   // printf("its module load quads \n");
 232
 233   TClonesArray *digits;
 234   Float_t       x, z, dpx, dpz;
 235   Int_t         i, j, ndigits;
 236   digits  = fInfo->GetDigits(fID, fDetID);
 237   ndigits = digits->GetEntriesFast();
 238
 239   switch(fDetID)
 240   {
 241
 242     case 0: { // SPD
 243       AliITSsegmentationSPD* seg =  fInfo->fSegSPD;
 244
 245       Reset(QT_RectangleXZFixedY, kFALSE, 32);
 246
 247       for (Int_t k=0; k<ndigits; ++k)
 248       {
 249         AliITSdigitSPD *d = (AliITSdigitSPD*) digits->UncheckedAt(k);
 250         j = d->GetCoord1();
 251         i = d->GetCoord2();
 252         x  = -0.5*seg->Dx() + i*seg->Dpx(0);
 253         x *=  0.0001;
 254         fInfo->GetSPDLocalZ(j, z);
 255         dpx = seg->Dpx(i)*0.0001;
 256         dpz = seg->Dpz(j)*0.0001;
 257
 258         AddQuad(x, z, dpx, dpz);
 259         QuadValue(1); // In principle could have color based on number of neigbours
 260       }
 261       break;
 262     }
 263
 264     case 1: { // SDD
 265       AliITSsegmentationSDD *seg =  fInfo->fSegSDD;
 266
 267       Reset(QT_RectangleXZFixedY, kFALSE, 32);
 268
 269       for (Int_t k=0; k<ndigits; ++k)
 270       {
 271         AliITSdigitSDD* d = (AliITSdigitSDD*) digits->UncheckedAt(k);
 272
 273         // if (d->GetSignal() > fgSDDThreshold)
 274         {
 275           j = d->GetCoord1();
 276           i = d->GetCoord2();
 277           seg->DetToLocal(i, j, x, z);
 278           dpx = seg->Dpx(i)*0.0001;
 279           dpz = seg->Dpz(j)*0.0001;
 280
 281           AddQuad(x-2*dpx, z, 4*dpx, dpz);
 282           QuadValue(d->GetSignal());
 283         }
 284       }
 285       break;
 286     }
 287
 288     case 2: { // SSD
 289       AliITSsegmentationSSD* seg = fInfo->fSegSSD;
 290
 291       Reset(QT_LineXZFixedY, kFALSE, 32);
 292
 293       Float_t ap, an; // positive/negative angles -> offsets
 294       seg->Angles(ap, an);
 295       ap =   TMath::Tan(ap) * fDz;
 296       an = - TMath::Tan(an) * fDz;
 297
 298       for (Int_t k=0; k<ndigits; ++k)
 299       {
 300         AliITSdigitSSD *d = (AliITSdigitSSD*) digits->UncheckedAt(k);
 301         // if(d->GetSignal() > fgSSDThreshold)
 302         {
 303           j = d->GetCoord1();
 304           i = d->GetCoord2();
 305           seg->DetToLocal(i,j,x,z);
 306
 307           Float_t a = ( d->GetCoord1() == 1) ? ap : an;
 308
 309           AddLine(x-a, -fDz, 2*a, 2*fDz);
 310           QuadValue(d->GetSignal());
 311           // printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
 312         }
 313       }
 314       break;
 315     }
 316
 317   } // end switch
 318
 319   RefitPlex();
 320 }
 321
 322 /**************************************************************************/
 323
 324 void ITSModule::SetTrans()
 325 {
 326   Double_t x[9];
 327   fHMTrans.UnitTrans();
 328
 329    // column major
 330   fInfo->fGeom->GetRotMatrix(fID, x);
 331   fHMTrans.SetBaseVec(1, x[0], x[3], x[6]);
 332   fHMTrans.SetBaseVec(2, x[1], x[4], x[7]);
 333   fHMTrans.SetBaseVec(3, x[2], x[5], x[8]);
 334   // translation
 335   fInfo->fGeom->GetTrans(fID, x);
 336   fHMTrans.SetBaseVec(4, x);
 337 }
 338
 339 /**************************************************************************/
 340
 341 void ITSModule::Print(Option_t* ) const
 342 {
 343   printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
 344 }