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