EVE/EveDet/AliEveITSScaledModule.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 "AliEveITSScaledModule.h"
  11
  12 #include <AliITSgeom.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 <TMath.h>
  22
  23 //______________________________________________________________________________
  24 // AliEveDigitScaleInfo
  25 //
  26
  27 ClassImp(AliEveDigitScaleInfo)
  28
  29 AliEveDigitScaleInfo::AliEveDigitScaleInfo():
  30   fScale(1),
  31   fStatType (kST_Average),
  32   fSyncPalette(kFALSE)
  33 {
  34 }
  35
  36 void AliEveDigitScaleInfo::ScaleChanged(Int_t s)
  37 {
  38   fScale = s;
  39
  40   AliEveITSScaledModule* sm;
  41   std::list<TEveElement*>::iterator i = fBackRefs.begin();
  42   while (i != fBackRefs.end())
  43   {
  44     sm = dynamic_cast<AliEveITSScaledModule*>(*i);
  45     if(sm) sm->LoadQuads();
  46     ++i;
  47   }
  48 }
  49
  50 void AliEveDigitScaleInfo::StatTypeChanged(Int_t t)
  51 {
  52   fStatType = t;
  53   fSyncPalette = kTRUE;
  54
  55   AliEveITSScaledModule* sm;
  56   std::list<TEveElement*>::iterator i = fBackRefs.begin();
  57   while (i != fBackRefs.end())
  58   {
  59     sm = dynamic_cast<AliEveITSScaledModule*>(*i);
  60     if(sm) sm->SetQuadValues();
  61     ++i;
  62   }
  63 }
  64
  65 //______________________________________________________________________________
  66 // ScaledDigit
  67 //
  68
  69 AliEveITSScaledModule::ScaledDigit::ScaledDigit() :
  70   TObject(),
  71   N(0),
  72   sum(0), sqr_sum(0),
  73   min_i(-1), min_j(-1), max_i(-1), max_j(-1)
  74 {
  75 }
  76
  77 AliEveITSScaledModule::ScaledDigit::ScaledDigit(Int_t di, Int_t dj) :
  78   TObject(),
  79   N(0),
  80   sum(0), sqr_sum(0),
  81   min_i(di), min_j(dj), max_i(di), max_j(dj)
  82 {
  83 }
  84
  85 void AliEveITSScaledModule::ScaledDigit::Dump() const
  86 {
  87   printf("N %d, sum %f, sqr_sum %f",N, sum, sqr_sum);
  88 }
  89
  90
  91 //______________________________________________________________________________
  92
  93 // AliEveITSScaledModule
  94
  95 //______________________________________________________________________________
  96 //
  97 // Visualization of an ITS module with digits aggregated
  98 // on a grid of pre-defined size.
  99
 100 ClassImp(AliEveITSScaledModule)
 101
 102 AliEveITSScaledModule::AliEveITSScaledModule(Int_t gid, AliEveITSDigitsInfo* info, AliEveDigitScaleInfo* si):
 103   AliEveITSModule("AliEveITSScaledModule", "AliEveITSScaledModule"),
 104   fDigitsMap(),
 105   fNx(-1),
 106   fNz(-1),
 107   fNCx(-1),
 108   fNCz(-1),
 109   fScaleInfo(si)
 110 {
 111   SetOwnIds(kTRUE);
 112
 113   SetDigitsInfo(info);
 114   SetID(gid);
 115   fScaleInfo->IncRefCount(this);
 116 }
 117
 118 AliEveITSScaledModule::~AliEveITSScaledModule()
 119 {
 120   fScaleInfo->DecRefCount(this);
 121 }
 122
 123 /******************************************************************************/
 124
 125 void AliEveITSScaledModule::LoadQuads()
 126 {
 127   // Here we still use 'z' for the name of axial coordinates.
 128   // The transforamtion matrix aplied rotates y -> z.
 129   // We need this as TEveQuadSet offers optimized treatment for
 130   // quads in the x-y plane.
 131
 132   TClonesArray *digits;
 133   Float_t       x, z, zo, dpx, dpz; // orig cells size, pos
 134   Int_t         i, j, ndigits;   // orig cells idx
 135   Int_t         c1, c2;          // original coordinates
 136
 137   Int_t id;
 138   std::map<Int_t, Int_t> dmap;
 139   std::map<Int_t, Int_t>::iterator miter;
 140   digits  = fInfo->GetDigits(fID, fDetID);
 141   ndigits = digits->GetEntriesFast();
 142
 143   ScaledDigit* sd;
 144   Int_t scale = fScaleInfo->GetScale() -1;
 145   switch(fDetID)
 146   {
 147     case 0:
 148     {
 149       // SPD
 150       Reset(kQT_RectangleXZFixedY, kFALSE, 32);
 151
 152       fNCz = fInfo->fSPDScaleZ[scale];
 153       fNCx = fInfo->fSPDScaleX[scale];
 154       fNz  = Int_t(fInfo->fSegSPD->Npz()/fNCz);
 155       fNx  = Int_t(fInfo->fSegSPD->Npx()/fNCx);
 156       dpz = 2*fDz/fNz;
 157       dpx = 2*fDx/fNx;
 158       //printf("SPD orig cells (%d, %d) (%d, %d)\n", fInfo->fSegSPD->Npx(), fInfo->fSegSPD->Npz(), Nx, Nz);
 159
 160       AliITSdigitSPD *od ;
 161       for (Int_t k=0; k<ndigits; ++k)
 162       {
 163         od = (AliITSdigitSPD*) digits->UncheckedAt(k);
 164
 165         fInfo->GetSPDLocalZ(od->GetCoord1(),zo);
 166         c1 = od->GetCoord1(); c2 = od->GetCoord2();
 167         i = Int_t((zo+fDz)/dpz);
 168         j = Int_t((od->GetCoord2()*fNx)/fInfo->fSegSPD->Npx());
 169         id = j*fNx + i;
 170
 171         miter = dmap.find(id);
 172         if(miter == dmap.end())
 173         {
 174           dmap[id] = fPlex.Size();
 175           z = dpz*(i) - fDz;
 176           x = dpx*(j) - fDx;
 177           AddQuad(x, z, dpx, dpz);
 178           sd = new ScaledDigit(c1, c2);
 179           QuadId(sd);
 180         }
 181         else
 182         {
 183           sd = dynamic_cast<ScaledDigit*>(GetId(miter->second));
 184           if(c1 < sd->min_i)
 185             sd->min_i = c1;
 186           else if( c1 > sd->max_i)
 187             sd->max_i = c1;
 188
 189           if(c2 < sd->min_j)
 190             sd->min_j = c2;
 191           else if( c2 > sd->max_j)
 192             sd->max_j = c2;
 193         }
 194
 195         sd->N++;
 196         sd->sum  += od->GetSignal();
 197         sd->sqr_sum += od->GetSignal()*od->GetSignal();
 198       }
 199       break;
 200     }
 201     case 1:
 202     {
 203       // SDD
 204       Reset(kQT_RectangleXZFixedY, kFALSE, 32);
 205
 206       fNCz = fInfo->fSDDScaleZ[scale];
 207       fNCx = fInfo->fSDDScaleX[scale];
 208       fNz  = Int_t(fInfo->fSegSDD->Npz()/fNCz);
 209       fNx  = Int_t(fInfo->fSegSDD->Npx()/fNCx);
 210       dpz = 2*fDz/fNz;
 211       dpx = 2*fDx/fNx;
 212
 213       AliITSdigitSDD *od=0;
 214       for (Int_t k=0; k<ndigits; k++) {
 215         od=(AliITSdigitSDD*)digits->UncheckedAt(k);
 216         fInfo->fSegSDD->DetToLocal(od->GetCoord2(), od->GetCoord1(),x,z);
 217         z+= fDz;
 218         x+= fDx;
 219         i = Int_t(z/dpz);
 220         j = Int_t(x/dpx);
 221         //printf("Mod %d coord %d,%d out of %d,%d :: ORIG coord %d,%d out of %d,%d \n",fID,
 222         //       i,j,Nz,Nx,od->GetCoord1(),od->GetCoord2(),fInfo->fSegSDD->Npz(),fInfo->fSegSDD->Npx());
 223
 224         id = j*fNx + i;
 225         c1 = od->GetCoord1(); c2 = od->GetCoord2();
 226
 227         miter = dmap.find(id);
 228         if(miter == dmap.end())
 229         {
 230           dmap[id] = fPlex.Size();
 231           z = dpz*(i) - fDz;
 232           x = dpx*(j) - fDx;
 233           AddQuad(x, z, dpx, dpz);
 234           sd = new ScaledDigit(od->GetCoord1(),od->GetCoord2());
 235           QuadId(sd);
 236         }
 237         else
 238         {
 239           sd = dynamic_cast<ScaledDigit*>(GetId(miter->second));
 240           if(c1 < sd->min_i)
 241             sd->min_i = c1;
 242           else if( c1 > sd->max_i)
 243             sd->max_i = c1;
 244
 245           if(c2 < sd->min_j)
 246             sd->min_j = c2;
 247           else if( c2 > sd->max_j)
 248             sd->max_j = c2;
 249         }
 250         sd->N++;
 251         sd->sum  += od->GetSignal();
 252         sd->sqr_sum += od->GetSignal()*od->GetSignal();
 253       }
 254       break;
 255     }
 256     case 2:
 257     {
 258       // SSD
 259       Reset(kQT_LineXZFixedY, kFALSE, 32);
 260
 261       AliITSsegmentationSSD* seg = fInfo->fSegSSD;
 262       Float_t ap, an; // positive/negative angles -> offsets
 263       seg->Angles(ap, an);
 264       ap =   TMath::Tan(ap) * fDz;
 265       an = - TMath::Tan(an) * fDz;
 266
 267       fNCx  = fInfo->fSSDScale[scale];
 268       fNz  = 1;
 269       fNx  = Int_t(fInfo->fSegSSD->Npx()/fNCx);
 270       dpz = 2*fDz/fNz;
 271       dpx = 2*fDx/fNx;
 272
 273       AliITSdigitSSD *od=0;
 274       for (Int_t k=0; k<ndigits; k++) {
 275         od=(AliITSdigitSSD*)digits->UncheckedAt(k);
 276         if(od->GetCoord1() == 1)
 277           i = 1; // p side
 278         else
 279           i= -1; // n side
 280         j = Int_t(od->GetCoord2()/fNCx);
 281         c1 = od->GetCoord1(); c2 = od->GetCoord2();
 282         id = j*i;
 283
 284         miter = dmap.find(id);
 285         ScaledDigit* sd;
 286         if(miter == dmap.end())
 287         {
 288           // printf("orig digit %d,%d scaled %d,%d \n",od->GetCoord1(),od->GetCoord2(),i,j);
 289           dmap[id] = fPlex.Size();
 290           z = dpz*(i) - fDz;
 291           x = dpx*(j) - fDx;
 292           Float_t a = ( od->GetCoord1() == 1) ? ap : an;
 293           AddLine(x-a, -fDz, 2*a, 2*fDz);
 294
 295           sd = new ScaledDigit(c1, c2);
 296           QuadId(sd);
 297         }
 298         else
 299         {
 300           sd = dynamic_cast<ScaledDigit*>(GetId(miter->second));
 301           if(c1 < sd->min_i)
 302             sd->min_i = c1;
 303           else if( c1 > sd->max_i)
 304             sd->max_i = c1;
 305
 306           if(c2 < sd->min_j)
 307             sd->min_j = c2;
 308           else if( c2 > sd->max_j)
 309             sd->max_j = c2;
 310         }
 311         sd->N++;
 312         sd->sum  += od->GetSignal();
 313         sd->sqr_sum += od->GetSignal()*od->GetSignal();
 314       } // for digits
 315       break;
 316     } // end case 2
 317   } // end switch
 318
 319   SetQuadValues();
 320   RefitPlex();
 321 }
 322
 323 /******************************************************************************/
 324
 325 void AliEveITSScaledModule::SetQuadValues()
 326 {
 327   if(fScaleInfo->GetSyncPalette()) SyncPalette();
 328
 329   Int_t N = fPlex.Size();
 330   for (Int_t i = 0 ; i< N; i++)
 331   {
 332     ScaledDigit* sd = dynamic_cast<ScaledDigit*>(GetId(i));
 333     Int_t v = 0;
 334     switch(fScaleInfo->GetStatType())
 335     {
 336       using namespace TMath;
 337
 338       case AliEveDigitScaleInfo::kST_Occup:
 339         v = Nint((100.0*sd->N) / (fNCx*fNCz));
 340         break;
 341       case AliEveDigitScaleInfo::kST_Average:
 342         v = Nint((Double_t) sd->sum / sd->N);
 343         break;
 344       case AliEveDigitScaleInfo::kST_Rms:
 345         v = Nint(Sqrt(sd->sqr_sum) / sd->N);
 346         break;
 347     }
 348     DigitBase_t* qb = GetDigit(i);
 349     qb->fValue = v;
 350   }
 351 }
 352
 353 /******************************************************************************/
 354
 355 void AliEveITSScaledModule::SyncPalette()
 356 {
 357   // printf("AliEveITSScaledModule::SyncPalette()\n");
 358   if(fScaleInfo->GetStatType() == AliEveDigitScaleInfo::kST_Occup)
 359   {
 360     // SPD
 361     AliEveITSModule::fgSPDPalette->SetLimits(0, 100);
 362     AliEveITSModule::fgSPDPalette->SetMinMax(0, 100);
 363
 364     // SDD
 365     AliEveITSModule::fgSDDPalette->SetLimits(0, 100);
 366     AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
 367
 368     // SSD
 369     AliEveITSModule::fgSSDPalette->SetLimits(0, 100);
 370     AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
 371   }
 372   else
 373   {
 374     AliEveITSDigitsInfo& DI = *fInfo;
 375     // SPD
 376     AliEveITSModule::fgSPDPalette->SetLimits(0, DI.fSPDHighLim);
 377     AliEveITSModule::fgSPDPalette->SetMinMax(DI.fSPDMinVal, DI.fSPDMaxVal);
 378
 379     // SDD
 380     AliEveITSModule::fgSDDPalette->SetLimits(0, DI.fSDDHighLim);
 381     AliEveITSModule::fgSDDPalette->SetMinMax(DI.fSDDMinVal, DI.fSDDMaxVal);
 382
 383     // SSD
 384     AliEveITSModule::fgSSDPalette->SetLimits(0, DI.fSSDHighLim);
 385     AliEveITSModule::fgSSDPalette->SetMinMax(DI.fSSDMinVal, DI.fSSDMaxVal);
 386   }
 387
 388   fScaleInfo->SetSyncPalette(kFALSE);
 389 }
 390
 391 /******************************************************************************/
 392
 393 void AliEveITSScaledModule::GetScaleData(Int_t& cnx, Int_t& cnz, Int_t& total)
 394 {
 395   cnx =fNx;
 396   cnz =fNz;
 397   total = cnx*cnz;
 398 }
 399
 400 /******************************************************************************/
 401
 402 void  AliEveITSScaledModule::DigitSelected(Int_t idx)
 403 {
 404   // Override control-click from TEveQuadSet
 405   printf("AliEveITSScaledModule::DigitSelected "); Print();
 406
 407   DigitBase_t* qb  = GetDigit(idx);
 408   TObject* obj  = qb->fId.GetObject();
 409   ScaledDigit* sd = dynamic_cast<ScaledDigit*>(obj);
 410   TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
 411   Int_t ndigits = digits->GetEntriesFast();
 412
 413   printf("%d digits in cell scaleX = %d,  scaleZ = %d \n", sd->N, fNCx, fNCz);
 414
 415   Int_t il = 0;
 416   for(Int_t k=0; k<ndigits; k++)
 417   {
 418     AliITSdigit *d = (AliITSdigit*) digits->UncheckedAt(k);
 419
 420     if(d->GetCoord1()>=sd->min_i && d->GetCoord1()<=sd->max_i &&
 421        d->GetCoord2()>=sd->min_j && d->GetCoord2()<=sd->max_j)
 422     {
 423       printf("%3d, %3d: %3d", d->GetCoord1(), d->GetCoord2(), d->GetSignal());
 424       printf(" | ");
 425       il++;
 426       if(il>5) {
 427         printf("\n");
 428         il = 0;
 429       }
 430     }
 431   }
 432   if(il) printf("\n");
 433 }