EVE/EveDet/AliEveITSModule.cxx

   1 // $Id$
   2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
   3
   4 /**************************************************************************
   5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
   6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
   7  * full copyright notice.                                                 *
   8  **************************************************************************/
   9
  10 #include "AliEveITSModule.h"
  11
  12 #include <AliITSgeomTGeo.h>
  13 #include <AliITSsegmentationSPD.h>
  14 #include <AliITSsegmentationSDD.h>
  15 #include <AliITSsegmentationSSD.h>
  16
  17 #include <AliITSdigitSPD.h>
  18 #include <AliITSdigitSDD.h>
  19 #include <AliITSdigitSSD.h>
  20
  21 #include <TEveTrans.h>
  22 #include <TClonesArray.h>
  23 #include <TStyle.h>
  24
  25
  26 //______________________________________________________________________________
  27 //
  28 // Visualization of an ITS module.
  29
  30 ClassImp(AliEveITSModule)
  31
  32 Bool_t AliEveITSModule::fgStaticInitDone = kFALSE;
  33
  34 TEveFrameBox*    AliEveITSModule::fgSPDFrameBox = 0;
  35 TEveFrameBox*    AliEveITSModule::fgSPDFrameBoxDead = 0;
  36 TEveFrameBox*    AliEveITSModule::fgSDDFrameBox = 0;
  37 TEveFrameBox*    AliEveITSModule::fgSSDFrameBox = 0;
  38
  39 TEveRGBAPalette* AliEveITSModule::fgSPDPalette  = 0;
  40 TEveRGBAPalette* AliEveITSModule::fgSDDPalette  = 0;
  41 TEveRGBAPalette* AliEveITSModule::fgSSDPalette  = 0;
  42
  43 /******************************************************************************/
  44
  45 AliEveITSModule::AliEveITSModule(const Text_t* n, const Text_t* t) :
  46   TEveQuadSet(n, t),
  47   fInfo(0),
  48   fID(-1), fDetID(-1),
  49   fLayer(-1), fLadder(-1), fDet(-1),
  50   fDx(0), fDz(0), fDy(0)
  51 {
  52   // Constructor.
  53 }
  54
  55 AliEveITSModule::AliEveITSModule(Int_t gid, AliEveITSDigitsInfo* info) :
  56   TEveQuadSet(Form("ITS module %d", gid)),
  57   fInfo  (0),
  58   fID(-1), fDetID(-1),
  59   fLayer(-1), fLadder(-1), fDet(-1),
  60   fDx(0), fDz(0), fDy(0)
  61 {
  62   // Constructor with module id and data-source.
  63
  64   SetDigitsInfo(info);
  65   SetID(gid);
  66 }
  67
  68 AliEveITSModule::~AliEveITSModule()
  69 {
  70   // Destructor.
  71
  72   if (fInfo) fInfo->DecRefCount();
  73 }
  74
  75 /******************************************************************************/
  76
  77 void AliEveITSModule::InitStatics(AliEveITSDigitsInfo* info)
  78 {
  79   // Initialize static variables.
  80   //
  81   // Warning all sensor sizes are in microns, here we transform them
  82   // to cm. In Eve half-lengths/widths are used, hence another 1/2.
  83
  84   if (fgStaticInitDone) return;
  85   fgStaticInitDone = kTRUE;
  86
  87   {
  88     Float_t dx = info->fSegSPD->Dx()*0.00005;
  89     Float_t dz = info->fSegSPD->Dz()*0.00005;
  90
  91     fgSPDFrameBox = new TEveFrameBox();
  92     fgSPDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
  93     fgSPDFrameBox->SetFrameColor(Color_t(31));
  94     fgSPDFrameBox->SetFrameFill(kTRUE);
  95     fgSPDFrameBox->IncRefCount();
  96     fgSPDPalette  = new TEveRGBAPalette(info->fSPDMinVal,info->fSPDMaxVal);
  97     fgSPDPalette->IncRefCount();
  98
  99     fgSPDFrameBoxDead = new TEveFrameBox();
 100     fgSPDFrameBoxDead->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
 101     fgSPDFrameBoxDead->SetFrameColor(kRed);
 102     fgSPDFrameBoxDead->SetFrameFill(kTRUE);
 103     fgSPDFrameBoxDead->IncRefCount();
 104   }
 105
 106   {
 107     Float_t dx = info->fSegSDD->Dx()*0.0001;
 108     Float_t dz = info->fSegSDD->Dz()*0.00005;
 109
 110     fgSDDFrameBox = new TEveFrameBox();
 111     fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
 112     fgSDDFrameBox->SetFrameColor(Color_t(32));
 113     fgSDDFrameBox->SetFrameFill(kTRUE);
 114     fgSDDFrameBox->IncRefCount();
 115     fgSDDPalette  = new TEveRGBAPalette(info->fSDDMinVal,info->fSDDMaxVal);
 116     fgSDDPalette->SetLimits(0, info->fSDDHighLim); // Set proper ADC range.
 117     fgSDDPalette->IncRefCount();
 118   }
 119
 120   {
 121     Float_t dx = info->fSegSSD->Dx()*0.00005;
 122     Float_t dz = info->fSegSSD->Dz()*0.00005;
 123
 124     fgSSDFrameBox = new TEveFrameBox();
 125     fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
 126     fgSSDFrameBox->SetFrameColor(Color_t(33));
 127     fgSSDFrameBox->SetFrameFill(kTRUE);
 128     fgSSDFrameBox->IncRefCount();
 129     fgSSDPalette  = new TEveRGBAPalette(info->fSSDMinVal,info->fSSDMaxVal);
 130     fgSSDPalette->SetLimits(0, info->fSSDHighLim); // Set proper ADC range.
 131     fgSSDPalette->IncRefCount();
 132   }
 133
 134 }
 135
 136 /******************************************************************************/
 137
 138 void AliEveITSModule::SetDigitsInfo(AliEveITSDigitsInfo* info)
 139 {
 140   // Set data and geometry source.
 141
 142   if (fInfo == info) return;
 143   if (fInfo) fInfo->DecRefCount();
 144   fInfo = info;
 145   if (fInfo) fInfo->IncRefCount();
 146 }
 147
 148 /******************************************************************************/
 149
 150 void AliEveITSModule::SetID(Int_t gid, Bool_t trans)
 151 {
 152   // Set detector id.
 153
 154   static const TEveException kEH("AliEveITSModule::SetID ");
 155
 156   if (fInfo == 0)
 157     throw(kEH + "AliEveITSDigitsInfo not set.");
 158
 159   Int_t firstSPD = AliITSgeomTGeo::GetModuleIndex(1,1,1);
 160   Int_t lastSSD  = AliITSgeomTGeo::GetNModules() - 1;
 161   if (gid < firstSPD || gid > lastSSD)
 162   {
 163     throw(kEH + Form("%d is not valid. ID range from %d to %d", gid,
 164                     firstSPD, lastSSD ));
 165   }
 166
 167   fID = gid;
 168
 169   if (!fgStaticInitDone)
 170   {
 171     InitStatics(fInfo);
 172   }
 173
 174   AliITSgeomTGeo::GetModuleId(fID, fLayer, fLadder, fDet);
 175   TString strLadder = "Ladder";
 176   TString strSensor = "Sensor";
 177   TString symname;
 178   Int_t   id, nsector, nstave, nladder, rest;
 179
 180   if (fID <= (AliITSgeomTGeo::GetModuleIndex(3,1,1) - 1))
 181   {
 182     // SPD
 183
 184     fDetID = 0;
 185
 186     SetFrame(fInfo->IsDead(fID, fDetID) ? fgSPDFrameBoxDead : fgSPDFrameBox);
 187     SetPalette(fgSPDPalette);
 188
 189     symname += strLadder;
 190     if (fID < 80)
 191     {
 192       nsector = fID/8;
 193       rest    = fID - 8*nsector;
 194       nstave  = 1;
 195     }
 196     else
 197     {
 198       id      = fID - 80;
 199       nsector = id/8;
 200       rest    = id - 8*nsector;
 201       nstave  = 1;
 202     }
 203     if (rest < 4) nstave = 0;
 204     rest    -= 4*nstave;
 205     symname += rest;
 206     SetName(symname);
 207     fDx = fInfo->fSegSPD->Dx()*0.00005;
 208     fDz = 3.50;
 209     fDy = fInfo->fSegSPD->Dy()*0.00005;
 210   }
 211   else if (fID <= (AliITSgeomTGeo::GetModuleIndex(5,1,1) - 1))
 212   {
 213     // SDD
 214
 215     fDetID = 1;
 216
 217     SetFrame(fgSDDFrameBox);
 218     SetPalette(fgSDDPalette);
 219
 220     symname += strSensor;
 221     if (fID < 324)
 222     {
 223       id      = fID - 240;
 224       nladder = id/6;
 225       rest    = id - 6*nladder;
 226     }
 227     else
 228     {
 229       id      = fID - 324;
 230       nladder = id/8;
 231       rest    = id - 8*nladder;
 232     }
 233     symname += rest;
 234     SetName(symname);
 235     fDx = fInfo->fSegSDD->Dx()*0.0001;
 236     fDz = fInfo->fSegSDD->Dz()*0.00005;
 237     fDy = fInfo->fSegSDD->Dy()*0.00005;
 238   }
 239   else
 240   {
 241     // SSD
 242
 243     fDetID = 2;
 244
 245     SetFrame(fgSSDFrameBox);
 246     SetPalette(fgSSDPalette);
 247
 248     symname += strSensor;
 249     if (fID < 1248)
 250     {
 251       id      = fID - 500;
 252       nladder = id/22;
 253       rest    = id - nladder*22;
 254     }
 255     else
 256     {
 257       id      = fID - 1248;
 258       nladder = id/25;
 259       rest    = id - nladder*25;
 260     }
 261     symname += rest;
 262     SetName(symname);
 263     fInfo->fSegSSD->SetLayer(fLayer);
 264     fDx = fInfo->fSegSSD->Dx()*0.00005;
 265     fDz = fInfo->fSegSSD->Dz()*0.00005;
 266     fDy = fInfo->fSegSSD->Dy()*0.00005;
 267   }
 268
 269   LoadQuads();
 270   RefitPlex();
 271   ComputeBBox();
 272   InitMainTrans();
 273   if (trans)
 274     SetTrans();
 275
 276 }
 277
 278 void AliEveITSModule::LoadQuads()
 279 {
 280   // Read module data from source and create low-level objects for
 281   // visualization - called quads.
 282
 283   TClonesArray *digits  = fInfo->GetDigits(fID, fDetID);
 284   Int_t         ndigits = digits ? digits->GetEntriesFast() : 0;
 285
 286   Float_t       x, z, dpx, dpz;
 287   Int_t         i, j;
 288
 289   switch(fDetID)
 290   {
 291     case 0:
 292     {
 293       AliITSsegmentationSPD* seg =  fInfo->fSegSPD;
 294
 295       Reset(kQT_RectangleXZFixedY, kFALSE, 32);
 296
 297       for (Int_t k=0; k<ndigits; ++k)
 298       {
 299         AliITSdigit *d = (AliITSdigit*) digits->UncheckedAt(k);
 300         j = d->GetCoord1();
 301         i = d->GetCoord2();
 302         x  = -0.5*seg->Dx() + i*seg->Dpx(0);
 303         x *=  0.0001;
 304         fInfo->GetSPDLocalZ(j, z);
 305         dpx = seg->Dpx(i)*0.0001;
 306         dpz = seg->Dpz(j)*0.0001;
 307
 308         AddQuad(x, z, dpx, dpz);
 309         QuadValue(1); // In principle could have color based on number of neigbours
 310         QuadId(d);
 311       }
 312       break;
 313     }
 314
 315     case 1:
 316     {
 317       AliITSsegmentationSDD *seg =  fInfo->fSegSDD;
 318
 319       Reset(kQT_RectangleXZFixedY, kFALSE, 32);
 320
 321       for (Int_t k=0; k<ndigits; ++k)
 322       {
 323         AliITSdigit* d = (AliITSdigit*) digits->UncheckedAt(k);
 324
 325         j = d->GetCoord1();
 326         i = d->GetCoord2();
 327         seg->DetToLocal(i, j, x, z);
 328         dpx = seg->Dpx(i)*0.0001;
 329         dpz = seg->Dpz(j)*0.0001;
 330
 331         AddQuad(x-2*dpx, z - dpz*0.5, 4*dpx, dpz);
 332         QuadValue(d->GetSignal());
 333         QuadId(d);
 334       }
 335       break;
 336     }
 337
 338     case 2:
 339     {
 340       AliITSsegmentationSSD* seg = fInfo->fSegSSD;
 341
 342       Reset(kQT_LineXZFixedY, kFALSE, 32);
 343
 344       Float_t ap, an; // positive/negative angles -> offsets
 345       seg->Angles(ap, an);
 346       ap =   TMath::Tan(ap) * fDz;
 347       an = - TMath::Tan(an) * fDz;
 348
 349       for (Int_t k=0; k<ndigits; ++k)
 350       {
 351         AliITSdigit *d = (AliITSdigit*) digits->UncheckedAt(k);
 352
 353         j = d->GetCoord1();
 354         i = d->GetCoord2();
 355         // !!!! The following function complains about not being verified.
 356         // !!!! Experts should check.
 357         seg->DetToLocal(i,j,x,z);
 358
 359         Float_t a = (d->GetCoord1() == 1) ? ap : an;
 360
 361         AddLine(x-a, -fDz, 2*a, 2*fDz);
 362         QuadValue(d->GetSignal());
 363         QuadId(d);
 364         // printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
 365       }
 366       break;
 367     }
 368
 369   } // end switch
 370 }
 371
 372 /******************************************************************************/
 373
 374 void AliEveITSModule::SetTrans()
 375 {
 376   // Set transformation matrix based on module id (use geometry to
 377   // retrieve this information).
 378
 379   fMainTrans->SetFrom(*AliITSgeomTGeo::GetMatrix(fID));
 380 }
 381
 382 /******************************************************************************/
 383
 384 void AliEveITSModule::DigitSelected(Int_t idx)
 385 {
 386   // Override secondary select (alt-click) from TEveQuadSet.
 387
 388   DigitBase_t *qb  = GetDigit(idx);
 389   TObject     *obj = qb->fId.GetObject();
 390   AliITSdigit *d   = dynamic_cast<AliITSdigit*>(obj);
 391   printf("AliEveITSModule::QuadSelected "); Print();
 392   printf("  idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
 393          idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
 394   if (d)
 395     printf("  coord1=%3d coord2=%3d signal=%d\n",
 396            d->GetCoord1(), d->GetCoord2(), d->GetSignal());
 397
 398 }
 399
 400 /******************************************************************************/
 401
 402 void AliEveITSModule::Print(Option_t* ) const
 403 {
 404   // Print object summary information.
 405
 406   printf("AliEveITSModule: ID %d, layer %d, ladder %d, det %d\n",
 407          fID, fLayer, fLadder, fDetID);
 408 }