2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
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 **************************************************************************/
10 #include "AliEveITSDigitsInfo.h"
11 #include <AliEveEventManager.h>
14 #include <AliITSInitGeometry.h>
15 #include <AliITSgeomTGeo.h>
16 #include <AliITSsegmentationSPD.h>
17 #include <AliITSsegmentationSDD.h>
18 #include <AliITSsegmentationSSD.h>
19 #include <AliITSDDLModuleMapSDD.h>
21 #include <AliITSCalibrationSPD.h>
22 #include <AliITSCalibrationSDD.h>
23 #include <AliITSCalibrationSSD.h>
24 #include <AliITSdigit.h>
25 #include <AliITSdigitSPD.h>
27 #include <AliCDBEntry.h>
28 #include <AliCDBManager.h>
30 #include <AliRawReader.h>
31 #include <AliITSRawStreamSPD.h>
32 #include <AliITSRawStreamSDD.h>
33 #include <AliITSRawStreamSDDCompressed.h>
34 #include <AliITSRawStreamSSD.h>
36 #include <TGeoMatrix.h>
37 #include <TEveTrans.h>
43 //==============================================================================
44 //==============================================================================
45 // AliEveITSModuleSelection
46 //==============================================================================
48 //______________________________________________________________________________
50 // Helper for selecting a range of ITS modules by type, layer, phi and
51 // theta. Taken as an argument to AliEveITSDigitsInfo::GetModuleIDs().
53 ClassImp(AliEveITSModuleSelection)
55 AliEveITSModuleSelection::AliEveITSModuleSelection():
58 fMinPhi(-TMath::Pi()),
60 fMinTheta(-TMath::Pi()),
61 fMaxTheta(TMath::Pi())
67 //==============================================================================
68 //==============================================================================
69 // AliEveITSDigitsInfo
70 //==============================================================================
72 //______________________________________________________________________________
74 // Stores ITS geometry information and event-data in format suitable
77 ClassImp(AliEveITSDigitsInfo)
79 AliITSDDLModuleMapSDD *AliEveITSDigitsInfo::fgDDLMapSDD = 0;
80 TObjArray *AliEveITSDigitsInfo::fgDeadModSPD = 0;
81 TObjArray *AliEveITSDigitsInfo::fgDeadModSDD = 0;
82 TObjArray *AliEveITSDigitsInfo::fgDeadModSSD = 0;
84 /******************************************************************************/
86 AliEveITSDigitsInfo::AliEveITSDigitsInfo() :
90 fSegSPD (0), fSegSDD (0), fSegSSD (0),
91 fSPDMinVal (0), fSSDMinVal (0), fSDDMinVal (0),
92 fSPDMaxVal (0), fSSDMaxVal (0), fSDDMaxVal (0),
93 fSPDHighLim (0), fSDDHighLim (0), fSSDHighLim (0),
94 fSPDmap (), fSDDmap (), fSSDmap ()
96 // Default constructor.
101 void AliEveITSDigitsInfo::InitInternals()
103 // Initialize internal geometry structures, in particular the
104 // module-id to transformation-matrix mapping and segmentation
105 // classes and data-structures.
107 static const TEveException kEH("AliEveITSDigitsInfo::InitInternals ");
109 AliEveEventManager::AssertGeometry();
111 SetITSSegmentation();
113 // create tables for scaling
126 // lowest scale factor refers to unscaled ITS module
133 // spd lowest resolution
134 Int_t nx = 8; // fSegSPD->Npx()/8; // 32
135 Int_t nz = 6; // fSegSPD->Npz()/2; // 128
136 fSPDScaleX[1] = Int_t(nx);
137 fSPDScaleZ[1] = Int_t(nz);
138 fSPDScaleX[2] = Int_t(nx*2);
139 fSPDScaleZ[2] = Int_t(nz*2);
140 fSPDScaleX[3] = Int_t(nx*3);
141 fSPDScaleZ[3] = Int_t(nz*3);
142 fSPDScaleX[4] = Int_t(nx*4);
143 fSPDScaleZ[4] = Int_t(nz*4);
159 if (fgDDLMapSDD == 0)
161 fgDDLMapSDD = new AliITSDDLModuleMapSDD();
162 AliCDBManager *man = AliCDBManager::Instance();
163 Bool_t cacheStatus = man->GetCacheFlag();
164 AliCDBEntry *ddlMapSDD = man->Get("ITS/Calib/DDLMapSDD");
168 AliWarning("SDD DDL map file retrieval from OCDB failed! - Use default DDL map");
172 AliITSDDLModuleMapSDD *ddlsdd = (AliITSDDLModuleMapSDD*)ddlMapSDD->GetObject();
175 AliWarning("SDD DDL map object not found in OCDB file! - Use default DDL map");
180 ddlMapSDD->SetObject(0);
181 ddlMapSDD->SetOwner(kTRUE);
182 fgDDLMapSDD->SetDDLMap(ddlsdd);
190 if (fgDeadModSPD == 0)
192 AliCDBManager *cdb = AliCDBManager::Instance();
194 AliCDBEntry *deadSPD = cdb->Get("ITS/Calib/SPDDead");
198 AliWarning("SPD Calibration object retrieval failed!");
202 fgDeadModSPD = (TObjArray*)deadSPD->GetObject();
203 fgDeadModSPD->SetOwner(kTRUE);
207 // if (fgDeadModSDD == 0)
209 // AliCDBManager *cdb = AliCDBManager::Instance();
211 // AliCDBEntry *deadSDD = cdb->Get("ITS/Calib/SDDDead");
215 // AliWarning("SDD Calibration object retrieval failed!");
219 // fgDeadModSDD = (TObjArray*)deadSDD->GetObject();
220 // fgDeadModSDD->SetOwner(kTRUE);
224 // if (fgDeadModSSD == 0)
226 // AliCDBManager *cdb = AliCDBManager::Instance();
228 // AliCDBEntry *deadSSD = cdb->Get("ITS/Calib/SSDDead");
232 // AliWarning("SSD Calibration object retrieval failed!");
236 // fgDeadModSSD = (TObjArray*)deadSSD->GetObject();
237 // fgDeadModSSD->SetOwner(kTRUE);
242 /******************************************************************************/
244 AliEveITSDigitsInfo::~AliEveITSDigitsInfo()
247 // Deletes the data-maps.
248 // The tree, if it was passed into the object, is not touched.
250 std::map<Int_t, TClonesArray*>::iterator j;
251 for (j = fSPDmap.begin(); j != fSPDmap.end(); ++j)
253 for (j = fSDDmap.begin(); j != fSDDmap.end(); ++j)
255 for (j = fSSDmap.begin(); j != fSSDmap.end(); ++j)
258 delete fSegSPD; delete fSegSDD; delete fSegSSD;
261 /******************************************************************************/
263 void AliEveITSDigitsInfo::SetTree(TTree* tree)
265 // Set digit-tree to be used for digit retrieval. Data is loaded on
271 void AliEveITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
273 // Read raw-data into internal structures. AliITSdigit is used to
274 // store raw-adata for all sub-detectors.
276 if ((mode & 1) || (mode & 2))
278 AliITSRawStreamSPD inputSPD(raw);
279 TClonesArray* digits = 0;
280 while (inputSPD.Next())
282 Int_t module = inputSPD.GetModuleID();
283 Int_t column = inputSPD.GetColumn();
284 Int_t row = inputSPD.GetRow();
286 if (inputSPD.IsNewModule())
288 digits = fSPDmap[module];
290 fSPDmap[module] = digits = new TClonesArray("AliITSdigit", 16);
292 AliFatal("No module found\n");
295 AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
296 d->SetCoord1(column);
300 // printf("SPD: %d %d %d\n",module,column,row);
305 if ((mode & 4) || (mode & 8))
307 AliITSRawStream* inputSDD = AliITSRawStreamSDD::CreateRawStreamSDD(raw);
308 inputSDD->SetDDLModuleMap(fgDDLMapSDD);
309 TClonesArray* digits = 0;
310 while (inputSDD->Next())
312 Int_t module = inputSDD->GetModuleID();
314 digits = fSDDmap[module];
316 fSDDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
318 if (inputSDD->IsCompletedModule()==kFALSE && inputSDD->IsCompletedDDL()==kFALSE)
320 Int_t anode = inputSDD->GetCoord1()+inputSDD->GetChannel()*AliITSsegmentationSDD::GetNAnodesPerHybrid();
321 Int_t time = inputSDD->GetCoord2();
322 Int_t signal = inputSDD->GetSignal();
323 AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
326 d->SetSignal(signal);
328 // printf("SDD: %d %d %d %d\n",module,anode,time,signal);
334 if ((mode & 16) || (mode & 32))
336 AliITSRawStreamSSD input(raw);
337 TClonesArray* digits = 0;
340 Int_t module = input.GetModuleID();
341 Int_t side = input.GetSideFlag();
342 Int_t strip = input.GetStrip();
343 Int_t signal = input.GetSignal();
345 // !!!! IsNewModule() is false in the beginning of the stream, so we also
346 // !!!! check for digits == 0. Should be fixed in SSD stream.
347 if (input.IsNewModule() || digits == 0)
349 digits = fSSDmap[module];
351 fSSDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
354 AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
357 d->SetSignal(signal);
359 // printf("SSD: %d %d %d %d\n",module,side,strip,signal);
365 /******************************************************************************/
367 void AliEveITSDigitsInfo::SetITSSegmentation()
369 // Create the segmentation objects and fill internal
373 fSegSPD = new AliITSsegmentationSPD("TGeo");
375 Float_t fNzSPD = 160;
376 Float_t fHlSPD = 3.48;
377 Float_t fZ1pitchSPD = 0.0425, fZ2pitchSPD = 0.0625;
379 fSPDZCoord[0] = fZ1pitchSPD - fHlSPD;
380 for (Int_t m=1; m<fNzSPD; m++)
382 Float_t dz = fZ1pitchSPD;
383 if (m==31 || m==32 || m==63 || m==64 || m==95 || m==96 || m==127 || m==128)
387 fSPDZCoord[m] = fSPDZCoord[m-1] + dz;
390 for (Int_t m=0; m<fNzSPD; m++)
392 Float_t dz = fZ1pitchSPD;
393 if (m==31 || m==32 || m==63 || m==64 || m==95 || m==96 || m==127 || m==128)
401 fSegSDD = new AliITSsegmentationSDD("TGeo");
402 // !!!! Set default drift speed, eventually need to get it from CDB.
403 fSegSDD->SetDriftSpeed(7.3);
406 fSegSSD = new AliITSsegmentationSSD("TGeo");
409 /******************************************************************************/
411 TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet) const
413 // Return TClonesArray of digits for specified module and sub-detector-id.
419 std::map<Int_t, TClonesArray*>::iterator i = fSPDmap.find(mod);
420 if (i != fSPDmap.end())
426 TClonesArray *digitsSPD = 0;
427 TBranch *br = fTree->GetBranch("ITSDigitsSPD");
428 br->SetAddress(&digitsSPD);
430 fSPDmap[mod] = digitsSPD;
438 std::map<Int_t, TClonesArray*>::iterator i = fSDDmap.find(mod);
439 if (i != fSDDmap.end())
445 TClonesArray *digitsSDD = 0;
446 TBranch *br = fTree->GetBranch("ITSDigitsSDD");
447 br->SetAddress(&digitsSDD);
449 fSDDmap[mod] = digitsSDD;
457 std::map<Int_t, TClonesArray*>::iterator i = fSSDmap.find(mod);
458 if (i != fSSDmap.end())
464 TClonesArray *digitsSSD = 0;
465 TBranch *br = fTree->GetBranch("ITSDigitsSSD");
466 br->SetAddress(&digitsSSD);
468 fSSDmap[mod] = digitsSSD;
478 /******************************************************************************/
480 void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel,
481 std::vector<UInt_t>& ids) const
483 // Fill the id-vector with ids of modules that satisfy conditions
484 // given by the AliEveITSModuleSelection object.
486 Int_t idx0 = 0, idx1 = 0;
487 switch(sel->GetType())
491 idx1 = AliITSgeomTGeo::GetModuleIndex(3, 1, 1) - 1;
494 idx0 = AliITSgeomTGeo::GetModuleIndex(3, 1, 1);
495 idx1 = AliITSgeomTGeo::GetModuleIndex(5, 1, 1) - 1;
498 idx0 = AliITSgeomTGeo::GetModuleIndex(5, 1, 1);
499 idx1 = AliITSgeomTGeo::GetNModules() - 1;
503 idx1 = AliITSgeomTGeo::GetNModules() - 1;
510 for (Int_t id = idx0; id < idx1; ++id)
512 AliITSgeomTGeo::GetModuleId(id, lay, lad, det);
513 if (sel->GetLayer() == lay || sel->GetLayer() == -1)
515 // check data from matrix
516 mx.SetFrom(*AliITSgeomTGeo::GetMatrix(id));
518 if (v.Phi() <= sel->GetMaxPhi() && v.Phi() >= sel->GetMinPhi() &&
519 v.Theta() <= sel->GetMaxTheta() && v.Theta() >= sel->GetMinTheta())
527 /******************************************************************************/
529 Bool_t AliEveITSDigitsInfo::HasData(Int_t module, Int_t det_id) const
531 // Return true if given module has data.
533 TClonesArray *digits = GetDigits(module, det_id);
534 return digits && digits->GetEntriesFast() > 0;
537 Bool_t AliEveITSDigitsInfo::IsDead (Int_t module, Int_t det_id) const
539 // Return true if given module is dead.
540 // Only implemented for SPD.
542 if (det_id == 0 && fgDeadModSPD)
543 return ((AliITSCalibrationSPD*) fgDeadModSPD->At(module))->IsBad();
544 if (det_id == 1 && fgDeadModSDD)
545 return ((AliITSCalibrationSDD*) fgDeadModSDD->At(module))->IsBad();
546 if (det_id == 2 && fgDeadModSSD)
547 return ((AliITSCalibrationSSD*) fgDeadModSSD->At(module))->IsBad();
551 /******************************************************************************/
553 void AliEveITSDigitsInfo::Print(Option_t* ) const
555 // Print information about stored geometry and segmentation.
557 printf("*********************************************************\n");
558 printf("SPD module dimension (%f,%f)\n", fSegSPD->Dx()*0.0001, fSegSPD->Dz()*0.0001);
559 printf("SPD first,last module: %d, %d\n",
560 AliITSgeomTGeo::GetModuleIndex(1,1,1),
561 AliITSgeomTGeo::GetModuleIndex(3,1,1) - 1);
562 printf("SPD num cells per module (x::%d,z::%d)\n", fSegSPD->Npx(), fSegSPD->Npz());
563 Int_t iz = 0, ix = 0;
564 printf("SPD dimesion of (%d,%d) in pixel(%f,%f)\n", ix, iz, fSegSPD->Dpx(ix), fSegSPD->Dpz(iz));
566 printf("SPD dimesion of pixel (%d,%d) are (%f,%f)\n", ix, iz, fSegSPD->Dpx(ix)*0.001, fSegSPD->Dpz(iz)*0.001);
568 printf("*********************************************************\n");
569 printf("SDD module dimension (%f,%f)\n", fSegSDD->Dx()*0.0001, fSegSDD->Dz()*0.0001);
570 printf("SDD first,last module: %d, %d\n",
571 AliITSgeomTGeo::GetModuleIndex(3,1,1),
572 AliITSgeomTGeo::GetModuleIndex(5,1,1) - 1);
573 printf("SDD num cells per module (x::%d,z::%d)\n", fSegSDD->Npx(), fSegSDD->Npz());
574 printf("SDD dimesion of pixel are (%f,%f)\n", fSegSDD->Dpx(1)*0.001, fSegSDD->Dpz(1)*0.001);
577 printf("*********************************************************\n");
578 printf("SSD module dimension (%f,%f)\n", fSegSSD->Dx()*0.0001, fSegSSD->Dz()*0.0001);
579 printf("SSD first, last module: %d, %d\n",
580 AliITSgeomTGeo::GetModuleIndex(5,1,1),
581 AliITSgeomTGeo::GetNModules() - 1);
582 printf("SSD strips in module %d\n", fSegSSD->Npx());
583 printf("SSD strip sizes are (%f,%f)\n", fSegSSD->Dpx(1), fSegSSD->Dpz(1));
584 fSegSSD->SetLayer(5); fSegSSD->Angles(ap,an);
585 printf("SSD layer 5 stereoP %f stereoN %f angle\n", ap, an);
586 fSegSSD->SetLayer(6); fSegSSD->Angles(ap,an);
587 printf("SSD layer 6 stereoP %f stereoN %f angle\n", ap, an);
592 printf("num cells %d,%d scaled %d,%d \n",fSegSPD->Npz(),fSegSPD->Npx(),Nz,Nx);
593 printf("%d digits in AliEveITSModule %d\n",ne, module);
594 Float_t zn = i*(3.48*2)/Nz - 3.48 ;
595 Float_t xo = -fSegSPD->Dx()*0.00005 + fSegSPD->Dpx(0)*od->GetCoord2()*0.0001;
596 Float_t xn = -fSegSPD->Dx()*0.00005 + j*0.0001*fSegSPD->Dx()/Nx;
597 Float_t dpx = 0.0001*fSegSPD->Dx()/Nx;
598 Float_t dpz = 3.48*2/Nz;
599 printf("Z::original (%3f) scaled (%3f, %3f) \n", zo, zn-dpz/2, zn+dpz/2);
600 printf("X::original (%3f) scaled (%3f, %3f) \n", xo, xn-dpx/2, xn+dpx/2);
601 printf("%d,%d maped to %d,%d \n", od->GetCoord1(), od->GetCoord2(), i,j );