Comments.
[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.50; 
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(info->fSPDMinVal,info->fSPDMaxVal);
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(info->fSDDMinVal,info->fSDDMaxVal);
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(info->fSSDMinVal,info->fSSDMaxVal);
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, Bool_t trans)
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) {
123     InitStatics(fInfo);
124     
125     fgSPDFrameBox->IncRefCount(this);
126     fgSPDPalette->IncRefCount();
127   
128     fgSDDFrameBox->IncRefCount(this);
129     fgSDDPalette->IncRefCount();
130
131     fgSSDFrameBox->IncRefCount(this);
132     fgSSDPalette->IncRefCount();
133   }
134
135   fInfo->fGeom->GetModuleId(fID, fLayer, fLadder, fDet);
136   TString strLadder = "Ladder";
137   TString strSensor = "Sensor";
138   TString symname;
139   Int_t   id, nsector, nstave, nladder, rest;
140   
141   if (fID <= fInfo->fGeom->GetLastSPD())
142   {
143     // SPD
144
145     SetFrame(fgSPDFrameBox);
146     SetPalette(fgSPDPalette);
147  
148     symname += strLadder;
149     if (fID < 80)
150     {
151       nsector = fID/8;
152       rest    = fID - 8*nsector;
153       nstave  = 1;
154     }
155     else
156     {
157       id      = fID - 80;
158       nsector = id/8;
159       rest    = id - 8*nsector;
160       nstave  = 1;
161     }
162     if (rest < 4) nstave = 0;
163     rest    -= 4*nstave;
164     symname += rest;
165     SetName(symname);
166     fDetID = 0;
167     fDx = fInfo->fSegSPD->Dx()*0.00005;
168     fDz = 3.50; 
169     fDy = fInfo->fSegSPD->Dy()*0.00005;
170
171   }
172   else if (fID <= fInfo->fGeom->GetLastSDD())
173   {
174     // SDD
175
176     SetFrame(fgSDDFrameBox);
177     SetPalette(fgSDDPalette);
178  
179     symname += strSensor;
180     if (fID < 324)
181     {
182       id      = fID - 240;
183       nladder = id/6;
184       rest    = id - 6*nladder;
185     }
186     else
187     {
188       id      = fID - 324;
189       nladder = id/8;
190       rest    = id - 8*nladder;
191     }
192     symname += rest;
193     SetName(symname);
194     fDetID = 1;
195     fDx = fInfo->fSegSDD->Dx()*0.0001;
196     fDz = fInfo->fSegSDD->Dz()*0.00005;
197     fDy = fInfo->fSegSDD->Dy()*0.00005;
198
199   }
200   else
201   {
202     // SSD
203
204     SetFrame(fgSSDFrameBox);
205     SetPalette(fgSSDPalette);
206
207     symname += strSensor;
208     if (fID < 1248)
209     {
210       id      = fID - 500;
211       nladder = id/22;
212       rest    = id - nladder*22;
213     }
214     else
215     {
216       id      = fID - 1248;
217       nladder = id/25;
218       rest    = id - nladder*25;
219     }
220     symname += rest;
221     SetName(symname);
222     fDetID = 2;
223     fInfo->fSegSSD->SetLayer(fLayer);  
224     fDx = fInfo->fSegSSD->Dx()*0.00005;
225     fDz = fInfo->fSegSSD->Dz()*0.00005;
226     fDy = fInfo->fSegSSD->Dy()*0.00005;
227
228   }
229
230   LoadQuads();  
231   ComputeBBox();
232   if (trans)
233     SetTrans();
234 }
235
236 void ITSModule::LoadQuads()
237 {
238   // Here we still use 'z' for the name of axial coordinates.
239   // The transforamtion matrix aplied rotates y -> z.
240   // We need this as QuadSet offers optimized treatment for
241   // quads in the x-y plane.
242
243   // printf("its module load quads \n");
244
245   TClonesArray *digits  = fInfo->GetDigits(fID, fDetID);
246   Int_t         ndigits = digits ? digits->GetEntriesFast() : 0;
247
248   Float_t       x, z, dpx, dpz; 
249   Int_t         i, j;
250
251   switch(fDetID)
252   {
253
254     case 0: { // SPD
255       AliITSsegmentationSPD* seg =  fInfo->fSegSPD; 
256
257       Reset(QT_RectangleXZFixedY, kFALSE, 32);
258
259       for (Int_t k=0; k<ndigits; ++k)
260       {
261         AliITSdigit *d = (AliITSdigit*) digits->UncheckedAt(k);
262         j = d->GetCoord1();
263         i = d->GetCoord2();
264         x  = -0.5*seg->Dx() + i*seg->Dpx(0);
265         x *=  0.0001;
266         fInfo->GetSPDLocalZ(j, z);
267         dpx = seg->Dpx(i)*0.0001;
268         dpz = seg->Dpz(j)*0.0001;
269
270         AddQuad(x, z, dpx, dpz);
271         QuadValue(1); // In principle could have color based on number of neigbours
272         QuadId(d);
273       }
274       break;
275     }
276
277     case 1: { // SDD
278       AliITSsegmentationSDD *seg =  fInfo->fSegSDD; 
279
280       Reset(QT_RectangleXZFixedY, kFALSE, 32);
281
282       for (Int_t k=0; k<ndigits; ++k)
283       {
284         AliITSdigit* d = (AliITSdigit*) digits->UncheckedAt(k);
285
286         // if (d->GetSignal() > fgSDDThreshold)
287         {
288           j = d->GetCoord1();
289           i = d->GetCoord2();
290           seg->DetToLocal(i, j, x, z);
291           dpx = seg->Dpx(i)*0.0001;
292           dpz = seg->Dpz(j)*0.0001;
293
294           AddQuad(x-2*dpx, z - dpz*0.5, 4*dpx, dpz);
295           QuadValue(d->GetSignal());
296           QuadId(d);
297         }
298       }
299       break;
300     }
301
302     case 2: { // SSD
303       AliITSsegmentationSSD* seg = fInfo->fSegSSD; 
304
305       Reset(QT_LineXZFixedY, kFALSE, 32);
306
307       Float_t ap, an; // positive/negative angles -> offsets
308       seg->Angles(ap, an);
309       ap =   TMath::Tan(ap) * fDz;
310       an = - TMath::Tan(an) * fDz;
311
312       for (Int_t k=0; k<ndigits; ++k)
313       {
314         AliITSdigit *d = (AliITSdigit*) digits->UncheckedAt(k);
315         // if(d->GetSignal() > fgSSDThreshold)
316         {
317           j = d->GetCoord1();
318           i = d->GetCoord2();
319           seg->DetToLocal(i,j,x,z);
320
321           Float_t a = ( d->GetCoord1() == 1) ? ap : an;
322
323           AddLine(x-a, -fDz, 2*a, 2*fDz);
324           QuadValue(d->GetSignal());
325           QuadId(d);
326           // printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
327         }
328       }
329       break;
330     }
331
332   } // end switch
333
334   RefitPlex();
335 }
336
337 /**************************************************************************/
338
339 void ITSModule::SetTrans()
340 {
341   // Set transformation matrix based on module id (use geometry to
342   // retrieve this information).
343
344   Double_t x[9];
345   fHMTrans.UnitTrans();
346
347   // !!!! Here should use AliITSgeomTGeo ... but can i be sure
348   // the geometry has been loaded?
349
350   // column major
351   fInfo->fGeom->GetRotMatrix(fID, x);
352   fHMTrans.SetBaseVec(1, x[0], x[3], x[6]);
353   fHMTrans.SetBaseVec(2, x[1], x[4], x[7]);
354   fHMTrans.SetBaseVec(3, x[2], x[5], x[8]);
355   // translation
356   fInfo->fGeom->GetTrans(fID, x);  
357   fHMTrans.SetBaseVec(4, x);
358 }
359
360 /**************************************************************************/
361
362 void ITSModule::QuadSelected(Int_t idx)
363 {
364   // Override control-click from QuadSet
365
366   QuadBase* qb   = GetQuad(idx);
367   TObject* obj   = qb->fId.GetObject();
368   AliITSdigit* d = dynamic_cast<AliITSdigit*>(obj);
369   printf("ITSModule::QuadSelected "); Print();
370   printf("  idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
371          idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
372   if (d)
373     printf("  coord1=%3d coord2=%3d signal=%d\n",
374            d->GetCoord1(), d->GetCoord2(), d->GetSignal());
375
376 }
377
378 /**************************************************************************/
379
380 void ITSModule::Print(Option_t* ) const
381 {
382   printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
383 }