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 using namespace std;
  12
  13 Short_t ITSModule::fgSDDThreshold  = 5;
  14 Short_t ITSModule::fgSDDMaxVal     = 80;
  15 Short_t ITSModule::fgSSDThreshold  = 2;
  16 Short_t ITSModule::fgSSDMaxVal     = 100;
  17
  18 ClassImp(ITSModule)
  19
  20 /**************************************************************************/
  21
  22 ITSModule::ITSModule(const Text_t* n, const Text_t* t, Color_t col) :
  23   Reve::RenderElement(fFrameColor),
  24   OldQuadSet(n, t),
  25   fInfo(0),
  26   fID(-1), fDetID(-1),
  27   fLayer(-1), fLadder(-1), fDet(-1),
  28   fDx(0), fDz(0), fDy(0),
  29   fFrameColor(col)
  30 {}
  31
  32 ITSModule::ITSModule(Int_t id, ITSDigitsInfo* info, Color_t col) :
  33   Reve::RenderElement(fFrameColor),
  34   OldQuadSet(Form("ITS module %d", id)),
  35   fInfo  (0),
  36   fID(-1), fDetID(-1),
  37   fLayer(-1), fLadder(-1), fDet(-1),
  38   fDx(0), fDz(0), fDy(0),
  39   fFrameColor(col)
  40 {
  41   SetDigitsInfo(info);
  42   SetID(id);
  43 }
  44
  45 ITSModule::~ITSModule()
  46 {
  47   if(fInfo) fInfo->DecRefCount();
  48 }
  49
  50 /**************************************************************************/
  51
  52 void ITSModule::SetMainColor(Color_t col)
  53 {
  54   Reve::RenderElement::SetMainColor(col);
  55   if(!fQuads.empty()) {
  56     fQuads.front().ColorFromIdx(col);
  57   }
  58 }
  59
  60 /**************************************************************************/
  61
  62 void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
  63 {
  64   if(fInfo) fInfo->DecRefCount();
  65   fInfo = info;
  66   if(fInfo) fInfo->IncRefCount();
  67 }
  68
  69 void ITSModule::SetID(Int_t id)
  70 {
  71   static const Exc_t eH("ITSModule::SetID ");
  72
  73   if(fInfo == 0)
  74     throw(eH + "ITSDigitsInfo not set.");
  75
  76   if (id < fInfo->fGeom->GetStartSPD() || id > fInfo->fGeom->GetLastSSD())
  77     throw(eH + Form("%d is not valid. ID range from %d to %d", id,
  78                      fInfo->fGeom->GetStartSPD(), fInfo->fGeom->GetLastSSD()));
  79
  80   fID = id;
  81   InitModule();
  82 }
  83
  84 /**************************************************************************/
  85
  86 void ITSModule::InitModule()
  87 {
  88   fInfo->fGeom->GetModuleId(fID,fLayer,fLadder,fDet);
  89   TString strLadder = "Ladder";
  90   TString strSensor = "Sensor";
  91   TString symname;
  92   Int_t id, nsector, nstave, nladder, rest;
  93
  94   if (fID <= fInfo->fGeom->GetLastSPD()) {
  95     symname+=strLadder;
  96     if (fID<80) {
  97       nsector = fID/8;
  98       rest=fID-nsector*8;
  99       nstave=1;
 100       if (rest<4) nstave=0;
 101       rest-=nstave*4;
 102       symname+=rest;
 103       SetName(symname.Data());
 104       fDetID = 0;
 105       fDx = fInfo->fSegSPD->Dx()*0.00005;
 106       fDz = 3.48;
 107       fDy = fInfo->fSegSPD->Dy()*0.00005;
 108     } else {
 109       id=fID-80;
 110       nsector = id/8;
 111       rest=id-nsector*8;
 112       nstave=1;
 113       if (rest<4) nstave=0;
 114       rest-=nstave*4;
 115       symname+=rest;
 116       SetName(symname.Data());
 117       fDetID = 0;
 118       fDx = fInfo->fSegSPD->Dx()*0.00005;
 119       fDz = 3.48;
 120       fDy = fInfo->fSegSPD->Dy()*0.00005;
 121     }
 122   }
 123   else if (fID <= fInfo->fGeom->GetLastSDD()) {
 124     symname+=strSensor;
 125     if (fID<324) {
 126       id = fID-240;
 127       nladder = id/6;
 128       rest=id-nladder*6;
 129       symname+=rest;
 130       SetName(symname.Data());
 131       fDetID = 1;
 132       fDx = fInfo->fSegSDD->Dx()*0.0001;
 133       fDz = fInfo->fSegSDD->Dz()*0.00005;
 134       fDy = fInfo->fSegSDD->Dy()*0.00005;
 135     } else {
 136       id = fID-324;
 137       nladder = id/8;
 138       rest=id-nladder*8;
 139       symname+=rest;
 140       SetName(symname.Data());
 141       fDetID = 1;
 142       fDx = fInfo->fSegSDD->Dx()*0.0001;
 143       fDz = fInfo->fSegSDD->Dz()*0.00005;
 144       fDy = fInfo->fSegSDD->Dy()*0.00005;
 145     }
 146   }
 147   else {
 148     symname+=strSensor;
 149     if (fID<1248) {
 150       id = fID-500;
 151       nladder = id/22;
 152       rest=id-nladder*22;
 153       symname+=rest;
 154       SetName(symname.Data());
 155       fDetID = 2;
 156       fInfo->fSegSSD->SetLayer(fLayer);
 157       fDx = fInfo->fSegSSD->Dx()*0.00005;
 158       fDz = fInfo->fSegSSD->Dz()*0.00005;
 159       fDy = fInfo->fSegSSD->Dy()*0.00005;
 160     } else {
 161       id = fID-1248;
 162       nladder = id/25;
 163       rest=id-nladder*25;
 164       symname+=rest;
 165       SetName(symname.Data());
 166       fDetID = 2;
 167       fInfo->fSegSSD->SetLayer(fLayer);
 168       fDx = fInfo->fSegSSD->Dx()*0.00005;
 169       fDz = fInfo->fSegSSD->Dz()*0.00005;
 170       fDy = fInfo->fSegSSD->Dy()*0.00005;
 171     }
 172   }
 173
 174   LoadQuads();
 175   ComputeBBox();
 176   SetTrans();
 177 }
 178
 179 void ITSModule::LoadQuads()
 180 {
 181   // printf("its module load quads \n");
 182   Float_t x = fDx;
 183   Float_t z = fDz;
 184   Bool_t aboveThreshold = false;
 185
 186   // Module frame in xy plane
 187   fQuads.push_back(Reve::Quad(fFrameColor));
 188   Float_t dy = -0.;
 189   Float_t* p = fQuads.back().vertices;
 190   p[0] = -x;  p[1] =  dy; p[2]  = -z;
 191   p[3] = -x;  p[4] =  dy; p[5]  =  z;
 192   p[6] =  x;  p[7] =  dy; p[8]  =  z;
 193   p[9] =  x;  p[10] = dy; p[11] = -z;
 194
 195   // Digits
 196   TClonesArray *digits;
 197   Int_t ndigits;
 198   Float_t dpx,dpz;
 199   Int_t i,j;
 200   digits  = fInfo->GetDigits(fID, fDetID );
 201   ndigits = digits->GetEntriesFast();
 202   Int_t n_col = gStyle->GetNumberOfColors();
 203
 204   switch(fDetID) {
 205
 206   case 0: { // SPD
 207     aboveThreshold = true;
 208     AliITSsegmentationSPD* seg =  fInfo->fSegSPD;
 209     AliITSdigitSPD *d=0;
 210
 211     for (Int_t k=0; k<ndigits; k++) {
 212       d=(AliITSdigitSPD*)digits->UncheckedAt(k);
 213       j = d->GetCoord1();
 214       i = d->GetCoord2();
 215       x  = -seg->Dx()/2 + seg->Dpx(0) *i;
 216       x *=  0.0001;
 217       fInfo->GetSPDLocalZ(j,z);
 218       dpx = seg->Dpx(i)*0.0001;
 219       dpz = seg->Dpz(j)*0.0001;
 220
 221       fQuads.push_back(Reve::Quad(7));
 222       Float_t* p = fQuads.back().vertices;
 223       p[0] = x;        p[1] = 0.; p[2]  = z;
 224       p[3] = x;        p[4] = 0.; p[5]  = z + dpz;
 225       p[6] = x + dpx;  p[7] = 0.; p[8]  = z + dpz;
 226       p[9] = x + dpx;  p[10] =0.; p[11] = z;
 227     }
 228     break;
 229   }
 230
 231   case 1: { // SDD
 232     AliITSsegmentationSDD* seg =  fInfo->fSegSDD;
 233     AliITSdigitSDD *d=0;
 234     x = 2*fDx;
 235     z = 2*fDz;
 236     for (Int_t k=0; k<ndigits; k++) {
 237       d=(AliITSdigitSDD*)digits->UncheckedAt(k);
 238
 239       if (d->GetSignal() > fgSDDThreshold) {
 240         j = d->GetCoord1();
 241         i = d->GetCoord2();
 242         aboveThreshold = true;
 243         seg->DetToLocal(i,j,x,z);
 244         dpx = seg->Dpx(i)*0.0001;
 245         dpz = seg->Dpz(j)*0.0001;
 246
 247         Int_t ci = gStyle->GetColorPalette
 248           (TMath::Min(n_col - 1,
 249                       (n_col*(d->GetSignal() - fgSDDThreshold))/(fgSDDMaxVal - fgSDDThreshold)));
 250         fQuads.push_back(Reve::Quad(ci, p));
 251         Float_t* p = fQuads.back().vertices;
 252         p[0] = x;        p[1] = 0.; p[2]  = z;
 253         p[3] = x;        p[4] = 0.; p[5]  = z + dpz;
 254         p[6] = x + dpx;  p[7] = 0.; p[8]  = z + dpz;
 255         p[9] = x + dpx;  p[10] =0.; p[11] = z;
 256       }
 257     }
 258     break;
 259   }
 260
 261   case 2: { // SSD
 262     AliITSsegmentationSSD* seg = fInfo->fSegSSD;
 263     AliITSdigitSSD *d=0;
 264     Float_t ap,an,a;
 265     seg->Angles(ap,an);
 266     for (Int_t k=0; k<ndigits; k++) {
 267       d=(AliITSdigitSSD*)digits->UncheckedAt(k);
 268       if(d->GetSignal() > fgSSDThreshold){
 269         aboveThreshold = true;
 270         j = d->GetCoord1();
 271         i = d->GetCoord2();
 272         seg->DetToLocal(i,j,x,z);
 273
 274         if( d->GetCoord1() == 1) {
 275           a = ap;
 276         }
 277         else {
 278           a = -an;
 279         }
 280         fQuads.push_back(Reve::Quad());
 281         Int_t ci = gStyle->GetColorPalette
 282           (TMath::Min(n_col - 1,
 283                       (n_col*(d->GetSignal() - fgSSDThreshold))/(fgSSDMaxVal - fgSSDThreshold)));
 284
 285         fQuads.back().ColorFromIdx(ci);
 286         Float_t* p = fQuads.back().vertices;
 287
 288         p[0] = x-TMath::Tan(a)*fDz;  p[1] =  0; p[2]  = -fDz;
 289         p[3] = x+TMath::Tan(a)*fDz;  p[4] =  0; p[5]  = fDz ;
 290         p[6] = x+TMath::Tan(a)*fDz;  p[7] =  0; p[8]  = fDz  ;
 291         p[9] = x-TMath::Tan(a)*fDz;  p[10] = 0; p[11] = -fDz;
 292         //      printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
 293       }
 294     }
 295     break;
 296   }
 297
 298   }
 299 }
 300
 301 /**************************************************************************/
 302
 303 void ITSModule::SetTrans()
 304 {
 305   Double_t pos[3];
 306   Double_t rot[9];
 307   fInfo->fGeom->GetTrans(fID,pos);
 308   fInfo->fGeom->GetRotMatrix(fID,rot);
 309   Double_t *s, *d;
 310
 311   // column major ii
 312   s = &rot[0]; d = &fMatrix[0];
 313   d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
 314   s = &rot[1]; d = &fMatrix[4];
 315   d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
 316   s = &rot[2]; d = &fMatrix[8];
 317   d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
 318   s = &pos[0]; d = &fMatrix[12];
 319   d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; d[3] = 1;
 320
 321   fTrans = true;
 322 }
 323
 324 /**************************************************************************/
 325
 326 void ITSModule::Print(Option_t* ) const
 327 {
 328   printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
 329 }