From Francesco:
[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveITSDigitsInfo.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 "AliEveITSDigitsInfo.h"
11 #include <EveBase/AliEveEventManager.h>
12
13 #include <TEveTreeTools.h>
14 #include <TEveTrans.h>
15
16 #include <AliITS.h>
17 #include <AliITSInitGeometry.h>
18 #include <AliITSgeom.h>
19 #include <AliITSsegmentationSPD.h>
20 #include <AliITSsegmentationSDD.h>
21 #include <AliITSsegmentationSSD.h>
22 #include <AliITSDDLModuleMapSDD.h>
23
24 #include <AliITSCalibrationSDD.h>
25 #include <AliITSdigit.h>
26 #include <AliITSdigitSPD.h>
27
28 #include <AliCDBEntry.h>
29 #include <AliCDBManager.h>
30
31 #include <AliRawReader.h>
32 #include <AliITSRawStreamSPD.h>
33 #include <AliITSRawStreamSDD.h>
34 #include <AliITSRawStreamSSD.h>
35
36 #include <TMath.h>
37 #include <TVector3.h>
38
39 //______________________________________________________________________________
40 //
41 // Helper for selecting a range of ITS modules by type, layer, phi and
42 // theta. Taken as an argument to AliEveITSDigitsInfo::GetModuleIDs().
43
44 ClassImp(AliEveITSModuleSelection)
45
46 AliEveITSModuleSelection::AliEveITSModuleSelection():
47   fType(-1),
48   fLayer(-1),
49   fMinPhi(-TMath::Pi()),
50   fMaxPhi(TMath::Pi()),
51   fMinTheta(-TMath::Pi()),
52   fMaxTheta(TMath::Pi())
53 {
54   // Constructor.
55 }
56
57
58 //______________________________________________________________________________
59 //
60 // Stores ITS geometry information and event-data in format suitable
61 // for visualization.
62
63 ClassImp(AliEveITSDigitsInfo)
64
65 /******************************************************************************/
66
67 AliEveITSDigitsInfo::AliEveITSDigitsInfo() :
68   TObject(),
69   TEveRefCnt(),
70   fSPDmap(), fSDDmap(), fSSDmap(),
71   fTree (0),
72   fGeom (0),
73   fSegSPD     (0), fSegSDD     (0), fSegSSD     (0),
74   fDDLMapSDD  (0),
75   fSPDMinVal  (0), fSSDMinVal  (0), fSDDMinVal  (0),
76   fSPDMaxVal  (0), fSSDMaxVal  (0), fSDDMaxVal  (0),
77   fSPDHighLim (0), fSDDHighLim (0), fSSDHighLim (0)
78 {
79   // Default constructor.
80
81   InitInternals();
82 }
83
84 void AliEveITSDigitsInfo::InitInternals()
85 {
86   // Initialize internal geometry structures, in particular the
87   // module-id to transformation-matrix mapping and segmentation
88   // classes and data-structures.
89
90   static const TEveException eH("AliEveITSDigitsInfo::InitInternals ");
91
92   AliEveEventManager::AssertGeometry();
93   AliITSInitGeometry initGeom;
94   fGeom = initGeom.CreateAliITSgeom();
95
96   SetITSSegmentation();
97
98   // create tables for scaling
99   fSPDMinVal = 0;
100   fSDDMinVal = 5;
101   fSSDMinVal = 2;
102
103   fSPDMaxVal = 1;
104   fSDDMaxVal = 80;
105   fSSDMaxVal = 100;
106
107   fSPDHighLim = 1;
108   fSDDHighLim = 512;
109   fSSDHighLim = 1024;
110
111   // lowest scale factor refers to unscaled ITS module
112   fSPDScaleX[0] = 1;
113   fSPDScaleZ[0] = 1;
114   fSDDScaleX[0] = 1;
115   fSDDScaleZ[0] = 1;
116   fSSDScale [0] = 1;
117
118   // spd lowest resolution
119   Int_t nx = 8; // fSegSPD->Npx()/8; // 32
120   Int_t nz = 6; // fSegSPD->Npz()/2; // 128
121   fSPDScaleX[1] = Int_t(nx);
122   fSPDScaleZ[1] = Int_t(nz);
123   fSPDScaleX[2] = Int_t(nx*2);
124   fSPDScaleZ[2] = Int_t(nz*2);
125   fSPDScaleX[3] = Int_t(nx*3);
126   fSPDScaleZ[3] = Int_t(nz*3);
127   fSPDScaleX[4] = Int_t(nx*4);
128   fSPDScaleZ[4] = Int_t(nz*4);
129
130   fSDDScaleX[1] = 2;
131   fSDDScaleZ[1] = 2;
132   fSDDScaleX[2] = 8;
133   fSDDScaleZ[2] = 8;
134   fSDDScaleX[3] = 16;
135   fSDDScaleZ[3] = 16;
136   fSDDScaleX[4] = 25;
137   fSDDScaleZ[4] = 25;
138
139   fSSDScale[1] = 3;
140   fSSDScale[2] = 9;
141   fSSDScale[3] = 20;
142   fSSDScale[4] = 30;
143   
144   fDDLMapSDD = new AliITSDDLModuleMapSDD();
145   AliCDBManager *man       = AliCDBManager::Instance();
146   AliCDBEntry   *ddlMapSDD = man->Get("ITS/Calib/DDLMapSDD");
147   ddlMapSDD->SetOwner(kTRUE);
148   if (!ddlMapSDD) {
149     AliWarning("SDD DDL map file retrieval from OCDB failed! - Use default DDL map");
150   } else {
151     AliITSDDLModuleMapSDD *ddlsdd = (AliITSDDLModuleMapSDD*)ddlMapSDD->GetObject();
152     if (!ddlsdd) {
153       AliWarning("SDD DDL map object not found in OCDB file! - Use default DDL map");
154     } else {
155       fDDLMapSDD->SetDDLMap(ddlsdd);
156     }
157   }
158   delete ddlMapSDD;
159 }
160
161 /******************************************************************************/
162
163 AliEveITSDigitsInfo:: ~AliEveITSDigitsInfo()
164 {
165   // Destructor.
166   // Deletes the data-maps and the tree.
167
168   std::map<Int_t, TClonesArray*>::iterator j;
169   for (j = fSPDmap.begin(); j != fSPDmap.end(); ++j)
170     delete j->second;
171   for (j = fSDDmap.begin(); j != fSDDmap.end(); ++j)
172     delete j->second;
173   for (j = fSSDmap.begin(); j != fSSDmap.end(); ++j)
174     delete j->second;
175   delete fDDLMapSDD;
176   delete fSegSPD; delete fSegSDD; delete fSegSSD;
177   delete fGeom;
178   delete fTree;
179 }
180
181 /******************************************************************************/
182
183 void AliEveITSDigitsInfo::SetTree(TTree* tree)
184 {
185   // Set digit-tree to be used for digit retrieval. Data is loaded on
186   // demand.
187
188   fTree = tree;
189 }
190
191 void AliEveITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
192 {
193   // Read raw-data into internal structures. AliITSdigit is used to
194   // store raw-adata for all sub-detectors.
195
196   if ((mode & 1) || (mode & 2))
197   {
198     AliITSRawStreamSPD inputSPD(raw);
199     TClonesArray* digits = 0;
200     while (inputSPD.Next())
201     {
202       Int_t module = inputSPD.GetModuleID();
203       Int_t column = inputSPD.GetColumn();
204       Int_t row    = inputSPD.GetRow();
205
206       if (inputSPD.IsNewModule())
207       {
208         digits = fSPDmap[module];
209         if (digits == 0)
210           fSPDmap[module] = digits = new TClonesArray("AliITSdigit", 16);
211       }
212
213       AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
214       d->SetCoord1(column);
215       d->SetCoord2(row);
216       d->SetSignal(1);
217
218       // printf("SPD: %d %d %d\n",module,column,row);
219     }
220     raw->Reset();
221   }
222
223   if ((mode & 4) || (mode & 8))
224   {
225     AliITSRawStreamSDD input(raw);
226     input.SetDDLModuleMap(fDDLMapSDD);
227     TClonesArray* digits = 0;
228     while (input.Next())
229     {
230       Int_t module = input.GetModuleID();
231       Int_t anode  = input.GetAnode();
232       Int_t time   = input.GetTime();
233       Int_t signal = input.GetSignal();
234
235       if (input.IsNewModule())
236       {
237         digits = fSDDmap[module];
238         if (digits == 0)
239           fSDDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
240       }
241
242       AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
243       d->SetCoord1(anode);
244       d->SetCoord2(time);
245       d->SetSignal(signal);
246
247       // printf("SDD: %d %d %d %d\n",module,anode,time,signal);
248     }
249     raw->Reset();
250   }
251
252   if ((mode & 16) || (mode & 32))
253   {
254     AliITSRawStreamSSD input(raw);
255     TClonesArray* digits = 0;
256     while (input.Next())
257     {
258       Int_t module  = input.GetModuleID();
259       Int_t side    = input.GetSideFlag();
260       Int_t strip   = input.GetStrip();
261       Int_t signal  = input.GetSignal();
262
263       if (input.IsNewModule())
264       {
265         digits = fSSDmap[module];
266         if (digits == 0)
267           fSSDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
268       }
269
270       AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
271       d->SetCoord1(side);
272       d->SetCoord2(strip);
273       d->SetSignal(signal);
274
275       // printf("SSD: %d %d %d %d\n",module,side,strip,signal);
276     }
277     raw->Reset();
278   }
279 }
280
281 /******************************************************************************/
282
283 void AliEveITSDigitsInfo::SetITSSegmentation()
284 {
285   // Create the segmentation objects and fill internal
286   // data-structures.
287
288   // SPD
289   fSegSPD = new AliITSsegmentationSPD(fGeom);
290
291   Int_t m;
292   Float_t fNzSPD=160;
293   Float_t fZ1pitchSPD=0.0425; Float_t fZ2pitchSPD=0.0625;
294   Float_t fHlSPD=3.48;
295
296   fSPDZCoord[0]=fZ1pitchSPD -fHlSPD;
297   for (m=1; m<fNzSPD; m++) {
298     Double_t dz=fZ1pitchSPD;
299     if (m==31 || m==32 || m==63  || m==64  || m==95 || m==96 ||
300         m==127 || m==128) dz=fZ2pitchSPD;
301     fSPDZCoord[m]=fSPDZCoord[m-1]+dz;
302   }
303
304   for (m=0; m<fNzSPD; m++) {
305     Double_t dz=1.*fZ1pitchSPD;
306     if (m==31 || m==32 || m==63  || m==64  || m==95 || m==96 ||
307         m==127 || m==128) dz=1.*fZ2pitchSPD;
308     fSPDZCoord[m]-=dz;
309   }
310
311   // SDD
312   fSegSDD = new AliITSsegmentationSDD(fGeom);
313   // !!!! Set default drift speed, eventually need to get it from CDB.
314   fSegSDD->SetDriftSpeed(7.3);
315
316   // SSD
317   fSegSSD = new AliITSsegmentationSSD(fGeom);
318 }
319
320 /******************************************************************************/
321
322 TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
323 {
324   // Return TClonesArray of digits for specified module and sub-detector-id.
325
326   switch(subdet)
327   {
328     case 0:
329     {
330       TClonesArray* digitsSPD = 0;
331       std::map<Int_t, TClonesArray*>::iterator i = fSPDmap.find(mod);
332       if (i == fSPDmap.end()) {
333         if (fTree) {
334           TBranch* br =  fTree->GetBranch("ITSDigitsSPD");
335           br->SetAddress(&digitsSPD);
336           br->GetEntry(mod);
337           fSPDmap[mod] = digitsSPD;
338           return digitsSPD;
339         }
340         else
341           return NULL;
342       } else {
343         return i->second;
344       }
345       break;
346     }
347     case 1:
348     {
349       TClonesArray* digitsSDD = 0;
350       std::map<Int_t, TClonesArray*>::iterator i = fSDDmap.find(mod);
351       if (i == fSDDmap.end()) {
352         if (fTree) {
353           TBranch* br =  fTree->GetBranch("ITSDigitsSDD");
354           br->SetAddress(&digitsSDD);
355           br->GetEntry(mod);
356           fSDDmap[mod] = digitsSDD;
357           return digitsSDD;
358         }
359         else
360           return NULL;
361        } else {
362         return i->second;
363       }
364       break;
365     }
366     case 2:
367     {
368       TClonesArray* digitsSSD = 0;
369       std::map<Int_t, TClonesArray*>::iterator i = fSSDmap.find(mod);
370       if (i == fSSDmap.end()) {
371         if (fTree) {
372           TBranch* br =  fTree->GetBranch("ITSDigitsSSD");
373           br->SetAddress(&digitsSSD);
374           br->GetEntry(mod);
375
376           fSSDmap[mod] = digitsSSD;
377           return digitsSSD;
378         }
379         else
380           return NULL;
381        } else {
382         return i->second;
383       }
384       break;
385     }
386     default:
387       return 0;
388   }
389   return 0;
390 }
391
392 /******************************************************************************/
393
394 void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel,
395                                        std::vector<UInt_t>& ids)
396 {
397   // Fill the id-vector with ids of modules that satisfy conditions
398   // given by the AliEveITSModuleSelection object.
399
400   Int_t idx0 = 0, idx1 = 0;
401   switch(sel->GetType())
402   {
403     case 0:
404       idx0 = 0;
405       idx1 = fGeom->GetLastSPD();
406       break;
407     case 1:
408       idx0 = fGeom->GetLastSPD()+1;
409       idx1 = fGeom->GetLastSDD();
410       break;
411     case 2:
412       idx0 = fGeom->GetLastSDD()+1;
413       idx1 = fGeom->GetLastSSD();
414       break;
415     default:
416       idx1 = 0;
417       idx1 = fGeom->GetLastSSD();
418       break;
419   }
420
421   TVector3 v;
422   Double_t x[9];
423   Int_t lay, lad, det;
424   TEveTrans mx;
425   for (Int_t id = idx0; id<idx1; ++id)
426   {
427     fGeom->GetModuleId(id, lay, lad, det);
428     if (sel->GetLayer() == lay || sel->GetLayer() == -1)
429     {
430       // check data from matrix
431       mx.UnitTrans();
432       fGeom->GetRotMatrix(id, x);
433       mx.SetBaseVec(1, x[0], x[3], x[6]);
434       mx.SetBaseVec(2, x[1], x[4], x[7]);
435       mx.SetBaseVec(3, x[2], x[5], x[8]);
436       fGeom->GetTrans(id, x);
437       mx.SetBaseVec(4, x);
438       mx.GetPos(v);
439       if (v.Phi()   <= sel->GetMaxPhi()   && v.Phi()   >= sel->GetMinPhi()   &&
440           v.Theta() <= sel->GetMaxTheta() && v.Theta() >= sel->GetMinTheta())
441       {
442         ids.push_back(id);
443       }
444     }
445   }
446 }
447
448 /******************************************************************************/
449
450 void AliEveITSDigitsInfo::Print(Option_t* ) const
451 {
452   // Print information about stored geometry and segmentation.
453
454   printf("*********************************************************\n");
455   printf("SPD module dimension (%f,%f)\n",           fSegSPD->Dx()*0.0001, fSegSPD->Dz()*0.0001);
456   printf("SPD first,last module:: %d,%d\n",          fGeom->GetStartSPD(), fGeom->GetLastSPD() );
457   printf("SPD num cells per module (x::%d,z::%d)\n", fSegSPD->Npx(), fSegSPD->Npz());
458   Int_t iz = 0, ix = 0;
459   printf("SPD dimesion of (%d,%d) in pixel(%f,%f)\n",   ix, iz, fSegSPD->Dpx(ix), fSegSPD->Dpz(iz));
460   iz = 32;
461   printf("SPD dimesion of pixel (%d,%d) are (%f,%f)\n", ix, iz, fSegSPD->Dpx(ix)*0.001, fSegSPD->Dpz(iz)*0.001);
462
463   printf("*********************************************************\n");
464   printf("SDD module dimension (%f,%f)\n",           fSegSDD->Dx()*0.0001, fSegSDD->Dz()*0.0001);
465   printf("SDD first,last module:: %d,%d\n",          fGeom->GetStartSDD(), fGeom->GetLastSDD());
466   printf("SDD num cells per module (x::%d,z::%d)\n", fSegSDD->Npx(), fSegSDD->Npz());
467   printf("SDD dimesion of pixel are (%f,%f)\n",      fSegSDD->Dpx(1)*0.001, fSegSDD->Dpz(1)*0.001);
468
469   Float_t ap, an;
470   printf("*********************************************************\n");
471   printf("SSD module dimension (%f,%f)\n",  fSegSSD->Dx()*0.0001, fSegSSD->Dz()*0.0001);
472   printf("SSD first,last module:: %d,%d\n", fGeom->GetStartSSD(), fGeom->GetLastSSD() );
473   printf("SSD strips in module %d\n",       fSegSSD->Npx());
474   printf("SSD strip sizes are (%f,%f)\n",   fSegSSD->Dpx(1), fSegSSD->Dpz(1));
475   fSegSSD->SetLayer(5);  fSegSSD->Angles(ap,an);
476   printf("SSD layer 5 stereoP %f stereoN %f angle\n", ap, an);
477   fSegSSD->SetLayer(6);  fSegSSD->Angles(ap,an);
478   printf("SSD layer 6 stereoP %f stereoN %f angle\n", ap, an);
479 }
480
481
482 /*
483   printf("num cells %d,%d scaled %d,%d \n",fSegSPD->Npz(),fSegSPD->Npx(),Nz,Nx);
484   printf("%d digits in AliEveITSModule %d\n",ne, module);
485   Float_t zn = i*(3.48*2)/Nz - 3.48 ;
486   Float_t xo =  -fSegSPD->Dx()*0.00005 + fSegSPD->Dpx(0)*od->GetCoord2()*0.0001;
487   Float_t xn =  -fSegSPD->Dx()*0.00005 + j*0.0001*fSegSPD->Dx()/Nx;
488   Float_t dpx = 0.0001*fSegSPD->Dx()/Nx;
489   Float_t dpz = 3.48*2/Nz;
490   printf("Z::original (%3f) scaled (%3f, %3f) \n", zo, zn-dpz/2, zn+dpz/2);
491   printf("X::original (%3f) scaled (%3f, %3f) \n", xo, xn-dpx/2, xn+dpx/2);
492   printf("%d,%d maped to %d,%d \n", od->GetCoord1(), od->GetCoord2(), i,j );
493 */