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