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