d76cad60b5a1e21c4e2bef54c74d13403f00639b
[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       }
261       break;
262     }
263
264     case 1: { // SDD
265       AliITSsegmentationSDD *seg =  fInfo->fSegSDD; 
266
267       Reset(QT_RectangleXZFixedY, kFALSE, 32);
268
269       for (Int_t k=0; k<ndigits; ++k)
270       {
271         AliITSdigitSDD* d = (AliITSdigitSDD*) digits->UncheckedAt(k);
272
273         // if (d->GetSignal() > fgSDDThreshold)
274         {
275           j = d->GetCoord1();
276           i = d->GetCoord2();
277           seg->DetToLocal(i, j, x, z);
278           dpx = seg->Dpx(i)*0.0001;
279           dpz = seg->Dpz(j)*0.0001;
280
281           AddQuad(x-2*dpx, z, 4*dpx, dpz);
282           QuadValue(d->GetSignal());
283         }
284       }
285       break;
286     }
287
288     case 2: { // SSD
289       AliITSsegmentationSSD* seg = fInfo->fSegSSD; 
290
291       Reset(QT_LineXZFixedY, kFALSE, 32);
292
293       Float_t ap, an; // positive/negative angles -> offsets
294       seg->Angles(ap, an);
295       ap =   TMath::Tan(ap) * fDz;
296       an = - TMath::Tan(an) * fDz;
297
298       for (Int_t k=0; k<ndigits; ++k)
299       {
300         AliITSdigitSSD *d = (AliITSdigitSSD*) digits->UncheckedAt(k);
301         // if(d->GetSignal() > fgSSDThreshold)
302         {
303           j = d->GetCoord1();
304           i = d->GetCoord2();
305           seg->DetToLocal(i,j,x,z);
306
307           Float_t a = ( d->GetCoord1() == 1) ? ap : an;
308
309           AddLine(x-a, -fDz, 2*a, 2*fDz);
310           QuadValue(d->GetSignal());
311           // printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
312         }
313       }
314       break;
315     }
316
317   } // end switch
318
319   RefitPlex();
320 }
321
322 /**************************************************************************/
323
324 void ITSModule::SetTrans()
325 {
326   Double_t x[9];
327   fHMTrans.UnitTrans();
328
329    // column major
330   fInfo->fGeom->GetRotMatrix(fID, x);
331   fHMTrans.SetBaseVec(1, x[0], x[3], x[6]);
332   fHMTrans.SetBaseVec(2, x[1], x[4], x[7]);
333   fHMTrans.SetBaseVec(3, x[2], x[5], x[8]);
334   // translation
335   fInfo->fGeom->GetTrans(fID, x);  
336   fHMTrans.SetBaseVec(4, x);
337 }
338
339 /**************************************************************************/
340
341 void ITSModule::Print(Option_t* ) const
342 {
343   printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
344 }