Use two-level selection, implement callback QuadSelected() to print out the digit...
[u/mrichter/AliRoot.git] / 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
12
13 Bool_t       ITSModule::fgStaticInitDone = kFALSE;
14
15 FrameBox*    ITSModule::fgSPDFrameBox = 0;
16 FrameBox*    ITSModule::fgSDDFrameBox = 0;
17 FrameBox*    ITSModule::fgSSDFrameBox = 0;
18
19 RGBAPalette* ITSModule::fgSPDPalette  = 0;
20 RGBAPalette* ITSModule::fgSDDPalette  = 0;
21 RGBAPalette* ITSModule::fgSSDPalette  = 0;
22
23 //__________________________________________________________________________
24 // ITSModule
25 //
26 //
27
28 ClassImp(ITSModule)
29
30 /**************************************************************************/
31
32 ITSModule::ITSModule(const Text_t* n, const Text_t* t) :
33   QuadSet(n, t),
34   fInfo(0),
35   fID(-1), fDetID(-1),
36   fLayer(-1), fLadder(-1), fDet(-1),
37   fDx(0), fDz(0), fDy(0)
38 {}
39
40 ITSModule::ITSModule(Int_t gid, ITSDigitsInfo* info) :
41   QuadSet(Form("ITS module %d", gid)),
42   fInfo  (0),
43   fID(-1), fDetID(-1),
44   fLayer(-1), fLadder(-1), fDet(-1),
45   fDx(0), fDz(0), fDy(0)
46 {
47   SetDigitsInfo(info);
48   SetID(gid);
49 }
50
51 ITSModule::~ITSModule()
52 {
53   if(fInfo) fInfo->DecRefCount();
54 }
55
56 /**************************************************************************/
57
58 void ITSModule::InitStatics(ITSDigitsInfo* info)
59 {
60   if (fgStaticInitDone) return;
61   fgStaticInitDone = kTRUE;
62
63   {
64     Float_t dx = info->fSegSPD->Dx()*0.00005;
65     Float_t dz = 3.48; 
66
67     fgSPDFrameBox = new FrameBox();
68     fgSPDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
69     fgSPDFrameBox->SetFrameColor((Color_t) 31);
70     fgSPDPalette  = new RGBAPalette(0, 1);
71   }
72
73   {
74     Float_t dx = info->fSegSDD->Dx()*0.0001;
75     Float_t dz = info->fSegSDD->Dz()*0.00005;
76
77     fgSDDFrameBox = new FrameBox();
78     fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
79     fgSDDFrameBox->SetFrameColor((Color_t) 32);
80     fgSDDPalette  = new RGBAPalette(5, 80);
81     fgSDDPalette->SetLimits(0, 512); // Set proper ADC range.
82   }
83
84   {
85     Float_t dx = info->fSegSSD->Dx()*0.00005;
86     Float_t dz = info->fSegSSD->Dz()*0.00005;
87
88     fgSSDFrameBox = new FrameBox();
89     fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
90     fgSSDFrameBox->SetFrameColor((Color_t) 33);
91     fgSSDPalette  = new RGBAPalette(2, 100);
92     fgSSDPalette->SetLimits(0, 1024); // Set proper ADC range.
93   }
94
95 }
96
97 /**************************************************************************/
98
99 void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
100 {
101   if (fInfo == info) return;
102   if (fInfo) fInfo->DecRefCount();
103   fInfo = info;
104   if (fInfo) fInfo->IncRefCount();
105 }
106
107 /**************************************************************************/
108
109 void ITSModule::SetID(Int_t gid)
110 {
111   static const Exc_t eH("ITSModule::SetID ");
112
113   if(fInfo == 0)
114     throw(eH + "ITSDigitsInfo not set.");
115
116   if (gid < fInfo->fGeom->GetStartSPD() || gid > fInfo->fGeom->GetLastSSD())
117     throw(eH + Form("%d is not valid. ID range from %d to %d", gid,
118                      fInfo->fGeom->GetStartSPD(), fInfo->fGeom->GetLastSSD()));
119
120   fID = gid;
121
122   if (!fgStaticInitDone) InitStatics(fInfo);
123
124   fInfo->fGeom->GetModuleId(fID, fLayer, fLadder, fDet);
125   TString strLadder = "Ladder";
126   TString strSensor = "Sensor";
127   TString symname;
128   Int_t   id, nsector, nstave, nladder, rest;
129   
130   if (fID <= fInfo->fGeom->GetLastSPD())
131   {
132     // SPD
133
134     SetFrame(fgSPDFrameBox);
135     SetPalette(fgSPDPalette);
136  
137     symname += strLadder;
138     if (fID < 80)
139     {
140       nsector = fID/8;
141       rest    = fID - 8*nsector;
142       nstave  = 1;
143     }
144     else
145     {
146       id      = fID - 80;
147       nsector = id/8;
148       rest    = id - 8*nsector;
149       nstave  = 1;
150     }
151     if (rest < 4) nstave = 0;
152     rest    -= 4*nstave;
153     symname += rest;
154     SetName(symname);
155     fDetID = 0;
156     fDx = fInfo->fSegSPD->Dx()*0.00005;
157     fDz = 3.48; 
158     fDy = fInfo->fSegSPD->Dy()*0.00005;
159
160   }
161   else if (fID <= fInfo->fGeom->GetLastSDD())
162   {
163     // SDD
164
165     SetFrame(fgSDDFrameBox);
166     SetPalette(fgSDDPalette);
167  
168     symname += strSensor;
169     if (fID < 324)
170     {
171       id      = fID - 240;
172       nladder = id/6;
173       rest    = id - 6*nladder;
174     }
175     else
176     {
177       id      = fID - 324;
178       nladder = id/8;
179       rest    = id - 8*nladder;
180     }
181     symname += rest;
182     SetName(symname);
183     fDetID = 1;
184     fDx = fInfo->fSegSDD->Dx()*0.0001;
185     fDz = fInfo->fSegSDD->Dz()*0.00005;
186     fDy = fInfo->fSegSDD->Dy()*0.00005;
187
188   }
189   else
190   {
191     // SSD
192
193     SetFrame(fgSSDFrameBox);
194     SetPalette(fgSSDPalette);
195
196     symname += strSensor;
197     if (fID < 1248)
198     {
199       id      = fID - 500;
200       nladder = id/22;
201       rest    = id - nladder*22;
202     }
203     else
204     {
205       id      = fID - 1248;
206       nladder = id/25;
207       rest    = id - nladder*25;
208     }
209     symname += rest;
210     SetName(symname);
211     fDetID = 2;
212     fInfo->fSegSSD->SetLayer(fLayer);  
213     fDx = fInfo->fSegSSD->Dx()*0.00005;
214     fDz = fInfo->fSegSSD->Dz()*0.00005;
215     fDy = fInfo->fSegSSD->Dy()*0.00005;
216
217   }
218
219   LoadQuads();  
220   ComputeBBox();
221   SetTrans();
222 }
223
224 void ITSModule::LoadQuads()
225 {
226   // Here we still use 'z' for the name of axial coordinates.
227   // The transforamtion matrix aplied rotates y -> z.
228   // We need this as QuadSet offers optimized treatment for
229   // quads in the x-y plane.
230
231   // printf("its module load quads \n");
232
233   TClonesArray *digits;
234   Float_t       x, z, dpx, dpz; 
235   Int_t         i, j, ndigits;
236   digits  = fInfo->GetDigits(fID, fDetID);
237   ndigits = digits->GetEntriesFast(); 
238
239   switch(fDetID)
240   {
241
242     case 0: { // SPD
243       AliITSsegmentationSPD* seg =  fInfo->fSegSPD; 
244
245       Reset(QT_RectangleXZFixedY, kFALSE, 32);
246
247       for (Int_t k=0; k<ndigits; ++k)
248       {
249         AliITSdigitSPD *d = (AliITSdigitSPD*) digits->UncheckedAt(k);
250         j = d->GetCoord1();
251         i = d->GetCoord2();
252         x  = -0.5*seg->Dx() + i*seg->Dpx(0);
253         x *=  0.0001;
254         fInfo->GetSPDLocalZ(j, z);
255         dpx = seg->Dpx(i)*0.0001;
256         dpz = seg->Dpz(j)*0.0001;
257
258         AddQuad(x, z, dpx, dpz);
259         QuadValue(1); // In principle could have color based on number of neigbours
260         QuadId(d);
261       }
262       break;
263     }
264
265     case 1: { // SDD
266       AliITSsegmentationSDD *seg =  fInfo->fSegSDD; 
267
268       Reset(QT_RectangleXZFixedY, kFALSE, 32);
269
270       for (Int_t k=0; k<ndigits; ++k)
271       {
272         AliITSdigitSDD* d = (AliITSdigitSDD*) digits->UncheckedAt(k);
273
274         // if (d->GetSignal() > fgSDDThreshold)
275         {
276           j = d->GetCoord1();
277           i = d->GetCoord2();
278           seg->DetToLocal(i, j, x, z);
279           dpx = seg->Dpx(i)*0.0001;
280           dpz = seg->Dpz(j)*0.0001;
281
282           AddQuad(x-2*dpx, z, 4*dpx, dpz);
283           QuadValue(d->GetSignal());
284           QuadId(d);
285         }
286       }
287       break;
288     }
289
290     case 2: { // SSD
291       AliITSsegmentationSSD* seg = fInfo->fSegSSD; 
292
293       Reset(QT_LineXZFixedY, kFALSE, 32);
294
295       Float_t ap, an; // positive/negative angles -> offsets
296       seg->Angles(ap, an);
297       ap =   TMath::Tan(ap) * fDz;
298       an = - TMath::Tan(an) * fDz;
299
300       for (Int_t k=0; k<ndigits; ++k)
301       {
302         AliITSdigitSSD *d = (AliITSdigitSSD*) digits->UncheckedAt(k);
303         // if(d->GetSignal() > fgSSDThreshold)
304         {
305           j = d->GetCoord1();
306           i = d->GetCoord2();
307           seg->DetToLocal(i,j,x,z);
308
309           Float_t a = ( d->GetCoord1() == 1) ? ap : an;
310
311           AddLine(x-a, -fDz, 2*a, 2*fDz);
312           QuadValue(d->GetSignal());
313           QuadId(d);
314           // printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
315         }
316       }
317       break;
318     }
319
320   } // end switch
321
322   RefitPlex();
323 }
324
325 /**************************************************************************/
326
327 void ITSModule::SetTrans()
328 {
329   Double_t x[9];
330   fHMTrans.UnitTrans();
331
332    // column major
333   fInfo->fGeom->GetRotMatrix(fID, x);
334   fHMTrans.SetBaseVec(1, x[0], x[3], x[6]);
335   fHMTrans.SetBaseVec(2, x[1], x[4], x[7]);
336   fHMTrans.SetBaseVec(3, x[2], x[5], x[8]);
337   // translation
338   fInfo->fGeom->GetTrans(fID, x);  
339   fHMTrans.SetBaseVec(4, x);
340 }
341
342 /**************************************************************************/
343
344 void ITSModule::QuadSelected(Int_t idx)
345 {
346   // Override control-click from QuadSet
347
348   QuadBase* qb   = GetQuad(idx);
349   TObject* obj   = qb->fId.GetObject();
350   AliITSdigit* d = dynamic_cast<AliITSdigit*>(obj);
351   printf("ITSModule::QuadSelected "); Print();
352   printf("  idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
353          idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
354   if (d)
355     printf("  coord1=%3d coord2=%3d signal=%d\n",
356            d->GetCoord1(), d->GetCoord2(), d->GetSignal());
357
358 }
359
360 /**************************************************************************/
361
362 void ITSModule::Print(Option_t* ) const
363 {
364   printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
365 }