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